@oh-story/dsh 0.1.8 → 0.1.10

package/lib/drama/skills/short-drama-produce/SKILL.md

@@ -16,7 +16,8 @@ license: MIT
 取出本次提示词，建立一个有边界的运行 job。creator-first job 的 `source` 必须指向拥有这条提示词的
 当前 Markdown，`source_entry` 必须点名该文档允许的二级标题：`图片提示词.md` 用 `IMG-*`，
 `视频提示词.md` 用 `MOTION-*`，`分镜.md` 用 `SHOT-*`（modality 为 `image`，正文取该镜的
-`### 冻结关键帧提示词`）。分镜这一路是本套件里唯一能把某一镜的起始画面渲染成文件的入口，但不是创作者获得起始帧的唯一办法——
+`### 冻结关键帧提示词`）。此选择器只提取首帧；尾帧需先由图片提示词阶段建立独立 `IMG-*` 状态图条目，
+再从 `图片提示词.md` 准备 image job。创作者也可以提供已有起始帧——
 在自己的工具里出图再放进项目同样成立，图片始终不进项目时走分镜的 `PLAN-...`；
 产出落在 `剧集/<EP>/制作成果/images/` 后，分镜 owner 才能把它绑成 `用途：起始帧` 的 `REF-...`。存在真实参考图时，
 还必须逐张填写 `reference_bindings` 的槽位、顺序、路径、中文名、用途以及允许/禁止控制范围；
@@ -75,11 +76,13 @@ python3 <本技能目录>/scripts/production_tool.py prepare <project> --job <jo
 python3 <本技能目录>/scripts/production_tool.py confirm <project> --job-id <id> --confirmation "CONFIRM <id> <code>"
 python3 <本技能目录>/scripts/production_tool.py run <project> --job-id <id> --adapter-config <outside-project-config.json>
 python3 <本技能目录>/scripts/production_tool.py status <project> --job-id <id>
