agent-conveyor 0.1.7 → 0.1.9

package/dist/cli/typescript-runtime.js

@@ -5,6 +5,7 @@ import { homedir, tmpdir } from "node:os";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { taskAuditSync } from "../runtime/audit.js";
+import { appLoopStatusSync, appWakeupDispatchPlanSync, appWakeupPlanSync, directInboxPollCommand, } from "../runtime/app-autonomy.js";
 import { classifyBusyWait, classifyStartupOutput } from "../runtime/classify.js";
 import { exportTaskSync } from "../runtime/export.js";
 import { ingestSessionSync } from "../runtime/ingest.js";
@@ -118,6 +119,18 @@ export function runTypescriptRuntimeCommand(options) {
         if (parsed.command === "loop-status") {
             return runLoopStatusCommand(parsed, options);
         }
+        if (parsed.command === "app-heartbeat") {
+            return runAppHeartbeatCommand(parsed, options);
+        }
+        if (parsed.command === "app-loop-status") {
+            return runAppLoopStatusCommand(parsed, options);
+        }
+        if (parsed.command === "app-wakeup-plan") {
+            return runAppWakeupPlanCommand(parsed, options);
+        }
+        if (parsed.command === "app-wakeup-dispatch") {
+            return runAppWakeupDispatchCommand(parsed, options);
+        }
         if (parsed.command === "qa-plan") {
             return runQaPlanCommand(parsed);
         }
@@ -417,6 +430,7 @@ function parseRuntimeArgs(args, env) {
         includeLegacy: false,
         help: false,
         redactIdentityToken: false,
+        appStaleAfterSeconds: 180,
         active: false,
         add: false,
         apply: false,
@@ -425,6 +439,10 @@ function parseRuntimeArgs(args, env) {
         candidate: null,
         check: null,
         classifyPrompt: null,
+        workerCodexAppThreadId: null,
+        workerCodexAppThreadTitle: null,
+        managerCodexAppThreadId: null,
+        managerCodexAppThreadTitle: null,
         codexSession: null,
         create: null,
         createRun: null,
@@ -1465,7 +1483,14 @@ function parseRuntimeArgs(args, env) {
             index += 1;
         }
         else if (arg === "--dispatcher-id") {
-            if (command !== "pair" && command !== "dispatch" && command !== "qa-run" && command !== "dashboard") {
+            if (command !== "pair"
+                && command !== "dispatch"
+                && command !== "qa-run"
+                && command !== "dashboard"
+                && command !== "app-heartbeat"
+                && command !== "app-loop-status"
+                && command !== "app-wakeup-plan"
+                && command !== "app-wakeup-dispatch") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --dispatcher-id", explicit, flags, task };
             }
             const value = valueAfter(queue, index, arg);
@@ -1947,6 +1972,31 @@ function parseRuntimeArgs(args, env) {
             flags.manager = value.value;
             index += 1;
         }
+        else if (arg === "--worker-codex-app-thread-id"
+            || arg === "--worker-codex-app-thread-title"
+            || arg === "--manager-codex-app-thread-id"
+            || arg === "--manager-codex-app-thread-title") {
+            if (command !== "create-disposable-binding") {
+                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 === "--worker-codex-app-thread-id") {
+                flags.workerCodexAppThreadId = value.value;
+            }
+            else if (arg === "--worker-codex-app-thread-title") {
+                flags.workerCodexAppThreadTitle = value.value;
+            }
+            else if (arg === "--manager-codex-app-thread-id") {
+                flags.managerCodexAppThreadId = value.value;
+            }
+            else {
+                flags.managerCodexAppThreadTitle = value.value;
+            }
+            index += 1;
+        }
         else if (arg === "--template") {
             if (command !== "create-disposable-binding" && command !== "loop-templates") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --template", explicit, flags, task };
@@ -2373,6 +2423,21 @@ function parseRuntimeArgs(args, env) {
             flags.statusStaleSeconds = value;
             index += 1;
         }
+        else if (arg === "--stale-after") {
+            if (command !== "app-heartbeat" && command !== "app-loop-status" && command !== "app-wakeup-plan" && command !== "app-wakeup-dispatch") {
+                return { command, enabled, error: "Unsupported TypeScript runtime option: --stale-after", explicit, flags, task };
+            }
+            const parsedValue = valueAfter(queue, index, arg);
+            if (parsedValue.error) {
+                return { command, enabled, error: parsedValue.error, explicit, flags, task };
+            }
+            const value = Number(parsedValue.value);
+            if (!Number.isFinite(value) || value < 0) {
+                return { command, enabled, error: "--stale-after must be a non-negative number.", explicit, flags, task };
+            }
+            flags.appStaleAfterSeconds = value;
+            index += 1;
+        }
         else if (arg === "--terminal-stale-seconds") {
             if (command !== "idle-check") {
                 return { command, enabled, error: "Unsupported TypeScript runtime option: --terminal-stale-seconds", explicit, flags, task };
@@ -3318,6 +3383,233 @@ function runLoopStatusCommand(parsed, options) {
         database.close();
     }
 }
+function runAppHeartbeatCommand(parsed, options) {
+    const taskName = requireTask(parsed);
+    if (parsed.flags.role !== "manager" && parsed.flags.role !== "worker") {
+        return errorResult("app-heartbeat requires --role manager|worker");
+    }
+    const role = parsed.flags.role;
+    const database = openRuntimeDatabase(parsed, options);
+    try {
+        const task = taskRowForDiagnostics(database, taskName);
+        const session = boundAppSessionForRoleSync(database, { role, taskId: task.id });
+        const timestamp = nowIsoSeconds(options);
+        const dbPath = runtimeDbPath(parsed, options);
+        database.prepare("update sessions set last_heartbeat_at = ? where id = ?").run(timestamp, session.id);
+        emitTelemetrySync(database, {
+            actor: role,
+            attributes: {
+                direct_inbox_command: directInboxPollCommand(role, task.name, dbPath),
+                role,
+                session_id: session.id,
+                task: task.name,
+            },
+            correlation: { command: "app-heartbeat" },
+            eventType: "app_heartbeat",
+            severity: "info",
+            summary: `${role} app heartbeat for ${task.name}.`,
+            taskId: task.id,
+            timestamp,
+        });
+        const status = appLoopStatusSync(database, {
+            dbPath,
+            dispatcherId: parsed.flags.dispatcherId ?? "dispatch-local",
+            heartbeatStaleSeconds: parsed.flags.appStaleAfterSeconds,
+            now: timestamp,
+            taskName: task.name,
+        });
+        const roleStatus = role === "manager" ? status.manager : status.worker;
+        const output = {
+            heartbeat: {
+                recorded_at: timestamp,
+                state: "recorded",
+            },
+            next: {
+                direct_inbox_command: roleStatus.direct_inbox_command,
+                poll_command: roleStatus.poll_command,
+            },
+            role,
+            status,
+            task: { id: task.id, name: task.name },
+        };
+        if (parsed.flags.json) {
+            return jsonResult(output);
+        }
+        return {
+            exitCode: 0,
+            handled: true,
+            stdout: `${role} heartbeat recorded for ${task.name}\nNext: ${roleStatus.direct_inbox_command ?? roleStatus.poll_command ?? "(none)"}\n`,
+        };
+    }
+    finally {
+        database.close();
+    }
+}
+function runAppLoopStatusCommand(parsed, options) {
+    const taskName = requireTask(parsed);
+    const database = openRuntimeDatabase(parsed, options);
+    try {
+        const status = appLoopStatusSync(database, {
+            dbPath: runtimeDbPath(parsed, options),
+            dispatcherId: parsed.flags.dispatcherId ?? "dispatch-local",
+            heartbeatStaleSeconds: parsed.flags.appStaleAfterSeconds,
+            now: nowIsoSeconds(options),
+            taskName,
+        });
+        if (parsed.flags.json) {
+            return jsonResult(status);
+        }
+        return {
+            exitCode: 0,
+            handled: true,
+            stdout: renderAppLoopStatusText(status),
+        };
+    }
+    finally {
+        database.close();
+    }
+}
+function runAppWakeupPlanCommand(parsed, options) {
+    const taskName = requireTask(parsed);
+    const database = openRuntimeDatabase(parsed, options);
+    try {
+        const plan = appWakeupPlanSync(database, {
+            dbPath: runtimeDbPath(parsed, options),
+            dispatcherId: parsed.flags.dispatcherId ?? "dispatch-local",
+            heartbeatStaleSeconds: parsed.flags.appStaleAfterSeconds,
+            now: nowIsoSeconds(options),
+            taskName,
+        });
+        if (parsed.flags.json) {
+            return jsonResult(plan);
+        }
+        return {
+            exitCode: 0,
+            handled: true,
+            stdout: renderAppWakeupPlanText(plan),
+        };
+    }
+    finally {
+        database.close();
+    }
+}
+function runAppWakeupDispatchCommand(parsed, options) {
+    const taskName = requireTask(parsed);
+    const database = openRuntimeDatabase(parsed, options);
+    try {
+        const timestamp = nowIsoSeconds(options);
+        const dispatch = appWakeupDispatchPlanSync(database, {
+            dbPath: runtimeDbPath(parsed, options),
+            dispatcherId: parsed.flags.dispatcherId ?? "dispatch-local",
+            heartbeatStaleSeconds: parsed.flags.appStaleAfterSeconds,
+            now: timestamp,
+            taskName,
+        });
+        const eventId = emitTelemetrySync(database, {
+            actor: "manager",
+            attributes: {
+                actions: dispatch.actions.map((action) => ({
+                    blocker: action.blocker,
+                    reason: action.reason,
+                    role: action.role,
+                    send_ready: action.send_ready,
+                    status: action.status,
+                    thread_id: action.thread.id,
+                    thread_title: action.thread.title,
+                })),
+                dispatcher: dispatch.dispatcher,
+                status_ok: dispatch.status.ok,
+                summary: dispatch.summary,
+            },
+            correlation: {
+                command: "app-wakeup-dispatch",
+                dispatcher_id: dispatch.status.dispatch.dispatcher_id,
+            },
+            eventType: "app_wakeup_dispatch_planned",
+            severity: dispatch.summary.blocked > 0 || dispatch.dispatcher.required ? "warning" : "info",
+            summary: `App wakeup dispatch planned for ${dispatch.status.task.name}.`,
+            taskId: dispatch.status.task.id,
+            timestamp,
+        });
+        const output = {
+            ...dispatch,
+            receipt: {
+                event_id: eventId,
+                event_type: "app_wakeup_dispatch_planned",
+                recorded_at: timestamp,
+            },
+        };
+        if (parsed.flags.json) {
+            return jsonResult(output);
+        }
+        return {
+            exitCode: 0,
+            handled: true,
+            stdout: renderAppWakeupDispatchText(output),
+        };
+    }
+    finally {
+        database.close();
+    }
+}
+function renderAppLoopStatusText(status) {
+    const lines = [
+        `App loop ${status.task.name}: ${status.ok ? "ok" : "attention required"}`,
+        `Dispatch ${status.dispatch.dispatcher_id}: ${status.dispatch.state}`,
+        `Manager ${status.manager.name ?? "(missing)"}: ${status.manager.lease.state}`,
+        `Worker ${status.worker.name ?? "(missing)"}: ${status.worker.lease.state}`,
+    ];
+    for (const action of status.next_actions) {
+        lines.push(`Next: ${action.kind} - ${action.reason}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+function renderAppWakeupDispatchText(plan) {
+    const lines = [
+        `App wakeup dispatch for ${plan.status.task.name}: ${plan.status.ok ? "ok" : "attention required"}`,
+        `Dispatch: ${plan.dispatcher.state}${plan.dispatcher.required ? ` (${plan.dispatcher.command})` : ""}`,
+        `Receipt: ${plan.receipt.event_type} ${plan.receipt.event_id}`,
+    ];
+    for (const action of plan.actions) {
+        lines.push(`${action.role}: ${action.status} - ${action.reason}`);
+        if (action.blocker) {
+            lines.push(`Blocker: ${action.blocker}`);
+        }
+        if (action.send_ready && action.thread.id) {
+            lines.push(`Thread: ${action.thread.title ?? "(untitled)"} ${action.thread.id}`);
+        }
+        if (action.prompt) {
+            lines.push(action.prompt);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+function renderAppWakeupPlanText(plan) {
+    const lines = [
+        `App wakeup plan for ${plan.status.task.name}: ${plan.status.ok ? "ok" : "attention required"}`,
+        `Dispatch: ${plan.dispatcher.state}${plan.dispatcher.required ? ` (${plan.dispatcher.command})` : ""}`,
+    ];
+    for (const wakeup of plan.wakeups) {
+        lines.push(`Wake ${wakeup.role}${wakeup.thread.title ? ` (${wakeup.thread.title})` : ""}: ${wakeup.reason}`);
+        lines.push(wakeup.prompt);
+    }
+    return `${lines.join("\n")}\n`;
+}
+function boundAppSessionForRoleSync(database, options) {
+    const sessionJoin = options.role === "manager" ? "manager_session_id" : "worker_session_id";
+    const row = database.prepare(`
+    select s.id, s.name
+    from bindings b
+    join sessions s on s.id = b.${sessionJoin}
+    where b.task_id = ? and b.state in ('active', 'ending') and s.role = ? and s.state = 'active'
+    order by b.created_at desc
+    limit 1
+  `).get(options.taskId, options.role);
+    if (!row) {
+        throw new Error(`No active bound ${options.role} session for task.`);
+    }
+    return row;
+}
 function runQaPlanCommand(parsed) {
     const unsupported = unsupportedLoopCommandOptions(parsed, {
         allowedFlags: new Set(["json", "subtype"]),
@@ -3968,10 +4260,10 @@ function qaRunBuildClearLoop(context) {
     const artifactDir = qaArtifactDir(context, "build-clear-loop", slug, run.id);
     const buildReceipt = join(artifactDir, "build-passed.json");
     mkdirSync(dirname(buildReceipt), { recursive: true });
-    writeFileSync(buildReceipt, `${JSON.stringify(sortJson({ command: "scripts/run-unittests-isolated -k build_clear_loop", result: "pass", status: "build_passed" }), null, 2)}\n`);
+    writeFileSync(buildReceipt, `${JSON.stringify(sortJson({ command: "npm test -- --runInBand", result: "pass", status: "build_passed" }), null, 2)}\n`);
     qaRecordLoopEvidence(context, task, run.id, "build_passed", "qa-run-build-clear-build-passed", {
         artifactPath: buildReceipt,
-        metadata: { command: "scripts/run-unittests-isolated -k build_clear_loop", result: "Focused build/test command passed before retry." },
+        metadata: { command: "npm test -- --runInBand", result: "Focused build/test command passed before retry." },
     });
     enqueueQaContinue(context, task, run.id, "qa-run-build-clear-build-only", "Run after build evidence only.");
     const buildOnlyDispatch = qaDispatchContinueOnce(context, "qa-run-build-clear-build-only");
@@ -4884,19 +5176,14 @@ function dispatchWatchCommand(workerctlPath, dispatcherId, dbPath) {
 }
 function installableSkillSources() {
     const root = packageRootFromRuntimeModule();
-    const candidates = [
-        join(root, "skills"),
-        join(root, "workerctl", "assets", "skills"),
-    ];
-    for (const candidate of candidates) {
-        const skills = ["manage-codex-workers", "codex-review"]
-            .map((name) => ({ name, source: join(candidate, name) }))
-            .filter((skill) => existsSync(join(skill.source, "SKILL.md")));
-        if (skills.length === 2) {
-            return skills;
-        }
+    const candidate = join(root, "skills");
+    const skills = ["manage-codex-workers", "codex-review"]
+        .map((name) => ({ name, source: join(candidate, name) }))
+        .filter((skill) => existsSync(join(skill.source, "SKILL.md")));
+    if (skills.length === 2) {
+        return skills;
     }
-    throw new Error("Bundled Agent Conveyor skills not found in skills/ or workerctl/assets/skills.");
+    throw new Error("Bundled Agent Conveyor skills not found in skills/.");
 }
 function runBindCommand(parsed, options) {
     const unsupported = unsupportedBindOptions(parsed);
@@ -4997,6 +5284,8 @@ function runCreateDisposableBindingCommand(parsed, options) {
         const workerRollout = writeDisposableRollout(sessionDir, workerName, cwd);
         const managerRollout = writeDisposableRollout(sessionDir, managerName, cwd);
         const worker = registerSessionSync(database, {
+            codexAppThreadId: parsed.flags.workerCodexAppThreadId,
+            codexAppThreadTitle: parsed.flags.workerCodexAppThreadTitle,
             codexSessionPath: workerRollout.path,
             cwd,
             name: workerName,
@@ -5005,6 +5294,8 @@ function runCreateDisposableBindingCommand(parsed, options) {
             tmuxSession: null,
         });
         const manager = registerSessionSync(database, {
+            codexAppThreadId: parsed.flags.managerCodexAppThreadId,
+            codexAppThreadTitle: parsed.flags.managerCodexAppThreadTitle,
             codexSessionPath: managerRollout.path,
             cwd,
             name: managerName,
@@ -5043,6 +5334,8 @@ function runCreateDisposableBindingCommand(parsed, options) {
             db_path: dbPath,
             manager: {
                 communication: disposableSessionCommunication("manager", task.name, dbPath),
+                codex_app_thread_id: manager.codex_app_thread_id,
+                codex_app_thread_title: manager.codex_app_thread_title,
                 id: manager.session_id,
                 name: managerName,
                 rollout_path: managerRollout.path,
@@ -5068,11 +5361,14 @@ function runCreateDisposableBindingCommand(parsed, options) {
             },
             worker: {
                 communication: disposableSessionCommunication("worker", task.name, dbPath),
+                codex_app_thread_id: worker.codex_app_thread_id,
+                codex_app_thread_title: worker.codex_app_thread_title,
                 id: worker.session_id,
                 name: workerName,
                 rollout_path: workerRollout.path,
                 tmux_session: null,
             },
+            heartbeat_recommendations: disposableHeartbeatRecommendations(task.name, dbPath),
             worker_handoff: disposableWorkerHandoff(task.name, run?.name ?? null, dbPath),
         };
         if (parsed.flags.json) {
@@ -13590,6 +13886,10 @@ function isDefaultRuntimeCommand(command) {
         || command === "runs"
         || command === "loop-evidence"
         || command === "loop-status"
+        || command === "app-heartbeat"
+        || command === "app-loop-status"
+        || command === "app-wakeup-plan"
+        || command === "app-wakeup-dispatch"
         || command === "loop-templates"
         || command === "loop-triggers"
         || command === "ralph-loop-presets"
@@ -16581,6 +16881,9 @@ function disposableWorkerHandoff(taskName, runName, dbPath) {
         `You are the worker for task ${taskName}${loopClause}.`,
         "Keep polling your Conveyor worker inbox until there are no items left or the loop reaches max_iterations. Consume the next item now, treat each consumed item as the manager's next instruction, complete the requested work, and report changed files, exact commands run, evidence, and any residual risk.",
         "",
+        "Because this is a pull-required Codex app/no-tmux session, autonomous operation requires a heartbeat/wake layer that repeats this worker inbox poll while the thread is idle. If no heartbeat automation is available, report the loop as manual-poll only.",
+        "Do not delete, pause, or disable heartbeat automation just because an inbox poll is idle; the manager or operator owns terminal loop teardown.",
+        "",
         `Run: ${sessionPollCommand("worker", taskName, dbPath)}`,
     ].join("\n");
 }
@@ -16595,14 +16898,87 @@ function renderDisposableBindingText(result) {
     }
     lines.push("Replay commands:");
     lines.push(...result.replay_commands.map((command) => `  ${command}`));
+    if (result.heartbeat_recommendations) {
+        lines.push("Heartbeat recommendations:");
+        lines.push(`  interval: every ${result.heartbeat_recommendations.interval_minutes} minutes`);
+        lines.push(`  manager: ${result.heartbeat_recommendations.manager.poll_command}`);
+        lines.push(`  worker: ${result.heartbeat_recommendations.worker.poll_command}`);
+        lines.push(`  status: ${result.heartbeat_recommendations.status_command}`);
+        lines.push(`  wakeup plan: ${result.heartbeat_recommendations.wakeup_plan_command}`);
+        lines.push(`  teardown: ${result.heartbeat_recommendations.teardown_policy.idle_poll}`);
+        lines.push(`  closeout: ${result.heartbeat_recommendations.teardown_policy.terminal_closeout_command}`);
+    }
     lines.push("Worker handoff:");
     lines.push(result.worker_handoff);
     return `${lines.join("\n")}\n`;
 }
+function disposableHeartbeatRecommendations(taskName, dbPath) {
+    const terminalCloseoutCommand = `${conveyorPollInvocation()} finish-task ${shellQuote(taskName)} --reason ${shellQuote("Verified terminal closeout")} --require-criteria-audit --path ${shellQuote(dbPath)}`;
+    const managerHeartbeatCommand = disposableAppHeartbeatCommand("manager", taskName, dbPath);
+    const workerHeartbeatCommand = disposableAppHeartbeatCommand("worker", taskName, dbPath);
+    const managerInboxCommand = sessionPollCommand("manager", taskName, dbPath);
+    const workerInboxCommand = sessionPollCommand("worker", taskName, dbPath);
+    return {
+        applies_when: {
+            can_receive_push: false,
+            delivery_mode: "pull_required",
+            receive_style: "pull",
+            session_kind: "codex_app",
+        },
+        interval_minutes: 2,
+        note: "Dispatch can deliver pull-required inbox items, but Codex app/no-tmux sessions still need a heartbeat or operator wake-up to poll while idle.",
+        status_command: `${conveyorPollInvocation()} app-loop-status ${shellQuote(taskName)} --path ${shellQuote(dbPath)} --json`,
+        teardown_policy: {
+            idle_poll: "Never delete, pause, or disable a manager or worker heartbeat because an inbox poll returned no item; that is only a quiet poll interval.",
+            owner: "manager_or_operator",
+            terminal_closeout: "Only the manager or operator should tear down heartbeats, and only after a terminal manager decision plus verified task closeout, or after explicit operator instruction.",
+            terminal_closeout_command: terminalCloseoutCommand,
+            worker_rule: "The worker must not own loop teardown and must not remove heartbeat automation based on idle polling.",
+        },
+        wakeup_plan_command: `${conveyorPollInvocation()} app-wakeup-plan ${shellQuote(taskName)} --path ${shellQuote(dbPath)} --json`,
+        manager: {
+            direct_inbox_command: managerInboxCommand,
+            kind: "thread_heartbeat",
+            poll_command: managerHeartbeatCommand,
+            prompt: [
+                "Use the manage-codex-workers skill.",
+                `Run the manager app heartbeat for task ${taskName}.`,
+                `Run: ${managerHeartbeatCommand}`,
+                `If the heartbeat output asks for direct inbox polling, run: ${managerInboxCommand}`,
+                "If an item is consumed, execute only that manager instruction, verify worker claims before recording conclusions, update Conveyor state as appropriate, and produce exactly one next worker task.",
+                "If no item is consumed, stop after a one-line idle receipt.",
+                "Do not delete, pause, or disable manager or worker heartbeat automation after an idle poll; an idle poll is only a quiet interval.",
+                `If all accepted criteria are satisfied, deferred, or rejected and there is no next worker task, record the terminal manager decision, run or report the result of: ${terminalCloseoutCommand}`,
+                "After verified task closeout, explicitly report heartbeat teardown status; if the task remains managed/active, report that as a control-plane blocker instead of calling the loop complete.",
+            ].join("\n"),
+        },
+        worker: {
+            direct_inbox_command: workerInboxCommand,
+            kind: "thread_heartbeat",
+            poll_command: workerHeartbeatCommand,
+            prompt: [
+                "Use the manage-codex-workers skill.",
+                `Run the worker app heartbeat for task ${taskName}.`,
+                `Run: ${workerHeartbeatCommand}`,
+                `If the heartbeat output asks for direct inbox polling, run: ${workerInboxCommand}`,
+                "If an item is consumed, execute only that single worker instruction and return exact commands, compact evidence, blockers/residual risk, and exactly one next recommended worker task.",
+                "If no item is consumed, stop after a one-line idle receipt.",
+                "Do not delete, pause, or disable worker heartbeat automation after an idle poll; the manager or operator owns terminal loop teardown.",
+            ].join("\n"),
+        },
+    };
+}
+function disposableAppHeartbeatCommand(role, taskName, dbPath) {
+    return `${conveyorPollInvocation()} app-heartbeat ${shellQuote(taskName)} --role ${role} --path ${shellQuote(dbPath)} --json`;
+}
 function sessionPollCommand(role, taskName, dbPath) {
     const inbox = role === "worker" ? "worker-inbox" : "manager-inbox";
     const task = taskName ? shellQuote(taskName) : "<task>";
-    return `conveyor ${inbox} ${task} --consume-next --wait --timeout 60 --path ${shellQuote(dbPath)} --json`;
+    return `${conveyorPollInvocation()} ${inbox} ${task} --consume-next --wait --timeout 60 --path ${shellQuote(dbPath)} --json`;
+}
+function conveyorPollInvocation() {
+    const binDir = join(packageRootFromRuntimeModule(), "bin");
+    return pathIsExecutable(join(binDir, "conveyor")) ? `PATH=${shellQuote(binDir)}:$PATH conveyor` : "conveyor";
 }
 function resolveCodexStartupOptions(options) {
     const defaults = {
@@ -16850,6 +17226,7 @@ function emitTelemetrySync(database, options) {
     )
     values (?, ?, ?, ?, ?, ?, ?)
   `).run(eventId, options.taskId ?? null, options.runId ?? null, options.actor, options.eventType, options.summary, attributesJson);
+    return eventId;
 }
 function latestCodexEventsForSession(database, options) {
     const clauses = ["session_id = ?"];