agent-conveyor 0.1.21 → 0.1.23

package/dist/cli/typescript-runtime.js

@@ -18,7 +18,7 @@ import { executeDispatchCommandSync } from "../runtime/dispatch.js";
 import { deregisterSessionSync, discoverRegistrySync, findRolloutPathForPid, listRegisteredSessionsSync, registerSessionSync, readSessionMeta, sessionRow, } from "../runtime/codex-session.js";
 import { managerConfigPermissionAllowed, managerConfigSync } from "../runtime/manager-config.js";
 import { canonicalManagerPermissionNames, flattenManagerPermissions, normalizeManagerPermissions, } from "../runtime/manager-permissions.js";
-import { deferRoutedNotificationBeforeSideEffectSync, deliveryModeForTargetSessionSync, finishRoutedNotificationSync, insertRoutedNotificationSync, markRoutedNotificationSideEffectStartedSync, consumeNextSessionInboxItemSync, routedNotificationsSync, sessionInboxSync, } from "../runtime/notifications.js";
+import { deferRoutedNotificationBeforeSideEffectSync, deliveryModeForTargetSessionSync, finishRoutedNotificationSync, insertRoutedNotificationSync, insertNotificationAcknowledgementSync, latestNotificationAcknowledgementSync, markRoutedNotificationSideEffectStartedSync, notificationAcknowledgementsSync, consumeNextSessionInboxItemSync, routedNotificationsSync, sessionInboxSync, } from "../runtime/notifications.js";
 import { activeBindingForTaskSync, bindSessionsSync, createTaskSync, listTasksSync, unbindTaskSync, } from "../runtime/tasks.js";
 import { captureTmuxTargetWithRunner, captureTranscriptTmuxTargetWithRunner, currentPaneIdWithRunner, killTmuxSessionWithRunner, sendEnterToTmuxSessionWithRunner, sendTextToSessionWithRunner, sessionExists, startTmuxSessionWithRunner, tmuxCommandFailureMessage, tmuxSession, tmuxSessionRunning, } from "../runtime/tmux.js";
 import { captureMetaPath, configPath, defaultDbPath, eventsPath, loadJsonSync, stateRoot, statusPath, transcriptPath, validateWorkerName, workerDir, writeJsonSync, } from "../state/files.js";
