agent-conveyor 0.1.22 → 0.1.24

package/README.md

@@ -168,9 +168,9 @@ conveyor plugin-status
 
 The per-project default ledger for operator sessions is
 `.codex-workers/workerctl.db`. The initial included skills are
-`conveyor-app-wake-relay`, `conveyor-create-pair`,
-`conveyor-create-worker-set`, `conveyor-check-status`, and
-`conveyor-whats-next-nudger`.
+`conveyor-app-wake-relay`, `conveyor-smoke-app-connections`,
+`conveyor-create-pair`, `conveyor-create-worker-set`,
+`conveyor-check-status`, and `conveyor-whats-next-nudger`.
 
 After install, the intended Codex app entry point is natural language. Open a
 new Codex app session in the target repo and say:
@@ -186,7 +186,21 @@ For multiple workers, start with `Use the conveyor-create-worker-set skill`.
 The installed plugin skill should call the `conveyor` CLI, choose names, create
 the no-tmux binding with `create-disposable-binding`, point the worker at
 `worker-inbox`, and use `loop-status` plus telemetry receipts before reporting
-that the loop is ready. When the manager is itself running in the Codex app and
+that the loop is ready. Pair and worker-set skills run
+`conveyor-smoke-app-connections` before real task work by default. Required
+smoke first checks package/plugin/ledger/thread metadata, then starts a
+nonce-scoped `app-smoke` session and blocks real work until the manager and each
+worker have visible app-thread send receipts, fresh app heartbeats, durable
+received/accepted acknowledgements, and an `app-smoke status` result with
+`real_work_allowed=true`. The plain CLI records and evaluates receipts; the
+Codex app skill/operator layer must perform live `send_message_to_thread`
+delivery and record `sent`, `blocked`, or skipped/advisory evidence. After
+required smoke passes, pair and worker-set skills start `app-autopilot` before
+real work so the just-proved sessions keep polling. A setup is autonomous only
+when the emitted heartbeat automation specs have been applied, or explicitly
+deferred as `manual-poll only`; smoke-passed by itself only proves connection
+plumbing at that moment.
+When the manager is itself running in the Codex app and
 thread tools are available, the skill should first call `create_thread` for a
 fresh same-project worker, name it with `set_thread_title`, pass the returned
 thread identity through `--worker-codex-app-thread-id` and
@@ -539,6 +553,21 @@ stay out of receipts.
   heartbeats since the last command or inbox-consumption receipt, it recommends
   `stop_autopilot` so operators can quiesce blocked/no-progress loops instead
   of repeating idle pulses.
+- `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] [--from-stdin]
+  [--json]` —
+  Record and evaluate the durable side of Codex app connection smoke. Required
+  mode blocks real work until the active binding has bound app thread ids,
+  nonce-matching send receipts, fresh app heartbeats after smoke start, worker
+  `received`, and manager/worker `accepted` receipts. Advisory mode reports the
+  same blockers without blocking, and skip mode records an explicit bypass. The
+  CLI does not call Codex app thread tools; use the
+  `conveyor-smoke-app-connections` plugin skill from a Codex app operator
+  session for live `send_message_to_thread` delivery. A smoke-passed operator
+  flow should immediately run `app-autopilot start` and handle the emitted
+  automation specs before sending real task prompts.
 - `app-worker-rotation-plan TASK --old-worker-thread-id ID [--require-handoff]
   [--reason TEXT] [--json]` — Prepare a Codex app fresh-worker rotation. The
   CLI verifies that `ID` exactly matches the active bound worker session before
@@ -823,7 +852,8 @@ stay out of receipts.
   either received, accepted, or blocked on it. `received` requires delivery;
   `accepted` and `blocked` require consumption. Use this after visible Codex app
   sessions print `CONVEYOR RECEIVED`; do not use direct app-thread text as the
-  durable receipt.
+  durable receipt. `--from-stdin` expects a JSON object, for example
+  `printf '%s\n' '{"summary":"accepted","evidence":["consumed notification"],"blockers":[]}' | conveyor inbox-ack ... --from-stdin`.
 
 ### Actuation
 

package/dist/cli/typescript-runtime.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);
         }
@@ -451,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]`,
             "",
@@ -630,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,
@@ -735,6 +754,7 @@ function parseRuntimeArgs(args, env) {
         telemetryView: null,
         telemetryViewTask: null,
         workerName: null,
+        workerCount: null,
         search: null,
         severity: null,
         staleCycleSeconds: 3600.0,
@@ -1515,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" && command !== "inbox-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;
@@ -1649,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);
@@ -2047,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);
@@ -2325,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 };
             }
@@ -2386,7 +2415,7 @@ function parseRuntimeArgs(args, env) {
                 flags.epilogueStatus = true;
                 continue;
             }
-            if (command !== "criteria" && command !== "runs" && command !== "loop-evidence" && command !== "campaign" && command !== "inbox-ack") {
+            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);
@@ -2396,7 +2425,7 @@ function parseRuntimeArgs(args, env) {
             if (command === "criteria") {
                 flags.statuses.push(parsedValue.value);
             }
-            else if (command === "inbox-ack") {
+            else if (command === "inbox-ack" || command === "app-smoke") {
                 flags.statusState = parsedValue.value;
             }
             else {
@@ -2405,7 +2434,7 @@ function parseRuntimeArgs(args, env) {
             index += 1;
         }
         else if (arg === "--notification-id") {
-            if (command !== "inbox-ack") {
+            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);
@@ -2419,6 +2448,43 @@ function parseRuntimeArgs(args, env) {
             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) {
@@ -2572,7 +2638,8 @@ function parseRuntimeArgs(args, env) {
                 && 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);
@@ -3068,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 };
@@ -4358,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;
@@ -6738,6 +7212,7 @@ 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",
@@ -15878,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"