+python3 <本技能目录>/scripts/production_tool.py collect <project> --job-id <id> --adapter-config <outside-project-config.json>
 python3 <本技能目录>/scripts/production_tool.py audit <project>
 ```
 
 `prepare` 只验证并预览，不生产。`confirm` 只保存与当前 job 指纹绑定的一次性确认。
-`run` 才启动 adapter。`audit` 只对账本地任务历史、失败后恢复、重复内容尝试和当前输出字节，
+`run` 才启动 adapter。`collect` 只取回**已经提交过、已经计费**的那次任务的结果，
+不重新提交、也不需要新的确认——见下面「中断不等于要重跑」。`audit` 只对账本地任务历史、失败后恢复、重复内容尝试和当前输出字节，
 不会调用供应商，也不把技术成功、文件存在或哈希一致写成媒体质量结论。同一 job 存在未决
 `running` attempt 时禁止重新 prepare、confirm 或 run；先等待完成或排查遗留 attempt。
 
@@ -97,8 +100,8 @@ python3 <本技能目录>/scripts/production_tool.py audit <project>
 - **tts**：从 `剧本.md` 读取原句与表演要求，声音参考由用户或现有媒体明确提供。不得在生产 job
   中改词，也不为 TTS 新建第六份创作文档。
 - **music**：读取 `视频提示词.md` 中创作者已确认的时间线音乐章节；主题曲使用已确认歌词，纯配乐
-  不携带歌词。供应商不能精确承诺时长时，生成源音轨后仍由剪辑按文档里的混音意图完成落点、循环、
-  淡入淡出和对白 ducking。
+  不携带歌词。供应商不能精确承诺时长时，生成源音轨后仍由 `$short-drama-edit` 按文档里的混音意图完成落点、
+  循环、淡入淡出和对白 ducking。
 
 一个 job 不混合 modality。大批量工作拆成创作者能看清数量和成本边界的小 job；不为方便把整季
 隐式塞进一次确认。
@@ -124,6 +127,9 @@ adapter 配置必须在项目外，只包含 argv 命令和超时；凭据由 ad
   固定高保真引用并校验尺寸、格式与透明背景限制。
 - [MiniMax Music](references/providers/minimax-music.md)：使用 `music-3.0` 与 hex 结果，区分主题曲
   和纯配乐，不伪造时长请求字段。
+- [MiniMax 语音](references/providers/minimax-speech.md)：`tts` 模态；模型与 `voice_id` 都必须
+  由账号与文档显式给出，不内置音色清单。只从预置音色合成，不做声音克隆——克隆是授权问题，
+  创作者授权的参考录音按普通创作者输入走 `输入/`。
 - [MiniMax H3 视频](references/providers/minimax-h3-video.md)：模型 ID、分辨率集合与时长区间必须
   由账号显式配置；提示词进 `content` 的 text 项，参考图按显式 role 绑定，本地参考在没有可信上传时
   fail closed。该模型与画面同一次生成声音，写法影响见视频提示词技能的目标模型能力档案。
@@ -133,6 +139,23 @@ adapter 配置必须在项目外，只包含 argv 命令和超时；凭据由 ad
 
 仓库自带 `fixture_adapter.py` 只用于离线测试，不代表真实生成质量或默认生产 adapter。
 
+## 中断不等于要重跑
+
+视频任务在**提交那一刻**就已经计费，不是在拿到结果时。提交之后的一切——轮询几分钟、下载——
+都可能被进程被杀、断网、机器休眠打断。内置 adapter 因此在拿到供应商任务 ID 的第一时间就把它
+写进 `handle_path`（早于第一次轮询），这个路径不随本次尝试一起删除。
+
+于是中断之后有三条确定的动作，不必再花一次钱：
+
+1. `audit` 会把带着任务 ID 的未完成尝试报成 `orphaned_provider_job`，
+   `action` 是 `collect_before_retry`；
+2. `collect` 用那个 ID 取回结果并把这次尝试标成成功；
+3. 只有在 `collect` 也确认那边确实失败之后，才走重新确认与重投的老路。
+
+**不要在 `audit` 报出 `orphaned_provider_job` 时直接重投**——那是在为同一个镜头付第二次钱。
+`collect` 不走确认闸门是有意的：闸门防的是意外花钱，而 collect 不花钱；
+如果它也要求重新确认，那么中断之后最省事的路径就变成再付一次，正好是闸门要防的事。
+
 ## 结果与复核
 
 成功后回报实际输出路径、媒体类型和运行状态；不要把“adapter 返回成功”写成质量结论。
@@ -145,6 +168,8 @@ adapter 配置必须在项目外，只包含 argv 命令和超时；凭据由 ad
 构图与角色一致、画面本身合规的图；音频被拒重录那句台词。改动写进新的 job 重新 prepare，让创
 作者在预览里看到改的是哪一项再确认；原样重投的那次确认不产生修复，只产生一笔费用。重复内容
 缺陷回到对应 prompt/spec owner。
+生产结束后不自动进入剪辑。素材要装配成成片时由用户点名 `$short-drama-edit`；它只取舍已有帧，
+不回头改本阶段的 job，也不生成新素材。
 如需质量复核，报告可把已有结果另行交给 `$short-drama-review`；不要在生产调用中自动启动复核。
 Dashboard 只负责展示这些文件和运行摘要，不提供 adapter 设置或生产按钮。
 

package/lib/drama/skills/short-drama-produce/references/adapter-contract.md

@@ -99,6 +99,12 @@ Keep this file outside the project:
 `command` is an argv array, never a shell string. Timeout is 1–3600 seconds. Do not put credentials in this file;
 let the adapter read its environment or operating-system credential store.
 
+## Capability sources
+
+Use the provider's current API reference for roles, limits and supported combinations.
+A relay can expose a different subset, reject inputs itself or transform requests.
+Record the tested execution path and distinguish its observations from the native API contract.
+
 ## Adapter stdin
 
 The adapter receives one UTF-8 JSON document as raw stdin bytes. Read the
@@ -113,6 +119,22 @@ on the machine locale. The document contains the confirmed job plus:
   production tool. Every adapter output source must be a direct regular-file
   child of this directory. The whole directory is deleted after success or
   failure.
+- `handle_path`: absolute path where the adapter records the provider's task id
+  **as soon as it has one, before it starts polling** — write
+  `{"provider_job_id": "<id>"}`, atomically. Unlike `output_root` this path
+  survives the attempt.
+- `collect_provider_job_id`: present only on a collect call. When it is set the
+  adapter must **not submit anything**; it polls and downloads that existing
+  task and returns its outputs as usual.
+
+## Recovering a submitted task
+
+Record the provider task ID before polling so an interrupted task can be collected without resubmission.
+A local handle-write failure is non-fatal after submission. The tool copies the handle into the attempt
+record on success or failure; `audit` reports unfinished tasks as `orphaned_provider_job` with
+`action: collect_before_retry`.
+
+`production_tool.py collect` retrieves the existing task without new submission or confirmation.
 
 It may translate provider-neutral parameters into its chosen SDK/API. Optional
 provider adapters under `scripts/` document and implement known translations;

package/lib/drama/skills/short-drama-produce/references/providers/minimax-h3-video.md

@@ -31,6 +31,12 @@ required and are only accepted when the runtime profile above permits their valu
 optional for reference-conditioned jobs and **required** for text-to-video, where `adaptive` is
 refused because there is no reference frame to adapt to.
 
+The adapter validates and forwards `duration`; it does not estimate speech length or retime dialogue.
+Before preparing a speaking shot, compare the accepted shot duration, the prompt's spoken timeline,
+and the job's `duration`. Resolve insufficient speaking time in the storyboard and regenerate the
+dependent prompt before preparing the job. Prompt timestamps alone do not change the request duration.
+The official video API has no separate speech-rate parameter.
+
 The prompt is compiled into one `text` item of the multimodal `content` array and is refused above
 7000 characters. Each declared reference becomes one further `content` item carrying an explicit
 `role`: `first_frame`, `last_frame`, `reference_image`, `reference_video`, or `reference_audio`.
@@ -68,18 +74,13 @@ structured: base/first-frame/first-last-frame tasks use `integrated_multimodal_d
 form. Chinese dialogue remains exact inside `<d>[Chinese] ...</d>`. Full details live in the
 video-prompt skill's `references/minimax-h3.md`.
 
