Pad task_id in the campaign submit template to match task filenames

Task files are written zero-padded (task-{task_id:04d}.json.gz) and
collect() reads them padded, but the generated submit file referenced the
unpadded $(task_id), so every job failed its input-file transfer on
HTCondor (looking for task-0.json.gz, not task-0000.json.gz); the output
remap would likewise have missed the runner's padded output. The local
runner pads correctly, so this only surfaced on real condor submission.

Fill the filenames from a {pad} field set to HTCondor's $INT(task_id,%04d),
which pads from the unpadded task_id column in remaining.txt that status
regenerates unpadded — so the submit file stays correct across resubmits.
Regression test emulates the macro expansion and asserts every
submit-referenced filename matches an on-disk task file (red on the bare
macro, green with the fix).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NafThGCY6Zrxo8s3Pdf6fV

Author: wmayner

pyphi/campaign/__init__.py

@@ -278,21 +278,30 @@ def _pack(
     return [sorted(b) for b in bins]
 
 
+# Task files are written zero-padded (``task-{task_id:04d}.json.gz``), and
+# collection reads them back with the same padding, so every filename the
+# scheduler forms from ``task_id`` must pad identically. ``{pad}`` is filled
+# with HTCondor's ``$INT(task_id,%04d)``, which pads from the unpadded
+# ``task_id`` column in ``remaining.txt`` (which ``status`` regenerates
+# unpadded), keeping the submit file correct across resubmits. A bare
+# ``$(task_id)`` here would expand to ``task-0.json.gz`` and every job would
+# fail its input-file transfer.
+_TASK_ID_PAD = "$INT(task_id,%04d)"
 _SUBMIT_TEMPLATE = """\
 universe            = container
 container_image     = {container_image}
 executable          = run_task.sh
-arguments           = $(task_id)
-transfer_input_files = tasks/task-$(task_id).json.gz, substrates/
-transfer_output_remaps = "task-$(task_id).json.gz = outputs/task-$(task_id).json.gz"
+arguments           = {pad}
+transfer_input_files = tasks/task-{pad}.json.gz, substrates/
+transfer_output_remaps = "task-{pad}.json.gz = outputs/task-{pad}.json.gz"
 should_transfer_files = YES
 when_to_transfer_output = ON_EXIT_OR_EVICT
 request_cpus        = 1
 request_memory      = $(memory)
 request_disk        = {request_disk}
-log                 = logs/task-$(task_id).log
-output              = logs/task-$(task_id).out
-error               = logs/task-$(task_id).err
+log                 = logs/task-{pad}.log
+output              = logs/task-{pad}.out
+error               = logs/task-{pad}.err
 queue task_id, memory from remaining.txt
 """
 
@@ -508,6 +517,7 @@ def _write_campaign_scaffold(
         _SUBMIT_TEMPLATE.format(
             container_image=container_image,
             request_disk=request_disk,
+            pad=_TASK_ID_PAD,
         )
     )
 

test/campaign/test_prepare_ces.py

@@ -321,3 +321,66 @@ def test_state_keyed_mapping_requires_singleton_axes(tmp_path):
             units_per_job=50.0,
             resolution_state=resolution,
         )
+
+
+def _expand_condor_macros(pattern: str, task_id: str) -> str:
+    """Emulate HTCondor's expansion of the macros the submit template uses.
+
+    ``$INT(task_id,%0Nd)`` -> the task id zero-padded to N digits;
+    ``$(task_id)`` -> the raw id. Enough to reconstruct the filename the
+    scheduler would transfer for a given ``remaining.txt`` row.
+    """
+    import re
+
+    pattern = re.sub(
+        r"\$INT\(task_id,\s*%0(\d+)d\)",
+        lambda m: str(int(task_id)).zfill(int(m.group(1))),
+        pattern,
+    )
+    return pattern.replace("$(task_id)", task_id)
+
+
+def test_submit_filenames_match_padded_task_files(tmp_path):
+    """Every input file the submit template references for a task must be the
+    zero-padded name that ``prepare`` actually wrote (regression: a bare
+    ``$(task_id)`` expanded to ``task-0.json.gz`` and held every job)."""
+    directory = tmp_path / "camp"
+    prepare_ces(
+        examples.basic_substrate(),
+        states=BASIC_STATE,
+        formalisms="IIT_4_0_2026",
+        directory=directory,
+        units_per_job=50.0,
+    )
+    import re
+
+    submit = (directory / "pyphi.sub").read_text()
+    # The value can hold commas inside ``$INT(task_id,%04d)``, so match the
+    # ``tasks/...json.gz`` token directly instead of splitting on commas.
+    input_pattern = next(
+        re.search(r"tasks/\S*\.json\.gz", line).group(0)
+        for line in submit.splitlines()
+        if line.strip().startswith("transfer_input_files")
+    )
+    remap_lhs = next(
+        line.split("=", 1)[1].split("=", 1)[0].strip().strip('"')
+        for line in submit.splitlines()
+        if line.strip().startswith("transfer_output_remaps")
+    )
+    task_ids = [
+        line.split(",", 1)[0].strip()
+        for line in (directory / "remaining.txt").read_text().splitlines()
+        if line.strip()
+    ]
+    assert task_ids
+    for task_id in task_ids:
+        # The file the scheduler transfers in must be the one on disk.
+        transferred = _expand_condor_macros(input_pattern, task_id)
+        assert (directory / transferred).exists(), (
+            f"submit references {transferred} but it does not exist"
+        )
+        # The remap's source name must match what the runner writes back
+        # (``task-{task_id:04d}.json.gz``), or output transfer silently fails.
+        assert _expand_condor_macros(remap_lhs, task_id) == (
+            f"task-{int(task_id):04d}.json.gz"
+        )