@indigoai-us/hq-cli 5.202.1 → 5.203.0

package/dist/commands/lanes.js

@@ -32,13 +32,15 @@ import { vaultApiFetch } from "../utils/vault-api.js";
 import { openMeshTransport } from "../lib/mesh/client.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
-import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, withLaneAdmissionLock, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { providerCompactAfterMs } from "../lib/lanes/config.js";
 import { parseCliEffort, resolveLaneEffort, } from "../lib/lanes/effort.js";
 import { LanesError } from "../lib/lanes/errors.js";
+import { dispatchLaneDelivery } from "../lib/lanes/delivery-core.js";
+import { formatMonitorEvent } from "../lib/lanes/dropbox.js";
 import { accountQuotaView, loadQuotaState, quotaBlockFor } from "../lib/lanes/quota.js";
 import { SESSION_MOVE_REASON } from "../lib/lanes/move-account.js";
 import { ensureSessionHome } from "../lib/lanes/session-relink.js";
@@ -235,6 +237,7 @@ function resolveDeps(deps = {}) {
         throttleDeps: deps.throttleDeps ?? defaultThrottleDeps(env),
         existsSync: deps.existsSync ?? ((p) => fs.existsSync(p)),
         readFileSync: deps.readFileSync ?? ((p, encoding) => fs.readFileSync(p, encoding)),
+        readStdin: deps.readStdin ?? (() => fs.readFileSync(0, "utf8")),
         homedir: deps.homedir ?? (() => os.homedir()),
         mesh: deps.mesh ?? createDefaultMesh(),
         sleep: deps.sleep ?? defaultSleep,
@@ -5021,11 +5024,10 @@ async function prepareAccountMove(ctx, lane, input) {
             account: target,
         });
     }
-    if (!providerSupportsSessionResume(lane.provider)) {
-        throw new LanesError("provider_session_not_portable", `Provider ${lane.provider} has no session resume, so a lane cannot move between its accounts`, { lane_id: laneId, provider: lane.provider });
-    }
-    if (lane.provider === "grok") {
-        throw new LanesError("provider_session_not_portable", `Provider ${lane.provider} has no session resume, so a lane cannot move between its accounts`, { lane_id: laneId, provider: lane.provider });
+    // The grok comparison repeats PROVIDER_SESSION_PORTABLE so TypeScript narrows
+    // the provider for ensureSessionHome below.
+    if (!providerSessionPortable(lane.provider) || lane.provider === "grok") {
+        throw new LanesError("provider_session_not_portable", sessionNotPortableMessage(lane.provider), { lane_id: laneId, provider: lane.provider });
     }
     if (!hasRecordedSessionId(lane)) {
         throw new LanesError("no_provider_session", `Lane ${laneId} has no recorded provider session id, so there is no session to move`, { lane_id: laneId, provider: lane.provider });
@@ -5310,8 +5312,8 @@ async function runMessage(ctx, laneId, opts) {
             state: lane.state,
         });
     }