-Audio generation is a **capability**, not a style:
-what changes upstream is only which axes of the target-model profile a project declares — see the
-video-prompt skill's target-model profile. Two consequences are worth stating here because they
-show up as production defects rather than as API errors:
-
-- an unstated audio channel is not a silent one. A shot that says nothing about music or speech can
-  come back with invented score and invented lines, so the shot's own sound intent, including what
-  must **not** be produced, has to be in the copyable body;
-- readable on-screen text is likewise produced unless it is excluded, so a shot with no readable-text
-  obligation states that exclusion instead of relying on the model to omit it.
+State the intended sound layers in the prompt. For no non-diegetic music, the
+H3 dialect uses `non_diegetic_music: N/A`; small probes observed unwanted music
+when this layer was omitted. They did not establish that omitted speech or
+negative clauses cause extra dialogue.
 
-Neither is written here as a fixed phrase, and this suite never injects one. The wording belongs to
-the shot and to the project's declared prompt language.
+Follow the project's subtitle and in-scene-text policy. Prompt wording belongs
+to the video-prompt skill and the declared language, not to adapter-generated
+boilerplate.
 
 Protocol reference: [MiniMax video generation API](https://platform.minimax.io/docs/api-reference/video-generation-v2-create).

package/lib/drama/skills/short-drama-produce/references/providers/minimax-speech.md

@@ -0,0 +1,41 @@
+# MiniMax Speech adapter
+
+Adapter command:
+
+```json
+{"command": ["python3", "/absolute/path/provider_adapters.py", "minimax-speech"], "timeout_seconds": 600}
+```
+
+Required environment: `MINIMAX_API_KEY`. `MINIMAX_BASE_URL` optionally overrides the default
+`https://api.minimax.io/v1` and must remain HTTPS.
+
+The job uses the suite's `tts` modality and must have exactly one output. The production prompt is the
+line to be spoken, verbatim — not a description of it. Supported public parameters are `model`,
+`voice_id`, `emotion`, `speed`, `vol`, `pitch`, `sample_rate`, `bitrate`, and `format`. The requested
+format must match the target extension and be `mp3` or `wav`.
+
+`model` and `voice_id` are both required and neither has a default. The model is an account-enabled
+endpoint, exactly as for the video providers. The voice is a creative decision recorded in
+`视觉设定.md` under the character's 声音方向, and it reaches the adapter through the confirmed job.
+
+## Voice selection
+
+Read the provider's voice listing and confirm availability for the chosen model and account.
+The adapter validates the ID format, not catalogue membership. Record the selected ID in the
+character's 声音方向 and pass it through the confirmed job.
+
+This workflow selects preset voices. The adapter does not enrol or clone a voice;
+any supplied recording retains its documented authorization and usage scope.
+
+## Request shape
+
+The request is non-streaming with `output_format: hex`, `POST /t2a_v2`, and carries
+`voice_setting` (`voice_id`, and any of `emotion`, `speed`, `vol`, `pitch`) alongside `audio_setting`
+(`sample_rate`, `bitrate`, `format`). The adapter validates `base_resp.status_code`, decodes
+`data.audio` as hexadecimal bytes, and writes it to a private temporary file.
+
+`emotion` accepts the provider's seven values: `happy`, `sad`, `angry`, `fearful`, `disgusted`,
+`surprised`, `neutral`. Anything outside that set is refused rather than passed through — a rejected
+emotion is a typo caught before it is paid for.
+
+Protocol reference: [MiniMax Text to Speech](https://platform.minimax.io/docs/api-reference/speech-t2a-http).

package/lib/drama/skills/short-drama-produce/references/providers/seedance.md

@@ -29,6 +29,13 @@ profile above explicitly permits their values, then sent as the API's top-level
 `generate_audio` is a boolean. The broad compiler envelope remains configurable rather than proving
 that every Seedance release supports every value.
 
+The compiler also forwards `duration: -1` without applying the positive-integer range. For ordinary
+Seedance 2.0/2.5 generation this asks the model to choose within its native range; for 2.5 `edit` it
+preserves the source video's duration instead. The adapter does not estimate spoken dialogue or
+lengthen a short job. Fixed-duration delivery needs an explicit accepted duration; auto-duration
+output needs its actual media length and speech checked before timing is accepted. The API response's
+integer `duration` rounds down the frame-based duration, so it is not a precise media measurement.
+
 `compile_seedance_payload` accepts explicit `reference_image`, `reference_video`, and
 `reference_audio` roles with matching HTTPS, `asset://` or base64 data URI values. It emits the matching multimodal
 content type and uses `@图片N`、`@视频N`、`@音频N` in its appended reference contract. The bundled

package/lib/drama/skills/short-drama-produce/scripts/fixture_adapter.py

@@ -27,8 +27,22 @@ PNG = base64.b64decode(
 def main() -> int:
     parser = argparse.ArgumentParser()
     parser.add_argument("--fail", action="store_true")
+    # A real video provider bills at submission and can be interrupted at any
+    # point afterwards. `--submit-then-fail` reproduces exactly that: record the
+    # handle the way a live adapter does, then die before returning anything.
+    parser.add_argument("--submit-then-fail", action="store_true")
     args = parser.parse_args()
     job = json.load(sys.stdin.buffer)
+    collecting = job.get("collect_provider_job_id")
+    if args.submit_then_fail and not collecting:
+        destination = job.get("handle_path")
+        if isinstance(destination, str) and destination:
+            path = Path(destination)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(
+                json.dumps({"provider_job_id": "fixture-task-1"}), encoding="utf-8"
+            )
+        return 7
     if args.fail:
         return 7
     directory_raw = job.get("output_root")
@@ -52,7 +66,10 @@ def main() -> int:
                 handle.setframerate(8000)
                 handle.writeframes(struct.pack("<h", 0) * 80)
         outputs.append({"target": target, "source": str(path)})
-    json.dump({"outputs": outputs, "provider_job_id": "fixture-local"}, sys.stdout)
+    response = {"outputs": outputs, "provider_job_id": "fixture-local"}
+    if isinstance(collecting, str) and collecting:
+        response["provider_job_id"] = collecting
+    json.dump(response, sys.stdout)
     return 0
 
 

package/lib/drama/skills/short-drama-produce/scripts/production_tool.py

@@ -1547,6 +1547,37 @@ def _active_run(root: Path, job_id: str) -> dict[str, Any] | None:
     return running[-1] if running else None
 
 
+def _read_provider_handle(root: Path, job_id: str, run_id: str) -> str | None:
+    """The provider job id an adapter recorded before it started polling.
+
+    A video task is billed the moment it is submitted, not when it is collected.
+    If the adapter is then interrupted — killed, disconnected, the machine
+    sleeps — the run record would otherwise say `running` with no way back to a
+    task that is alive and already paid for, and the only move left is to submit
+    (and pay) again. The adapter writes the id here as soon as it has one, into
+    project metadata rather than the attempt's temporary directory, so it
+    outlives the process that created it.
+    """
+
+    try:
+        document = _metadata_read_json(
+            root, ("handles", _job_key(job_id)), f"{run_id}.json",
+            maximum=MAX_RUN_RECORD_BYTES,
+        )
+    except (FileNotFoundError, ValueError, json.JSONDecodeError):
+        return None
+    if not isinstance(document, Mapping):
+        return None
+    value = document.get("provider_job_id")
+    if isinstance(value, str) and 0 < len(value) <= 200:
+        return value
+    return None
+
+
+def _handle_metadata_path(root: Path, job_id: str, run_id: str) -> Path:
+    return root / PRODUCTION_ROOT / "handles" / _job_key(job_id) / f"{run_id}.json"
+
+
 def _write_run(root: Path, job_id: str, run: Mapping[str, Any]) -> None:
     _metadata_atomic_json(
         root,
@@ -1620,6 +1651,9 @@ def run_job(root: Path, *, job_id: str, adapter_config: Path) -> dict[str, Any]:
                 "run_id": run_id,
                 "project_root": str(snapshot_root),
                 "output_root": str(output_root),
+                # Where to record the provider job id the instant it exists, so
+                # an interrupted attempt can be collected instead of re-billed.
+                "handle_path": str(_handle_metadata_path(root, job_id, run_id)),
             }
         )
         try:
@@ -1640,11 +1674,20 @@ def run_job(root: Path, *, job_id: str, adapter_config: Path) -> dict[str, Any]:
                             "sha256": digest,
                         }
                     )
