agent-conveyor 0.1.12 → 0.1.14

package/dist/cli/typescript-runtime.js

@@ -5,7 +5,7 @@ import { homedir, tmpdir } from "node:os";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { taskAuditSync } from "../runtime/audit.js";
-import { appAutopilotPlanSync, appLoopStatusSync, appWakeupDispatchPlanSync, appWakeupPlanSync, directInboxPollCommand, } from "../runtime/app-autonomy.js";
+import { appAutopilotPlanSync, appLoopStatusSync, appWakeupDispatchPlanSync, appWakeupPlanSync, directInboxPollCommand, visibleSessionProtocolLines, } from "../runtime/app-autonomy.js";
 import { classifyBusyWait, classifyStartupOutput } from "../runtime/classify.js";
 import { exportTaskSync } from "../runtime/export.js";
 import { ingestSessionSync } from "../runtime/ingest.js";
@@ -368,10 +368,10 @@ function commandHelpText(program, command) {
             `  ${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}`,
+            `usage: ${program} finish-task <task> --reason <reason> [--require-criteria-audit] ${path} [--json]`,
             "",
             "Examples:",
-            `  ${program} finish-task my-task --reason "Accepted criteria satisfied" --require-criteria-audit --path /tmp/work/workerctl.db`,
+            `  ${program} finish-task my-task --reason "Accepted criteria satisfied" --require-criteria-audit --path /tmp/work/workerctl.db --json`,
         ],
         "manager-ack": [
             `usage: ${program} manager-ack <task> --from-stdin ${path}`,
@@ -389,7 +389,7 @@ function commandHelpText(program, command) {
             `  ${program} dispatch --once --type nudge_worker --path /tmp/work/workerctl.db`,
         ],
         "app-autopilot": [
-            `usage: ${program} app-autopilot start|stop|status <task> [--dispatcher-id ID] [--interval SECONDS] [--watch-iterations N] [--stale-after N] ${path} [--json]`,
+            `usage: ${program} app-autopilot start|stop|status <task> [--dispatcher-id ID] [--interval SECONDS] [--watch-iterations N] [--stale-after N] [--quiet-after N] ${path} [--json]`,
             "",
             "Manage the app-native heartbeat policy for a bound manager/worker pair.",
             "The CLI records policy receipts and emits Codex app heartbeat automation specs; app-thread automation creation still happens through Codex app tools.",
@@ -528,6 +528,7 @@ function parseRuntimeArgs(args, env) {
         source: null,
         proof: null,
         purpose: null,
+        quietAfterCycles: 3,
         questions: false,
         rationale: null,
         receiptOutput: null,
@@ -2496,6 +2497,21 @@ function parseRuntimeArgs(args, env) {
             flags.appStaleAfterSeconds = value;
             index += 1;
         }
+        else if (arg === "--quiet-after") {
+            if (command !== "app-autopilot") {
+                return { command, enabled, error: "Unsupported TypeScript runtime option: --quiet-after", explicit, flags, task };
+            }
+            const parsedValue = valueAfter(queue, index, arg);
+            if (parsedValue.error) {
+                return { command, enabled, error: parsedValue.error, explicit, flags, task };
+            }
+            const value = Number(parsedValue.value);
+            if (!Number.isInteger(value) || value < 0) {
+                return { command, enabled, error: "--quiet-after must be a non-negative integer.", explicit, flags, task };
+            }
+            flags.quietAfterCycles = value;
+            index += 1;
+        }
         else if (arg === "--terminal-stale-seconds") {
             if (command !== "idle-check") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --terminal-stale-seconds", explicit, flags, task };
@@ -2838,7 +2854,7 @@ function parseRuntimeArgs(args, env) {
             }
         }
         else if (command === "loop-evidence" && flags.subtype === null) {
-            if (!["add", "visual-diff", "visual_diff", "adversarial-check", "adversarial_check"].includes(arg)) {
+            if (!["add", "visual-diff", "visual_diff", "build-passed", "build_passed", "adversarial-check", "adversarial_check"].includes(arg)) {
                 return { command, enabled, error: `Unsupported loop-evidence action: ${arg}`, explicit, flags, task };
             }
             flags.subtype = arg;
@@ -3148,7 +3164,7 @@ function runLoopEvidenceCommand(parsed, options) {
     }
     const action = parsed.flags.subtype;
     if (!action) {
-        return unsupportedRuntimeResult(parsed, "loop-evidence requires an action: add, visual-diff, or adversarial-check.");
+        return unsupportedRuntimeResult(parsed, "loop-evidence requires an action: add, visual-diff, build-passed, or adversarial-check.");
     }
     const task = requireTask(parsed);
     if (!parsed.flags.loopRun) {
@@ -3175,6 +3191,24 @@ function runLoopEvidenceCommand(parsed, options) {
             });
             return jsonResult(result);
         }
+        if (action === "build-passed" || action === "build_passed") {
+            if (parsed.flags.evidenceType && parsed.flags.evidenceType !== "build_passed") {
+                return errorResult("loop-evidence build-passed records evidence_type=build_passed; omit --evidence-type or use build_passed.");
+            }
+            const result = recordLoopEvidenceSync(database, {
+                artifactPath: parsed.flags.output,
+                correlationId: parsed.flags.correlationId,
+                evidenceType: "build_passed",
+                iteration: parsed.flags.currentIteration,
+                loopRunId: parsed.flags.loopRun,
+                metadata: jsonObjectArg(parsed.flags.metadataJson, "--metadata-json"),
+                proof: parsed.flags.proof,
+                source,
+                status: parsed.flags.statusState ?? "pass",
+                task,
+            });
+            return jsonResult(result);
+        }
         if (action === "adversarial-check" || action === "adversarial_check") {
             const result = recordAdversarialLoopEvidenceSync(database, {
                 artifactPath: parsed.flags.output,
@@ -3738,6 +3772,7 @@ function runAppAutopilotCommand(parsed, options) {
             heartbeatIntervalMinutes: 2,
             heartbeatStaleSeconds: parsed.flags.appStaleAfterSeconds,
             now: timestamp,
+            quietAfterCycles: parsed.flags.quietAfterCycles,
             taskName,
             watchIterations: parsed.flags.watchIterations ?? 1000000,
         });
@@ -3759,6 +3794,7 @@ function runAppAutopilotCommand(parsed, options) {
                     dispatcher_command: plan.control.dispatcher_command,
                     dispatcher_id: dispatcherId,
                     interval_minutes: plan.interval_minutes,
+                    quiescence: plan.quiescence,
                     summary: plan.summary,
                 },
                 correlation: {
@@ -3918,6 +3954,13 @@ function renderAppAutopilotText(result) {
         `Dispatch command: ${result.plan.control.dispatcher_command}`,
         `Wake dispatch: ${result.plan.control.wakeup_dispatch_command}`,
     ];
+    if (result.plan.quiescence.recommended_action === "stop_autopilot") {
+        lines.push(`Quiescence: stop recommended - ${result.plan.quiescence.reason}`);
+        lines.push(`Stop command: ${result.plan.control.stop_command}`);
+    }
+    else {
+        lines.push(`Quiescence: ${result.plan.quiescence.state} (${result.plan.quiescence.quiet_cycles}/${result.plan.quiescence.threshold_cycles} quiet cycles)`);
+    }
     if (result.receipt) {
         lines.push(`Receipt: ${result.receipt.event_type} ${result.receipt.event_id}`);
     }
@@ -4024,6 +4067,7 @@ const QA_PLAN_SCENARIOS = new Set([
     "tmux-errors",
     "dispatch-completion",
     "ralph-loop",
+    "ship-it-loop",
     "adversarial-triggers",
     "goalbuddy-conveyor",
 ]);
@@ -4157,6 +4201,52 @@ function qaPlan(scenario) {
             ],
         };
     }
+    if (scenario === "ship-it-loop") {
+        return {
+            authority_boundaries: [
+                "Do not push a branch before repo.push_branch is permitted.",
+                "Do not open or update a PR before repo.open_pr is permitted.",
+                "Do not treat CI monitoring as CI truth; record explicit ci_green evidence.",
+                "Do not resolve conflicts without a bounded manager instruction and retry limit.",
+                "Do not merge before repo.merge_green_pr, ci_green, mergeability, manager_merge_decision, merge, post_merge_verification, and adversarial_check evidence exist.",
+            ],
+            correlation_markers: [
+                { correlation_id: "ship-it-push-permission", purpose: "push branch permission gate" },
+                { correlation_id: "ship-it-open-pr-permission", purpose: "open PR permission gate" },
+                { correlation_id: "ship-it-merge-permission", purpose: "merge permission gate" },
+                { correlation_id: "ship-it-missing-evidence", purpose: "missing lifecycle evidence block" },
+                { correlation_id: "ship-it-conflict-block", purpose: "conflict retry limit proof" },
+                { correlation_id: "ship-it-allowed-closeout", purpose: "allowed closeout after all lifecycle evidence" },
+            ],
+            evidence_template: {
+                branch_ready: { branch: "<branch>", commit_sha: "<sha>" },
+                branch_pushed: { remote: "origin", branch: "<branch>" },
+                pr_url: { url: "<pull request URL>" },
+                ci_green: { command: "gh pr checks --required", status: "green" },
+                mergeability_clean: { conflicts: false, mergeable_state: "clean" },
+                manager_merge_decision: { decision: "merge_ready", manager_verified: true },
+                merge: { merge_sha: "<sha>" },
+                post_merge_verification: { command: "<post-merge check>", status: "pass" },
+                adversarial_check: { failure_mode: "<risk>", check: "<proof>", result: "<outcome>" },
+            },
+            expected_observations: [
+                "push, PR creation, and merge commands fail closed until their manager permissions are granted",
+                "missing lifecycle evidence blocks a continue_iteration before worker delivery",
+                "unresolved conflicts are represented as bounded blockers, not hidden behind CI green",
+                "a fresh retry delivers only after branch, PR, CI, mergeability, manager decision, merge, post-merge, and adversarial evidence exists",
+                "the recipe and prompts keep merge readiness as a manager decision, not a worker claim",
+            ],
+            scenario,
+            steps: [
+                "Create a disposable no-tmux task with the ship_it_loop template.",
+                "Run the permission-gate checks for repo.push_branch, repo.open_pr, and repo.merge_green_pr.",
+                "Attempt a lifecycle continuation before evidence and verify missing evidence blocks before worker delivery.",
+                "Record partial PR/CI evidence and verify mergeability/manager-decision/merge/post-merge proof is still required.",
+                "Record conflict retry-limit evidence as blocked when unresolved.",
+                "Record all lifecycle receipts plus structured adversarial proof and verify a fresh retry reaches the worker inbox.",
+            ],
+        };
+    }
     if (scenario === "adversarial-triggers") {
         return {
             correlation_markers: [
@@ -4257,6 +4347,7 @@ const SUPPORTED_QA_RUN_SCENARIOS = new Set([
     "generic-loop-template",
     "generic-loop-template-browser",
     "ralph-loop-guardrails",
+    "ship-it-loop",
     "test-coverage-loop",
 ]);
 function isSupportedQaRunScenario(scenario) {
@@ -4299,6 +4390,9 @@ function runQaScenario(scenario, context) {
     if (scenario === "build-clear-loop") {
         return qaRunBuildClearLoop(context);
     }
+    if (scenario === "ship-it-loop") {
+        return qaRunShipItLoop(context);
+    }
     if (scenario === "adversarial-triggers") {
         return qaRunAdversarialTriggers(context);
     }
@@ -4644,6 +4738,166 @@ function qaRunBuildClearLoop(context) {
         template_metadata: templateMetadata,
     };
 }
+function qaRunShipItLoop(context) {
+    const slug = randomUUID().slice(0, 8);
+    const checks = [];
+    const generatedTasks = [];
+    const pushTask = createQaBoundTask(context, slug, "ship-it-push-permission");
+    generatedTasks.push(generatedTask(pushTask, "ship-it-push-permission"));
+    checks.push(qaRunPermissionGate(context, pushTask, {
+        checkName: "ship_it_push_branch_requires_repo_push_branch",
+        correlationId: "ship-it-push-permission-denied",
+        message: "Push branch origin/codex/ship-it-loop.",
+        permission: "repo.push_branch",
+    }));
+    qaConfigureManagerPermissions(context, pushTask, ["repo.push_branch"]);
+    checks.push(qaRunPermissionGate(context, pushTask, {
+        checkName: "ship_it_push_branch_delivers_after_permission",
+        correlationId: "ship-it-push-permission-allowed",
+        expectAllowed: true,
+        message: "Push branch origin/codex/ship-it-loop after manager permission.",
+        permission: "repo.push_branch",
+    }));
+    const prTask = createQaBoundTask(context, slug, "ship-it-open-pr-permission");
+    generatedTasks.push(generatedTask(prTask, "ship-it-open-pr-permission"));
+    checks.push(qaRunPermissionGate(context, prTask, {
+        checkName: "ship_it_open_pr_requires_repo_open_pr",
+        correlationId: "ship-it-open-pr-permission-denied",
+        message: "Open PR for ship-it loop.",
+        permission: "repo.open_pr",
+    }));
+    qaConfigureManagerPermissions(context, prTask, ["repo.open_pr"]);
+    checks.push(qaRunPermissionGate(context, prTask, {
+        checkName: "ship_it_open_pr_delivers_after_permission",
+        correlationId: "ship-it-open-pr-permission-allowed",
+        expectAllowed: true,
+        message: "Open PR for ship-it loop after manager permission.",
+        permission: "repo.open_pr",
+    }));
+    const mergeTask = createQaBoundTask(context, slug, "ship-it-merge-permission");
+    generatedTasks.push(generatedTask(mergeTask, "ship-it-merge-permission"));
+    checks.push(qaRunPermissionGate(context, mergeTask, {
+        checkName: "ship_it_merge_requires_repo_merge_green_pr",
+        correlationId: "ship-it-merge-permission-denied",
+        message: "Merge PR after verified closeout.",
+        permission: "repo.merge_green_pr",
+    }));
+    qaConfigureManagerPermissions(context, mergeTask, ["repo.merge_green_pr"]);
+    checks.push(qaRunPermissionGate(context, mergeTask, {
+        checkName: "ship_it_merge_delivers_after_permission",
+        correlationId: "ship-it-merge-permission-allowed",
+        expectAllowed: true,
+        message: "Merge PR after verified closeout and manager permission.",
+        permission: "repo.merge_green_pr",
+    }));
+    const lifecycleTask = createQaBoundTask(context, slug, "ship-it-lifecycle");
+    generatedTasks.push(generatedTask(lifecycleTask, "ship-it-lifecycle"));
+    const templateMetadata = loopTemplateMetadata("ship_it_loop", {
+        currentIteration: 1,
+        maxIterations: 2,
+        seedPromptSha256: "qa-run-ship-it-seed",
+    });
+    const run = createQaRalphLoopRun(context, lifecycleTask, {
+        currentIteration: 1,
+        maxIterations: 2,
+        metadata: templateMetadata,
+        preset: "ship_it_loop",
+        requiredBeforeContinue: asStringArray(templateMetadata.required_before_continue),
+        seedPromptSha256: "qa-run-ship-it-seed",
+        stopConditions: asStringArray(templateMetadata.stop_conditions),
+    });
+    enqueueQaContinue(context, lifecycleTask, run.id, "ship-it-missing-evidence", "Run ship-it continuation before lifecycle evidence.");
+    const missing = qaDispatchContinueOnce(context, "ship-it-missing-evidence");
+    const missingCounts = qaDeliveryCounts(context, lifecycleTask);
+    qaExpectBlocked(missing, missingCounts, {
+        message: "ship_it_loop missing lifecycle evidence",
+        missingEvidence: asStringArray(templateMetadata.required_before_continue),
+        reason: "missing_required_evidence",
+    });
+    checks.push(qaCheck("ship_it_lifecycle_blocks_before_any_evidence", missing, missingCounts));
+    qaRecordLoopEvidence(context, lifecycleTask, run.id, "branch_ready", "ship-it-branch-ready", {
+        metadata: { branch: "codex/ship-it-loop", commit_sha: "1111111111111111111111111111111111111111" },
+    });
+    qaRecordLoopEvidence(context, lifecycleTask, run.id, "branch_pushed", "ship-it-branch-pushed", {
+        metadata: { branch: "codex/ship-it-loop", remote: "origin" },
+    });
+    qaRecordLoopEvidence(context, lifecycleTask, run.id, "pr_url", "ship-it-pr-url", {
+        metadata: { url: "https://github.example.test/acme/repo/pull/42" },
+    });
+    qaRecordLoopEvidence(context, lifecycleTask, run.id, "ci_green", "ship-it-ci-green", {
+        metadata: { command: "gh pr checks 42 --required", status: "green" },
+        status: "green",
+    });
+    enqueueQaContinue(context, lifecycleTask, run.id, "ship-it-partial-evidence", "Run ship-it continuation after PR and CI but before merge readiness.");
+    const partial = qaDispatchContinueOnce(context, "ship-it-partial-evidence");
+    const partialCounts = qaDeliveryCounts(context, lifecycleTask);
+    qaExpectBlocked(partial, partialCounts, {
+        message: "ship_it_loop partial lifecycle evidence",
+        missingEvidence: ["mergeability_clean", "manager_merge_decision", "merge", "post_merge_verification", "adversarial_check"],
+        reason: "missing_required_evidence",
+    });
+    checks.push(qaCheck("ship_it_lifecycle_blocks_before_mergeability_and_manager_decision", partial, partialCounts));
+    const artifactDir = qaArtifactDir(context, "ship-it-loop", slug, run.id);
+    const conflictReceipt = join(artifactDir, "conflict-blocked.json");
+    mkdirSync(dirname(conflictReceipt), { recursive: true });
+    const conflictPayload = {
+        conflict_state: "unresolved",
+        max_retries: 2,
+        retry_count: 2,
+        status: "blocked",
+        stop_reason: "conflict_retry_limit_reached",
+    };
+    writeFileSync(conflictReceipt, `${JSON.stringify(sortJson(conflictPayload), null, 2)}\n`);
+    checks.push({
+        artifact_path: conflictReceipt,
+        conflict: conflictPayload,
+        name: "ship_it_conflict_retry_blocks_after_limit",
+        status: "passed",
+    });
+    qaRecordLoopEvidence(context, lifecycleTask, run.id, "mergeability_clean", "ship-it-mergeability-clean", {
+        metadata: { conflicts: false, mergeable_state: "clean" },
+    });
+    qaRecordLoopEvidence(context, lifecycleTask, run.id, "manager_merge_decision", "ship-it-manager-merge-decision", {
+        metadata: { decision: "merge_ready", manager_verified: true },
+    });
+    qaRecordLoopEvidence(context, lifecycleTask, run.id, "merge", "ship-it-merge", {
+        metadata: { merge_sha: "2222222222222222222222222222222222222222" },
+    });
+    qaRecordLoopEvidence(context, lifecycleTask, run.id, "post_merge_verification", "ship-it-post-merge-verification", {
+        metadata: { command: "git rev-parse HEAD && npm test -- --runInBand", status: "pass" },
+    });
+    qaRecordAdversarialEvidence(context, lifecycleTask, run.id, "ship-it-adversarial-proof", {
+        check: "Inspect permission denials, missing-evidence blocks, conflict retry receipt, and final evidence set.",
+        failure_mode: "A ship-it loop could merge after CI green while conflicts, manager decision, or post-merge proof are missing.",
+        result: "Dispatch stayed blocked until mergeability, manager decision, merge, post-merge, and adversarial receipts were present.",
+    });
+    enqueueQaContinue(context, lifecycleTask, run.id, "ship-it-allowed-closeout", "Run ship-it continuation after all lifecycle evidence.");
+    const allowed = qaDispatchContinueOnce(context, "ship-it-allowed-closeout");
+    const allowedCounts = qaDeliveryCounts(context, lifecycleTask);
+    qaExpectDelivered(allowed, allowedCounts, "ship_it_loop allowed closeout");
+    checks.push(qaCheck("ship_it_lifecycle_retry_delivers_after_all_evidence", allowed, allowedCounts));
+    return {
+        artifacts: { conflict_receipt: conflictReceipt, db_path: context.dbPath },
+        checks,
+        generated_at: new Date().toISOString(),
+        generated_tasks: generatedTasks,
+        replay_commands: [
+            "conveyor loop-templates --show ship_it_loop --json",
+            "conveyor manager-recipes --show ship-it-loop --json",
+            "conveyor manager-permission <task> repo.push_branch --require",
+            "conveyor manager-permission <task> repo.open_pr --require",
+            "conveyor manager-permission <task> repo.merge_green_pr --require",
+            "conveyor loop-evidence add <task> --loop-run <run-id> --iteration 1 --evidence-type branch_ready",
+            "conveyor loop-evidence add <task> --loop-run <run-id> --iteration 1 --evidence-type ci_green",
+            "conveyor loop-evidence adversarial-check <task> --loop-run <run-id> --iteration 1 --failure-mode <failure> --check <check> --result <result>",
+            `conveyor dispatch --once --type continue_iteration --dispatcher-id ${context.dispatcherId} --path ${context.dbPath}`,
+        ],
+        result: "passed",
+        scenario: "ship-it-loop",
+        template: "ship_it_loop",
+        template_metadata: templateMetadata,
+    };
+}
 function qaRunAdversarialTriggers(context) {
     const slug = randomUUID().slice(0, 8);
     const triggerDefinitions = listLoopTriggers();
@@ -4941,24 +5195,27 @@ function enqueueQaContinue(context, task, runId, correlationId, message) {
     }
 }
 function qaDispatchContinueOnce(context, expectedCorrelationId) {
+    return qaDispatchCommandOnce(context, "continue_iteration", expectedCorrelationId);
+}
+function qaDispatchCommandOnce(context, commandType, expectedCorrelationId) {
     const before = openDatabaseSync(context.dbPath);
     try {
         initializeDatabaseSync(before);
         const rows = before.prepare(`
       select correlation_id, state
       from commands
-      where type = 'continue_iteration' and state in ('pending', 'attempted')
+      where type = ? and state in ('pending', 'attempted')
       order by created_at, id
-    `).all();
+    `).all(commandType);
         const seen = rows.map((row) => `${row.correlation_id}:${row.state}`);
         if (rows.length !== 1 || rows[0]?.correlation_id !== expectedCorrelationId || rows[0]?.state !== "pending") {
-            throw new Error(`qa-run continue_iteration dispatch queue is not clean; expected only ${expectedCorrelationId}, found ${JSON.stringify(seen)}`);
+            throw new Error(`qa-run ${commandType} dispatch queue is not clean; expected only ${expectedCorrelationId}, found ${JSON.stringify(seen)}`);
         }
     }
     finally {
         before.close();
     }
-    const parsed = parseRuntimeArgs(["dispatch", "--type", "continue_iteration", "--path", context.dbPath], {
+    const parsed = parseRuntimeArgs(["dispatch", "--type", commandType, "--path", context.dbPath], {
         AGENT_CONVEYOR_TS_RUNTIME: "1",
     });
     const processed = dispatchOncePass(parsed, context.runtimeOptions, {
@@ -4968,13 +5225,68 @@ function qaDispatchContinueOnce(context, expectedCorrelationId) {
         limit: 1,
     });
     if (processed.length !== 1) {
-        throw new Error(`expected exactly one continue_iteration dispatch item, got ${processed.length}`);
+        throw new Error(`expected exactly one ${commandType} dispatch item, got ${processed.length}`);
     }
     if (processed[0]?.correlation_id !== expectedCorrelationId) {
         throw new Error(`qa-run dispatched unexpected command ${String(processed[0]?.correlation_id)}`);
     }
     return processed[0] ?? {};
 }
+function qaConfigureManagerPermissions(context, task, permissions) {
+    const result = runTypescriptRuntimeCommand({
+        ...context.runtimeOptions,
+        args: [
+            "manager-config",
+            task.task_name,
+            "--mode",
+            "strict",
+            "--objective",
+            "Ship-it lifecycle QA permission contract.",
+            ...permissions.flatMap((permission) => ["--permit", permission]),
+            "--path",
+            context.dbPath,
+        ],
+        env: {
+            ...(context.runtimeOptions.env ?? {}),
+            AGENT_CONVEYOR_TS_RUNTIME: "1",
+        },
+    });
+    qaRequire(result.exitCode === 0, `manager-config permission setup failed: ${result.stderr ?? result.stdout ?? ""}`);
+}
+function qaRunPermissionGate(context, task, options) {
+    const database = openDatabaseSync(context.dbPath);
+    try {
+        initializeDatabaseSync(database);
+        createCommandSync(database, {
+            commandType: "nudge_worker",
+            correlationId: options.correlationId,
+            payload: { message: options.message, ship_it: { required_permission: options.permission } },
+            requiredPermission: options.permission,
+            taskId: task.task_id,
+        });
+    }
+    finally {
+        database.close();
+    }
+    const dispatch = qaDispatchCommandOnce(context, "nudge_worker", options.correlationId);
+    const counts = qaDeliveryCounts(context, task);
+    if (options.expectAllowed === true) {
+        qaExpectDelivered(dispatch, counts, `${options.permission} permission gate`);
+    }
+    else {
+        qaRequire(dispatch.state === "failed", `${options.permission} gate did not fail without permission`);
+        qaRequire(String(dispatch.error ?? "").includes("manager permission required"), `${options.permission} gate failed for the wrong reason`);
+        qaRequire(counts.worker_inbox_count === 0, `${options.permission} denied gate left worker inbox mail`);
+    }
+    return {
+        ...counts,
+        command_type: "nudge_worker",
+        dispatch,
+        name: options.checkName,
+        permission: options.permission,
+        status: "passed",
+    };
+}
 function qaDeliveryCounts(context, task) {
     const database = openDatabaseSync(context.dbPath);
     try {
@@ -11917,8 +12229,10 @@ const MANAGER_PERMISSION_ACTION_NAMES = new Set([
     "context.fetch_prs",
     "context.spawn_reviewer",
     "repo.merge_green_pr",
+    "repo.monitor_ci",
     "repo.open_pr",
     "repo.push_branch",
+    "repo.resolve_conflicts",
     "verification.run_cargo",
     "verification.run_playwright",
     "verification.run_pytest",
@@ -14075,6 +14389,7 @@ const DEFERRED_HEADING_RE = /\b(follow[- ]?up|deferred)\b/i;
 const LIST_ITEM_RE = /^\s*(?:[-*+]|\d+[.)]|\[[ xX]\])\s+(?<text>.+?)\s*$/;
 const EMPTY_ITEM_RE = /^(?:n\/?a|none|no follow[- ]?ups?|no deferred(?: criteria)?|nothing)$/i;
 const INDENTED_CONTINUATION_RE = /^\s+\S/;
+const CLOSEOUT_CRITERION_RE = /\b(?:finish-task|require-criteria-audit|task (?:is )?(?:marked )?done|mark(?:ed)? (?:the )?task done|terminal closeout|verified task closeout|heartbeat teardown|final manager (?:report|decision)|manager final (?:report|handoff)|closeout proof|control-plane closeout)\b/i;
 function planCriteriaCommands(task, text, options) {
     const { suggestions, warnings } = parseWorkerCriteriaResponse(text);
     return {
@@ -14136,6 +14451,11 @@ function parseWorkerCriteriaResponse(text) {
     else if (suggestions.length === 0) {
         warnings.push("Clear criteria headings were found, but no bullet or numbered criteria items were detected.");
     }
+    for (const suggestion of suggestions) {
+        if (suggestion.classification?.kind === "manager_closeout_proof") {
+            warnings.push(`Criterion "${suggestion.criterion}" appears to describe manager closeout/control-plane proof. Keep closeout proof in the manager final report, audit, replay, or epilogue evidence instead of accepted worker/task criteria unless this task is explicitly Conveyor closeout QA.`);
+        }
+    }
     return { suggestions, warnings };
 }
 function headingStatus(line) {
@@ -14157,12 +14477,23 @@ function makeCriteriaSuggestion(text, status) {
         return null;
     }
     return {
+        classification: classifyCriteriaSuggestion(criterion),
         criterion,
         rationale: status === "deferred" ? DEFAULT_DEFERRED_RATIONALE : null,
         source: "worker_proposed",
         status,
     };
 }
+function classifyCriteriaSuggestion(criterion) {
+    if (!CLOSEOUT_CRITERION_RE.test(criterion)) {
+        return null;
+    }
+    return {
+        kind: "manager_closeout_proof",
+        reason: "The criterion names manager closeout mechanics rather than the worker/task outcome being accepted.",
+        recommendation: "keep_out_of_acceptance_criteria",
+    };
+}
 function suggestionToArgv(task, suggestion, options) {
     const argv = [
         "conveyor",
@@ -14698,7 +15029,6 @@ function unsupportedLifecycleTaskOptions(parsed, finish) {
         || parsed.flags.includeFullTranscripts
         || parsed.flags.includeLegacy
         || parsed.flags.includeTranscripts
-        || parsed.flags.json
         || parsed.flags.limit !== null
         || parsed.flags.names.length > 0
         || parsed.flags.output !== null
@@ -15854,7 +16184,91 @@ const ADVERSARIAL_CHECK_REQUIREMENT = {
     required: ["failure_mode", "check", "result"],
     type: "object",
 };
+const SHIP_IT_ARTIFACT_REQUIREMENTS = {
+    adversarial_check: ADVERSARIAL_CHECK_REQUIREMENT,
+    branch_pushed: {
+        description: "Receipt that the worker branch was pushed only after repo.push_branch was permitted.",
+        properties: {
+            branch: { type: "string" },
+            remote: { type: "string" },
+        },
+        required: ["branch", "remote"],
+        type: "object",
+    },
+    branch_ready: {
+        description: "Branch and commit evidence for the candidate ship-it change.",
+        properties: {
+            branch: { type: "string" },
+            commit_sha: { type: "string" },
+        },
+        required: ["branch", "commit_sha"],
+        type: "object",
+    },
+    ci_green: {
+        description: "Explicit CI/check evidence. Prefer gh pr checks --required, or record why no required checks exist.",
+        properties: {
+            command: { type: "string" },
+            status: { type: "string" },
+        },
+        required: ["command", "status"],
+        type: "object",
+    },
+    manager_merge_decision: {
+        description: "Manager-owned decision that all required evidence has been independently verified and merge is allowed.",
+        properties: {
+            decision: { type: "string" },
+            manager_verified: { type: "boolean" },
+        },
+        required: ["decision", "manager_verified"],
+        type: "object",
+    },
+    merge: {
+        description: "Merge receipt recorded only after repo.merge_green_pr, CI, mergeability, and manager decision gates pass.",
+        properties: {
+            merge_sha: { type: "string" },
+        },
+        required: ["merge_sha"],
+        type: "object",
+    },
+    mergeability_clean: {
+        description: "Evidence that the PR is mergeable or conflicts were resolved within the manager-approved retry limit.",
+        properties: {
+            conflicts: { type: "boolean" },
+            mergeable_state: { type: "string" },
+        },
+        required: ["conflicts", "mergeable_state"],
+        type: "object",
+    },
+    post_merge_verification: {
+        description: "Post-merge or main-branch verification receipt.",
+        properties: {
+            command: { type: "string" },
+            status: { type: "string" },
+        },
+        required: ["command", "status"],
+        type: "object",
+    },
+    pr_url: {
+        description: "Pull request URL recorded only after repo.open_pr was permitted.",
+        properties: {
+            url: { type: "string" },
+        },
+        required: ["url"],
+        type: "object",
+    },
+};
 const LOOP_TEMPLATES = {
+    app_visible_build_loop: {
+        artifactRequirements: { adversarial_check: ADVERSARIAL_CHECK_REQUIREMENT },
+        cleanupPolicy: "off",
+        description: "Require build evidence and adversarial proof between visible Codex app iterations without a cleanup gate.",
+        maxIterations: 2,
+        name: "app_visible_build_loop",
+        recommendedTools: ["verification.run_tests"],
+        requiredBeforeContinue: ["build_passed", "adversarial_check"],
+        stopConditions: ["max_iterations", "required_evidence"],
+        tags: ["build", "codex_app", "visible_session"],
+    },
     build_then_clear: {
         artifactRequirements: {},
         cleanupPolicy: "clear",
@@ -15888,6 +16302,27 @@ const LOOP_TEMPLATES = {
         stopConditions: ["max_iterations", "required_evidence"],
         tags: ["repo", "ci"],
     },
+    ship_it_loop: {
+        artifactRequirements: SHIP_IT_ARTIFACT_REQUIREMENTS,
+        cleanupPolicy: "clear",
+        description: "Require branch, push, PR, CI, mergeability, manager merge decision, merge, post-merge, and adversarial evidence before ship-it continuation.",
+        maxIterations: 2,
+        name: "ship_it_loop",
+        recommendedTools: ["gh", "verification.run_tests", "git"],
+        requiredBeforeContinue: [
+            "branch_ready",
+            "branch_pushed",
+            "pr_url",
+            "ci_green",
+            "mergeability_clean",
+            "manager_merge_decision",
+            "merge",
+            "post_merge_verification",
+            "adversarial_check",
+        ],
+        stopConditions: ["max_iterations", "required_evidence", "manager_accepts"],
+        tags: ["repo", "ci", "merge", "ship_it"],
+    },
     test_coverage_loop: {
         artifactRequirements: { adversarial_check: ADVERSARIAL_CHECK_REQUIREMENT },
         cleanupPolicy: "clear",
@@ -16010,6 +16445,9 @@ const MANAGER_RECIPES = {
             "PR/CI/merge or satisfied_on_main proof",
             "parent receipt update before the next child",
         ],
+        finalReportRequirements: [
+            "Record manager closeout proof, including final task state and any finish-task/heartbeat teardown receipt, in the final report instead of accepted worker criteria.",
+        ],
         guidelines: [
             "Keep exactly one child board active at a time.",
             "Before activating the next child, update the parent receipt.",
@@ -16033,6 +16471,9 @@ const MANAGER_RECIPES = {
         displayName: "Nudge / What's Next Manager",
         epilogues: [],
         evidenceGates: ["manager decision", "worker receipt", "accepted criteria closure"],
+        finalReportRequirements: [
+            "Record status, residual risk, and any finish-task or terminal closeout proof in the final report, not as worker acceptance criteria.",
+        ],
         guidelines: [
             "Prefer wait over nudge while the worker is active.",
             "Ask for must-have current-task criteria versus follow-ups when scope changes.",
@@ -16060,6 +16501,9 @@ const MANAGER_RECIPES = {
         displayName: "PR/CI/Merge Ralph Loop",
         epilogues: ["draft-pr", "record-handoff"],
         evidenceGates: ["pr_url", "ci_green", "merge", "adversarial_check"],
+        finalReportRequirements: [
+            "Record PR URL, CI, merge, handoff, finish-task, and cleanup receipts in the final report; keep accepted criteria focused on deliverable proof.",
+        ],
         guidelines: ["Merge only after green CI and recorded manager decision evidence."],
         loopTemplate: "pr_ci_merge_loop",
         mode: "strict",
@@ -16069,6 +16513,57 @@ const MANAGER_RECIPES = {
         supportPatterns: ["Inbox / No-Tmux App Loop", "Recovery / Resume / Handoff"],
         tools: ["verification.run_tests", "context.fetch_prs"],
     },
+    "ship-it-loop": {
+        acceptance: [
+            "Branch, push, PR URL, CI-green, mergeability, manager merge decision, merge, post-merge verification, and adversarial proof are recorded.",
+            "Push, PR creation, conflict resolution, and merge actions are each gated by explicit manager permissions.",
+            "Merge readiness is a manager decision after independent verification, not a worker claim or CI-green shortcut.",
+        ],
+        cleanup: "clear after saved handoff",
+        description: "Drive a visible manager-worker ship-it loop through branch push, PR, CI, conflict handling, manager merge decision, merge, and post-merge receipts.",
+        disallowedActions: [
+            "Do not push branches before repo.push_branch is permitted.",
+            "Do not open or update PRs before repo.open_pr is permitted.",
+            "Do not resolve conflicts before repo.resolve_conflicts is permitted and retry bounds are recorded.",
+            "Do not merge before repo.merge_green_pr is permitted, CI is green, mergeability is clean, and the manager records merge_ready.",
+        ],
+        displayName: "Autonomous Ship-It Loop",
+        epilogues: ["draft-pr", "record-handoff"],
+        evidenceGates: [
+            "branch_ready",
+            "branch_pushed",
+            "pr_url",
+            "ci_green",
+            "mergeability_clean",
+            "manager_merge_decision",
+            "merge",
+            "post_merge_verification",
+            "adversarial_check",
+        ],
+        finalReportRequirements: [
+            "Record branch, PR URL, CI/check output, mergeability/conflict status, manager merge decision, merge SHA, post-merge verification, finish-task, and heartbeat teardown proof in the final report.",
+        ],
+        guidelines: [
+            "Keep all PR lifecycle phases visible in the manager and worker sessions.",
+            "Treat CI-green, mergeability, and worker receipts as claims until the manager verifies them.",
+            "Use a bounded conflict retry and block with evidence when conflicts remain unresolved.",
+        ],
+        loopTemplate: "ship_it_loop",
+        mode: "strict",
+        name: "ship-it-loop",
+        objective: "Supervise a worker from implementation through explicit branch, PR, CI, conflict, merge, and post-merge evidence gates.",
+        permissions: [
+            "repo.push_branch",
+            "repo.open_pr",
+            "repo.monitor_ci",
+            "repo.resolve_conflicts",
+            "repo.merge_green_pr",
+            "worker_session.compact",
+            "worker_session.clear",
+        ],
+        supportPatterns: ["Inbox / No-Tmux App Loop", "Recovery / Resume / Handoff"],
+        tools: ["gh", "git", "verification.run_tests", "context.fetch_prs"],
+    },
     "test-coverage-loop": {
         acceptance: [
             "Coverage or targeted test evidence is recorded before another worker pass.",
@@ -16080,6 +16575,9 @@ const MANAGER_RECIPES = {
         displayName: "Test Coverage Loop",
         epilogues: [],
         evidenceGates: ["test_coverage", "adversarial_check"],
+        finalReportRequirements: [
+            "Record final closeout and finish-task proof in the manager final report; do not make closeout mechanics a test-coverage criterion.",
+        ],
         guidelines: ["Record coverage evidence before asking for another worker pass."],
         loopTemplate: "test_coverage_loop",
         mode: "strict",
@@ -16106,6 +16604,9 @@ const MANAGER_RECIPES = {
             "diff_below_threshold",
             "adversarial_check",
         ],
+        finalReportRequirements: [
+            "Record final visual decision, closeout, and cleanup proof in the manager final report; keep accepted criteria focused on visible-output evidence.",
+        ],
         guidelines: ["Compare visible output against references before requesting another pass."],
         loopTemplate: "visual_diff_loop",
         mode: "guided",
@@ -16124,6 +16625,9 @@ const MANAGER_RECIPE_ALIASES = {
     "pr ci merge ralph loop": "pr-ci-merge-ralph-loop",
     "pr/ci/merge ralph loop": "pr-ci-merge-ralph-loop",
     "ralph loop": "pr-ci-merge-ralph-loop",
+    "ship it": "ship-it-loop",
+    "ship it loop": "ship-it-loop",
+    "ship-it": "ship-it-loop",
     "test coverage": "test-coverage-loop",
     "test coverage loop": "test-coverage-loop",
     "ux polish": "ux-polish-loop",
@@ -16157,6 +16661,7 @@ function managerRecipeSummary(name) {
         display_name: recipe.displayName,
         epilogues: [...recipe.epilogues],
         evidence_gates: [...recipe.evidenceGates],
+        final_report_requirements: [...recipe.finalReportRequirements],
         guidelines: [...recipe.guidelines],
         locked_summary_template: lockedManagerRecipeSummary(recipe),
         loop_template: recipe.loopTemplate,
@@ -16211,6 +16716,7 @@ function lockedManagerRecipeSummary(recipe) {
         `Epilogues: ${recipe.epilogues.length > 0 ? recipe.epilogues.join(", ") : "none"}`,
         `Cleanup: ${recipe.cleanup}`,
         `Evidence gates: ${recipe.evidenceGates.length > 0 ? recipe.evidenceGates.join(", ") : "manager-reviewed evidence"}`,
+        `Final report: ${recipe.finalReportRequirements.join("; ")}`,
         `Not allowed: ${recipe.disallowedActions.length > 0 ? recipe.disallowedActions.join("; ") : "unconfirmed custom actions"}`,
         "User confirmed: <yes|no>",
     ].join("\n");
@@ -16517,7 +17023,7 @@ function loopStatusSummarySync(database, options) {
     const matchingCommands = commandRows.filter((row) => commandRowMatchesRun(row, options.run.id));
     const commandStates = countBy(matchingCommands.map((row) => row.state));
     const notificationRows = database.prepare(`
-    select state, payload_json
+    select consumed_at, state, payload_json
     from routed_notifications
     where task_id = ?
     order by created_at, id
@@ -16550,6 +17056,12 @@ function loopStatusSummarySync(database, options) {
             .filter((value) => typeof value === "string" && value.length > 0))].sort();
     const telemetryEvents = telemetryEventsForRunSync(database, { runId: options.run.id, taskId: options.task.id });
     const telemetryByType = countBy(telemetryEvents.map((event) => event.event_type));
+    const appTaskDispatch = appTaskDispatchSummarySync(database, {
+        commandRows,
+        notificationRows,
+        runScopedActivityTotal: matchingCommands.length + matchingNotifications.length + telemetryEvents.length,
+        taskId: options.task.id,
+    });
     const failedCommandCount = commandStates.failed ?? 0;
     const failureCounts = loopFailureCountsSync(database, {
         failedCommandCount,
@@ -16570,6 +17082,7 @@ function loopStatusSummarySync(database, options) {
             total: evidenceItems.length,
             types: evidenceTypes,
         },
+        app_task_dispatch: appTaskDispatch,
         failures: failureCounts,
         inbox: {
             worker_unconsumed: workerInbox,
@@ -16613,6 +17126,52 @@ function telemetryEventsForRunSync(database, options) {
     limit 1000
   `).all(options.taskId, options.runId);
 }
+function appTaskDispatchSummarySync(database, options) {
+    const taskDispatchEventTypes = [
+        "app_autopilot_started",
+        "app_autopilot_stopped",
+        "app_heartbeat",
+        "app_wakeup_delivery_recorded",
+        "app_wakeup_dispatch_planned",
+        "command_created",
+        "dispatch_inbox_consumed",
+    ];
+    const telemetryRows = database.prepare(`
+    select event_type, timestamp
+    from telemetry_events
+    where task_id = ?
+      and event_type in (${taskDispatchEventTypes.map(() => "?").join(", ")})
+    order by timestamp, id
+  `).all(options.taskId, ...taskDispatchEventTypes);
+    const telemetryByType = countBy(telemetryRows.map((row) => row.event_type));
+    const commandStates = countBy(options.commandRows.map((row) => row.state));
+    const notificationStates = countBy(options.notificationRows.map((row) => row.state));
+    const recordsTotal = options.commandRows.length + options.notificationRows.length + telemetryRows.length;
+    const blindToRun = options.runScopedActivityTotal === 0 && recordsTotal > 0;
+    return {
+        commands: {
+            states: sortJson(commandStates),
+            total: options.commandRows.length,
+        },
+        latest_event_at: telemetryRows.at(-1)?.timestamp ?? null,
+        note: blindToRun
+            ? "Requested run has no run-scoped activity, but task-level app Dispatch records exist."
+            : null,
+        notifications: {
+            delivered_unconsumed: options.notificationRows
+                .filter((row) => row.state === "delivered" && row.consumed_at === null).length,
+            states: sortJson(notificationStates),
+            total: options.notificationRows.length,
+        },
+        records_total: recordsTotal,
+        telemetry: {
+            by_event_type: sortJson(telemetryByType),
+            command_created: telemetryByType.command_created ?? 0,
+            dispatch_inbox_consumed: telemetryByType.dispatch_inbox_consumed ?? 0,
+            total: telemetryRows.length,
+        },
+    };
+}
 function loopFailureCountsSync(database, options) {
     const failedCycles = database.prepare(`
     select count(distinct mc.id) as count
@@ -16702,6 +17261,8 @@ function renderLoopStatusText(result) {
     const notifications = result.notifications;
     const inbox = result.inbox;
     const telemetry = result.telemetry;
+    const appTaskDispatch = result.app_task_dispatch;
+    const appTaskDispatchTelemetry = appTaskDispatch?.telemetry;
     return [
         `task: ${task.name} (${task.state})`,
         `run: ${run.name || run.id} (${run.status})`,
@@ -16710,6 +17271,7 @@ function renderLoopStatusText(result) {
         `notifications: ${notifications.delivered}/${notifications.total} delivered`,
         `worker_unconsumed: ${inbox.worker_unconsumed}`,
         `dispatch_inbox_consumed: ${telemetry.dispatch_inbox_consumed}`,
+        `app_task_dispatch: ${appTaskDispatch?.records_total ?? 0} records ${JSON.stringify(appTaskDispatchTelemetry?.by_event_type ?? {})}${appTaskDispatch?.note ? ` (${appTaskDispatch.note})` : ""}`,
         `failures: ${JSON.stringify(result.failures ?? {})}`,
         `recommendation: ${result.recommendation}`,
     ].join("\n") + "\n";
@@ -17218,11 +17780,18 @@ function disposableWorkerHandoff(taskName, runName, dbPath) {
     const loopClause = runName
         ? ` for Ralph loop run ${runName}`
         : " for this disposable no-tmux binding";
+    const notifyCommand = durableWorkerNotifyManagerCommand(taskName, dbPath);
+    const dispatchCommand = durableWorkerNotifyDispatchCommand(dbPath);
     return [
         "Use the manage-codex-workers skill.",
         "",
         `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.",
+        ...visibleSessionProtocolLines("worker"),
+        "After completing or blocking on a consumed item, send the manager a durable Conveyor notification before your final answer. A direct app-thread final answer is not a manager receipt and is not task completion.",
+        `Run: ${notifyCommand}`,
+        `Then run: ${dispatchCommand}`,
+        "If either notify/dispatch command fails, include that failure as the blocker and do not claim the manager was notified.",
         "",
         "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.",
@@ -17263,6 +17832,8 @@ function disposableHeartbeatRecommendations(taskName, dbPath) {
     const workerHeartbeatCommand = disposableAppHeartbeatCommand("worker", taskName, dbPath);
     const managerInboxCommand = sessionPollCommand("manager", taskName, dbPath);
     const workerInboxCommand = sessionPollCommand("worker", taskName, dbPath);
+    const workerNotifyCommand = durableWorkerNotifyManagerCommand(taskName, dbPath);
+    const workerNotifyDispatchCommand = durableWorkerNotifyDispatchCommand(dbPath);
     const wakeupDispatchCommand = `${conveyorPollInvocation()} app-wakeup-dispatch ${shellQuote(taskName)} --path ${shellQuote(dbPath)} --json`;
     const deliveryReceiptCommands = disposableDeliveryReceiptCommands(taskName, dbPath);
     return {
@@ -17299,9 +17870,11 @@ function disposableHeartbeatRecommendations(taskName, dbPath) {
                 `After a successful app-thread send, record it with: ${deliveryReceiptCommands.sent}`,
                 `For healthy skipped actions, record: ${deliveryReceiptCommands.skipped}`,
                 `For missing-thread blocked actions, record: ${deliveryReceiptCommands.blocked}`,
+                ...visibleSessionProtocolLines("manager"),
                 "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.",
+                "Keep manager closeout/control-plane proof out of accepted worker criteria; record finish-task, final task state, and heartbeat teardown proof in the manager final report or audit receipts.",
                 `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"),
@@ -17315,7 +17888,12 @@ function disposableHeartbeatRecommendations(taskName, dbPath) {
                 `Run the worker app heartbeat for task ${taskName}.`,
                 `Run: ${workerHeartbeatCommand}`,
                 `If the heartbeat output asks for direct inbox polling, run: ${workerInboxCommand}`,
+                ...visibleSessionProtocolLines("worker"),
                 "If an item is consumed, execute only that single worker instruction and return exact commands, compact evidence for any completion claim, blockers/residual risk, and exactly one next recommended worker task.",
+                "Before your final answer after any consumed item, notify the manager durably; a direct app-thread final answer is not a manager receipt and is not task completion.",
+                `Run: ${workerNotifyCommand}`,
+                `Then run: ${workerNotifyDispatchCommand}`,
+                "If either notify/dispatch command fails, include that failure as the blocker and do not claim the manager was notified.",
                 "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"),
@@ -17335,6 +17913,12 @@ function disposableDeliveryReceiptCommands(taskName, dbPath) {
 function disposableAppHeartbeatCommand(role, taskName, dbPath) {
     return `${conveyorPollInvocation()} app-heartbeat ${shellQuote(taskName)} --role ${role} --path ${shellQuote(dbPath)} --json`;
 }
+function durableWorkerNotifyManagerCommand(taskName, dbPath) {
+    return `${conveyorPollInvocation()} enqueue-notify-manager ${shellQuote(taskName)} --message ${shellQuote("<compact completion/blocker report with files, commands, evidence, residual risk, and next recommended worker task>")} --correlation-id ${shellQuote("<worker-result-id>")} --path ${shellQuote(dbPath)} --json`;
+}
+function durableWorkerNotifyDispatchCommand(dbPath) {
+    return `${conveyorPollInvocation()} dispatch --watch --watch-iterations 1 --interval 2 --dispatcher-id dispatch-local --path ${shellQuote(dbPath)} --json`;
+}
 function sessionPollCommand(role, taskName, dbPath) {
     const inbox = role === "worker" ? "worker-inbox" : "manager-inbox";
     const task = taskName ? shellQuote(taskName) : "<task>";
@@ -17540,6 +18124,7 @@ function startManagerBootstrapPrompt(database, options) {
         "- Treat acceptance criteria as living supervision state.",
         "- 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.",
+        "- Keep manager closeout/control-plane proof out of accepted worker criteria; record finish-task, final task state, teardown, and final-report proof in manager closeout evidence instead.",
         "- Before finishing, compare worker receipts/verification against accepted open criteria.",
         `- 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}\`.`,