-    if (opts.account !== undefined && !keepCurrentAccount && !providerSupportsSessionResume(lane.provider)) {
-        throw new LanesError("provider_session_not_portable", `Provider ${lane.provider} has no session resume, so a lane cannot move between its accounts`, { lane_id: laneId, provider: lane.provider });
+    if (opts.account !== undefined && !keepCurrentAccount && !providerSessionPortable(lane.provider)) {
+        throw new LanesError("provider_session_not_portable", sessionNotPortableMessage(lane.provider), { lane_id: laneId, provider: lane.provider });
     }
     // One decision point for how a follow-up reaches this lane (delivery.ts).
     // `none` refuses before anything is written: no inbox append, no spawn.
@@ -5359,12 +5361,27 @@ async function runMessage(ctx, laneId, opts) {
     if ((opts.project !== undefined || opts.story !== undefined) && ctx.storyLedgerEnabled()) {
         validateProjectStories(hqRoot, projectId, [storyId], lane.company?.slug);
     }
+    const framedMonitorEvent = opts.monitorEvent === undefined
+        ? undefined
+        : formatMonitorEvent({
+            monitorId: opts.monitorEvent.monitor_id,
+            description: opts.monitorEvent.description,
+            sequence: opts.monitorEvent.sequence,
+            text,
+        });
+    const deliveryText = framedMonitorEvent ?? text;
     const dropboxMessage = {
         at,
         message_id: messageId,
         text,
         project_id: projectId,
         story_id: storyId,
+        ...(opts.monitorEvent === undefined ? {} : {
+            kind: "monitor_event",
+            monitor_id: opts.monitorEvent.monitor_id,
+            description: opts.monitorEvent.description,
+            sequence: opts.monitorEvent.sequence,
+        }),
     };
     let resumed = null;
     let move = null;
@@ -5377,7 +5394,13 @@ async function runMessage(ctx, laneId, opts) {
             cliModel: opts.model?.trim() || undefined,
             ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
             ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
-            pending: { trigger: "message", text, message_id: messageId, compact: opts.compact !== false },
+            pending: {
+                trigger: "message",
+                text: deliveryText,
+                ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
+                message_id: messageId,
+                compact: opts.compact !== false,
+            },
         });
         lane = move.lane;
         if (move.queued) {
@@ -5395,7 +5418,8 @@ async function runMessage(ctx, laneId, opts) {
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     pending: {
                         trigger: "message",
-                        text,
+                        text: deliveryText,
+                        ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
                         message_id: messageId,
                         compact: opts.compact !== false,
                     },
@@ -5423,81 +5447,94 @@ async function runMessage(ctx, laneId, opts) {
     if (move?.queued) {
         // Parked at the target's cap: reconcile resumes the session there.
     }
-    else if (mechanism === "dropbox") {
-        // Live (or about-to-be-live) process: the PreToolUse drain delivers it.
-        if (!laneAcceptsOperatorMessage(lane)) {
-            throw new LanesError("lane_not_accepting_messages", operatorMessageRefusalReason(lane.state), { lane_id: laneId, state: lane.state });
-        }
-        appendDropboxMessage(hqRoot, laneId, dropboxMessage);
-    }
     else {
-        // Exited worker with a recorded session: queue the message when capacity
-        // is occupied, otherwise start its next turn under the shared admission lock.
-        assertLaneRunsHereForAdmission(ctx, lane);
-        resumed = await withLaneAdmissionLock(hqRoot, lane.provider, async () => {
-            const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
-            if (admission.action === "refuse" && admission.error)
-                throw admission.error;
-            return withResumeHireAdmission(ctx, lane, () => {
-                if (admission.action === "queue") {
-                    const sessionId = lane.provider_session_id;
-                    if (!sessionId) {
-                        throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this message resume`, {
-                            lane_id: laneId,
-                            provider: lane.provider,
-                        });
-                    }
-                    archiveResumeMessage(hqRoot, laneId, dropboxMessage);
-                    queuedOnAdmission = true;
-                    return casUpdateLane(hqRoot, laneId, (current) => {
-                        if (current.version !== lane.version || current.state !== lane.state) {
-                            throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while message admission was checked`, {
-                                lane_id: laneId,
-                                prepared_version: lane.version,
-                                version: current.version,
-                                state: current.state,
+        const dispatched = await dispatchLaneDelivery(lane, {
+            dropbox: () => {
+                // Live (or about-to-be-live) process: the PreToolUse drain delivers it.
+                if (!laneAcceptsOperatorMessage(lane)) {
+                    throw new LanesError("lane_not_accepting_messages", operatorMessageRefusalReason(lane.state), { lane_id: laneId, state: lane.state });
+                }
+                appendDropboxMessage(hqRoot, laneId, dropboxMessage);
+                return null;
+            },
+            resume: async () => {
+                // Exited worker with a recorded session: queue the message when capacity
+                // is occupied, otherwise start its next turn under the shared admission lock.
+                assertLaneRunsHereForAdmission(ctx, lane);
+                return withLaneAdmissionLock(hqRoot, lane.provider, async () => {
+                    const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
+                    if (admission.action === "refuse" && admission.error)
+                        throw admission.error;
+                    return withResumeHireAdmission(ctx, lane, () => {
+                        if (admission.action === "queue") {
+                            const sessionId = lane.provider_session_id;
+                            if (!sessionId) {
+                                throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this message resume`, {
+                                    lane_id: laneId,
+                                    provider: lane.provider,
+                                });
+                            }
+                            archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                            queuedOnAdmission = true;
+                            return casUpdateLane(hqRoot, laneId, (current) => {
+                                if (current.version !== lane.version || current.state !== lane.state) {
+                                    throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while message admission was checked`, {
+                                        lane_id: laneId,
+                                        prepared_version: lane.version,
+                                        version: current.version,
+                                        state: current.state,
+                                    });
+                                }
+                                return {
+                                    ...current,
+                                    state: "queued",
+                                    queued_reason: admission.reason ?? "throttle",
+                                    queued_at: at,
+                                    pending_resume: {
+                                        session_id: sessionId,
+                                        trigger: "message",
+                                        text: deliveryText,
+                                        ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
+                                        message_id: messageId,
+                                        compact: opts.compact !== false,
+                                        at,
+                                    },
+                                };
                             });
                         }
-                        return {
-                            ...current,
-                            state: "queued",
-                            queued_reason: admission.reason ?? "throttle",
-                            queued_at: at,
-                            pending_resume: {
-                                session_id: sessionId,
-                                trigger: "message",
-                                text,
+                        const started = spawnLaneWorker(hqRoot, lane, {
+                            env: ctx.env,
+                            modelDeps: {
+                                readFileSync: ctx.readFileSync,
+                                probe: ctx.probeProvider,
+                                env: ctx.env,
+                            },
+                            existsSync: ctx.existsSync,
+                            spawnProcess: ctx.spawnProcess,
+                            proveDetached: ctx.proveDetached,
+                            killProcess: ctx.killProcess,
+                            now: ctx.now,
+                            resolveMachineIdentity: ctx.resolveMachineIdentity,
+                            runCompaction: ctx.runCompaction,
+                            locateTranscript: ctx.locateTranscript,
+                        }, {
+                            trigger: {
+                                kind: "message",
+                                text: deliveryText,
                                 message_id: messageId,
-                                compact: opts.compact !== false,
-                                at,
+                                ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
                             },
-                        };
+                            compact: opts.compact !== false,
+                            effort: resumeEffort ?? recordedResumeEffort(lane),
+                        });
+                        archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                        return started;
                     });
-                }
-                const started = spawnLaneWorker(hqRoot, lane, {
-                    env: ctx.env,
-                    modelDeps: {
-                        readFileSync: ctx.readFileSync,
-                        probe: ctx.probeProvider,
-                        env: ctx.env,
-                    },
-                    existsSync: ctx.existsSync,
-                    spawnProcess: ctx.spawnProcess,
-                    proveDetached: ctx.proveDetached,
-                    killProcess: ctx.killProcess,
-                    now: ctx.now,
-                    resolveMachineIdentity: ctx.resolveMachineIdentity,
-                    runCompaction: ctx.runCompaction,
-                    locateTranscript: ctx.locateTranscript,
-                }, {
-                    trigger: { kind: "message", text, message_id: messageId },
-                    compact: opts.compact !== false,
-                    effort: resumeEffort ?? recordedResumeEffort(lane),
-                });
-                archiveResumeMessage(hqRoot, laneId, dropboxMessage);
-                return started;
-            });
-        }, ctx.sleep);
+                }, ctx.sleep);
+            },
+        }, mechanism);
+        if (dispatched.mechanism === "resume")
+            resumed = dispatched.value;
     }
     // Every accepted message moves the compaction reference forward.
     let next = casUpdateLane(hqRoot, laneId, (current) => ({
@@ -5736,8 +5773,6 @@ async function runClaudeBalanceMoveTarget(ctx, laneId, opts) {
     });
 }
 function laneWithRecoveredProviderSession(hqRoot, lane) {
-    if (lane.provider === "grok")
-        return lane;
     const manifest = readSpawnManifest(laneRunDir(hqRoot, lane.lane_id));
     const sessionId = (typeof lane.provider_session_id === "string" && lane.provider_session_id.trim()
         ? lane.provider_session_id
@@ -5795,8 +5830,8 @@ async function runResume(ctx, laneId, opts) {
             state: lane.state,
         });
     }
-    if (opts.account !== undefined && !providerSupportsSessionResume(lane.provider)) {
-        throw new LanesError("provider_session_not_portable", `Provider ${lane.provider} has no session resume, so a lane cannot move between its accounts`, { lane_id: laneId, provider: lane.provider });
+    if (opts.account !== undefined && !providerSessionPortable(lane.provider)) {
+        throw new LanesError("provider_session_not_portable", sessionNotPortableMessage(lane.provider), { lane_id: laneId, provider: lane.provider });
     }
     if (lane.state === "queued") {
         throw new LanesError("lane_not_resumable", `Lane ${laneId} is queued; use hq lanes admit ${laneId} to request admission`, { lane_id: laneId, state: lane.state, admission_command: `hq lanes admit ${laneId}` });
@@ -8304,6 +8339,38 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (laneId, opts) => {
         await runMessage(ctx, laneId, opts);
     }));
+    lanes
+        .command("_monitor-message", { hidden: true })
+        .argument("<lane-id>", "Lane id")
+        .action(wrap(async (laneId) => {
+        const input = ctx.readStdin();
+        let payload;
+        try {
+            payload = JSON.parse(input);
+        }
+        catch (err) {
+            throw new LanesError("monitor_lane_payload_invalid", `Monitor lane delivery payload is invalid JSON: ${err instanceof Error ? err.message : String(err)}.`, {});
+        }
+        if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+            throw new LanesError("monitor_lane_payload_invalid", "Monitor lane delivery payload must be an object.", {});
+        }
+        const value = payload;
+        if (typeof value.text !== "string" ||
+            typeof value.monitor_id !== "string" ||
+            typeof value.description !== "string" ||
+            !Number.isInteger(value.sequence) ||
+            Number(value.sequence) < 1) {
+            throw new LanesError("monitor_lane_payload_invalid", "Monitor lane delivery payload is missing text, monitor metadata, or sequence.", {});
+        }
+        await runMessage(ctx, laneId, {
+            text: value.text,
+            monitorEvent: {
+                monitor_id: value.monitor_id,
+                description: value.description,
+                sequence: Number(value.sequence),
+            },
+        });
+    }));
     lanes
         .command("resume")
         .description("Resume an interrupted, done or blocked lane on its recorded provider session")

package/dist/commands/monitor.d.ts

@@ -0,0 +1,58 @@
+import { spawn } from "node:child_process";
+import { Command } from "commander";
+import { drainDropboxAtPath } from "../lib/lanes/dropbox.js";
+import { recordMonitorTargetActivity, type MonitorMetadata, type MonitorState, type MonitorTarget, type MonitorProcessEntry, type MonitorRuntimeIdentity } from "../lib/monitor.js";
+import type { LaneCompanyRef, LaneProvider } from "../lib/lanes/types.js";
+export declare function findSessionOwner(target: MonitorTarget, deps?: {
+    env?: NodeJS.ProcessEnv;
+    parentPid?: number;
+    readProcess?: (pid: number) => MonitorProcessEntry | null;
+    readStarttime?: (pid: number) => number | null;
+}): {
+    pid: number;
+    starttime: number | null;
+} | null;
+export declare function sessionOwnerTarget(discovered: MonitorTarget, resolved: MonitorTarget): MonitorTarget;
+declare function monitorEnabled(company?: LaneCompanyRef | null): Promise<boolean>;
+export declare function runMonitorEnabledCommand(deps?: {
+    readFlag?: (company: LaneCompanyRef | null) => Promise<boolean>;
+    writeOut?: (text: string) => void;
+    writeError?: (text: string) => void;
+}): Promise<number>;
+export declare function armText(meta: MonitorMetadata): string;
+export declare function resolveMonitorStartTarget(hqRoot: string, discovered: MonitorTarget, explicitlyProvided: boolean, runtime?: MonitorRuntimeIdentity): MonitorTarget;
+export declare function deliverNormalEvent(hqRoot: string, meta: MonitorMetadata, state: MonitorState, rawText: string): Promise<MonitorState>;
+export interface RunSupervisorDeps {
+    resolveRoot?: () => string;
+    monitorEnabled?: typeof monitorEnabled;
+    deliver?: typeof deliverNormalEvent;
+    spawn?: typeof spawn;
+}
+export declare function runSupervisor(id: string, deps?: RunSupervisorDeps): Promise<void>;
+interface MonitorHookResult {
+    stdout: string;
+    exitCode: 0 | 2;
+}
+export interface WaitForSessionDeps {
+    monitorEnabled?: () => Promise<boolean>;
+    resolveRoot?: () => string;
+    readStdin?: () => Promise<string>;
+    recordActivity?: typeof recordMonitorTargetActivity;
+    drainDropbox?: typeof drainDropboxAtPath;
+    sleep?: (milliseconds: number) => Promise<void>;
+}
+export declare function runMonitorHookSafely(kind: "drain" | "wait", operation: () => Promise<MonitorHookResult>, writeError?: (text: string) => void): Promise<MonitorHookResult>;
+export interface DrainSessionDeps {
+    monitorEnabled?: () => Promise<boolean>;
+    resolveRoot?: () => string;
+    readStdin?: () => Promise<string>;
+    sessionEnvironmentId?: (provider: LaneProvider) => string | undefined;
+    nearestRuntimeIdentity?: () => MonitorRuntimeIdentity | undefined;
+    recordActivity?: typeof recordMonitorTargetActivity;
+    drainDropbox?: typeof drainDropboxAtPath;
+}
+export declare function drainSession(provider: LaneProvider, event: "PreToolUse" | "UserPromptSubmit", deps?: DrainSessionDeps): Promise<MonitorHookResult>;
+export declare function waitForSession(provider: LaneProvider, deps?: WaitForSessionDeps): Promise<MonitorHookResult>;
+export declare function registerMonitorCommand(parent: Command): Command;
+export {};
+//# sourceMappingURL=monitor.d.ts.map