agent-conveyor 0.1.14 → 0.1.16

package/dist/cli/typescript-runtime.js

@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";
 import { taskAuditSync } from "../runtime/audit.js";
 import { appAutopilotPlanSync, appLoopStatusSync, appWakeupDispatchPlanSync, appWakeupPlanSync, directInboxPollCommand, visibleSessionProtocolLines, } from "../runtime/app-autonomy.js";
 import { classifyBusyWait, classifyStartupOutput } from "../runtime/classify.js";
+import { addCampaignWorkerSlotSync, campaignDashboardSync, campaignStatusSync, createCampaignAssignmentSync, createCampaignSync, recordCampaignAssetReceiptSync, updateCampaignWorkerSlotLifecycleSync, upsertCampaignChannelBriefSync, } from "../runtime/campaigns.js";
 import { exportTaskSync } from "../runtime/export.js";
 import { ingestSessionSync } from "../runtime/ingest.js";
 import { acceptanceCriteriaForTaskSync, loopEvidenceCriterion, recordAdversarialLoopEvidenceSync, recordLoopEvidenceSync, recordVisualDiffLoopEvidenceSync, } from "../runtime/loop-evidence.js";
@@ -134,6 +135,12 @@ export function runTypescriptRuntimeCommand(options) {
         if (parsed.command === "app-wakeup-record-delivery") {
             return runAppWakeupRecordDeliveryCommand(parsed, options);
         }
+        if (parsed.command === "app-worker-rotation-plan") {
+            return runAppWorkerRotationPlanCommand(parsed, options);
+        }
+        if (parsed.command === "app-worker-rotation-record") {
+            return runAppWorkerRotationRecordCommand(parsed, options);
+        }
         if (parsed.command === "app-autopilot") {
             return runAppAutopilotCommand(parsed, options);
         }
@@ -146,6 +153,9 @@ export function runTypescriptRuntimeCommand(options) {
         if (parsed.command === "tasks") {
             return runTasksCommand(parsed, options);
         }
+        if (parsed.command === "campaign") {
+            return runCampaignCommand(parsed, options);
+        }
         if (parsed.command === "start") {
             return runLegacyStartCommand(parsed, options);
         }
@@ -373,6 +383,22 @@ function commandHelpText(program, command) {
             "Examples:",
             `  ${program} finish-task my-task --reason "Accepted criteria satisfied" --require-criteria-audit --path /tmp/work/workerctl.db --json`,
         ],
+        campaign: [
+            `usage: ${program} campaign <create|add-slot|attach-slot|rotate-slot|archive-slot|brief|assign|asset|status|dashboard> --name <campaign> [options] ${path} [--json]`,
+            "",
+            "Examples:",
+            `  ${program} campaign create --name launch --objective "Create launch assets" --metadata-json '{"owner":"ops"}' --json`,
+            `  ${program} campaign add-slot --name launch --slot-key tiktok --role-label "TikTok worker" --channel tiktok --thread-id thread-1 --state active --json`,
+            `  ${program} campaign attach-slot --name launch --slot campaign-slot-id --session-id session-worker --thread-id thread-1 --state active --json`,
+            `  ${program} campaign rotate-slot --name launch --slot campaign-slot-id --expected-thread-id thread-1 --thread-id thread-2 --thread-title "TikTok Worker 2" --json`,
+            `  ${program} campaign archive-slot --name launch --slot campaign-slot-id --expected-thread-id thread-2 --json`,
+            `  ${program} campaign brief --name launch --channel tiktok --brief-json '{"format":"9:16"}' --json`,
+            `  ${program} campaign assign --name launch --slot campaign-slot-id --title "Draft hooks" --instructions "Create hooks" --status active --json`,
+            `  ${program} campaign asset --name launch --slot campaign-slot-id --assignment campaign-assignment-id --asset-type copy --title "Hooks v1" --status needs_review --json`,
+            `  ${program} campaign asset --name launch --slot campaign-slot-id --assignment campaign-assignment-id --asset-type copy --title "Hooks v2" --allow-additional-receipt --json`,
+            `  ${program} campaign status --name launch --json`,
+            `  ${program} campaign dashboard --name launch --json`,
+        ],
         "manager-ack": [
             `usage: ${program} manager-ack <task> --from-stdin ${path}`,
             `usage: ${program} manager-ack <task> --json ${path}`,
@@ -399,6 +425,21 @@ function commandHelpText(program, command) {
             `  ${program} app-autopilot status dogfood --path /tmp/work/workerctl.db`,
             `  ${program} app-autopilot stop dogfood --path /tmp/work/workerctl.db --json`,
         ],
+        "app-worker-rotation-plan": [
+            `usage: ${program} app-worker-rotation-plan <task> --old-worker-thread-id ID [--require-handoff] [--reason TEXT] ${path} [--json]`,
+            "",
+            "Emit Codex app actions for replacing a worker thread with a fresh thread.",
+            "The plan fails closed unless the old thread id exactly matches the active bound worker session; it never authorizes archiving a manager or unrelated thread.",
+            "",
+            "Examples:",
+            `  ${program} app-worker-rotation-plan dogfood --old-worker-thread-id thread-old --require-handoff --path /tmp/work/workerctl.db --json`,
+        ],
+        "app-worker-rotation-record": [
+            `usage: ${program} app-worker-rotation-record <task> --old-worker-thread-id OLD --new-worker-thread-id NEW [--new-worker-thread-title TITLE] --archive-status archived|blocked [--reason TEXT] ${path} [--json]`,
+            "",
+            "Record the Codex app worker-thread rotation after the app layer creates the new worker thread and archives or blocks on the old one.",
+            "The command re-checks active binding ownership before updating the worker session to the new thread id.",
+        ],
         pair: [
             `usage: ${program} pair --task <task> --worker-name <worker> --manager-name <manager> [options] ${path}`,
             "",
@@ -431,6 +472,26 @@ function commandHelpText(program, command) {
     };
     return linesByCommand[command] ?? [`usage: ${program} ${command} [-h] [options]`];
 }
+const CAMPAIGN_ACTIONS = new Set(["create", "add-slot", "attach-slot", "rotate-slot", "archive-slot", "brief", "assign", "asset", "status", "dashboard"]);
+const CAMPAIGN_STRING_FLAGS = {
+    "--artifact-path": "artifactPath",
+    "--asset-type": "assetType",
+    "--assignment": "assignment",
+    "--brief-json": "briefJson",
+    "--channel": "channel",
+    "--expected-thread-id": "expectedThreadId",
+    "--instructions": "instructions",
+    "--objective": "objective",
+    "--prompt-summary": "promptSummary",
+    "--review-notes": "reviewNotes",
+    "--role-label": "roleLabel",
+    "--session-id": "sessionId",
+    "--slot": "slot",
+    "--slot-key": "slotKey",
+    "--thread-id": "threadId",
+    "--thread-title": "threadTitle",
+    "--title": "title",
+};
 function parseRuntimeArgs(args, env) {
     const flags = {
         format: "timeline",
@@ -438,9 +499,14 @@ function parseRuntimeArgs(args, env) {
         includeFullTranscripts: false,
         includeTranscripts: false,
         all: false,
+        allowAdditionalReceipt: false,
         action: null,
+        artifactPath: null,
+        assetType: null,
+        assignment: null,
         asRole: "all",
         attempts: false,
+        briefJson: null,
         json: false,
         activeOnly: false,
         actor: null,
@@ -454,7 +520,9 @@ function parseRuntimeArgs(args, env) {
         blocker: null,
         busyWaitSeconds: DEFAULT_BUSY_WAIT_SECONDS,
         candidate: null,
+        campaignName: null,
         check: null,
+        channel: null,
         classifyPrompt: null,
         workerCodexAppThreadId: null,
         workerCodexAppThreadTitle: null,
@@ -480,6 +548,7 @@ function parseRuntimeArgs(args, env) {
         epilogueStatus: false,
         epilogueStep: null,
         eventType: null,
+        expectedThreadId: null,
         failureMode: null,
         file: null,
         finishRun: null,
@@ -487,6 +556,7 @@ function parseRuntimeArgs(args, env) {
         fromText: null,
         fromWorkerResponse: null,
         goal: null,
+        instructions: null,
         keepLatest: 20,
         key: "C-c",
         list: false,
@@ -512,7 +582,10 @@ function parseRuntimeArgs(args, env) {
         require: false,
         requireHandoff: false,
         result: null,
+        reviewNotes: null,
+        roleLabel: null,
         review: false,
+        sessionId: null,
         sessionRole: null,
         sessionState: null,
         show: null,
@@ -523,9 +596,13 @@ function parseRuntimeArgs(args, env) {
         statuses: [],
         statusStaleSeconds: DEFAULT_STATUS_STALE_SECONDS,
         submitRole: null,
+        slot: null,
+        slotKey: null,
         subtype: null,
         summary: null,
         source: null,
+        objective: null,
+        promptSummary: null,
         proof: null,
         purpose: null,
         quietAfterCycles: 3,
@@ -568,8 +645,14 @@ function parseRuntimeArgs(args, env) {
         dispatchReceipt: null,
         force: false,
         message: null,
+        newWorkerThreadId: null,
+        newWorkerThreadTitle: null,
+        oldWorkerThreadId: null,
         reason: null,
         threadId: null,
+        threadTitle: null,
+        title: null,
+        archiveStatus: null,
         consumeNext: false,
         wait: false,
         requireAcks: false,
@@ -686,6 +769,12 @@ function parseRuntimeArgs(args, env) {
         else if (arg === "--all") {
             flags.all = true;
         }
+        else if (arg === "--allow-additional-receipt") {
+            if (command !== "campaign") {
+                return { command, enabled, error: "Unsupported TypeScript runtime option: --allow-additional-receipt", explicit, flags, passthroughArgs, task };
+            }
+            flags.allowAdditionalReceipt = true;
+        }
         else if (arg === "--active") {
             flags.active = true;
         }
@@ -937,7 +1026,7 @@ function parseRuntimeArgs(args, env) {
             }
         }
         else if (arg === "--require-handoff") {
-            if (command !== "manager-permission") {
+            if (command !== "manager-permission" && command !== "app-worker-rotation-plan") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --require-handoff", explicit, flags, task };
             }
             flags.requireHandoff = true;
@@ -1037,6 +1126,17 @@ function parseRuntimeArgs(args, env) {
             flags.workerctlPath = value.value;
             index += 1;
         }
+        else if (arg === "--campaign") {
+            if (command !== "dashboard") {
+                return { command, enabled, error: "Unsupported TypeScript runtime option: --campaign", explicit, flags, task };
+            }
+            const value = valueAfter(queue, index, arg);
+            if (value.error) {
+                return { command, enabled, error: value.error, explicit, flags, task };
+            }
+            flags.campaignName = value.value;
+            index += 1;
+        }
         else if (arg === "--output") {
             const value = valueAfter(queue, index, arg);
             if (value.error) {
@@ -1166,7 +1266,7 @@ function parseRuntimeArgs(args, env) {
             index += 1;
         }
         else if (arg === "--metadata-json") {
-            if (command !== "runs" && command !== "loop-evidence") {
+            if (command !== "runs" && command !== "loop-evidence" && command !== "campaign") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --metadata-json", explicit, flags, task };
             }
             const value = valueAfter(queue, index, arg);
@@ -1232,6 +1332,14 @@ function parseRuntimeArgs(args, env) {
             flags.names.push(value.value);
             index += 1;
         }
+        else if (command === "campaign" && Object.prototype.hasOwnProperty.call(CAMPAIGN_STRING_FLAGS, arg)) {
+            const value = valueAfter(queue, index, arg);
+            if (value.error) {
+                return { command, enabled, error: value.error, explicit, flags, task };
+            }
+            flags[CAMPAIGN_STRING_FLAGS[arg]] = value.value;
+            index += 1;
+        }
         else if (arg === "--pid") {
             const parsedValue = valueAfter(queue, index, arg);
             if (parsedValue.error) {
@@ -1668,14 +1776,19 @@ function parseRuntimeArgs(args, env) {
             index += 1;
         }
         else if (arg === "--objective") {
-            if (command !== "manager-config") {
+            if (command !== "manager-config" && command !== "campaign") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --objective", explicit, flags, task };
             }
             const value = valueAfter(queue, index, arg);
             if (value.error) {
                 return { command, enabled, error: value.error, explicit, flags, task };
             }
-            flags.managerObjective = value.value;
+            if (command === "manager-config") {
+                flags.managerObjective = value.value;
+            }
+            else {
+                flags.objective = value.value;
+            }
             index += 1;
         }
         else if (arg === "--recipe") {
@@ -1855,7 +1968,13 @@ function parseRuntimeArgs(args, env) {
             index = queue.length;
         }
         else if (arg === "--reason") {
-            if (command !== "finish-task" && command !== "stop-task" && command !== "record-decision" && command !== "compact-worker" && command !== "app-wakeup-record-delivery") {
+            if (command !== "finish-task"
+                && command !== "stop-task"
+                && command !== "record-decision"
+                && command !== "compact-worker"
+                && command !== "app-wakeup-record-delivery"
+                && command !== "app-worker-rotation-plan"
+                && command !== "app-worker-rotation-record") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --reason", explicit, flags, task };
             }
             const value = valueAfter(queue, index, arg);
@@ -1887,8 +2006,19 @@ function parseRuntimeArgs(args, env) {
             flags.deliveryStatus = value.value;
             index += 1;
         }
+        else if (arg === "--archive-status") {
+            if (command !== "app-worker-rotation-record") {
+                return { command, enabled, error: "Unsupported TypeScript runtime option: --archive-status", explicit, flags, task };
+            }
+            const value = valueAfter(queue, index, arg);
+            if (value.error) {
+                return { command, enabled, error: value.error, explicit, flags, task };
+            }
+            flags.archiveStatus = value.value;
+            index += 1;
+        }
         else if (arg === "--thread-id") {
-            if (command !== "app-wakeup-record-delivery") {
+            if (command !== "app-wakeup-record-delivery" && command !== "campaign") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --thread-id", explicit, flags, task };
             }
             const value = valueAfter(queue, index, arg);
@@ -1898,6 +2028,28 @@ function parseRuntimeArgs(args, env) {
             flags.threadId = value.value;
             index += 1;
         }
+        else if (arg === "--old-worker-thread-id" || arg === "--new-worker-thread-id" || arg === "--new-worker-thread-title") {
+            if (command !== "app-worker-rotation-plan" && command !== "app-worker-rotation-record") {
+                return { command, enabled, error: `Unsupported TypeScript runtime option: ${arg}`, explicit, flags, task };
+            }
+            if (arg !== "--old-worker-thread-id" && command !== "app-worker-rotation-record") {
+                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 === "--old-worker-thread-id") {
+                flags.oldWorkerThreadId = value.value;
+            }
+            else if (arg === "--new-worker-thread-id") {
+                flags.newWorkerThreadId = value.value;
+            }
+            else {
+                flags.newWorkerThreadTitle = value.value;
+            }
+            index += 1;
+        }
         else if (arg === "--message") {
             if (command !== "finish-task"
                 && command !== "stop-task"
@@ -2189,6 +2341,9 @@ function parseRuntimeArgs(args, env) {
                 }
                 flags.statusState = value;
             }
+            else if (command === "campaign") {
+                flags.statusState = value;
+            }
             else if (!isSessionState(value)) {
                 return { command, enabled, error: `Unsupported sessions state: ${value}`, explicit, flags, task };
             }
@@ -2202,7 +2357,7 @@ function parseRuntimeArgs(args, env) {
                 flags.epilogueStatus = true;
                 continue;
             }
-            if (command !== "criteria" && command !== "runs" && command !== "loop-evidence") {
+            if (command !== "criteria" && command !== "runs" && command !== "loop-evidence" && command !== "campaign") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --status", explicit, flags, task };
             }
             const parsedValue = valueAfter(queue, index, arg);
@@ -2865,6 +3020,12 @@ function parseRuntimeArgs(args, env) {
             }
             flags.action = arg;
         }
+        else if (command === "campaign" && flags.action === null) {
+            if (!CAMPAIGN_ACTIONS.has(arg)) {
+                return { command, enabled, error: `Unsupported campaign action: ${arg}`, explicit, flags, task };
+            }
+            flags.action = arg;
+        }
         else if ((command === "qa-plan" || command === "qa-run") && flags.subtype === null) {
             flags.subtype = arg;
         }
@@ -3752,6 +3913,319 @@ function runAppWakeupRecordDeliveryCommand(parsed, options) {
         database.close();
     }
 }
+function runAppWorkerRotationPlanCommand(parsed, options) {
+    const taskName = requireTask(parsed);
+    if (!parsed.flags.oldWorkerThreadId) {
+        return errorResult("app-worker-rotation-plan requires --old-worker-thread-id.");
+    }
+    const database = openRuntimeDatabase(parsed, options);
+    try {
+        const timestamp = nowIsoSeconds(options);
+        const dbPath = runtimeDbPath(parsed, options);
+        const plan = appWorkerRotationPlanSync(database, {
+            dbPath,
+            now: timestamp,
+            oldWorkerThreadId: parsed.flags.oldWorkerThreadId,
+            reason: parsed.flags.reason,
+            requireHandoff: parsed.flags.requireHandoff,
+            taskName,
+        });
+        const eventId = emitTelemetrySync(database, {
+            actor: "manager",
+            attributes: {
+                actions: plan.actions.map((action) => ({
+                    status: action.status,
+                    thread_id: action.thread.id,
+                    type: action.type,
+                })),
+                blockers: plan.blockers,
+                eligible: plan.eligible,
+                handoff_id: plan.handoff?.id ?? null,
+                old_worker_thread_id: parsed.flags.oldWorkerThreadId,
+                reason: parsed.flags.reason,
+            },
+            correlation: {
+                command: "app-worker-rotation-plan",
+                old_worker_thread_id: parsed.flags.oldWorkerThreadId,
+            },
+            eventType: "app_worker_rotation_planned",
+            severity: plan.eligible ? "info" : "warning",
+            summary: `Codex app worker rotation ${plan.eligible ? "planned" : "blocked"} for ${plan.task.name}.`,
+            taskId: plan.task.id,
+            timestamp,
+        });
+        const output = {
+            ...plan,
+            receipt: {
+                event_id: eventId,
+                event_type: "app_worker_rotation_planned",
+                recorded_at: timestamp,
+            },
+        };
+        if (parsed.flags.json) {
+            return jsonResult(output);
+        }
+        return {
+            exitCode: 0,
+            handled: true,
+            stdout: renderAppWorkerRotationPlanText(output),
+        };
+    }
+    finally {
+        database.close();
+    }
+}
+function runAppWorkerRotationRecordCommand(parsed, options) {
+    const taskName = requireTask(parsed);
+    if (!parsed.flags.oldWorkerThreadId) {
+        return errorResult("app-worker-rotation-record requires --old-worker-thread-id.");
+    }
+    if (!parsed.flags.newWorkerThreadId) {
+        return errorResult("app-worker-rotation-record requires --new-worker-thread-id.");
+    }
+    const archiveStatus = parseAppWorkerArchiveStatus(parsed.flags.archiveStatus);
+    if (archiveStatus instanceof Error) {
+        return errorResult(archiveStatus.message);
+    }
+    const database = openRuntimeDatabase(parsed, options);
+    try {
+        const timestamp = nowIsoSeconds(options);
+        const dbPath = runtimeDbPath(parsed, options);
+        const plan = appWorkerRotationPlanSync(database, {
+            dbPath,
+            now: timestamp,
+            oldWorkerThreadId: parsed.flags.oldWorkerThreadId,
+            reason: parsed.flags.reason,
+            requireHandoff: false,
+            taskName,
+        });
+        if (!plan.eligible) {
+            throw new Error(`Cannot record worker rotation; active worker ownership check failed: ${plan.blockers.join(", ")}`);
+        }
+        if (archiveStatus === "archived") {
+            database.prepare(`
+        update sessions
+        set codex_app_thread_id = ?, codex_app_thread_title = ?, last_heartbeat_at = null
+        where id = ? and role = 'worker'
+      `).run(parsed.flags.newWorkerThreadId, parsed.flags.newWorkerThreadTitle, plan.old_worker.session_id);
+        }
+        const eventId = emitTelemetrySync(database, {
+            actor: "manager",
+            attributes: {
+                archive_status: archiveStatus,
+                binding_id: plan.guard.binding_id,
+                handoff_id: plan.handoff?.id ?? null,
+                new_worker_thread_id: parsed.flags.newWorkerThreadId,
+                new_worker_thread_title: parsed.flags.newWorkerThreadTitle,
+                old_worker_session_id: plan.old_worker.session_id,
+                old_worker_thread_id: parsed.flags.oldWorkerThreadId,
+                reason: parsed.flags.reason,
+                session_updated: archiveStatus === "archived",
+            },
+            correlation: {
+                command: "app-worker-rotation-record",
+                new_worker_thread_id: parsed.flags.newWorkerThreadId,
+                old_worker_thread_id: parsed.flags.oldWorkerThreadId,
+            },
+            eventType: "app_worker_rotation_recorded",
+            severity: archiveStatus === "archived" ? "info" : "warning",
+            summary: `Codex app worker rotation ${archiveStatus} for ${plan.task.name}.`,
+            taskId: plan.task.id,
+            timestamp,
+        });
+        const output = {
+            archive: {
+                old_worker_thread_id: parsed.flags.oldWorkerThreadId,
+                status: archiveStatus,
+            },
+            guard: plan.guard,
+            new_worker: {
+                codex_app_thread_id: parsed.flags.newWorkerThreadId,
+                codex_app_thread_title: parsed.flags.newWorkerThreadTitle,
+                session_id: plan.old_worker.session_id,
+                session_updated: archiveStatus === "archived",
+            },
+            old_worker: plan.old_worker,
+            receipt: {
+                event_id: eventId,
+                event_type: "app_worker_rotation_recorded",
+                recorded_at: timestamp,
+            },
+            task: plan.task,
+        };
+        if (parsed.flags.json) {
+            return jsonResult(output);
+        }
+        return {
+            exitCode: 0,
+            handled: true,
+            stdout: [
+                `App worker rotation ${archiveStatus} for ${plan.task.name}.`,
+                `Old worker thread: ${parsed.flags.oldWorkerThreadId}`,
+                `New worker thread: ${parsed.flags.newWorkerThreadId}`,
+                `Receipt: ${eventId}`,
+            ].join("\n") + "\n",
+        };
+    }
+    finally {
+        database.close();
+    }
+}
+function parseAppWorkerArchiveStatus(value) {
+    if (value === "archived" || value === "blocked") {
+        return value;
+    }
+    return new Error("app-worker-rotation-record requires --archive-status archived|blocked");
+}
+function appWorkerRotationPlanSync(database, options) {
+    const task = taskRowForPair(database, options.taskName);
+    if (task === null) {
+        throw new Error(`Unknown task: ${options.taskName}`);
+    }
+    const binding = activeBindingForTaskSync(database, task.name);
+    const worker = sessionRow(database, binding.worker_session_name, "worker");
+    const manager = sessionRow(database, binding.manager_session_name, "manager");
+    const handoff = latestWorkerHandoffFullSync(database, task.id);
+    const blockers = [];
+    const exactThreadMatch = worker.codex_app_thread_id === options.oldWorkerThreadId;
+    if (binding.state !== "active") {
+        blockers.push("active_binding_not_active");
+    }
+    if (worker.state !== "active") {
+        blockers.push("worker_session_not_active");
+    }
+    if (worker.tmux_session !== null) {
+        blockers.push("worker_session_is_tmux_backed");
+    }
+    if (!worker.codex_app_thread_id) {
+        blockers.push("missing_worker_codex_app_thread_id");
+    }
+    if (!exactThreadMatch) {
+        blockers.push("old_worker_thread_id_mismatch");
+    }
+    if (manager.id === worker.id || manager.codex_app_thread_id === worker.codex_app_thread_id) {
+        blockers.push("manager_worker_thread_not_distinct");
+    }
+    if (options.requireHandoff) {
+        if (handoff === null) {
+            blockers.push("missing_worker_handoff");
+        }
+        else if (handoff.worker_session_id !== worker.id) {
+            blockers.push("handoff_worker_session_mismatch");
+        }
+    }
+    const guard = {
+        active_binding: binding.state === "active",
+        binding_id: binding.binding_id,
+        exact_thread_match: exactThreadMatch,
+        expected_old_worker_thread_id: options.oldWorkerThreadId,
+        manager_session_id: manager.id,
+        manager_thread_id: manager.codex_app_thread_id,
+        require_handoff: options.requireHandoff,
+        role: "worker",
+        task_id: task.id,
+        worker_session_id: worker.id,
+        worker_state: worker.state,
+    };
+    const eligible = blockers.length === 0;
+    const replacementTitle = replacementWorkerThreadTitle(task.name, worker.codex_app_thread_title);
+    const recordCommand = `${conveyorPollInvocation()} app-worker-rotation-record ${shellQuote(task.name)} --old-worker-thread-id ${shellQuote(options.oldWorkerThreadId)} --new-worker-thread-id <new.thread.id> --new-worker-thread-title <new.thread.title> --archive-status archived --path ${shellQuote(options.dbPath)} --json`;
+    return {
+        actions: eligible
+            ? [
+                {
+                    guard,
+                    prompt: replacementWorkerPrompt({
+                        dbPath: options.dbPath,
+                        handoff,
+                        reason: options.reason,
+                        taskName: task.name,
+                    }),
+                    role: "worker",
+                    send_ready: true,
+                    status: "ready_to_create",
+                    thread: { id: null, title: replacementTitle },
+                    type: "create_replacement_worker_thread",
+                },
+                {
+                    guard,
+                    role: "worker",
+                    send_ready: true,
+                    status: "ready_to_archive",
+                    thread: { id: worker.codex_app_thread_id, title: worker.codex_app_thread_title },
+                    type: "archive_old_worker_thread",
+                },
+            ]
+            : [],
+        blockers,
+        eligible,
+        guard,
+        handoff: handoff === null
+            ? null
+            : {
+                created_at: handoff.created_at,
+                id: handoff.id,
+                next_steps: handoff.next_steps,
+                summary: handoff.summary,
+                worker_session_id: handoff.worker_session_id,
+            },
+        old_worker: {
+            codex_app_thread_id: worker.codex_app_thread_id,
+            codex_app_thread_title: worker.codex_app_thread_title,
+            name: worker.name,
+            session_id: worker.id,
+        },
+        record_command: eligible ? recordCommand : null,
+        task: { id: task.id, name: task.name },
+    };
+}
+function replacementWorkerThreadTitle(taskName, oldTitle) {
+    const base = oldTitle && oldTitle.trim().length > 0 ? oldTitle.trim() : `${taskName} worker`;
+    return `${base} fresh`;
+}
+function replacementWorkerPrompt(options) {
+    const handoffLines = options.handoff === null
+        ? ["No saved handoff was required for this rotation plan."]
+        : [
+            `Saved handoff id: ${String(options.handoff.id)}`,
+            `Saved handoff summary: ${String(options.handoff.summary)}`,
+            `Saved handoff next steps: ${JSON.stringify(options.handoff.next_steps ?? [])}`,
+        ];
+    return [
+        "Use the manage-codex-workers skill.",
+        `You are the replacement Codex app worker thread for task ${options.taskName}.`,
+        options.reason ? `Rotation reason: ${options.reason}` : "Rotation reason: fresh worker context for Codex app usage.",
+        ...handoffLines,
+        "",
+        "Resume from the saved handoff and continue through Conveyor only. Do not rely on the archived worker thread for context beyond the handoff above.",
+        ...visibleSessionProtocolLines("worker"),
+        `Run: ${disposableAppHeartbeatCommand("worker", options.taskName, options.dbPath)}`,
+        `If the heartbeat output asks for direct inbox polling, run: ${sessionPollCommand("worker", options.taskName, options.dbPath)}`,
+        "If no item is consumed, stop after a one-line idle receipt.",
+    ].join("\n");
+}
+function renderAppWorkerRotationPlanText(plan) {
+    const lines = [
+        `App worker rotation for ${plan.task.name}: ${plan.eligible ? "ready" : "blocked"}`,
+        `Old worker thread: ${plan.old_worker.codex_app_thread_id ?? "(missing)"}`,
+    ];
+    if (plan.blockers.length > 0) {
+        lines.push(`Blockers: ${plan.blockers.join(", ")}`);
+    }
+    for (const action of plan.actions) {
+        lines.push(`${action.type}: ${action.status}`);
+        if (action.thread.id || action.thread.title) {
+            lines.push(`  thread: ${action.thread.title ?? "(untitled)"} ${action.thread.id ?? "(new)"}`);
+        }
+    }
+    if (plan.record_command) {
+        lines.push(`Record after app tools: ${plan.record_command}`);
+    }
+    if (plan.receipt) {
+        lines.push(`Receipt: ${plan.receipt.event_id}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
 function runAppAutopilotCommand(parsed, options) {
     const action = parsed.flags.action;
     if (action !== "start" && action !== "stop" && action !== "status") {
@@ -5596,6 +6070,270 @@ function runTasksCommand(parsed, options) {
         database.close();
     }
 }
+function runCampaignCommand(parsed, options) {
+    if (parsed.task) {
+        return errorResult(`Unexpected argument: ${parsed.task}`);
+    }
+    const action = parsed.flags.action;
+    if (!action) {
+        return errorResult("campaign requires an action: create, add-slot, brief, assign, asset, or status");
+    }
+    const campaign = campaignNameArg(parsed);
+    const database = openRuntimeDatabase(parsed, options);
+    try {
+        if (action === "create") {
+            const objective = requiredStringFlag(parsed.flags.objective, "--objective");
+            const metadata = jsonObjectArg(parsed.flags.metadataJson, "--metadata-json");
+            const campaignId = createCampaignSync(database, {
+                metadata,
+                name: campaign,
+                objective,
+            });
+            return campaignResult(parsed, {
+                action,
+                campaign,
+                campaign_id: campaignId,
+                created: true,
+            }, [`campaign ${campaign} created ${campaignId}`]);
+        }
+        if (action === "add-slot") {
+            const slotKey = requiredStringFlag(parsed.flags.slotKey, "--slot-key");
+            const roleLabel = requiredStringFlag(parsed.flags.roleLabel, "--role-label");
+            const state = campaignSlotStateArg(parsed.flags.statusState);
+            const metadata = jsonObjectArg(parsed.flags.metadataJson, "--metadata-json");
+            const slotId = addCampaignWorkerSlotSync(database, {
+                campaign,
+                channel: parsed.flags.channel,
+                codexAppThreadId: parsed.flags.threadId,
+                codexAppThreadTitle: parsed.flags.threadTitle,
+                metadata,
+                roleLabel,
+                sessionId: parsed.flags.sessionId,
+                slotKey,
+                ...(state ? { state } : {}),
+            });
+            return campaignResult(parsed, {
+                action,
+                campaign,
+                created: true,
+                slot_id: slotId,
+                slot_key: slotKey,
+            }, [`campaign ${campaign} slot ${slotKey} created ${slotId}`]);
+        }
+        if (action === "attach-slot") {
+            const slot = requiredStringFlag(parsed.flags.slot, "--slot");
+            const state = campaignSlotStateArg(parsed.flags.statusState) ?? "active";
+            const record = updateCampaignWorkerSlotLifecycleSync(database, {
+                campaign,
+                codexAppThreadId: parsed.flags.threadId,
+                codexAppThreadTitle: parsed.flags.threadTitle,
+                metadata: jsonObjectArg(parsed.flags.metadataJson, "--metadata-json"),
+                sessionId: parsed.flags.sessionId,
+                slot,
+                state,
+            });
+            return campaignResult(parsed, {
+                action,
+                campaign,
+                slot: record,
+                updated: true,
+            }, [`campaign ${campaign} slot ${record.slot_key} attached ${record.id}`]);
+        }
+        if (action === "rotate-slot") {
+            const slot = requiredStringFlag(parsed.flags.slot, "--slot");
+            const expectedThreadId = requiredStringFlag(parsed.flags.expectedThreadId, "--expected-thread-id");
+            const nextThreadId = requiredStringFlag(parsed.flags.threadId, "--thread-id");
+            const record = updateCampaignWorkerSlotLifecycleSync(database, {
+                campaign,
+                codexAppThreadId: nextThreadId,
+                codexAppThreadTitle: parsed.flags.threadTitle,
+                expectedThreadId,
+                sessionId: parsed.flags.sessionId,
+                slot,
+                state: campaignSlotStateArg(parsed.flags.statusState) ?? "active",
+            });
+            return campaignResult(parsed, {
+                action,
+                campaign,
+                expected_thread_id: expectedThreadId,
+                slot: record,
+                updated: true,
+            }, [`campaign ${campaign} slot ${record.slot_key} rotated ${expectedThreadId} -> ${record.codex_app_thread_id ?? "none"}`]);
+        }
+        if (action === "archive-slot") {
+            const slot = requiredStringFlag(parsed.flags.slot, "--slot");
+            const expectedThreadId = requiredStringFlag(parsed.flags.expectedThreadId, "--expected-thread-id");
+            const record = updateCampaignWorkerSlotLifecycleSync(database, {
+                campaign,
+                expectedThreadId,
+                slot,
+                state: "archived",
+            });
+            return campaignResult(parsed, {
+                action,
+                campaign,
+                expected_thread_id: expectedThreadId,
+                slot: record,
+                updated: true,
+            }, [`campaign ${campaign} slot ${record.slot_key} archived ${record.id}`]);
+        }
+        if (action === "brief") {
+            const channel = requiredStringFlag(parsed.flags.channel, "--channel");
+            if (parsed.flags.briefJson === null) {
+                return errorResult("campaign brief requires --brief-json");
+            }
+            const briefId = upsertCampaignChannelBriefSync(database, {
+                brief: jsonObjectArg(parsed.flags.briefJson, "--brief-json"),
+                campaign,
+                channel,
+            });
+            return campaignResult(parsed, {
+                action,
+                brief_id: briefId,
+                campaign,
+                channel,
+                upserted: true,
+            }, [`campaign ${campaign} brief ${channel} upserted ${briefId}`]);
+        }
+        if (action === "assign") {
+            const slot = requiredStringFlag(parsed.flags.slot, "--slot");
+            const title = requiredStringFlag(parsed.flags.title, "--title");
+            const instructions = requiredStringFlag(parsed.flags.instructions, "--instructions");
+            const status = campaignAssignmentStatusArg(parsed.flags.statusState);
+            const metadata = jsonObjectArg(parsed.flags.metadataJson, "--metadata-json");
+            const assignmentId = createCampaignAssignmentSync(database, {
+                campaign,
+                instructions,
+                metadata,
+                slot,
+                title,
+                ...(status ? { status } : {}),
+            });
+            return campaignResult(parsed, {
+                action,
+                assignment_id: assignmentId,
+                campaign,
+                created: true,
+                slot_id: slot,
+            }, [`campaign ${campaign} assignment created ${assignmentId}`]);
+        }
+        if (action === "asset") {
+            const slot = requiredStringFlag(parsed.flags.slot, "--slot");
+            const title = requiredStringFlag(parsed.flags.title, "--title");
+            const assetType = campaignAssetTypeArg(requiredStringFlag(parsed.flags.assetType, "--asset-type"));
+            const status = campaignAssetStatusArg(parsed.flags.statusState);
+            const metadata = jsonObjectArg(parsed.flags.metadataJson, "--metadata-json");
+            const assetReceiptId = recordCampaignAssetReceiptSync(database, {
+                allowAdditionalReceipt: parsed.flags.allowAdditionalReceipt,
+                artifactPath: parsed.flags.artifactPath,
+                assetType,
+                assignment: parsed.flags.assignment,
+                campaign,
+                channel: parsed.flags.channel,
+                metadata,
+                promptSummary: parsed.flags.promptSummary,
+                reviewNotes: parsed.flags.reviewNotes,
+                slot,
+                title,
+                ...(status ? { status } : {}),
+            });
+            return campaignResult(parsed, {
+                action,
+                asset_receipt_id: assetReceiptId,
+                campaign,
+                created: true,
+                slot_id: slot,
+            }, [`campaign ${campaign} asset receipt created ${assetReceiptId}`]);
+        }
+        if (action === "status") {
+            const status = campaignStatusSync(database, campaign);
+            return campaignResult(parsed, status, renderCampaignStatusText(status));
+        }
+        if (action === "dashboard") {
+            const dashboard = campaignDashboardSync(database, campaign);
+            return campaignResult(parsed, dashboard, renderCampaignDashboardText(dashboard));
+        }
+        return errorResult(`Unsupported campaign action: ${action}`);
+    }
+    finally {
+        database.close();
+    }
+}
+function campaignResult(parsed, payload, lines) {
+    return parsed.flags.json ? jsonResult(payload) : textResult(lines);
+}
+function campaignNameArg(parsed) {
+    if (parsed.flags.names.length !== 1) {
+        throw new Error("campaign requires exactly one --name <campaign>");
+    }
+    return parsed.flags.names[0];
+}
+function requiredStringFlag(value, flag) {
+    if (value === null || value.length === 0) {
+        throw new Error(`campaign requires ${flag}`);
+    }
+    return value;
+}
+function campaignSlotStateArg(value) {
+    if (value === null) {
+        return undefined;
+    }
+    if (value === "active" || value === "archived" || value === "blocked" || value === "idle" || value === "planned") {
+        return value;
+    }
+    throw new Error("--state must be one of: active, archived, blocked, idle, planned");
+}
+function campaignAssignmentStatusArg(value) {
+    if (value === null) {
+        return undefined;
+    }
+    if (value === "active" || value === "blocked" || value === "cancelled" || value === "done" || value === "queued") {
+        return value;
+    }
+    throw new Error("--status must be one of: active, blocked, cancelled, done, queued");
+}
+function campaignAssetStatusArg(value) {
+    if (value === null) {
+        return undefined;
+    }
+    if (value === "approved" || value === "draft" || value === "needs_review" || value === "published" || value === "rejected") {
+        return value;
+    }
+    throw new Error("--status must be one of: approved, draft, needs_review, published, rejected");
+}
+function campaignAssetTypeArg(value) {
+    if (value === "audio" || value === "copy" || value === "hyperframes" || value === "image" || value === "other" || value === "video") {
+        return value;
+    }
+    throw new Error("--asset-type must be one of: audio, copy, hyperframes, image, other, video");
+}
+function renderCampaignStatusText(status) {
+    return [
+        `campaign ${status.campaign.name} ${status.campaign.status}`,
+        `slots ${status.slots.length}`,
+        `assignments ${statusCountsText(status.assignment_counts)}`,
+        `assets ${statusCountsText(status.asset_counts)}`,
+        `briefs ${status.channel_briefs.length}`,
+    ];
+}
+function renderCampaignDashboardText(dashboard) {
+    const lines = [
+        `campaign ${dashboard.campaign.name} ${dashboard.campaign.status}`,
+        `next ${dashboard.next_manager_action.action}: ${dashboard.next_manager_action.reason}`,
+        `workers active=${dashboard.summary.active_slots} stale=${dashboard.summary.stale_slots} blocked=${dashboard.summary.blocked_slots} archived=${dashboard.summary.archived_slots}`,
+        `assignments ${statusCountsText(dashboard.assignment_counts)}`,
+        `assets ${statusCountsText(dashboard.asset_counts)}`,
+        `approvals needs_review=${dashboard.approvals.needs_review} approved=${dashboard.approvals.approved} rejected=${dashboard.approvals.rejected} published=${dashboard.approvals.published}`,
+        `blockers ${dashboard.blockers.length}`,
+    ];
+    for (const slot of dashboard.slots.slice(0, 8)) {
+        lines.push(`slot ${slot.slot_key} ${slot.state} ${slot.lifecycle.state} assignments=${slot.assignments.length} assets=${slot.assets.length}`);
+    }
+    return lines;
+}
+function statusCountsText(counts) {
+    return Object.entries(counts).map(([status, count]) => `${status}=${count}`).join(" ");
+}
 function runLegacyStartCommand(parsed, options) {
     if (!parsed.task) {
         return errorResult("start requires a session.");
@@ -5790,7 +6528,14 @@ function runInstallSkillsCommand(parsed, options) {
     return { exitCode: 0, handled: true, stdout: `${lines.join("\n")}\n` };
 }
 function dashboardLaunchPayload(parsed) {
-    const query = parsed.flags.taskName ? `?task=${encodeURIComponent(parsed.flags.taskName)}` : "";
+    const queryParams = new URLSearchParams();
+    if (parsed.flags.taskName) {
+        queryParams.set("task", parsed.flags.taskName);
+    }
+    if (parsed.flags.campaignName) {
+        queryParams.set("campaign", parsed.flags.campaignName);
+    }
+    const query = queryParams.toString() ? `?${queryParams.toString()}` : "";
     const command = [
         "npm",
         "run",
@@ -5806,6 +6551,9 @@ function dashboardLaunchPayload(parsed) {
     if (parsed.flags.taskName) {
         command.push("--task", parsed.flags.taskName);
     }
+    if (parsed.flags.campaignName) {
+        command.push("--campaign", parsed.flags.campaignName);
+    }
     if (parsed.flags.path) {
         command.push("--db-path", parsed.flags.path);
     }
@@ -5816,6 +6564,7 @@ function dashboardLaunchPayload(parsed) {
         ensure_dispatch: parsed.flags.require,
         host: parsed.flags.host,
         port: parsed.flags.port,
+        campaign: parsed.flags.campaignName,
         task: parsed.flags.taskName,
         url: `http://${parsed.flags.host}:${parsed.flags.port}/${query}`,
     };
@@ -14563,6 +15312,8 @@ function isDefaultRuntimeCommand(command) {
         || command === "app-wakeup-plan"
         || command === "app-wakeup-dispatch"
         || command === "app-wakeup-record-delivery"
+        || command === "app-worker-rotation-plan"
+        || command === "app-worker-rotation-record"
         || command === "app-autopilot"
         || command === "loop-templates"
         || command === "loop-triggers"
@@ -14578,6 +15329,7 @@ function isDefaultRuntimeCommand(command) {
         || command === "replay"
         || command === "export-task"
         || command === "tasks"
+        || command === "campaign"
         || command === "bind"
         || command === "unbind"
         || command === "create-disposable-binding"