agent-conveyor 0.1.6 → 0.1.8

package/dist/cli/typescript-runtime.js

@@ -76,7 +76,7 @@ export function runTypescriptRuntimeCommand(options) {
         return errorResult(`unknown command: ${parsed.command}`);
     }
     if (parsed.flags.help) {
-        return textResult([`usage: ${program} ${parsed.command} [-h] [options]`]);
+        return textResult(commandHelpText(program, parsed.command));
     }
     if (parsed.error) {
         return errorResult(parsed.error);
@@ -337,6 +337,70 @@ export function runTypescriptRuntimeCommand(options) {
         return errorResult(error instanceof Error ? error.message : String(error));
     }
 }
+function commandHelpText(program, command) {
+    const path = "[--path <workerctl.db>]";
+    const linesByCommand = {
+        criteria: [
+            `usage: ${program} criteria <task> [--list|--add --criterion <text> --source <source>|--accept ID|--satisfy ID|--defer ID|--reject ID] ${path} [--json]`,
+            "",
+            "Examples:",
+            `  ${program} criteria my-task --list --json --path /tmp/work/workerctl.db`,
+            `  ${program} criteria my-task --add --criterion "Note file exists" --source manager_inferred --status accepted --path /tmp/work/workerctl.db`,
+            `  ${program} criteria my-task --satisfy 1 --proof "File exists" --evidence-json '{"artifact":{"path":"docs/note.md"}}' --path /tmp/work/workerctl.db`,
+        ],
+        "finish-task": [
+            `usage: ${program} finish-task <task> --reason <reason> [--require-criteria-audit] ${path}`,
+            "",
+            "Examples:",
+            `  ${program} finish-task my-task --reason "Accepted criteria satisfied" --require-criteria-audit --path /tmp/work/workerctl.db`,
+        ],
+        "manager-ack": [
+            `usage: ${program} manager-ack <task> --from-stdin ${path}`,
+            `usage: ${program} manager-ack <task> --json ${path}`,
+            "",
+            "Example JSON:",
+            `  {"task":"my-task","manager_session":"mgr","supervision_contract":"I will supervise through Conveyor and verify criteria before finishing.","will_not_edit_project_files":true}`,
+        ],
+        nudge: [
+            `usage: ${program} nudge <worker-or-session> <message> ${path} [--dry-run]`,
+            `usage: ${program} session-nudge <session> <message> ${path} [--dry-run]`,
+            "",
+            "For task-routed delivery, prefer enqueue-nudge-worker plus dispatch:",
+            `  ${program} enqueue-nudge-worker my-task --message "Status and evidence?" --path /tmp/work/workerctl.db`,
+            `  ${program} dispatch --once --type nudge_worker --path /tmp/work/workerctl.db`,
+        ],
+        pair: [
+            `usage: ${program} pair --task <task> --worker-name <worker> --manager-name <manager> [options] ${path}`,
+            "",
+            "Options:",
+            "  --task-goal <text>             Task goal stored in Conveyor state.",
+            "  --task-prompt <text>           Initial worker prompt; defaults to task goal when omitted.",
+            "  --manager-recipe <recipe>      Seed a manager recipe, for example goalbuddy-conveyor.",
+            "  --manager-acceptance <text>    Seed an accepted manager criterion; repeat for multiple criteria.",
+            "  --manager-tool <tool>          Seed an expected manager/worker tool; repeat for multiple tools.",
+            "  --manager-reference <path>     Seed a manager reference path; repeat for multiple references.",
+            "  --manager-question <text>      Seed a manager setup question; repeat for multiple questions.",
+            "  --manager-guideline <text>     Seed a manager guideline; repeat for multiple guidelines.",
+            "  --cwd <dir>                    Working directory for both Codex sessions.",
+            "  --accept-trust                 Auto-accept the Codex trust prompt for the chosen cwd.",
+            "  --no-dispatch                  Do not start Dispatch after launching the pair.",
+            "  --dry-run                      Print the launch plan without creating sessions.",
+            "  --json                         Emit JSON output.",
+            "",
+            "Examples:",
+            `  ${program} pair --task dogfood --worker-name dogfood-worker --manager-name dogfood-manager --task-goal "Create docs/note.md" --task-prompt "Create docs/note.md" --manager-recipe goalbuddy-conveyor --manager-acceptance "docs/note.md exists" --cwd /tmp/work --path /tmp/work/workerctl.db --accept-trust`,
+            `  ${program} pair --task dogfood --worker-name dogfood-worker --manager-name dogfood-manager --path /tmp/work/workerctl.db --dry-run --json`,
+        ],
+        "worker-ack": [
+            `usage: ${program} worker-ack <task> --from-stdin ${path}`,
+            `usage: ${program} worker-ack <task> --json ${path}`,
+            "",
+            "Example JSON:",
+            `  {"goal_restatement":"Create docs/dogfood-note.md","proposed_criteria":{"must_have":["note file exists"],"follow_up":[]},"expected_tools":["shell"],"open_questions":[],"ready_to_start":true}`,
+        ],
+    };
+    return linesByCommand[command] ?? [`usage: ${program} ${command} [-h] [options]`];
+}
 function parseRuntimeArgs(args, env) {
     const flags = {
         format: "timeline",
@@ -361,6 +425,10 @@ function parseRuntimeArgs(args, env) {
         candidate: null,
         check: null,
         classifyPrompt: null,
+        workerCodexAppThreadId: null,
+        workerCodexAppThreadTitle: null,
+        managerCodexAppThreadId: null,
+        managerCodexAppThreadTitle: null,
         codexSession: null,
         create: null,
         createRun: null,
@@ -1883,6 +1951,31 @@ function parseRuntimeArgs(args, env) {
             flags.manager = value.value;
             index += 1;
         }
+        else if (arg === "--worker-codex-app-thread-id"
+            || arg === "--worker-codex-app-thread-title"
+            || arg === "--manager-codex-app-thread-id"
+            || arg === "--manager-codex-app-thread-title") {
+            if (command !== "create-disposable-binding") {
+                return { command, enabled, error: `Unsupported TypeScript runtime option: ${arg}`, explicit, flags, task };
+            }
+            const value = valueAfter(queue, index, arg);
+            if (value.error) {
+                return { command, enabled, error: value.error, explicit, flags, task };
+            }
+            if (arg === "--worker-codex-app-thread-id") {
+                flags.workerCodexAppThreadId = value.value;
+            }
+            else if (arg === "--worker-codex-app-thread-title") {
+                flags.workerCodexAppThreadTitle = value.value;
+            }
+            else if (arg === "--manager-codex-app-thread-id") {
+                flags.managerCodexAppThreadId = value.value;
+            }
+            else {
+                flags.managerCodexAppThreadTitle = value.value;
+            }
+            index += 1;
+        }
         else if (arg === "--template") {
             if (command !== "create-disposable-binding" && command !== "loop-templates") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --template", explicit, flags, task };
@@ -3904,10 +3997,10 @@ function qaRunBuildClearLoop(context) {
     const artifactDir = qaArtifactDir(context, "build-clear-loop", slug, run.id);
     const buildReceipt = join(artifactDir, "build-passed.json");
     mkdirSync(dirname(buildReceipt), { recursive: true });
-    writeFileSync(buildReceipt, `${JSON.stringify(sortJson({ command: "scripts/run-unittests-isolated -k build_clear_loop", result: "pass", status: "build_passed" }), null, 2)}\n`);
+    writeFileSync(buildReceipt, `${JSON.stringify(sortJson({ command: "npm test -- --runInBand", result: "pass", status: "build_passed" }), null, 2)}\n`);
     qaRecordLoopEvidence(context, task, run.id, "build_passed", "qa-run-build-clear-build-passed", {
         artifactPath: buildReceipt,
-        metadata: { command: "scripts/run-unittests-isolated -k build_clear_loop", result: "Focused build/test command passed before retry." },
+        metadata: { command: "npm test -- --runInBand", result: "Focused build/test command passed before retry." },
     });
     enqueueQaContinue(context, task, run.id, "qa-run-build-clear-build-only", "Run after build evidence only.");
     const buildOnlyDispatch = qaDispatchContinueOnce(context, "qa-run-build-clear-build-only");
@@ -4820,19 +4913,14 @@ function dispatchWatchCommand(workerctlPath, dispatcherId, dbPath) {
 }
 function installableSkillSources() {
     const root = packageRootFromRuntimeModule();
-    const candidates = [
-        join(root, "skills"),
-        join(root, "workerctl", "assets", "skills"),
-    ];
-    for (const candidate of candidates) {
-        const skills = ["manage-codex-workers", "codex-review"]
-            .map((name) => ({ name, source: join(candidate, name) }))
-            .filter((skill) => existsSync(join(skill.source, "SKILL.md")));
-        if (skills.length === 2) {
-            return skills;
-        }
+    const candidate = join(root, "skills");
+    const skills = ["manage-codex-workers", "codex-review"]
+        .map((name) => ({ name, source: join(candidate, name) }))
+        .filter((skill) => existsSync(join(skill.source, "SKILL.md")));
+    if (skills.length === 2) {
+        return skills;
     }
-    throw new Error("Bundled Agent Conveyor skills not found in skills/ or workerctl/assets/skills.");
+    throw new Error("Bundled Agent Conveyor skills not found in skills/.");
 }
 function runBindCommand(parsed, options) {
     const unsupported = unsupportedBindOptions(parsed);
@@ -4933,6 +5021,8 @@ function runCreateDisposableBindingCommand(parsed, options) {
         const workerRollout = writeDisposableRollout(sessionDir, workerName, cwd);
         const managerRollout = writeDisposableRollout(sessionDir, managerName, cwd);
         const worker = registerSessionSync(database, {
+            codexAppThreadId: parsed.flags.workerCodexAppThreadId,
+            codexAppThreadTitle: parsed.flags.workerCodexAppThreadTitle,
             codexSessionPath: workerRollout.path,
             cwd,
             name: workerName,
@@ -4941,6 +5031,8 @@ function runCreateDisposableBindingCommand(parsed, options) {
             tmuxSession: null,
         });
         const manager = registerSessionSync(database, {
+            codexAppThreadId: parsed.flags.managerCodexAppThreadId,
+            codexAppThreadTitle: parsed.flags.managerCodexAppThreadTitle,
             codexSessionPath: managerRollout.path,
             cwd,
             name: managerName,
@@ -4979,6 +5071,8 @@ function runCreateDisposableBindingCommand(parsed, options) {
             db_path: dbPath,
             manager: {
                 communication: disposableSessionCommunication("manager", task.name, dbPath),
+                codex_app_thread_id: manager.codex_app_thread_id,
+                codex_app_thread_title: manager.codex_app_thread_title,
                 id: manager.session_id,
                 name: managerName,
                 rollout_path: managerRollout.path,
@@ -5004,11 +5098,14 @@ function runCreateDisposableBindingCommand(parsed, options) {
             },
             worker: {
                 communication: disposableSessionCommunication("worker", task.name, dbPath),
+                codex_app_thread_id: worker.codex_app_thread_id,
+                codex_app_thread_title: worker.codex_app_thread_title,
                 id: worker.session_id,
                 name: workerName,
                 rollout_path: workerRollout.path,
                 tmux_session: null,
             },
+            heartbeat_recommendations: disposableHeartbeatRecommendations(task.name, dbPath),
             worker_handoff: disposableWorkerHandoff(task.name, run?.name ?? null, dbPath),
         };
         if (parsed.flags.json) {
@@ -5394,6 +5491,7 @@ function runStartSessionCommand(parsed, options, role) {
         const initialPrompt = role === "manager"
             ? startManagerBootstrapPrompt(database, {
                 cwd,
+                dbPath: runtimeDbPath(parsed, options),
                 managerName: name,
                 taskGoal: parsed.flags.taskGoal,
                 taskName: parsed.flags.taskName,
@@ -5720,7 +5818,7 @@ function runPairCommand(parsed, options) {
         return unsupportedRuntimeResult(parsed, "pair requires --task, --worker-name, and --manager-name.");
     }
     const dbPath = runtimeDbPath(parsed, options);
-    const dispatch = pairDispatchPayload(parsed, dbPath);
+    const dispatch = pairDispatchPayload(parsed, dbPath, options);
     const packageRoot = packageRootFromRuntimeModule();
     if (parsed.flags.dryRun) {
         return jsonResult({
@@ -5731,6 +5829,18 @@ function runPairCommand(parsed, options) {
             worker: workerName,
         });
     }
+    const codexPreflight = ensureRequiredTool("codex", options);
+    if (codexPreflight) {
+        return codexPreflight;
+    }
+    const tmuxPreflight = ensureTmuxAvailable(options.tmuxRunner ?? defaultTmuxRunner);
+    if (tmuxPreflight) {
+        return tmuxPreflight;
+    }
+    const tmuxAccessPreflight = ensureTmuxServerAccessible(options.tmuxRunner ?? defaultTmuxRunner);
+    if (tmuxAccessPreflight) {
+        return tmuxAccessPreflight;
+    }
     const cwd = parsed.flags.cwd ?? options.cwd ?? process.cwd();
     const database = openRuntimeDatabase(parsed, options);
     let taskId = null;
@@ -5848,7 +5958,7 @@ function runPairCommand(parsed, options) {
             acceptTrust: parsed.flags.acceptTrust,
             askForApproval: startup.askForApproval,
             cwd,
-            initialPrompt: workerAckTaskPrompt(taskName, parsed.flags.taskPrompt),
+            initialPrompt: workerAckTaskPrompt(taskName, parsed.flags.taskPrompt, dbPath),
             name: workerName,
             role: "worker",
             sandbox: startup.sandbox,
@@ -5876,6 +5986,7 @@ function runPairCommand(parsed, options) {
             cwd,
             initialPrompt: startManagerBootstrapPrompt(database, {
                 cwd,
+                dbPath,
                 managerName,
                 taskGoal: task.goal,
                 taskName,
@@ -6035,14 +6146,13 @@ function taskRowForPair(database, taskName) {
   `).get(taskName, taskName);
     return row ?? null;
 }
-function pairDispatchPayload(parsed, dbPath) {
+function pairDispatchPayload(parsed, dbPath, options) {
     const dispatcherId = parsed.flags.dispatcherId;
     const ensureDispatch = dispatcherId !== null && !parsed.flags.noDispatch;
-    const packageRoot = packageRootFromRuntimeModule();
     return {
         dispatchCommand: ensureDispatch
             ? [
-                join(packageRoot, "scripts", "workerctl"),
+                workerctlDispatchExecutable(options),
                 "dispatch",
                 "--watch",
                 "--dispatcher-id",
@@ -6054,6 +6164,17 @@ function pairDispatchPayload(parsed, dbPath) {
         ensureDispatch,
     };
 }
+function workerctlDispatchExecutable(options) {
+    const workerctlPath = commandPath("workerctl", options);
+    if (workerctlPath) {
+        return workerctlPath;
+    }
+    const workerctlScript = join(packageRootFromRuntimeModule(), "scripts", "workerctl");
+    if (pathIsExecutable(workerctlScript)) {
+        return workerctlScript;
+    }
+    throw new Error(`Cannot start Dispatch: workerctl is not on PATH and ${workerctlScript} is not executable.`);
+}
 function emitPairTelemetry(database, options) {
     emitTelemetrySync(database, {
         actor: "workerctl",
@@ -6407,20 +6528,24 @@ function spawnCodexAndRegisterPairSession(database, parsed, options, params) {
         tmux_session: registered.tmux_session,
     };
 }
-function workerAckTaskPrompt(taskName, taskPrompt) {
+function workerAckTaskPrompt(taskName, taskPrompt, dbPath) {
     if (taskPrompt === null) {
         return null;
     }
     const taskRef = taskName ?? "<task>";
+    const pathSuffix = commandPathSuffix(dbPath);
     return [
         taskPrompt,
         "",
         "Before editing files or running implementation work, acknowledge the task contract:",
         "",
-        `conveyor worker-ack ${taskRef} --from-stdin`,
+        `conveyor worker-ack ${taskRef} --from-stdin${pathSuffix}`,
+        "",
+        "Use a JSON object like:",
+        "",
+        `{"goal_restatement":"Restate the assigned task.","proposed_criteria":{"must_have":["Current-task proof"],"follow_up":[]},"expected_tools":["shell"],"open_questions":[],"ready_to_start":true}`,
         "",
-        "Use a JSON object with goal_restatement, proposed_criteria, expected_tools,",
-        "open_questions, and ready_to_start.",
+        "When your implementation is complete, leave a concise final reply with the files changed and verification you ran. Do not call `conveyor finish-task`; the manager owns criteria satisfaction and audited task closeout.",
     ].join("\n");
 }
 function createPairRunSync(database, options) {
@@ -16489,6 +16614,9 @@ function disposableWorkerHandoff(taskName, runName, dbPath) {
         `You are the worker for task ${taskName}${loopClause}.`,
         "Keep polling your Conveyor worker inbox until there are no items left or the loop reaches max_iterations. Consume the next item now, treat each consumed item as the manager's next instruction, complete the requested work, and report changed files, exact commands run, evidence, and any residual risk.",
         "",
+        "Because this is a pull-required Codex app/no-tmux session, autonomous operation requires a heartbeat/wake layer that repeats this worker inbox poll while the thread is idle. If no heartbeat automation is available, report the loop as manual-poll only.",
+        "Do not delete, pause, or disable heartbeat automation just because an inbox poll is idle; the manager or operator owns terminal loop teardown.",
+        "",
         `Run: ${sessionPollCommand("worker", taskName, dbPath)}`,
     ].join("\n");
 }
@@ -16503,14 +16631,72 @@ function renderDisposableBindingText(result) {
     }
     lines.push("Replay commands:");
     lines.push(...result.replay_commands.map((command) => `  ${command}`));
+    if (result.heartbeat_recommendations) {
+        lines.push("Heartbeat recommendations:");
+        lines.push(`  interval: every ${result.heartbeat_recommendations.interval_minutes} minutes`);
+        lines.push(`  manager: ${result.heartbeat_recommendations.manager.poll_command}`);
+        lines.push(`  worker: ${result.heartbeat_recommendations.worker.poll_command}`);
+        lines.push(`  teardown: ${result.heartbeat_recommendations.teardown_policy.idle_poll}`);
+        lines.push(`  closeout: ${result.heartbeat_recommendations.teardown_policy.terminal_closeout_command}`);
+    }
     lines.push("Worker handoff:");
     lines.push(result.worker_handoff);
     return `${lines.join("\n")}\n`;
 }
+function disposableHeartbeatRecommendations(taskName, dbPath) {
+    const terminalCloseoutCommand = `${conveyorPollInvocation()} finish-task ${shellQuote(taskName)} --reason ${shellQuote("Verified terminal closeout")} --require-criteria-audit --path ${shellQuote(dbPath)}`;
+    return {
+        applies_when: {
+            can_receive_push: false,
+            delivery_mode: "pull_required",
+            receive_style: "pull",
+            session_kind: "codex_app",
+        },
+        interval_minutes: 2,
+        note: "Dispatch can deliver pull-required inbox items, but Codex app/no-tmux sessions still need a heartbeat or operator wake-up to poll while idle.",
+        teardown_policy: {
+            idle_poll: "Never delete, pause, or disable a manager or worker heartbeat because an inbox poll returned no item; that is only a quiet poll interval.",
+            owner: "manager_or_operator",
+            terminal_closeout: "Only the manager or operator should tear down heartbeats, and only after a terminal manager decision plus verified task closeout, or after explicit operator instruction.",
+            terminal_closeout_command: terminalCloseoutCommand,
+            worker_rule: "The worker must not own loop teardown and must not remove heartbeat automation based on idle polling.",
+        },
+        manager: {
+            kind: "thread_heartbeat",
+            poll_command: sessionPollCommand("manager", taskName, dbPath),
+            prompt: [
+                "Use the manage-codex-workers skill.",
+                `Poll the manager inbox for task ${taskName}.`,
+                `Run: ${sessionPollCommand("manager", taskName, dbPath)}`,
+                "If an item is consumed, execute only that manager instruction, verify worker claims before recording conclusions, update Conveyor state as appropriate, and produce exactly one next worker task.",
+                "If no item is consumed, stop after a one-line idle receipt.",
+                "Do not delete, pause, or disable manager or worker heartbeat automation after an idle poll; an idle poll is only a quiet interval.",
+                `If all accepted criteria are satisfied, deferred, or rejected and there is no next worker task, record the terminal manager decision, run or report the result of: ${terminalCloseoutCommand}`,
+                "After verified task closeout, explicitly report heartbeat teardown status; if the task remains managed/active, report that as a control-plane blocker instead of calling the loop complete.",
+            ].join("\n"),
+        },
+        worker: {
+            kind: "thread_heartbeat",
+            poll_command: sessionPollCommand("worker", taskName, dbPath),
+            prompt: [
+                "Use the manage-codex-workers skill.",
+                `Poll the worker inbox for task ${taskName}.`,
+                `Run: ${sessionPollCommand("worker", taskName, dbPath)}`,
+                "If an item is consumed, execute only that single worker instruction and return exact commands, compact evidence, blockers/residual risk, and exactly one next recommended worker task.",
+                "If no item is consumed, stop after a one-line idle receipt.",
+                "Do not delete, pause, or disable worker heartbeat automation after an idle poll; the manager or operator owns terminal loop teardown.",
+            ].join("\n"),
+        },
+    };
+}
 function sessionPollCommand(role, taskName, dbPath) {
     const inbox = role === "worker" ? "worker-inbox" : "manager-inbox";
     const task = taskName ? shellQuote(taskName) : "<task>";
-    return `conveyor ${inbox} ${task} --consume-next --wait --timeout 60 --path ${shellQuote(dbPath)} --json`;
+    return `${conveyorPollInvocation()} ${inbox} ${task} --consume-next --wait --timeout 60 --path ${shellQuote(dbPath)} --json`;
+}
+function conveyorPollInvocation() {
+    const binDir = join(packageRootFromRuntimeModule(), "bin");
+    return pathIsExecutable(join(binDir, "conveyor")) ? `PATH=${shellQuote(binDir)}:$PATH conveyor` : "conveyor";
 }
 function resolveCodexStartupOptions(options) {
     const defaults = {
@@ -16660,16 +16846,20 @@ function startManagerBootstrapPrompt(database, options) {
     const goalLine = options.taskGoal ?? context?.goal ?? "No task goal supplied yet.";
     const workerLine = options.workerName ?? "No worker session supplied yet.";
     const workerctl = "conveyor";
+    const pathSuffix = commandPathSuffix(options.dbPath);
     const setupCommand = options.taskName
-        ? `${workerctl} manager-config ${taskLine} --questions`
-        : `${workerctl} manager-config <task> --questions`;
-    const cycleCommand = options.taskName ? `${workerctl} cycle ${taskLine}` : `${workerctl} cycle <task>`;
+        ? `${workerctl} manager-config ${taskLine} --questions${pathSuffix}`
+        : `${workerctl} manager-config <task> --questions${pathSuffix}`;
+    const cycleCommand = options.taskName ? `${workerctl} cycle ${taskLine}${pathSuffix}` : `${workerctl} cycle <task>${pathSuffix}`;
     const managerAckCommand = options.taskName
-        ? `${workerctl} manager-ack ${taskLine} --from-stdin`
-        : `${workerctl} manager-ack <task> --from-stdin`;
+        ? `${workerctl} manager-ack ${taskLine} --from-stdin${pathSuffix}`
+        : `${workerctl} manager-ack <task> --from-stdin${pathSuffix}`;
     const workerAckCommand = options.taskName
-        ? `${workerctl} worker-ack ${taskLine} --json`
-        : `${workerctl} worker-ack <task> --json`;
+        ? `${workerctl} worker-ack ${taskLine} --json${pathSuffix}`
+        : `${workerctl} worker-ack <task> --json${pathSuffix}`;
+    const satisfyCriterionCommand = options.taskName
+        ? `${workerctl} criteria ${taskLine} --satisfy <id> --proof "<proof>" --evidence-json '{"status":"pass","command":"<command>","summary":"<what this proved>"}'${pathSuffix}`
+        : `${workerctl} criteria <task> --satisfy <id> --proof "<proof>" --evidence-json '{"status":"pass","command":"<command>","summary":"<what this proved>"}'${pathSuffix}`;
     const config = context ? managerConfigSync(database, context.id) : null;
     const initialSetup = config
         ? seededManagerConfigSetup({ config, cycleCommand, managerAckCommand, workerAckCommand })
@@ -16677,11 +16867,12 @@ function startManagerBootstrapPrompt(database, options) {
             "Initial setup:",
             `1. Run \`${setupCommand}\`.`,
             "2. Ask the user the returned setup questions in this manager Codex chat.",
-            `3. Persist the answers with \`${workerctl} manager-config\`.`,
+            `3. Persist the answers with \`${workerctl} manager-config${pathSuffix}\`.`,
             "4. Use `conveyor manager-config --interactive` only when a human is directly running conveyor in a terminal.",
             "",
             "Acknowledgement:",
             `- Before your first cycle, record the supervision contract you are committing to with \`${managerAckCommand}\`.`,
+            `  Example JSON: {"task":"${taskLine}","manager_session":"${options.managerName}","supervision_contract":"I will supervise through Conveyor and verify criteria before finishing.","will_not_edit_project_files":true}`,
             `- Before nudging or finishing, inspect the worker acknowledgement with \`${workerAckCommand}\` when available.`,
         ].join("\n");
     return [
@@ -16704,7 +16895,8 @@ function startManagerBootstrapPrompt(database, options) {
         "- Inspect `manager_context.acceptance_criteria` each cycle.",
         "- If worker progress reveals new edge cases, tests, polish, or scope boundaries, ask the worker to propose must-have vs follow-up criteria.",
         "- Before finishing, compare worker receipts/verification against accepted open criteria.",
-        `- When all accepted criteria are satisfied, deferred, or rejected, finish the task with \`${workerctl} finish-task ${taskLine} --reason "Accepted criteria satisfied" --require-criteria-audit\`.`,
+        `- For each accepted criterion that is proven, record evidence with \`${satisfyCriterionCommand}\`.`,
+        `- When all accepted criteria are satisfied, deferred, or rejected, finish the task with \`${workerctl} finish-task ${taskLine} --reason "Accepted criteria satisfied" --require-criteria-audit${pathSuffix}\`.`,
         "- Communicate with the worker only through conveyor session/task commands.",
         "- Do not edit project files unless the user explicitly asks this manager session to change Agent Conveyor itself.",
     ].join("\n");
@@ -16719,7 +16911,7 @@ function seededManagerConfigSetup(options) {
     if (options.config.tools.length > 0) {
         lines.push(`Expected tools: ${options.config.tools.join(", ")}.`);
     }
-    lines.push("", "Acknowledgement:", `- Before your first cycle, record the supervision contract you are committing to with \`${options.managerAckCommand}\`.`, `- Before nudging or finishing, inspect the worker acknowledgement with \`${options.workerAckCommand}\` when available.`);
+    lines.push("", "Acknowledgement:", `- Before your first cycle, record the supervision contract you are committing to with \`${options.managerAckCommand}\`.`, `  Example JSON: {"task":"${options.config.task_id}","supervision_contract":"I will supervise through Conveyor and verify criteria before finishing.","will_not_edit_project_files":true}`, `- Before nudging or finishing, inspect the worker acknowledgement with \`${options.workerAckCommand}\` when available.`);
     return lines.join("\n");
 }
 function startManagerTaskContext(database, taskName) {
@@ -16733,6 +16925,9 @@ function startManagerTaskContext(database, taskName) {
 function shellQuote(value) {
     return `'${value.replace(/'/g, "'\"'\"'")}'`;
 }
+function commandPathSuffix(dbPath) {
+    return dbPath ? ` --path ${shellQuote(dbPath)}` : "";
+}
 function emitTelemetrySync(database, options) {
     const eventId = `telemetry-${randomUUID()}`;
     const attributesJson = stableJson(options.attributes);
@@ -18191,9 +18386,8 @@ The supported manager/worker setup is session-based:
 
    ${workerctl} worker-ack <task-name> --from-stdin
 
-   The JSON should include goal_restatement, proposed_criteria,
-   expected_tools, open_questions, and ready_to_start. Proposed criteria should
-   separate must-have and follow-up criteria.
+   Example JSON:
+   {"goal_restatement":"Restate the assigned task.","proposed_criteria":{"must_have":["Current-task proof"],"follow_up":[]},"expected_tools":["shell"],"open_questions":[],"ready_to_start":true}
 
 Required fields:
 - worker name
@@ -18280,6 +18474,14 @@ function ensureTmuxAvailable(runner) {
     const detail = (result.stderr || result.stdout || `exit code ${result.status}`).trim();
     return lifecycleWorkerErrorResult(tmuxCommandFailureMessage(["tmux", "-V"], detail));
 }
+function ensureTmuxServerAccessible(runner) {
+    const result = runner(["tmux", "start-server"], { check: false });
+    if (result.status === 0) {
+        return null;
+    }
+    const detail = (result.stderr || result.stdout || `exit code ${result.status}`).trim();
+    return lifecycleWorkerErrorResult(tmuxCommandFailureMessage(["tmux", "start-server"], detail));
+}
 const CONTENT_KEYS = new Set(["content", "message", "output", "segment_text", "text"]);
 function redactPayload(value) {
     if (Array.isArray(value)) {