+                if _run_status(root, job_id, run_id) == "succeeded":
+                    # `collect` reached the same provider task first and its
+                    # outputs are already in the project. Leave that record
+                    # alone rather than replacing a collected attempt.
+                    raise RuntimeError(
+                        "这次尝试已经被 collect 取回并标为成功；本次运行不覆盖它"
+                    )
                 run["status"] = "succeeded"
                 run["finished_at"] = utc_now()
                 run["outputs"] = written
-                provider_job_id = response.get("provider_job_id")
-                if isinstance(provider_job_id, str) and len(provider_job_id) <= 200:
+                provider_job_id = response.get("provider_job_id") or _read_provider_handle(
+                    root, job_id, run_id
+                )
+                if isinstance(provider_job_id, str) and 0 < len(provider_job_id) <= 200:
                     run["provider_job_id"] = provider_job_id
                 _write_run(root, job_id, run)
         except Exception as exc:
@@ -1653,6 +1696,12 @@ def run_job(root: Path, *, job_id: str, adapter_config: Path) -> dict[str, Any]:
                 run["finished_at"] = utc_now()
                 if isinstance(exc, AdapterError) and exc.public_error is not None:
                     run["error"] = exc.public_error
+                # A timeout or a killed adapter does not cancel the provider's
+                # task. Carry the handle onto the failed record so `audit` can
+                # say "collect this" instead of the creator paying twice.
+                orphan = _read_provider_handle(root, job_id, run_id)
+                if orphan is not None:
+                    run["provider_job_id"] = orphan
                 _write_run(root, job_id, run)
             raise
     return {
@@ -1663,6 +1712,101 @@ def run_job(root: Path, *, job_id: str, adapter_config: Path) -> dict[str, Any]:
     }
 
 
