agent-conveyor 0.1.9 → 0.1.10

package/README.md

@@ -394,6 +394,12 @@ tmux attach -t codex-live-test
   for prepared, skipped, and blocked role wakeups. This command does not send
   `send_message_to_thread`; the Codex app/operator layer sends prompts whose
   actions report `send_ready=true`.
+- `app-wakeup-record-delivery TASK --role manager|worker --dispatch-receipt ID
+  --delivery-status sent|skipped|blocked [--thread-id ID] [--reason TEXT]
+  [--json]` — Record what the Codex app/operator layer did with a wake action.
+  `sent` is accepted only when the referenced `app-wakeup-dispatch` receipt has
+  a matching `ready_to_send` action with `send_ready=true` and the same thread
+  id; healthy and blocked roles must be recorded as `skipped` or `blocked`.
 - `discover [QUERY] [--all] [--limit N]` / `search [QUERY]` — Search tasks,
   registered sessions, active bindings, and recent telemetry in one JSON result.
   Use this for conversational setup when a manager or Codex session needs to

package/dist/cli/typescript-runtime.js

@@ -131,6 +131,9 @@ export function runTypescriptRuntimeCommand(options) {
         if (parsed.command === "app-wakeup-dispatch") {
             return runAppWakeupDispatchCommand(parsed, options);
         }
+        if (parsed.command === "app-wakeup-record-delivery") {
+            return runAppWakeupRecordDeliveryCommand(parsed, options);
+        }
         if (parsed.command === "qa-plan") {
             return runQaPlanCommand(parsed);
         }
@@ -546,9 +549,12 @@ function parseRuntimeArgs(args, env) {
         captureTranscriptLines: DEFAULT_HISTORY_LINES,
         captureTranscriptMode: "segment",
         decisionId: null,
+        deliveryStatus: null,
+        dispatchReceipt: null,
         force: false,
         message: null,
         reason: null,
+        threadId: null,
         consumeNext: false,
         wait: false,
         requireAcks: false,
@@ -1833,7 +1839,7 @@ function parseRuntimeArgs(args, env) {
             index = queue.length;
         }
         else if (arg === "--reason") {
-            if (command !== "finish-task" && command !== "stop-task" && command !== "record-decision" && command !== "compact-worker") {
+            if (command !== "finish-task" && command !== "stop-task" && command !== "record-decision" && command !== "compact-worker" && command !== "app-wakeup-record-delivery") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --reason", explicit, flags, task };
             }
             const value = valueAfter(queue, index, arg);
@@ -1843,6 +1849,39 @@ function parseRuntimeArgs(args, env) {
             flags.reason = value.value;
             index += 1;
         }
+        else if (arg === "--dispatch-receipt") {
+            if (command !== "app-wakeup-record-delivery") {
+                return { command, enabled, error: "Unsupported TypeScript runtime option: --dispatch-receipt", explicit, flags, task };
+            }
+            const value = valueAfter(queue, index, arg);
+            if (value.error) {
+                return { command, enabled, error: value.error, explicit, flags, task };
+            }
+            flags.dispatchReceipt = value.value;
+            index += 1;
+        }
+        else if (arg === "--delivery-status") {
+            if (command !== "app-wakeup-record-delivery") {
+                return { command, enabled, error: "Unsupported TypeScript runtime option: --delivery-status", explicit, flags, task };
+            }
+            const value = valueAfter(queue, index, arg);
+            if (value.error) {
+                return { command, enabled, error: value.error, explicit, flags, task };
+            }
+            flags.deliveryStatus = value.value;
+            index += 1;
+        }
+        else if (arg === "--thread-id") {
+            if (command !== "app-wakeup-record-delivery") {
+                return { command, enabled, error: "Unsupported TypeScript runtime option: --thread-id", explicit, flags, task };
+            }
+            const value = valueAfter(queue, index, arg);
+            if (value.error) {
+                return { command, enabled, error: value.error, explicit, flags, task };
+            }
+            flags.threadId = value.value;
+            index += 1;
+        }
         else if (arg === "--message") {
             if (command !== "finish-task"
                 && command !== "stop-task"
@@ -3552,6 +3591,175 @@ function runAppWakeupDispatchCommand(parsed, options) {
         database.close();
     }
 }
+function runAppWakeupRecordDeliveryCommand(parsed, options) {
+    const taskName = requireTask(parsed);
+    if (parsed.flags.role !== "manager" && parsed.flags.role !== "worker") {
+        return errorResult("app-wakeup-record-delivery requires --role manager|worker");
+    }
+    const role = parsed.flags.role;
+    if (!parsed.flags.dispatchReceipt) {
+        return errorResult("app-wakeup-record-delivery requires --dispatch-receipt");
+    }
+    const deliveryStatus = parseAppWakeupDeliveryStatus(parsed.flags.deliveryStatus);
+    if (deliveryStatus instanceof Error) {
+        return errorResult(deliveryStatus.message);
+    }
+    const database = openRuntimeDatabase(parsed, options);
+    try {
+        const task = taskRowForDiagnostics(database, taskName);
+        const source = database.prepare(`
+      select id, task_id, event_type, attributes_json
+      from telemetry_events
+      where id = ?
+      limit 1
+    `).get(parsed.flags.dispatchReceipt);
+        if (!source) {
+            throw new Error(`Unknown app wakeup dispatch receipt: ${parsed.flags.dispatchReceipt}`);
+        }
+        if (source.event_type !== "app_wakeup_dispatch_planned") {
+            throw new Error(`Receipt ${source.id} is ${source.event_type}, expected app_wakeup_dispatch_planned.`);
+        }
+        if (source.task_id !== task.id) {
+            throw new Error(`Receipt ${source.id} does not belong to task ${task.name}.`);
+        }
+        const attributes = parseAppWakeupDispatchAttributes(source.attributes_json, source.id);
+        const action = attributes.actions.find((candidate) => candidate.role === role);
+        if (!action) {
+            throw new Error(`Receipt ${source.id} has no ${role} wake action.`);
+        }
+        validateAppWakeupDelivery({ action, deliveryStatus, role, threadId: parsed.flags.threadId });
+        const timestamp = nowIsoSeconds(options);
+        const eventId = emitTelemetrySync(database, {
+            actor: "manager",
+            attributes: {
+                delivery_status: deliveryStatus,
+                dispatch_receipt: source.id,
+                dispatch_required: attributes.summary.dispatcher_required,
+                reason: parsed.flags.reason,
+                role,
+                source_action_status: action.status,
+                source_send_ready: action.send_ready === true,
+                thread_id: parsed.flags.threadId ?? action.thread_id ?? null,
+                thread_title: action.thread_title ?? null,
+            },
+            correlation: {
+                command: "app-wakeup-record-delivery",
+                dispatch_receipt: source.id,
+                role,
+                thread_id: parsed.flags.threadId ?? action.thread_id ?? null,
+            },
+            eventType: "app_wakeup_delivery_recorded",
+            severity: deliveryStatus === "sent" ? "info" : "warning",
+            summary: `App wakeup delivery ${deliveryStatus} for ${role} on ${task.name}.`,
+            taskId: task.id,
+            timestamp,
+        });
+        const output = {
+            delivery: {
+                reason: parsed.flags.reason,
+                role,
+                source_action_status: action.status,
+                source_send_ready: action.send_ready === true,
+                status: deliveryStatus,
+                thread_id: parsed.flags.threadId ?? action.thread_id ?? null,
+            },
+            receipt: {
+                event_id: eventId,
+                event_type: "app_wakeup_delivery_recorded",
+                recorded_at: timestamp,
+            },
+            source: {
+                dispatch_receipt: source.id,
+                dispatch_required: attributes.summary.dispatcher_required,
+                dispatcher: attributes.dispatcher,
+            },
+            task: { id: task.id, name: task.name },
+        };
+        if (parsed.flags.json) {
+            return jsonResult(output);
+        }
+        return {
+            exitCode: 0,
+            handled: true,
+            stdout: [
+                `App wakeup delivery ${deliveryStatus} recorded for ${role} on ${task.name}.`,
+                `Source receipt: ${source.id}`,
+                `Receipt: ${eventId}`,
+                attributes.summary.dispatcher_required ? "Dispatch still required by source receipt." : "Dispatch healthy in source receipt.",
+            ].join("\n") + "\n",
+        };
+    }
+    finally {
+        database.close();
+    }
+}
+function parseAppWakeupDeliveryStatus(value) {
+    if (value === "sent" || value === "skipped" || value === "blocked") {
+        return value;
+    }
+    return new Error("app-wakeup-record-delivery requires --delivery-status sent|skipped|blocked");
+}
+function parseAppWakeupDispatchAttributes(value, receiptId) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error(`Receipt ${receiptId} has invalid attributes JSON.`);
+    }
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error(`Receipt ${receiptId} has invalid attributes shape.`);
+    }
+    const attributes = parsed;
+    if (!Array.isArray(attributes.actions)) {
+        throw new Error(`Receipt ${receiptId} is missing actions.`);
+    }
+    const summary = attributes.summary;
+    if (!summary || typeof summary !== "object" || typeof summary.dispatcher_required !== "boolean") {
+        throw new Error(`Receipt ${receiptId} is missing dispatcher_required summary.`);
+    }
+    const dispatcher = attributes.dispatcher && typeof attributes.dispatcher === "object"
+        ? attributes.dispatcher
+        : {};
+    return {
+        actions: attributes.actions,
+        dispatcher,
+        summary: { dispatcher_required: Boolean(summary.dispatcher_required) },
+    };
+}
+function validateAppWakeupDelivery(options) {
+    const sourceStatus = parseAppWakeupSourceActionStatus(options.action.status);
+    if (sourceStatus instanceof Error) {
+        throw sourceStatus;
+    }
+    if (options.deliveryStatus === "sent") {
+        if (sourceStatus !== "ready_to_send" || options.action.send_ready !== true) {
+            throw new Error(`Cannot record sent wakeup for ${options.role}; source action is ${sourceStatus}.`);
+        }
+        if (!options.threadId) {
+            throw new Error("app-wakeup-record-delivery --delivery-status sent requires --thread-id.");
+        }
+        if (options.action.thread_id !== options.threadId) {
+            throw new Error(`Thread id mismatch for ${options.role}; source action targets ${options.action.thread_id ?? "(none)"}.`);
+        }
+        return;
+    }
+    if (options.deliveryStatus === "skipped") {
+        if (sourceStatus !== "skipped_healthy") {
+            throw new Error(`Cannot record skipped wakeup for ${options.role}; source action is ${sourceStatus}.`);
+        }
+        return;
+    }
+    if (sourceStatus !== "blocked_missing_thread") {
+        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") {
+        return value;
+    }
+    return new Error(`Unsupported app wakeup source action status: ${value ?? "(missing)"}.`);
+}
 function renderAppLoopStatusText(status) {
     const lines = [
         `App loop ${status.task.name}: ${status.ok ? "ok" : "attention required"}`,
@@ -13890,6 +14098,7 @@ function isDefaultRuntimeCommand(command) {
         || command === "app-loop-status"
         || command === "app-wakeup-plan"
         || command === "app-wakeup-dispatch"
+        || command === "app-wakeup-record-delivery"
         || command === "loop-templates"
         || command === "loop-triggers"
         || command === "ralph-loop-presets"