@@ -144,6 +144,9 @@ export function runTypescriptRuntimeCommand(options) {
         if (parsed.command === "app-autopilot") {
             return runAppAutopilotCommand(parsed, options);
         }
+        if (parsed.command === "app-smoke") {
+            return runAppSmokeCommand(parsed, options);
+        }
         if (parsed.command === "qa-plan") {
             return runQaPlanCommand(parsed);
         }
@@ -261,6 +264,9 @@ export function runTypescriptRuntimeCommand(options) {
         if (parsed.command === "manager-ack") {
             return runTaskAckCommand(parsed, options, "manager");
         }
+        if (parsed.command === "inbox-ack") {
+            return runInboxAckCommand(parsed, options);
+        }
         if (parsed.command === "session-inbox") {
             return runSessionInboxCommand(parsed, options, "session");
         }
@@ -420,6 +426,15 @@ function commandHelpText(program, command) {
             "Example JSON:",
             `  {"task":"my-task","manager_session":"mgr","supervision_contract":"I will supervise through Conveyor and verify criteria before finishing.","will_not_edit_project_files":true}`,
         ],
+        "inbox-ack": [
+            `usage: ${program} inbox-ack <task> --notification-id N --role manager|worker --status received|accepted|blocked --from-stdin ${path} [--json]`,
+            `usage: ${program} inbox-ack <task> --notification-id N --json ${path}`,
+            "",
+            "Record or read a notification-scoped manager/worker acknowledgement.",
+            "",
+            "Example JSON:",
+            `  {"summary":"Received manager instruction and will run the bounded task.","evidence":[]}`,
+        ],
         nudge: [
             `usage: ${program} nudge <worker-or-session> <message> ${path} [--dry-run]`,
             `usage: ${program} session-nudge <session> <message> ${path} [--dry-run]`,
@@ -439,6 +454,18 @@ 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-smoke": [
+            `usage: ${program} app-smoke preflight|start|record|status <task> [--mode required|advisory|skip] [--scope pair|worker-set] [--smoke-id ID] [--nonce NONCE] [--role manager|worker] [--status sent|skipped|received|accepted|blocked] [--thread-id ID] [--notification-id N] [--worker-count N] ${path} [--from-stdin] [--json]`,
+            "",
+            "Manage a blocking Codex app connection smoke lifecycle for manager/worker bindings.",
+            "The CLI records durable smoke receipts; the Codex app/plugin layer still performs live app-thread sends.",
+            "",
+            "Examples:",
+            `  ${program} app-smoke preflight dogfood --mode required --path /tmp/work/workerctl.db --json`,
+            `  ${program} app-smoke start dogfood --mode required --path /tmp/work/workerctl.db --json`,
+            `  ${program} app-smoke record dogfood --smoke-id smoke-123 --nonce nonce --role worker --status accepted --thread-id thread-worker --from-stdin --path /tmp/work/workerctl.db --json`,
+            `  ${program} app-smoke status 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]`,
             "",
@@ -584,6 +611,7 @@ function parseRuntimeArgs(args, env) {
         nextAction: null,
         noFollowup: false,
         nextSteps: [],
+        notificationId: null,
         output: null,
         path: null,
         pid: null,
@@ -617,6 +645,10 @@ function parseRuntimeArgs(args, env) {
         subtype: null,
         summary: null,
         source: null,
+        smokeId: null,
+        smokeMode: null,
+        smokeNonce: null,
+        smokeScope: null,
         objective: null,
         promptSummary: null,
         proof: null,
@@ -722,6 +754,7 @@ function parseRuntimeArgs(args, env) {
         telemetryView: null,
         telemetryViewTask: null,
         workerName: null,
+        workerCount: null,
         search: null,
         severity: null,
         staleCycleSeconds: 3600.0,
@@ -1502,7 +1535,7 @@ function parseRuntimeArgs(args, env) {
             index += 1;
         }
         else if (arg === "--from-stdin") {
-            if (command !== "criteria-plan" && command !== "continuation" && command !== "worker-ack" && command !== "manager-ack") {
+            if (command !== "criteria-plan" && command !== "continuation" && command !== "worker-ack" && command !== "manager-ack" && command !== "inbox-ack" && command !== "app-smoke") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --from-stdin", explicit, flags, task };
             }
             flags.fromStdin = true;
@@ -1636,7 +1669,8 @@ function parseRuntimeArgs(args, env) {
                 && command !== "app-loop-status"
                 && command !== "app-wakeup-plan"
                 && command !== "app-wakeup-dispatch"
-                && command !== "app-autopilot") {
+                && command !== "app-autopilot"
+                && command !== "app-smoke") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --dispatcher-id", explicit, flags, task };
             }
             const value = valueAfter(queue, index, arg);
@@ -2034,7 +2068,7 @@ function parseRuntimeArgs(args, env) {
             index += 1;
         }
         else if (arg === "--thread-id") {
-            if (command !== "app-wakeup-record-delivery" && command !== "campaign") {
+            if (command !== "app-wakeup-record-delivery" && command !== "campaign" && command !== "app-smoke") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --thread-id", explicit, flags, task };
             }
             const value = valueAfter(queue, index, arg);
@@ -2312,6 +2346,14 @@ function parseRuntimeArgs(args, env) {
                 index += 1;
                 continue;
             }
+            if (command === "app-smoke") {
+                if (value !== "required" && value !== "advisory" && value !== "skip") {
+                    return { command, enabled, error: `Unsupported app-smoke mode: ${value}`, explicit, flags, task };
+                }
+                flags.smokeMode = value;
+                index += 1;
+                continue;
+            }
             if (!isTranscriptCaptureMode(value)) {
                 return { command, enabled, error: `Unsupported transcript capture mode: ${value}`, explicit, flags, task };
             }
@@ -2373,7 +2415,7 @@ function parseRuntimeArgs(args, env) {
                 flags.epilogueStatus = true;
                 continue;
             }
-            if (command !== "criteria" && command !== "runs" && command !== "loop-evidence" && command !== "campaign") {
+            if (command !== "criteria" && command !== "runs" && command !== "loop-evidence" && command !== "campaign" && command !== "inbox-ack" && command !== "app-smoke") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --status", explicit, flags, task };
             }
             const parsedValue = valueAfter(queue, index, arg);
@@ -2383,11 +2425,66 @@ function parseRuntimeArgs(args, env) {
             if (command === "criteria") {
                 flags.statuses.push(parsedValue.value);
             }
+            else if (command === "inbox-ack" || command === "app-smoke") {
+                flags.statusState = parsedValue.value;
+            }
             else {
                 flags.statusState = parsedValue.value;
             }
             index += 1;
         }
+        else if (arg === "--notification-id") {
+            if (command !== "inbox-ack" && command !== "app-smoke") {
+                return { command, enabled, error: "Unsupported TypeScript runtime option: --notification-id", 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: "--notification-id must be a positive integer.", explicit, flags, task };
+            }
+            flags.notificationId = value;
+            index += 1;
+        }
+        else if (arg === "--smoke-id" || arg === "--nonce" || arg === "--scope") {
+            if (command !== "app-smoke") {
+                return { command, enabled, error: `Unsupported TypeScript runtime option: ${arg}`, explicit, flags, task };
+            }
+            const parsedValue = valueAfter(queue, index, arg);
+            if (parsedValue.error) {
+                return { command, enabled, error: parsedValue.error, explicit, flags, task };
+            }
+            if (arg === "--smoke-id") {
+                flags.smokeId = parsedValue.value;
+            }
+            else if (arg === "--nonce") {
+                flags.smokeNonce = parsedValue.value;
+            }
+            else {
+                if (parsedValue.value !== "pair" && parsedValue.value !== "worker-set") {
+                    return { command, enabled, error: `Unsupported app-smoke scope: ${parsedValue.value}`, explicit, flags, task };
+                }
+                flags.smokeScope = parsedValue.value;
+            }
+            index += 1;
+        }
+        else if (arg === "--worker-count") {
+            if (command !== "app-smoke") {
+                return { command, enabled, error: "Unsupported TypeScript runtime option: --worker-count", 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: "--worker-count must be a positive integer.", explicit, flags, task };
+            }
+            flags.workerCount = value;
+            index += 1;
+        }
         else if (arg === "--type") {
             const value = valueAfter(queue, index, arg);
             if (value.error) {
@@ -2537,10 +2634,12 @@ function parseRuntimeArgs(args, env) {
                 && command !== "enqueue-continue-iteration"
                 && command !== "worker-ack"
                 && command !== "manager-ack"
+                && command !== "inbox-ack"
                 && command !== "loop-evidence"
                 && command !== "continuation"
                 && command !== "continuation-reviewer"
-                && command !== "epilogue") {
+                && command !== "epilogue"
+                && command !== "app-smoke") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --correlation-id", explicit, flags, task };
             }
             const value = valueAfter(queue, index, arg);
@@ -3036,6 +3135,12 @@ function parseRuntimeArgs(args, env) {
             }
             flags.action = arg;
         }
+        else if (command === "app-smoke" && flags.action === null) {
+            if (!["preflight", "record", "start", "status"].includes(arg)) {
+                return { command, enabled, error: `Unsupported app-smoke action: ${arg}`, explicit, flags, task };
+            }
+            flags.action = arg;
+        }
         else if (command === "campaign" && flags.action === null) {
             if (!CAMPAIGN_ACTIONS.has(arg)) {
                 return { command, enabled, error: unsupportedCampaignActionMessage(arg), explicit, flags, task };
@@ -3863,7 +3968,7 @@ function runAppWakeupRecordDeliveryCommand(parsed, options) {
         if (!action) {
             throw new Error(`Receipt ${source.id} has no ${role} wake action.`);
         }
-        validateAppWakeupDelivery({ action, deliveryStatus, role, threadId: parsed.flags.threadId });
+        validateAppWakeupDelivery({ action, deliveryStatus, reason: parsed.flags.reason, role, threadId: parsed.flags.threadId });
         const timestamp = nowIsoSeconds(options);
         const eventId = emitTelemetrySync(database, {
             actor: "manager",
@@ -4326,6 +4431,407 @@ function runAppAutopilotCommand(parsed, options) {
         database.close();
     }
 }
+function runAppSmokeCommand(parsed, options) {
+    const action = parsed.flags.action;
+    if (action !== "preflight" && action !== "record" && action !== "start" && action !== "status") {
+        return errorResult("app-smoke requires an action: preflight, start, record, or status");
+    }
+    const taskName = requireTask(parsed);
+    const database = openRuntimeDatabase(parsed, options);
+    try {
+        const timestamp = nowIsoSeconds(options);
+        const dbPath = runtimeDbPath(parsed, options);
+        const task = taskRowForDiagnostics(database, taskName);
+        if (action === "preflight") {
+            const output = appSmokePreflightSync(database, {
+                dbPath,
+                mode: parseAppSmokeMode(parsed.flags.smokeMode),
+                scope: parseAppSmokeScope(parsed.flags.smokeScope),
+                task,
+                workerCount: parsed.flags.workerCount ?? 1,
+            });
+            return parsed.flags.json ? jsonResult(output) : { exitCode: 0, handled: true, stdout: renderAppSmokeStatusText(output) };
+        }
+        if (action === "start") {
+            const mode = parseAppSmokeMode(parsed.flags.smokeMode);
+            const scope = parseAppSmokeScope(parsed.flags.smokeScope);
+            const binding = activeBindingForTaskSync(database, task.name);
+            const smokeId = parsed.flags.smokeId ?? `smoke-${randomUUID()}`;
+            const nonce = parsed.flags.smokeNonce ?? `nonce-${randomUUID()}`;
+            const eventId = emitTelemetrySync(database, {
+                actor: "operator",
+                attributes: {
+                    binding_id: binding.binding_id,
+                    mode,
+                    nonce,
+                    scope,
+                    smoke_id: smokeId,
+                    worker_count: parsed.flags.workerCount ?? 1,
+                },
+                correlation: {
+                    command: "app-smoke",
+                    smoke_id: smokeId,
+                },
+                eventType: mode === "skip" ? "app_smoke_skipped" : "app_smoke_started",
+                severity: mode === "skip" ? "warning" : "info",
+                summary: mode === "skip" ? `App smoke skipped for ${task.name}.` : `App smoke started for ${task.name}.`,
+                taskId: task.id,
+                timestamp,
+            });
+            const status = appSmokeStatusSync(database, {
+                dbPath,
+                now: timestamp,
+                smokeId,
+                staleAfterSeconds: parsed.flags.appStaleAfterSeconds,
+                task,
+            });
+            const output = {
+                receipt: {
+                    event_id: eventId,
+                    event_type: mode === "skip" ? "app_smoke_skipped" : "app_smoke_started",
+                    recorded_at: timestamp,
+                },
+                smoke: {
+                    id: smokeId,
+                    mode,
+                    nonce,
+                    scope,
+                    worker_count: parsed.flags.workerCount ?? 1,
+                },
+                status,
+                task: { id: task.id, name: task.name },
+            };
+            return parsed.flags.json ? jsonResult(output) : { exitCode: 0, handled: true, stdout: renderAppSmokeStatusText(status) };
+        }
+        if (action === "record") {
+            const smokeId = requiredStringFlag(parsed.flags.smokeId, "--smoke-id");
+            const nonce = requiredStringFlag(parsed.flags.smokeNonce, "--nonce");
+            const role = parseAppSmokeRole(parsed.flags.role);
+            const status = parseAppSmokeRecordStatus(parsed.flags.statusState);
+            if (role instanceof Error) {
+                return errorResult(role.message);
+            }
+            if (status instanceof Error) {
+                return errorResult(status.message);
+            }
+            const session = latestAppSmokeSessionSync(database, { smokeId, taskId: task.id });
+            if (session.nonce !== nonce) {
+                throw new Error(`Smoke nonce mismatch for ${smokeId}; expected ${session.nonce}.`);
+            }
+            validateAppSmokeRecordThread(database, {
+                role,
+                status,
+                taskId: task.id,
+                taskName: task.name,
+                threadId: parsed.flags.threadId,
+            });
+            const payload = parsed.flags.fromStdin ? parseStdinJsonObject(options.stdin) : {};
+            const eventId = emitTelemetrySync(database, {
+                actor: role,
+                attributes: {
+                    notification_id: parsed.flags.notificationId,
+                    nonce,
+                    payload,
+                    payload_keys: Object.keys(payload).sort(),
+                    role,
+                    smoke_id: smokeId,
+                    status,
+                    thread_id: parsed.flags.threadId,
+                },
+                correlation: {
+                    command: "app-smoke",
+                    correlation_id: parsed.flags.correlationId,
+                    nonce,
+                    role,
+                    smoke_id: smokeId,
+                },
+                eventType: "app_smoke_receipt_recorded",
+                severity: status === "blocked" ? "warning" : "info",
+                summary: `App smoke ${status} recorded for ${role} on ${task.name}.`,
+                taskId: task.id,
+                timestamp,
+            });
+            const output = {
+                receipt: {
+                    event_id: eventId,
+                    event_type: "app_smoke_receipt_recorded",
+                    recorded_at: timestamp,
+                },
+                smoke: {
+                    id: smokeId,
+                    nonce,
+                },
+                task: { id: task.id, name: task.name },
+            };
+            return parsed.flags.json ? jsonResult(output) : { exitCode: 0, handled: true, stdout: `App smoke ${status} recorded for ${role}.\n` };
+        }
+        const status = appSmokeStatusSync(database, {
+            dbPath,
+            now: timestamp,
+            smokeId: parsed.flags.smokeId,
+            staleAfterSeconds: parsed.flags.appStaleAfterSeconds,
+            task,
+        });
+        return parsed.flags.json ? jsonResult(status) : { exitCode: 0, handled: true, stdout: renderAppSmokeStatusText(status) };
+    }
+    finally {
+        database.close();
+    }
+}
+function appSmokePreflightSync(database, options) {
+    let binding = null;
+    let bindingError = null;
+    try {
+        binding = activeBindingForTaskSync(database, options.task.name);
+    }
+    catch (error) {
+        bindingError = error instanceof Error ? error.message : String(error);
+    }
+    const bound = binding ? appSmokeBoundSessionsSync(database, options.task.id) : null;
+    const checks = [
+        { ok: true, name: "ledger_writable", path: options.dbPath },
+        { ok: true, name: "package_cli_available", command: "app-smoke" },
+        {
+            detail: bindingError,
+            ok: binding !== null,
+            name: "active_binding",
+        },
+        {
+            ok: Boolean(bound?.manager.thread_id),
+            name: "manager_thread_metadata",
+            thread_id: bound?.manager.thread_id ?? null,
+        },
+        {
+            ok: Boolean(bound?.worker.thread_id),
+            name: "worker_thread_metadata",
+            thread_id: bound?.worker.thread_id ?? null,
+        },
+        {
+            ok: false,
+            name: "codex_app_thread_tools",
+            note: "Plain CLI cannot call Codex app thread tools; the plugin skill must perform live sends.",
+            required_in_plugin: true,
+        },
+    ];
+    const blockers = options.mode === "required"
+        ? checks.filter((check) => !check.ok && check.name !== "codex_app_thread_tools").map((check) => `${check.name}${check.detail ? `: ${check.detail}` : ""}`)
+        : [];
+    return {
+        blockers,
+        checks,
+        mode: options.mode,
+        ok: blockers.length === 0,
+        real_work_allowed: options.mode !== "required" || blockers.length === 0,
+        scope: options.scope,
+        task: { id: options.task.id, name: options.task.name },
+        worker_count: options.workerCount,
+    };
+}
+function appSmokeStatusSync(database, options) {
+    const smoke = latestAppSmokeSessionSync(database, { smokeId: options.smokeId, taskId: options.task.id });
+    const bound = appSmokeBoundSessionsSync(database, options.task.id);
+    const receipts = appSmokeReceiptsSync(database, { smokeId: smoke.smoke_id, taskId: options.task.id });
+    const manager = appSmokeRoleStatus("manager", bound.manager, receipts, smoke, options);
+    const worker = appSmokeRoleStatus("worker", bound.worker, receipts, smoke, options);
+    const blockers = smoke.mode === "skip" ? [] : [
+        ...appSmokeScopeBlockers(smoke),
+        ...appSmokeRoleBlockers("manager", manager),
+        ...appSmokeRoleBlockers("worker", worker),
+    ];
+    const ok = blockers.length === 0;
+    return {
+        blockers,
+        ok,
+        real_work_allowed: smoke.mode === "skip" || smoke.mode === "advisory" || ok,
+        roles: {
+            manager,
+            worker,
+        },
+        smoke: {
+            id: smoke.smoke_id,
+            mode: smoke.mode,
+            nonce: smoke.nonce,
+            recorded_at: smoke.recorded_at,
+            scope: smoke.scope,
+            worker_count: smoke.worker_count,
+        },
+        task: { id: options.task.id, name: options.task.name },
+    };
+}
+function appSmokeRoleStatus(role, session, receipts, smoke, options) {
+    const roleReceipts = receipts.filter((receipt) => receipt.role === role && receipt.nonce === smoke.nonce);
+    const sent = roleReceipts.some((receipt) => receipt.status === "sent");
+    const received = roleReceipts.some((receipt) => receipt.status === "received");
+    const accepted = roleReceipts.some((receipt) => receipt.status === "accepted");
+    const blockedReceipt = roleReceipts.find((receipt) => receipt.status === "blocked");
+    const heartbeatFresh = session.last_heartbeat_at !== null
+        && session.last_heartbeat_at >= smoke.recorded_at
+        && secondsBetweenIso(session.last_heartbeat_at, options.now) <= options.staleAfterSeconds;
+    return {
+        accepted,
+        blocked: Boolean(blockedReceipt),
+        blocker: typeof blockedReceipt?.payload.summary === "string" ? blockedReceipt.payload.summary : null,
+        heartbeat_fresh: heartbeatFresh,
+        last_heartbeat_at: session.last_heartbeat_at,
+        received,
+        sent,
+        session_id: session.session_id,
+        session_name: session.session_name,
+        thread_id: session.thread_id,
+    };
+}
+function appSmokeRoleBlockers(role, status) {
+    const blockers = [];
+    if (!status.thread_id) {
+        blockers.push(`${role} has no Codex app thread id`);
+    }
+    if (!status.sent) {
+        blockers.push(`${role} smoke prompt has not been recorded as sent`);
+    }
+    if (!status.heartbeat_fresh) {
+        blockers.push(`${role} heartbeat is not fresh after smoke start`);
+    }
+    if (role === "worker" && !status.received) {
+        blockers.push("worker has not recorded smoke received");
+    }
+    if (!status.accepted) {
+        blockers.push(`${role} has not accepted smoke`);
+    }
+    if (status.blocked) {
+        blockers.push(`${role} smoke blocked${status.blocker ? `: ${status.blocker}` : ""}`);
+    }
+    return blockers;
+}
+function appSmokeScopeBlockers(smoke) {
+    if (smoke.scope === "worker-set" && smoke.worker_count > 1) {
+        return [`worker-set smoke for one task proves 1 of ${smoke.worker_count} workers; run per-worker smoke and aggregate in the plugin skill`];
+    }
+    return [];
+}
+function latestAppSmokeSessionSync(database, options) {
+    const params = [options.taskId];
+    const smokeClause = options.smokeId ? "and json_extract(attributes_json, '$.smoke_id') = ?" : "";
+    if (options.smokeId) {
+        params.push(options.smokeId);
+    }
+    const row = database.prepare(`
+    select id, timestamp, event_type, attributes_json
+    from telemetry_events
+    where task_id = ?
+      and event_type in ('app_smoke_started', 'app_smoke_skipped')
+      ${smokeClause}
+    order by timestamp desc, id desc
+    limit 1
+  `).get(...params);
+    if (!row) {
+        throw new Error(options.smokeId ? `Unknown app smoke session: ${options.smokeId}` : "No app smoke session has been started for this task.");
+    }
+    const attributes = JSON.parse(row.attributes_json);
+    return {
+        event_id: row.id,
+        mode: attributes.mode,
+        nonce: attributes.nonce,
+        recorded_at: row.timestamp,
+        scope: attributes.scope,
+        smoke_id: attributes.smoke_id,
+        worker_count: attributes.worker_count,
+    };
+}
+function appSmokeReceiptsSync(database, options) {
+    const rows = database.prepare(`
+    select attributes_json
+    from telemetry_events
+    where task_id = ?
+      and event_type = 'app_smoke_receipt_recorded'
+      and json_extract(attributes_json, '$.smoke_id') = ?
+    order by timestamp, id
+  `).all(options.taskId, options.smokeId);
+    return rows.map((row) => JSON.parse(row.attributes_json));
+}
+function appSmokeBoundSessionsSync(database, taskId) {
+    const row = database.prepare(`
+    select
+      ms.id as manager_session_id,
+      ms.name as manager_session_name,
+      ms.codex_app_thread_id as manager_thread_id,
+      ms.codex_app_thread_title as manager_thread_title,
+      ms.last_heartbeat_at as manager_last_heartbeat_at,
+      ws.id as worker_session_id,
+      ws.name as worker_session_name,
+      ws.codex_app_thread_id as worker_thread_id,
+      ws.codex_app_thread_title as worker_thread_title,
+      ws.last_heartbeat_at as worker_last_heartbeat_at
+    from bindings b
+    join sessions ms on ms.id = b.manager_session_id
+    join sessions ws on ws.id = b.worker_session_id
+    where b.task_id = ?
+      and b.state in ('active', 'ending')
+    order by b.created_at desc
+    limit 1
+  `).get(taskId);
+    if (!row) {
+        throw new Error("No active app smoke binding for task.");
+    }
+    return {
+        manager: {
+            last_heartbeat_at: row.manager_last_heartbeat_at,
+            session_id: row.manager_session_id,
+            session_name: row.manager_session_name,
+            thread_id: row.manager_thread_id,
+            thread_title: row.manager_thread_title,
+        },
+        worker: {
+            last_heartbeat_at: row.worker_last_heartbeat_at,
+            session_id: row.worker_session_id,
+            session_name: row.worker_session_name,
+            thread_id: row.worker_thread_id,
+            thread_title: row.worker_thread_title,
+        },
+    };
+}
+function validateAppSmokeRecordThread(database, options) {
+    const bound = appSmokeBoundSessionsSync(database, options.taskId);
+    const expected = options.role === "manager" ? bound.manager.thread_id : bound.worker.thread_id;
+    if (options.status === "sent" && !options.threadId) {
+        throw new Error("app-smoke record --status sent requires --thread-id.");
+    }
+    if (options.threadId && expected !== options.threadId) {
+        throw new Error(`Thread id mismatch for ${options.role}; active binding for ${options.taskName} targets ${expected ?? "(missing)"}.`);
+    }
+}
+function parseAppSmokeMode(value) {
+    return value === "advisory" || value === "skip" ? value : "required";
+}
+function parseAppSmokeScope(value) {
+    return value === "worker-set" ? "worker-set" : "pair";
+}
+function parseAppSmokeRole(value) {
+    if (value === "manager" || value === "worker") {
+        return value;
+    }
+    return new Error("app-smoke record requires --role manager|worker");
+}
+function parseAppSmokeRecordStatus(value) {
+    if (value === "accepted" || value === "blocked" || value === "received" || value === "sent" || value === "skipped") {
+        return value;
+    }
+    return new Error("app-smoke record requires --status sent|skipped|received|accepted|blocked");
+}
+function secondsBetweenIso(left, right) {
+    return Math.max(0, (Date.parse(right) - Date.parse(left)) / 1000);
+}
+function renderAppSmokeStatusText(status) {
+    const smoke = isPlainRecord(status.smoke) ? status.smoke : {};
+    const blockers = Array.isArray(status.blockers) ? status.blockers.map(String) : [];
+    const lines = [
+        `App smoke ${String(smoke.id ?? "(preflight)")}: ${status.ok ? "ok" : "blocked"}`,
+        `Real work allowed: ${String(status.real_work_allowed ?? false)}`,
+    ];
+    for (const blocker of blockers) {
+        lines.push(`Blocker: ${blocker}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
 function parseAppWakeupDeliveryStatus(value) {
     if (value === "sent" || value === "skipped" || value === "blocked") {
         return value;
@@ -4383,9 +4889,16 @@ function validateAppWakeupDelivery(options) {
         }
         return;
     }
-    if (sourceStatus !== "blocked_missing_thread") {
-        throw new Error(`Cannot record blocked wakeup for ${options.role}; source action is ${sourceStatus}.`);
+    if (sourceStatus === "blocked_missing_thread") {
+        return;
+    }
+    if (sourceStatus === "ready_to_send" && options.action.send_ready === true) {
+        if (!options.reason?.trim()) {
+            throw new Error(`Cannot record blocked wakeup for ${options.role}; ready-to-send source actions require --reason.`);
+        }
+        return;
     }
+    throw new Error(`Cannot record blocked wakeup for ${options.role}; source action is ${sourceStatus}.`);
 }
 function parseAppWakeupSourceActionStatus(value) {
     if (value === "ready_to_send" || value === "skipped_healthy" || value === "blocked_missing_thread") {
@@ -6698,6 +7211,8 @@ function runInstallSkillsCommand(parsed, options) {
 }
 const AGENT_CONVEYOR_PLUGIN_NAME = "agent-conveyor";
 const AGENT_CONVEYOR_PLUGIN_SKILLS = [
+    "conveyor-app-wake-relay",
+    "conveyor-smoke-app-connections",
     "conveyor-create-pair",
     "conveyor-create-worker-set",
     "conveyor-check-status",
@@ -9092,6 +9607,94 @@ function runTaskAckCommand(parsed, options, role) {
         database.close();
     }
 }
+function runInboxAckCommand(parsed, options) {
+    const unsupported = unsupportedInboxAckOptions(parsed);
+    if (unsupported) {
+        return unsupportedRuntimeResult(parsed, unsupported);
+    }
+    const taskName = requireTask(parsed);
+    const notificationId = parsed.flags.notificationId;
+    if (notificationId === null) {
+        return errorResult("inbox-ack requires --notification-id.");
+    }
+    const database = openRuntimeDatabase(parsed, options);
+    try {
+        const task = taskRowForLifecycle(database, taskName);
+        if (task === null) {
+            throw new Error(`Unknown task: ${taskName}`);
+        }
+        const binding = activeBindingForTaskSync(database, task.name);
+        const notification = notificationForInboxAckSync(database, {
+            notificationId,
+            taskId: task.id,
+            taskName: task.name,
+        });
+        if (notification.binding_id !== binding.binding_id) {
+            throw new Error(`Notification ${notificationId} does not belong to the active binding for task ${task.name}.`);
+        }
+        if (!parsed.flags.fromStdin) {
+            const acknowledgements = notificationAcknowledgementsSync(database, { notificationId, taskId: task.id });
+            return jsonResult({
+                acknowledgements,
+                latest: latestNotificationAcknowledgementSync(database, { notificationId, taskId: task.id }),
+                notification: inboxAckNotificationPayload(notification),
+                task: { id: task.id, name: task.name },
+            });
+        }
+        const role = parsed.flags.role;
+        const status = parseNotificationAcknowledgementStatus(parsed.flags.statusState);
+        if (status instanceof Error) {
+            return errorResult(status.message);
+        }
+        validateInboxAcknowledgement({ notification, role, status });
+        const payload = parseStdinJsonObject(options.stdin);
+        const ack = insertNotificationAcknowledgementSync(database, {
+            bindingId: notification.binding_id,
+            correlationId: parsed.flags.correlationId,
+            notificationId,
+            now: nowIsoSeconds(options),
+            payload,
+            role,
+            status,
+            taskId: task.id,
+        });
+        const eventId = emitTelemetrySync(database, {
+            actor: role,
+            attributes: {
+                binding_id: notification.binding_id,
+                notification_id: notificationId,
+                payload_keys: Object.keys(payload).sort(),
+                role,
+                signal_type: notification.signal_type,
+                status,
+            },
+            correlation: {
+                command: "inbox-ack",
+                correlation_id: parsed.flags.correlationId,
+                notification_id: notificationId,
+                role,
+            },
+            eventType: "dispatch_inbox_ack_recorded",
+            severity: status === "blocked" ? "warning" : "info",
+            summary: `${role} recorded ${status} acknowledgement for notification ${notificationId}.`,
+            taskId: task.id,
+            timestamp: ack.created_at,
+        });
+        return jsonResult({
+            acknowledgement: ack,
+            notification: inboxAckNotificationPayload(notification),
+            receipt: {
+                event_id: eventId,
+                event_type: "dispatch_inbox_ack_recorded",
+                recorded_at: ack.created_at,
+            },
+            task: { id: task.id, name: task.name },
+        });
+    }
+    finally {
+        database.close();
+    }
+}
 function runSessionInboxCommand(parsed, options, kind) {
     const unsupported = unsupportedSessionInboxOptions(parsed, kind);
     if (unsupported) {
@@ -9341,6 +9944,59 @@ function latestTaskAcknowledgementSync(database, options) {
         task_id: row.task_id,
     };
 }
+function notificationForInboxAckSync(database, options) {
+    const row = database.prepare(`
+    select rn.id, rn.task_id, rn.binding_id, rn.signal_type, rn.delivered_at,
+           rn.consumed_at, rn.delivery_mode, rn.state, rn.target_session_id,
+           ts.name as target_session_name, ts.role as target_session_role
+    from routed_notifications rn
+    join sessions ts on ts.id = rn.target_session_id
+    where rn.id = ? and rn.task_id = ?
+    limit 1
+  `).get(options.notificationId, options.taskId);
+    if (!row) {
+        throw new Error(`Unknown routed notification for task ${options.taskName}: ${options.notificationId}`);
+    }
+    return row;
+}
+function inboxAckNotificationPayload(notification) {
+    return {
+        binding_id: notification.binding_id,
+        consumed_at: notification.consumed_at,
+        delivered_at: notification.delivered_at,
+        delivery_mode: notification.delivery_mode,
+        id: notification.id,
+        signal_type: notification.signal_type,
+        state: notification.state,
+        target_session_id: notification.target_session_id,
+        target_session_name: notification.target_session_name,
+        target_session_role: notification.target_session_role,
+        task_id: notification.task_id,
+    };
+}
+function parseNotificationAcknowledgementStatus(value) {
+    if (value === "received" || value === "accepted" || value === "blocked") {
+        return value;
+    }
+    return new Error("inbox-ack --status must be received, accepted, or blocked.");
+}
+function validateInboxAcknowledgement(options) {
+    if (options.notification.target_session_role !== options.role) {
+        throw new Error(`Cannot record ${options.role} acknowledgement for notification ${options.notification.id}; target role is ${options.notification.target_session_role}.`);
+    }
+    if (options.notification.state !== "delivered") {
+        throw new Error(`Cannot acknowledge notification ${options.notification.id}; state is ${options.notification.state}, expected delivered.`);
+    }
+    if (options.status === "received") {
+        if (!options.notification.delivered_at) {
+            throw new Error(`Cannot record received acknowledgement for notification ${options.notification.id}; it has no delivered_at receipt.`);
+        }
+        return;
+    }
+    if (!options.notification.consumed_at) {
+        throw new Error(`Cannot record ${options.status} acknowledgement for notification ${options.notification.id}; it has not been consumed by the target session.`);
+    }
+}
 function sessionInboxResponse(database, options) {
     if (options.timeoutSeconds < 0) {
         throw new Error("--timeout must be non-negative");
@@ -15206,6 +15862,26 @@ function unsupportedTaskAckOptions(parsed) {
     }
     return null;
 }
+function unsupportedInboxAckOptions(parsed) {
+    if (!parsed.task) {
+        return "inbox-ack requires a task.";
+    }
+    if (parsed.flags.notificationId === null) {
+        return "inbox-ack requires --notification-id.";
+    }
+    if (!parsed.flags.fromStdin && !parsed.flags.json) {
+        return "inbox-ack requires --from-stdin to write or --json to read.";
+    }
+    if (parsed.flags.fromStdin) {
+        if (parsed.flags.role !== "manager" && parsed.flags.role !== "worker") {
+            return "inbox-ack write requires --role manager|worker.";
+        }
+        if (parsed.flags.statusState === null) {
+            return "inbox-ack write requires --status received|accepted|blocked.";
+        }
+    }
+    return null;
+}
 function unsupportedSessionInboxOptions(parsed, kind) {
     if (!parsed.task) {
         return kind === "session" ? "session-inbox requires a session name." : `${kind}-inbox requires a task.`;
@@ -15677,6 +16353,7 @@ function isDefaultRuntimeCommand(command) {
         || command === "app-worker-rotation-plan"
         || command === "app-worker-rotation-record"
         || command === "app-autopilot"
+        || command === "app-smoke"
         || command === "loop-templates"
         || command === "loop-triggers"
         || command === "ralph-loop-presets"
@@ -15723,6 +16400,7 @@ function isDefaultRuntimeCommand(command) {
         || command === "nudge"
         || command === "worker-ack"
         || command === "manager-ack"
+        || command === "inbox-ack"
         || command === "session-inbox"
         || command === "manager-inbox"
         || command === "worker-inbox"