+def _run_status(root: Path, job_id: str, run_id: str) -> str | None:
+    """The status one attempt currently has on disk, re-read rather than cached."""
+
+    for run in _read_run_history(root, job_id):
+        if str(run.get("run_id")) == run_id:
+            status = run.get("status")
+            return status if isinstance(status, str) else None
+    return None
+
+
+def collect_job(root: Path, *, job_id: str, adapter_config: Path) -> dict[str, Any]:
+    """Collect an already-submitted task's result without submitting a new one.
+
+    This is deliberately outside the confirmation gate. The gate exists to stop
+    an unintended charge; collecting costs nothing, because the charge already
+    happened when the task was submitted. Requiring a fresh confirmation here
+    would mean the cheapest way out of an interrupted attempt is to pay again,
+    which is exactly the outcome the gate is meant to prevent.
+    """
+
+    root = find_project(root)
+    with tempfile.TemporaryDirectory(prefix="short-drama-collect-") as directory:
+        output_root = Path(directory) / "outputs"
+        output_root.mkdir(parents=True)
+        with _project_lock(root):
+            job = _read_job(root, job_id)
+            command, timeout = _load_adapter(adapter_config, str(job["adapter"]), root)
+            target_run = None
+            for run in reversed(_read_run_history(root, job_id)):
+                if run.get("status") == "succeeded":
+                    continue
+                handle = run.get("provider_job_id") or _read_provider_handle(
+                    root, job_id, str(run["run_id"])
+                )
+                if handle:
+                    target_run = (run, handle)
+                    break
+            if target_run is None:
+                raise RuntimeError(
+                    "no unfinished attempt of this job carries a provider job id; "
+                    "there is nothing to collect"
+                )
+            run, provider_job_id = target_run
+
+        payload = {key: job[key] for key in ALLOWED_JOB_KEYS if key in job}
+        payload.update(
+            {
+                "run_id": str(run["run_id"]),
+                "output_root": str(output_root),
+                "collect_provider_job_id": provider_job_id,
+            }
+        )
+        response = _run_adapter(command, timeout, payload, root)
+        adapter_outputs = _validate_adapter_outputs(job, response, output_root)
+        written: list[dict[str, Any]] = []
+        with _project_lock(root):
+            # A live `run_job` on the same provider task is indistinguishable
+            # from a dead one — both sit at `running`. Re-read before writing,
+            # or two writers race onto the same bytes and one record is lost.
+            if _run_status(root, job_id, str(run["run_id"])) == "succeeded":
+                raise RuntimeError(
+                    "这次尝试在取回期间已经自己完成了，产物已经落进项目；"
+                    "没有覆盖它——先看 status，确认无误就不需要再做别的"
+                )
+            for target_name, source in adapter_outputs:
+                target = _project_file(root, target_name, create_parent=True)
+                digest, size = _copy_output(
+                    source, target, overwrite=bool(job["overwrite"])
+                )
+                written.append(
+                    {
+                        "path": target_name,
+                        "media_type": MEDIA_TYPES[PurePosixPath(target_name).suffix.casefold()],
+                        "bytes": size,
+                        "sha256": digest,
+                    }
+                )
+            collected = dict(run)
+            collected["status"] = "succeeded"
+            collected["finished_at"] = utc_now()
+            collected["outputs"] = written
+            collected["provider_job_id"] = provider_job_id
+            collected["collected"] = True
+            collected.pop("error", None)
+            _write_run(root, job_id, collected)
+    return {
+        "job_id": job_id,
+        "run_id": str(run["run_id"]),
+        "state": "succeeded",
+        "collected": True,
+        "provider_job_id": provider_job_id,
+        "outputs": written,
+    }
+
+
 def job_status(root: Path, *, job_id: str) -> dict[str, Any]:
     root = find_project(root)
     job = _read_job(root, job_id)
