@indigoai-us/hq-cli 5.295.0 → 5.297.0

package/dist/commands/core.js

@@ -36,7 +36,7 @@ import { registerCoreHandoffCommand } from "./core-handoff.js";
 import { registerCoreOntologyCommand } from "./core-ontology.js";
 import { registerCoreKnowledgePrefsCommand } from "./core-knowledge-prefs.js";
 import { registerCorePolicyCommand } from "./core-policy.js";
-import { registerCoreJobsNativeCommand } from "./core-jobs-native.js";
+import { registerCoreJobsNativeCommand } from "./core-job-native.js";
 import { registerCoreCheckpointGateSettingCommand } from "./core-checkpoint-gate-setting.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { interpreterFor, runBundledScript } from "../utils/run-bundled-script.js";

package/dist/commands/lanes-message.js

@@ -530,6 +530,7 @@ export function createLaneMessageHandlers(deps) {
                                             pending_resume: {
                                                 session_id: sessionId,
                                                 trigger: "message",
+                                                caller: ctx.env.HQ_LANE_ID?.trim() || "user",
                                                 text: deliveryText,
                                                 ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
                                                 message_id: messageId,

package/dist/commands/lanes-resume.js

@@ -359,6 +359,7 @@ export function createLaneResumeHandlers(deps) {
                                 pending_resume: {
                                     session_id: sessionId,
                                     trigger: "resume",
+                                    caller: ctx.env.HQ_LANE_ID?.trim() || "user",
                                     resumed_from: resumedFrom,
                                     ...(opts.fromFailed === true ? { from_failed: true } : {}),
                                     ...(failedResumeExpectedSenior !== undefined

package/dist/commands/lanes-stories.d.ts

@@ -8,6 +8,7 @@ export declare function createLaneStoryHandlers(deps: LaneStoryHandlerDeps): {
     runStoryList: (ctx: Ctx, laneId: string) => Promise<void>;
     runStoryAdd: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
     runStoryStart: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
+    runStoryReview: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
     runStoryBlock: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
     runStoryDone: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
 };

package/dist/commands/lanes-stories.js

@@ -18,6 +18,13 @@ export function createLaneStoryHandlers(deps) {
         }
         return { projectId, storyId: normalizedStoryId, story };
     }
+    function reviewableStoryTarget(lane, storyId, project) {
+        const target = storyCommandTarget(lane, storyId, project);
+        if (target.story.status === "done") {
+            throw new LanesError("story_already_done", `Story ${target.projectId}/${target.storyId} is done and cannot be moved to review`, { lane_id: lane.lane_id, project_id: target.projectId, story_id: target.storyId });
+        }
+        return target;
+    }
     function updateCarriedStory(lane, projectId, storyId, status, at, extras = {}) {
         const stories = laneStories(lane).map((story) => story.project_id === projectId && story.story_id === storyId
             ? {
@@ -229,6 +236,38 @@ export function createLaneStoryHandlers(deps) {
         const finalLane = readLane(hqRoot, laneId);
         printJson({ ok: true, action: "story.start", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "in_progress", story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
     }
+    async function runStoryReview(ctx, laneId, storyId, opts) {
+        const hqRoot = ctx.hqRoot();
+        let lane = readLane(hqRoot, laneId);
+        assertLaneRunsHereForOperatorMutation(ctx, lane, "update story status for");
+        const target = reviewableStoryTarget(lane, storyId, opts.project);
+        const at = ctx.now().toISOString();
+        const warnings = [];
+        const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
+        lane = thread.lane;
+        if (thread.warning !== undefined)
+            warnings.push(thread.warning);
+        const before = lane;
+        const next = casUpdateLane(hqRoot, laneId, (current) => {
+            assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
+            reviewableStoryTarget(current, target.storyId, target.projectId);
+            return updateCarriedStory(current, target.projectId, target.storyId, "review", at);
+        });
+        const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_progress", "review", { detail: "Story moved to review" });
+        if (transitionWarning !== undefined)
+            warnings.push(transitionWarning);
+        const finalLane = readLane(hqRoot, laneId);
+        printJson({
+            ok: true,
+            action: "story.review",
+            lane_id: laneId,
+            project_id: target.projectId,
+            story_id: target.storyId,
+            status: "review",
+            story_warning: combinedStoryWarning(finalLane, warnings),
+            lane: finalLane,
+        });
+    }
     async function runStoryBlock(ctx, laneId, storyId, opts) {
         const hqRoot = ctx.hqRoot();
         let lane = readLane(hqRoot, laneId);
@@ -303,6 +342,6 @@ export function createLaneStoryHandlers(deps) {
         const finalLane = readLane(hqRoot, laneId);
         printJson({ ok: true, action: "story.done", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "done", verified: true, story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
     }
-    return { runStoryList, runStoryAdd, runStoryStart, runStoryBlock, runStoryDone };
+    return { runStoryList, runStoryAdd, runStoryStart, runStoryReview, runStoryBlock, runStoryDone };
 }
 //# sourceMappingURL=lanes-stories.js.map

package/dist/commands/lanes.js

@@ -5062,10 +5062,12 @@ async function runShow(ctx, laneId) {
     })
         .slice(0, 20)
         .map(({ repo, pr, head_sha, recorded_at }) => ({ repo, pr, head_sha, recorded_at }));
+    const laneForShow = { ...lane };
+    delete laneForShow.resume_history;
     printJson({
         ok: true,
         action: "show",
-        lane,
+        lane: laneForShow,
         ...(laneIsSenior ? { reviews: recentReviews, reviews_skipped: reviewListing.skipped } : {}),
         ...hire,
         overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, ctx.now()),
@@ -5079,6 +5081,8 @@ async function runShow(ctx, laneId) {
         envelope_repair_mode: lane.envelope_repair?.mode ?? null,
         envelope_validation_errors: lane.envelope_validation_errors ?? [],
         last_resume: lane.last_resume ?? null,
+        // Public JSON key for the bounded start audit; `last_resume` remains unchanged.
+        resume_history: lane.resume_history ?? [],
         keep_alive_history: lane.keep_alive_history ?? [],
         account: lane.account ?? null,
         account_history: lane.account_history ?? [],
@@ -6191,7 +6195,12 @@ async function prepareAccountMove(ctx, lane, input) {
                 }),
                 pending_resume: input.deferTurnStart
                     ? undefined
-                    : { session_id: sessionId, at, ...input.pending },
+                    : {
+                        session_id: sessionId,
+                        at,
+                        caller: ctx.env.HQ_LANE_ID?.trim() || "user",
+                        ...input.pending,
+                    },
             };
             applyResumeProfileAndEffort(current, next, {
                 ...(input.workerProfile !== undefined ? { profile: input.workerProfile } : {}),
@@ -8171,6 +8180,15 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (laneId, storyId, opts) => {
         await storyHandlers.runStoryStart(ctx, laneId, storyId, opts);
     }));
+    stories
+        .command("review")
+        .description("Move a carried story to review")
+        .argument("<lane-id>", "Lane id")
+        .argument("<story-id>", "Story id")
+        .option("--project <slug>", "Project id; defaults to the lane's current project")
+        .action(wrap(async (laneId, storyId, opts) => {
+        await storyHandlers.runStoryReview(ctx, laneId, storyId, opts);
+    }));
     stories
         .command("block")
         .description("Mark one carried story blocked")

package/dist/commands/mesh.js

@@ -2129,7 +2129,9 @@ async function runDaemonInstall(opts) {
     // `hq daemon` runs mesh on this machine: installing a second unit would run it twice.
     // An explicit --hq-root is verified the same way as below and saved for the daemon.
     const explicitRoot = opts.hqRoot ? resolveInstallHqRoot({ explicit: opts.hqRoot }).root : undefined;
-    const handedOff = opts.systemUser ? null : handOffInstallHere(["mesh"], process.env, { hqRoot: explicitRoot });
+    const handedOff = opts.systemUser
+        ? null
+        : handOffInstallHere(["mesh"], process.env, { hqRoot: explicitRoot, ifStale: opts.ifStale });
     if (handedOff) {
         console.log(opts.json ? JSON.stringify({ ok: true, action: "hq-daemon", reinstalled: false, message: handedOff }) : handedOff);
         return;

package/dist/commands/run.js

@@ -128,6 +128,11 @@ export function registerRunCommand(program) {
             let state;
             const graph = await internal.loadEnvGraph({
                 entryFilePaths: paths,
+                // hq run owns its short-lived in-memory resolution. Varlock's default
+                // cache auto-detection can write ~/.config/varlock and initialize
+                // the native local-encryption helper, neither of which belongs on
+                // this command path.
+                skipCache: true,
                 afterInit: async (g) => { state = installHqPlugin(g, pluginOpts); },
             });
             // Refuse to resolve a graph varlock never finished loading (a malformed

package/dist/lib/daemon/handoff.d.ts

@@ -51,5 +51,6 @@ export declare function handOffInstall(opts: {
 /** handOffInstall for this machine and user, for the older install commands. */
 export declare function handOffInstallHere(services: readonly ServiceName[], env?: NodeJS.ProcessEnv, opts?: {
     hqRoot?: string;
+    ifStale?: boolean;
 }): string | null;
 //# sourceMappingURL=handoff.d.ts.map

package/dist/lib/daemon/handoff.js

@@ -17,6 +17,15 @@ import { daemonPaths } from "./paths.js";
 import { writeControlRequest } from "./requests.js";
 /** Statuses where the daemon itself owns the unit's process. */
 const OWNED = new Set(["running", "backoff", "exited", "idle", "stopped"]);
+const RECENT_HOSTED_DAEMON_MS = 5 * 60_000;
+/** The updater's postinstall may run in the short gap before the desktop app relaunches its daemon. */
+function recentlyHostedDaemon(paths) {
+    if (!fs.existsSync(paths.statePath))
+        return false;
+    const state = JSON.parse(fs.readFileSync(paths.statePath, "utf8"));
+    const age = Date.now() - (state.updatedAt ?? 0);
+    return state.host === "desktop" && age >= 0 && age <= RECENT_HOSTED_DAEMON_MS;
+}
 /** The live daemon's state, or null when no daemon is running. */
 function liveState(paths, alive) {
     if (runningDaemonPid(paths.lockPath, alive) === null)
@@ -124,14 +133,21 @@ export function handOffInstall(opts) {
 export function handOffInstallHere(services, env = process.env, opts = {}) {
     const home = os.homedir();
     const paths = daemonPaths(home, env);
+    const config = readDaemonConfig(paths.configPath);
+    if (opts.ifStale && services.every((service) => config.disable.includes(service))) {
+        return `hq daemon has ${services.join(", ")} disabled, so the older service will not be installed.`;
+    }
     const installed = daemonUnitInstalled({
         platform: process.platform,
         home,
         windowsTaskExists: (task) => spawnSync("schtasks.exe", ["/Query", "/TN", task], { encoding: "utf8", windowsHide: true }).status === 0,
     }) || hostedDaemonRunning(paths);
-    if (!installed)
+    if (!installed) {
+        if (opts.ifStale && services.includes("mesh") && recentlyHostedDaemon(paths)) {
+            return `hq daemon recently hosted mesh on this machine, so the older mesh service will not be installed during its restart.`;
+        }
         return null;
-    const config = readDaemonConfig(paths.configPath);
+    }
     const machineType = detectMachineType(undefined, {
         platform: process.platform,
         env,

package/dist/lib/daemon/legacy.d.ts

@@ -32,4 +32,11 @@ export declare function findLegacyUnits(deps: LegacyProbeDeps): LegacyUnit[];
  * own checks, because `hq daemon migrate` will never take them over.
  */
 export declare function legacyOwnerLookup(units: readonly LegacyUnit[]): (unitId: string) => string | null;
+/** A daemon-managed macOS mesh service takes over the old LaunchAgent on startup. */
+export declare function legacyMeshUnitsToRetire(units: readonly LegacyUnit[], opts: {
+    platform: NodeJS.Platform;
+    managed: boolean;
+    hosted: boolean;
+    meshEnabled: boolean;
+}): LegacyUnit[];
 //# sourceMappingURL=legacy.d.ts.map

package/dist/lib/daemon/legacy.js

@@ -122,4 +122,10 @@ export function legacyOwnerLookup(units) {
         return hit ? describeLegacyUnit(hit) : null;
     };
 }
+/** A daemon-managed macOS mesh service takes over the old LaunchAgent on startup. */
+export function legacyMeshUnitsToRetire(units, opts) {
+    if (opts.platform !== "darwin" || (!opts.managed && !opts.hosted) || !opts.meshEnabled)
+        return [];
+    return units.filter((unit) => unit.service === "mesh" && unit.kind === "launchd" && unit.migratable);
+}
 //# sourceMappingURL=legacy.js.map

package/dist/lib/daemon/lock.js

@@ -43,7 +43,7 @@ export function processCommandLine(pid, deps = defaultCommandLineDeps()) {
             "-Command",
             `(Get-CimInstance Win32_Process -Filter "ProcessId=${Math.trunc(pid)}").CommandLine`,
         ])
-        : deps.run("ps", ["-o", "command=", "-p", String(pid)]);
+        : deps.run("ps", ["-ww", "-o", "args=", "-p", String(pid)]);
     if (r.status !== 0)
         return null;
     const line = r.stdout.trim();

package/dist/lib/daemon/run.js

@@ -19,9 +19,12 @@ import { botsRoot } from "../bot/paths.js";
 import { CLAUDE_RUNNER_SCRIPT, CODEX_RUNNER_SCRIPT, enabledServices, planUnits } from "./catalog.js";
 import { effectiveSyncOwner, readDaemonConfig } from "./config.js";
 import { SUPERVISOR_HANDOFF_FLAG, readDaemonFlag } from "./flag.js";
-import { findLegacyUnits, legacyOwnerLookup } from "./legacy.js";
+import { findLegacyUnits, legacyMeshUnitsToRetire, legacyOwnerLookup } from "./legacy.js";
 import { readLegacySyncEnv } from "./legacy-sync-env.js";
-import { acquireDaemonLock, releaseDaemonLock } from "./lock.js";
+import { acquireDaemonLock, isProcessAlive, processCommandLine, releaseDaemonLock } from "./lock.js";
+import { adoptLegacyUnits } from "./migrate.js";
+import { daemonDir as meshDaemonDir, daemonPidPath as meshDaemonPidPath } from "../mesh/live/daemon/paths.js";
+import { readPidLock } from "../mesh/live/daemon/pid-lock.js";
 import { daemonRootRefusal } from "./install.js";
 import { detectMachineType } from "./machine-type.js";
 import { appendPrivate, daemonPaths, ensurePrivateDir, openPrivateAppend } from "./paths.js";
@@ -332,6 +335,54 @@ export async function runDaemon(opts) {
         }
         return legacyCache.units;
     };
+    const legacyMesh = legacyMeshUnitsToRetire(legacyUnits(), {
+        platform,
+        managed: opts.managed === true,
+        hosted: opts.host !== undefined,
+        meshEnabled: enabledServices(machineType, initial).includes("mesh"),
+    });
+    if (legacyMesh.length > 0) {
+        try {
+            const uid = process.getuid?.() ?? 0;
+            const result = adoptLegacyUnits(legacyMesh, {
+                run: (command, args) => {
+                    const r = spawnSync(command, args, { encoding: "utf8", windowsHide: true, timeout: 15_000 });
+                    return { status: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+                },
+                uid,
+                isRoot: uid === 0,
+                adoptedDir: path.join(paths.root, "adopted"),
+                recordPath: path.join(paths.root, "adopted.json"),
+                systemAdoptedDir: "/var/lib/hq/daemon/adopted",
+                systemRecordPath: "/var/lib/hq/daemon/adopted.json",
+                systemUnitDir: "/etc/systemd/system",
+            });
+            for (const unit of result.adopted)
+                log("info", `retired legacy ${unit.unitId} unit ${unit.name}; hq daemon now owns mesh`);
+            for (const failure of result.failed)
+                log("warn", `could not retire legacy ${failure.unit.unitId} unit ${failure.unit.name}: ${failure.error}`);
+        }
+        catch (err) {
+            log("error", `could not retire legacy mesh units: ${err.message}`);
+        }
+        legacyCache = null;
+    }
+    const meshOwnerReason = () => {
+        const lockPath = meshDaemonPidPath(meshDaemonDir(undefined, home, env));
+        const owner = readPidLock(lockPath);
+        if (!owner || owner.pid === process.pid || !isProcessAlive(owner.pid))
+            return undefined;
+        const command = processCommandLine(owner.pid, {
+            platform,
+            run: (file, args) => {
+                const r = spawnSync(file, args, { encoding: "utf8", windowsHide: true, timeout: 15_000 });
+                return { status: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+            },
+        });
+        if (command && !/\bmesh\s+daemon\s+run\b/.test(command))
+            return undefined;
+        return `mesh daemon already running (pid ${owner.pid}); waiting for it to exit`;
+    };
     let warnedMissingPin = null;
     const daemonSyncRunnerPids = new Set();
     const plan = () => {
@@ -554,6 +605,7 @@ export async function runDaemon(opts) {
                 return undefined;
             }
         },
+        meshOwnerReason,
         cliVersion: CLI_VERSION,
         adopt,
     });
@@ -603,6 +655,9 @@ export async function runDaemon(opts) {
                     log("info", "all services stopped");
                 releaseDaemonLock(paths.lockPath);
                 resolve(exitCode);
+                // Pipes, sockets and unrelated timers can outlive a clean shutdown.
+                // Keep restart and signal exits bounded just like the handoff path.
+                setTimeout(() => process.exit(exitCode), 5_000).unref();
             });
         };
         /** Exit for a restart but leave the services running for the next daemon to adopt. */

package/dist/lib/daemon/supervisor.d.ts

@@ -107,6 +107,8 @@ export interface SupervisorDeps {
     requestPollMs?: number;
     /** Read hq-cloud's lease status after it exits with the lease-conflict code. */
     syncOwnerBlockReason?: () => string | undefined;
+    /** A separate mesh daemon currently owns its pid lock after our mesh child exits. */
+    meshOwnerReason?: () => string | undefined;
     /** The running CLI's version; part of the key of units that run `hq` commands. */
     cliVersion?: string;
     /** Services to take over from the previous daemon instead of starting them. */

package/dist/lib/daemon/supervisor.js

@@ -27,6 +27,7 @@ export const BACKOFF_BASE_MS = 1_000;
 export const BACKOFF_MAX_MS = 60_000;
 export const HEALTHY_RUN_MS = 60_000;
 export const STOP_ESCALATION_MS = 10_000;
+const MESH_OWNER_RECHECK_MS = 15_000;
 /** After a handoff, how long a replaced unit must stay up before the next one is replaced. */
 export const HANDOFF_STAGGER_MS = 15_000;
 /** How long a draining unit may take to finish its work before it gets SIGTERM. */
@@ -294,6 +295,31 @@ export function createSupervisor(deps) {
                 emit();
                 return;
             }
+            const meshOwnerReason = slot.plan.service === "mesh" ? deps.meshOwnerReason?.() : undefined;
+            if (meshOwnerReason) {
+                const waitForOwner = (reason) => {
+                    slot.state.status = "waiting";
+                    slot.state.reason = reason;
+                    slot.state.nextRunAt = now() + MESH_OWNER_RECHECK_MS;
+                    deps.log("warn", `${reason}; retrying mesh ownership check in ${MESH_OWNER_RECHECK_MS}ms`);
+                    slot.timer = setT(() => {
+                        slot.timer = undefined;
+                        const current = deps.meshOwnerReason?.();
+                        if (current)
+                            waitForOwner(current);
+                        else {
+                            slot.attempts = 0;
+                            delete slot.state.reason;
+                            delete slot.state.nextRunAt;
+                            startLong(slot);
+                        }
+                        emit();
+                    }, MESH_OWNER_RECHECK_MS);
+                };
+                waitForOwner(meshOwnerReason);
+                emit();
+                return;
+            }
             deps.log("warn", `${slot.plan.id} exited (code=${code ?? "null"} signal=${signal ?? "none"})`);
             if (ranFor >= HEALTHY_RUN_MS)
                 slot.attempts = 0;

package/dist/lib/doctor/checks/work-context.js

@@ -8,6 +8,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { readDeviceConfig, } from "../../work-context/config.js";
 import { outboxStats, listOutboxOperations } from "../../work-context/outbox.js";
+import { outboxQuarantineStatusEnabled } from "../../work-context/outbox-quarantine-status-flag.js";
 import { workContextRoot, workContextSessionsDir } from "../../work-context/paths.js";
 import { countJsonlLines, deadLetterNonEmpty, } from "../../mesh/live/spool.js";
 import { workMeshDeadLetterPath, workMeshHeldPath, workMeshRoot, workMeshSpoolPath, } from "../../mesh/live/paths.js";
@@ -87,11 +88,14 @@ function runChecks(deps) {
         target: path.join(root, "outbox"),
         message: `Outbox queued depth=${stats.depth} (acked=${stats.acked}).`,
     });
+    const showQuarantineReason = stats.quarantined > 0 && outboxQuarantineStatusEnabled();
     results.push({
         status: stats.quarantined > 0 ? "WARN" : "PASS",
         checkId: "work-context.outbox-quarantined",
         target: path.join(root, "outbox"),
-        message: `Outbox quarantined count=${stats.quarantined}.`,
+        message: `Outbox quarantined count=${stats.quarantined}${showQuarantineReason
+            ? ` (last reason=${stats.lastQuarantineReason ?? "unknown"})`
+            : ""}.`,
     });
     // Default-company mode + migration capability (US-017B)
     try {

package/dist/lib/lanes/mesh-events.js

@@ -44,6 +44,7 @@
  */
 import { appendThreadEvent, clamp, ensureLaneMeshThread, ensureProjectThread, getProjectView, patchStoryStatus, putProjectView, requireToken, registerMeshProject, resolveMeshCompany, } from "../mesh/api.js";
 import { LanesError } from "./errors.js";
+import { terminalEnvelopeStoryStatus } from "./stories.js";
 export const LANE_MESH_EVENTS = [
     "lane_started",
     "lane_progress",
@@ -454,6 +455,8 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
     const patchStoryStatus = async (status) => {
         if (!lane.project_id?.trim() || !lane.story_id?.trim())
             return;
+        if (terminalEnvelopeStoryStatus(lane, envelope.decision) === undefined)
+            return;
         const suppressions = opts.storyStatusSuppressions;
         const key = laneStoryStatusSuppressionKey(company, lane.project_id, lane.story_id);
         if (suppressions?.has(key))

package/dist/lib/lanes/reconcile.js

@@ -31,7 +31,7 @@ import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./qu
 import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
 import { SILENCE_MS, appendWatcherEvent, classifyLaneExit, isPidAlive, missingExpectedEnvelopeFile, readLatestEnvelopeFile, readLatestEnvelopeRecord, watcherEventsPath, watcherOutLogPath, writeWatcherDecision, } from "./watcher.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshCompany, } from "./mesh-events.js";
-import { activeLaneStories, laneStories, storyStatusForEnvelope } from "./stories.js";
+import { activeLaneStories, laneStories, terminalEnvelopeStoryStatus } from "./stories.js";
 import { decideEnvelopeRepair, envelopeQuestionIds, routeProviderFailure } from "./watcher.js";
 import { PROVIDER_REJECTED_REASON, providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
 /** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
@@ -50,6 +50,7 @@ export const RECONCILE_TIMER_NAME = "hq-lanes-reconcile.timer";
 function spawnDepsForHost(deps) {
     return {
         ...(deps.spawnLaneDeps ?? {}),
+        env: deps.spawnLaneDeps?.env ?? deps.env ?? process.env,
         hostname: deps.host.hostname,
         admissionHost: deps.host,
     };
@@ -1270,24 +1271,22 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     }
                     if (terminalEnvelope && latest) {
                         const envelope = terminalEnvelope;
-                        next.story_status = envelope.story_status;
-                        next.story_complete = envelope.story_complete;
-                        next.story_complete_reason = envelope.story_complete_reason;
-                        const storyStatus = envelope.decision === "blocked"
-                            ? "blocked"
-                            : envelope.decision === "done"
-                                ? "review"
-                                : storyStatusForEnvelope(envelope.story_status);
-                        next.stories = laneStories(current).map((story) => story.project_id === current.project_id && story.story_id === current.story_id
-                            ? {
-                                ...story,
-                                status: storyStatus,
-                                updated_at: nowIso,
-                                ...(envelope.decision === "blocked"
-                                    ? { blocked_reason: envelope.blocked_reason ?? "" }
-                                    : { blocked_reason: undefined }),
-                            }
-                            : story);
+                        const storyStatus = terminalEnvelopeStoryStatus(current, envelope.decision, envelope.story_status);
+                        if (storyStatus !== undefined) {
+                            next.story_status = envelope.story_status;
+                            next.story_complete = envelope.story_complete;
+                            next.story_complete_reason = envelope.story_complete_reason;
+                            next.stories = laneStories(current).map((story) => story.project_id === current.project_id && story.story_id === current.story_id
+                                ? {
+                                    ...story,
+                                    status: storyStatus,
+                                    updated_at: nowIso,
+                                    ...(envelope.decision === "blocked"
+                                        ? { blocked_reason: envelope.blocked_reason ?? "" }
+                                        : { blocked_reason: undefined }),
+                                }
+                                : story);
+                        }
                         if (approvalGate?.violation) {
                             next.last_envelope = {
                                 ref: latest.ref,
@@ -2682,6 +2681,10 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
             if (!deps.dryRun)
                 writeAnsweredQuestions(hqRoot, current, questions);
             if (queueReason !== undefined) {
+                const answerEnv = deps.spawnLaneDeps?.env ?? deps.env ?? process.env;
+                const answerCaller = typeof answerEnv.HQ_LANE_ID === "string"
+                    ? answerEnv.HQ_LANE_ID.trim() || "user"
+                    : "user";
                 const queued = casLaneIf(hqRoot, current.lane_id, (latest) => latest.state === "awaiting_input", (latest) => ({
                     ...latest,
                     state: "queued",
@@ -2693,6 +2696,7 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
                             ? { session_id: latest.provider_session_id }
                             : {}),
                         trigger: "answered_questions",
+                        caller: answerCaller,
                         at: answeredAt,
                     },
                 }), deps.dryRun);

package/dist/lib/lanes/spawn.js

@@ -2005,6 +2005,18 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     // Claim running before spawning. Two callers that both observe queued must
     // not both start processes; the CAS loser returns without spawn.
     const nowIso = (deps.now ?? (() => new Date()))().toISOString();
+    const resumeHistoryTrigger = pendingResume?.keep_alive === true
+        ? "keep_alive"
+        : pendingResume?.trigger === "message" || trigger.kind === "message"
+            ? "message"
+            : pendingResume?.trigger === "resume" || trigger.kind === "resume"
+                ? "resume_cli"
+                : "reconcile";
+    const resumeHistoryCaller = pendingResume?.caller ||
+        (typeof env.HQ_LANE_ID === "string" ? env.HQ_LANE_ID.trim() : "") ||
+        (trigger.kind === "answered_questions" || trigger.kind === "resume" || trigger.kind === "message"
+            ? "user"
+            : undefined);
     let statusGateHeartbeat;
     try {
         statusGateHeartbeat = managerStatusGateHeartbeat(hqRoot, existing, laneTurnId, nowIso);
@@ -2016,6 +2028,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         statusGateHeartbeat = undefined;
     }
     let claimed = false;
+    let priorStartRecorded = false;
     const claimedRecord = retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => {
         claimed = false;
         if (current.state === "running" && current.account === resolved.id) {
@@ -2027,6 +2040,12 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         if (!claimableStatesFor(trigger, current).includes(current.state)) {
             throw new LanesError("spawn_state_mismatch", `Cannot mark ${current.lane_id} running from ${current.state}`, { lane_id: current.lane_id, state: current.state, trigger: trigger.kind });
         }
+        // The host report is written in the claim CAS before exec proves that a
+        // worker started. Use the prior spawn manifest's turn id (written only
+        // after detachment is proven), with last_resume for legacy manifests.
+        priorStartRecorded = previousSpawn.turn_id !== undefined ||
+            current.last_resume !== undefined ||
+            (current.resume_history?.length ?? 0) > 0;
         if (failedResumeClaim &&
             (failedResumeExpectedSenior === undefined ||
                 !sameSeniorRef(current.senior, failedResumeExpectedSenior))) {
@@ -2260,6 +2279,16 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         }
         throw err;
     }
+    if (priorStartRecorded) {
+        retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => ({
+            ...current,
+            resume_history: appendCappedHistory(current.resume_history ?? [], {
+                at: nowIso,
+                trigger: resumeHistoryTrigger,
+                ...(resumeHistoryCaller ? { caller: resumeHistoryCaller } : {}),
+            }),
+        }));
+    }
     return laneLaunchResult(readLane(hqRoot, lane.lane_id));
 }
 /**
@@ -2563,6 +2592,16 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
             killQuietly(killProcess, workerPid, "worker");
         throw err;
     }
+    const startedAt = (deps.now ?? (() => new Date()))().toISOString();
+    const callerLaneId = typeof env.HQ_LANE_ID === "string" ? env.HQ_LANE_ID.trim() : "";
+    retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => ({
+        ...current,
+        resume_history: appendCappedHistory(current.resume_history ?? [], {
+            at: startedAt,
+            trigger: "envelope_repair",
+            ...(callerLaneId ? { caller: callerLaneId } : {}),
+        }),
+    }));
     return workerPid;
 }
 export { PROVIDER_HOME_ENV, PROVIDER_COMMAND };

package/dist/lib/lanes/store.js

@@ -751,6 +751,10 @@ export function parseLaneRecord(raw, filePath) {
             path: filePath,
         });
     }
+    if (isPlainObject(raw.pending_resume) &&
+        raw.pending_resume.caller !== undefined) {
+        requireString(raw.pending_resume.caller, "pending_resume.caller");
+    }
     if (raw.keep_alive_history !== undefined) {
         if (!Array.isArray(raw.keep_alive_history) || raw.keep_alive_history.length > HISTORY_CAP) {
             throw new LaneSchemaError(`keep_alive_history must be an array capped at ${HISTORY_CAP} entries`, {
@@ -773,6 +777,29 @@ export function parseLaneRecord(raw, filePath) {
             requireTimestamp(value.at, `${field}.at`, filePath);
         }
     }
+    if (raw.resume_history !== undefined) {
+        if (!Array.isArray(raw.resume_history) || raw.resume_history.length > HISTORY_CAP) {
+            throw new LaneSchemaError(`resume_history must be an array capped at ${HISTORY_CAP} entries`, {
+                path: filePath,
+                field: "resume_history",
+            });
+        }
+        for (const [index, value] of raw.resume_history.entries()) {
+            const field = `resume_history[${index}]`;
+            if (!isPlainObject(value) ||
+                Object.keys(value).some((key) => !["at", "trigger", "caller"].includes(key))) {
+                throw new LaneSchemaError(`${field} must be a resume history entry`, {
+                    path: filePath,
+                    field,
+                    value,
+                });
+            }
+            requireTimestamp(value.at, `${field}.at`, filePath);
+            requireString(value.trigger, `${field}.trigger`);
+            if (value.caller !== undefined)
+                requireString(value.caller, `${field}.caller`);
+        }
+    }
     if (raw.stop_history !== undefined) {
         if (!Array.isArray(raw.stop_history)) {
             throw new LaneSchemaError("stop_history must be an array when present", {
@@ -1163,6 +1190,11 @@ export function mergeLaneRecords(live, sidecars) {
                 failed_resume_history: unionHistory(all.map((record) => record.failed_resume_history ?? []), entryIdentity, base.failed_resume_history ?? []),
             }
             : {}),
+        ...(all.some((record) => record.resume_history !== undefined)
+            ? {
+                resume_history: unionHistory(all.map((record) => record.resume_history ?? []), entryIdentity, base.resume_history ?? []),
+            }
+            : {}),
         ...(all.some((record) => record.settings_history !== undefined)
             ? {
                 settings_history: unionHistory(all.map((record) => record.settings_history ?? []), entryIdentity, base.settings_history ?? []),