@@ -1816,6 +1960,28 @@ def audit_project(root: Path) -> dict[str, Any]:
         attempts_failed += sum(run["status"] == "failed" for run in completed)
         attempts_running += len(running)
         attempts_superseded += len(history) - len(current)
+        for run in current:
+            if run.get("status") == "succeeded":
+                continue
+            handle = run.get("provider_job_id") or _read_provider_handle(
+                root, job_id, str(run["run_id"])
+            )
+            if not handle:
+                continue
+            problems.append(
+                {
+                    "code": "orphaned_provider_job",
+                    "job_id": job_id,
+                    "run_id": run["run_id"],
+                    "provider_job_id": handle,
+                    "action": "collect_before_retry",
+                    # A live attempt and a dead one both sit at `running`, so
+                    # this finding cannot tell them apart. Collecting is still
+                    # the right first move — it is the only one that costs
+                    # nothing — and it refuses safely if the attempt finished.
+                    "note": "status 为 running 时它可能仍在正常轮询；collect 会先确认再写",
+                }
+            )
         if running:
             running_jobs += 1
             for run in running:
@@ -1986,6 +2152,13 @@ def build_parser() -> argparse.ArgumentParser:
     run.add_argument("project")
     run.add_argument("--job-id", required=True)
     run.add_argument("--adapter-config", required=True)
+    collect = commands.add_parser(
+        "collect",
+        help="Fetch the result of an already-submitted provider task without paying again.",
+    )
+    collect.add_argument("project")
+    collect.add_argument("--job-id", required=True)
+    collect.add_argument("--adapter-config", required=True)
     status = commands.add_parser("status", help="Show one media job state.")
     status.add_argument("project")
     status.add_argument("--job-id", required=True)
@@ -2011,6 +2184,12 @@ def main(argv: list[str] | None = None) -> int:
                 job_id=args.job_id,
                 adapter_config=Path(args.adapter_config),
             )
+        elif args.command == "collect":
+            result = collect_job(
+                Path(args.project),
+                job_id=args.job_id,
+                adapter_config=Path(args.adapter_config),
+            )
         elif args.command == "status":
             result = job_status(Path(args.project), job_id=args.job_id)
         else: