@indigoai-us/hq-cli 5.345.56 → 5.345.57

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [5.345.57] — 2026-10-09
+- Add `hq lanes create --loop` and `hq lanes enqueue` for persistent worker lanes that process FIFO phase envelopes, return generic results or section 8 handoffs, reuse sessions per story, retry one stall, and park a second stall for the senior. Loop behavior uses the default-on `lanes.conduct-loop` hq-flags kill switch. See `docs/lanes.md` for command output and exit codes.
+
+- Add six-hour escalation for continuously blocked lanes, including durable cross-host inbox delivery and per-lane escalation history.
+- Lane questions addressed to the current operator session record session-specific visibility on the owning host; unanswered questions cannot age past that session before it sees them, and reparenting to a different audience clears the marker. Visibility is separate from answer delivery so conflict-sidecar merging cannot suppress answer delivery. Outpost question show and answer lookups ignore malformed rows for unrelated question ids while still validating the requested record.
+
 ## [5.345.56] — 2026-10-09
 - Add `hq lanes reap` to report local lanes whose session senior is confirmed ended, clear stale pid markers on request, and keep process-tree stopping behind the `lanes.reap-stop` hq-flags key. SessionStart runs the report-only sweep detached and stores its report in host-specific user state.
 - Record privacy-limited `hq members invite` success and failure outcomes through the existing CLI feature telemetry event.

package/dist/command-catalog.generated.d.ts

@@ -11654,6 +11654,10 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly flags: "--fresh-thread";
             readonly description: "Skip worker continuity and start a cold provider session";
             readonly hidden: false;
+        }, {
+            readonly flags: "--loop";
+            readonly description: "Keep one worker lane registered to process queued phase envelopes";
+            readonly hidden: false;
         }, {
             readonly flags: "--provider <name>";
             readonly description: "claude | codex | grok";
@@ -11734,6 +11738,52 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly hidden: false;
         }];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "_loop-worker";
+        readonly description: "";
+        readonly aliases: readonly [];
+        readonly hidden: true;
+        readonly helpOption: true;
+        readonly helpCommand: false;
+        readonly usage: "[options] <lane-id>";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [{
+            readonly name: "lane-id";
+            readonly required: true;
+            readonly variadic: false;
+            readonly description: "Loop lane id";
+        }];
+        readonly options: readonly [{
+            readonly flags: "--json";
+            readonly description: "JSON on stdout (always)";
+            readonly hidden: false;
+        }];
+        readonly subcommands: readonly [];
+    }, {
+        readonly name: "enqueue";
+        readonly description: "Validate and queue one phase envelope for a loop lane";
+        readonly aliases: readonly [];
+        readonly hidden: false;
+        readonly helpOption: true;
+        readonly helpCommand: false;
+        readonly usage: "[options] <lane-id>";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [{
+            readonly name: "lane-id";
+            readonly required: true;
+            readonly variadic: false;
+            readonly description: "Loop lane id";
+        }];
+        readonly options: readonly [{
+            readonly flags: "--envelope <file>";
+            readonly description: "Generic phase or hq-phase-envelope/v1 JSON file";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--json";
+            readonly description: "JSON on stdout (always)";
+            readonly hidden: false;
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "reparent-target";
         readonly description: "";
@@ -12606,6 +12656,40 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly hidden: false;
         }];
         readonly subcommands: readonly [];
+    }, {
+        readonly name: "_enqueue-blocked-escalation";
+        readonly description: "";
+        readonly aliases: readonly [];
+        readonly hidden: true;
+        readonly helpOption: true;
+        readonly helpCommand: false;
+        readonly usage: "[options] <recipient-kind> <recipient-id>";
+        readonly helpText: readonly [];
+        readonly arguments: readonly [{
+            readonly name: "recipient-kind";
+            readonly required: true;
+            readonly variadic: false;
+            readonly description: "";
+        }, {
+            readonly name: "recipient-id";
+            readonly required: true;
+            readonly variadic: false;
+            readonly description: "";
+        }];
+        readonly options: readonly [{
+            readonly flags: "--text <text>";
+            readonly description: "Escalation notice";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--message-id <id>";
+            readonly description: "Idempotency key";
+            readonly hidden: false;
+        }, {
+            readonly flags: "--json";
+            readonly description: "JSON on stdout (always)";
+            readonly hidden: false;
+        }];
+        readonly subcommands: readonly [];
     }, {
         readonly name: "_spawn-envelope-repair";
         readonly description: "";

package/dist/command-catalog.generated.js

@@ -14162,6 +14162,11 @@ export const COMMAND_CATALOG = [
                         "description": "Skip worker continuity and start a cold provider session",
                         "hidden": false
                     },
+                    {
+                        "flags": "--loop",
+                        "description": "Keep one worker lane registered to process queued phase envelopes",
+                        "hidden": false
+                    },
                     {
                         "flags": "--provider <name>",
                         "description": "claude | codex | grok",
@@ -14262,6 +14267,63 @@ export const COMMAND_CATALOG = [
                 ],
                 "subcommands": []
             },
+            {
+                "name": "_loop-worker",
+                "description": "",
+                "aliases": [],
+                "hidden": true,
+                "helpOption": true,
+                "helpCommand": false,
+                "usage": "[options] <lane-id>",
+                "helpText": [],
+                "arguments": [
+                    {
+                        "name": "lane-id",
+                        "required": true,
+                        "variadic": false,
+                        "description": "Loop lane id"
+                    }
+                ],
+                "options": [
+                    {
+                        "flags": "--json",
+                        "description": "JSON on stdout (always)",
+                        "hidden": false
+                    }
+                ],
+                "subcommands": []
+            },
+            {
+                "name": "enqueue",
+                "description": "Validate and queue one phase envelope for a loop lane",
+                "aliases": [],
+                "hidden": false,
+                "helpOption": true,
+                "helpCommand": false,
+                "usage": "[options] <lane-id>",
+                "helpText": [],
+                "arguments": [
+                    {
+                        "name": "lane-id",
+                        "required": true,
+                        "variadic": false,
+                        "description": "Loop lane id"
+                    }
+                ],
+                "options": [
+                    {
+                        "flags": "--envelope <file>",
+                        "description": "Generic phase or hq-phase-envelope/v1 JSON file",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "JSON on stdout (always)",
+                        "hidden": false
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "reparent-target",
                 "description": "",
@@ -15334,6 +15396,48 @@ export const COMMAND_CATALOG = [
                 ],
                 "subcommands": []
             },
+            {
+                "name": "_enqueue-blocked-escalation",
+                "description": "",
+                "aliases": [],
+                "hidden": true,
+                "helpOption": true,
+                "helpCommand": false,
+                "usage": "[options] <recipient-kind> <recipient-id>",
+                "helpText": [],
+                "arguments": [
+                    {
+                        "name": "recipient-kind",
+                        "required": true,
+                        "variadic": false,
+                        "description": ""
+                    },
+                    {
+                        "name": "recipient-id",
+                        "required": true,
+                        "variadic": false,
+                        "description": ""
+                    }
+                ],
+                "options": [
+                    {
+                        "flags": "--text <text>",
+                        "description": "Escalation notice",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--message-id <id>",
+                        "description": "Idempotency key",
+                        "hidden": false
+                    },
+                    {
+                        "flags": "--json",
+                        "description": "JSON on stdout (always)",
+                        "hidden": false
+                    }
+                ],
+                "subcommands": []
+            },
             {
                 "name": "_spawn-envelope-repair",
                 "description": "",

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

@@ -0,0 +1,12 @@
+import type { Ctx, LaneResumeOptions } from "./lanes-shared.js";
+import type { LaneRecord } from "../lib/lanes/types.js";
+export interface LoopControllerDeps {
+    resumeLane(laneId: string, options: LaneResumeOptions): Promise<unknown>;
+    interruptLane(laneId: string, reason: string, options: {
+        preserveLoopQueue: boolean;
+    }): Promise<void>;
+    emitTerminal(lane: LaneRecord): Promise<void>;
+}
+export declare function startLaneLoopController(ctx: Ctx, laneId: string, initialAdmission?: boolean): number;
+export declare function runLaneLoopController(ctx: Ctx, laneId: string, deps: LoopControllerDeps): Promise<void>;
+//# sourceMappingURL=lanes-loop.d.ts.map

package/dist/commands/lanes-loop.js

@@ -0,0 +1,214 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { LanesError } from "../lib/lanes/errors.js";
+import { readLane, retryUpdateLane } from "../lib/lanes/store.js";
+import { readLatestEnvelopeRecord } from "../lib/lanes/watcher.js";
+import { spawnLaneWorker } from "../lib/lanes/spawn.js";
+import { raiseLaneQuestion } from "../lib/lanes/questions.js";
+import { isTerminalLaneState } from "../lib/lanes/types.js";
+import { clearLoopControllerPid, loopAdmissionPath, runLoopLane, setLoopControllerPid } from "../lib/lanes/loop.js";
+import { laneStories } from "../lib/lanes/stories.js";
+const LOOP_RUNS_REL = path.join("workspace", "lanes-runs");
+function loopRunDir(hqRoot, laneId) {
+    return path.join(hqRoot, LOOP_RUNS_REL, laneId);
+}
+export function startLaneLoopController(ctx, laneId, initialAdmission = false) {
+    const entry = process.argv[1];
+    if (!entry)
+        throw new LanesError("loop_controller_entry_missing", "Cannot resolve the hq CLI entry point for the loop controller", { lane_id: laneId });
+    const child = spawn(process.execPath, [entry, "lanes", "_loop-worker", laneId], {
+        cwd: ctx.hqRoot(),
+        detached: true,
+        stdio: "ignore",
+        env: { ...ctx.env, HQ_LANE_LOOP_CONTROLLER: "1", ...(initialAdmission ? { HQ_LANE_LOOP_INITIAL: "1" } : {}) },
+    });
+    child.unref();
+    if (child.pid === undefined)
+        throw new LanesError("loop_controller_spawn_failed", "Loop controller did not start", { lane_id: laneId });
+    setLoopControllerPid(loopRunDir(ctx.hqRoot(), laneId), laneId, child.pid);
+    return child.pid;
+}
+export async function runLaneLoopController(ctx, laneId, deps) {
+    const hqRoot = ctx.hqRoot();
+    const lane = readLane(hqRoot, laneId);
+    if (lane.loop_mode !== true)
+        throw new LanesError("lane_not_loop_mode", `Lane ${laneId} is not a loop lane`, { lane_id: laneId });
+    const runDir = loopRunDir(hqRoot, laneId);
+    let initialAdmission = ctx.env.HQ_LANE_LOOP_INITIAL === "1";
+    const stop = new AbortController();
+    const onSignal = () => stop.abort();
+    process.once("SIGTERM", onSignal);
+    process.once("SIGINT", onSignal);
+    try {
+        const result = await runLoopLane({
+            lane,
+            runDir,
+            signal: stop.signal,
+            idlePollMs: 250,
+            execute: async ({ envelope, signal, fresh, sessionId }) => {
+                let current = readLane(hqRoot, laneId);
+                const data = envelope;
+                const storyId = typeof data.story_id === "string" && data.story_id.trim() ? data.story_id.trim() : current.story_id;
+                if (storyId !== current.story_id) {
+                    current = retryUpdateLane(hqRoot, laneId, "command", (record) => {
+                        const stories = laneStories(record);
+                        if (!stories.some((story) => story.project_id === record.project_id && story.story_id === storyId)) {
+                            stories.push({ project_id: record.project_id, story_id: storyId, status: "in_progress", added_at: ctx.now().toISOString(), updated_at: ctx.now().toISOString() });
+                        }
+                        return { ...record, story_id: storyId, stories };
+                    });
+                }
+                const worktree = typeof data.worktree === "string" ? path.resolve(data.worktree) : hqRoot;
+                if (typeof data.worktree === "string") {
+                    let isDirectory = false;
+                    try {
+                        isDirectory = fs.statSync(worktree).isDirectory();
+                    }
+                    catch (error) {
+                        if (error.code !== "ENOENT" && error.code !== "ENOTDIR")
+                            throw error;
+                    }
+                    if (!isDirectory)
+                        throw new Error(`phase worktree is not an accessible directory: ${worktree}`);
+                }
+                const phaseContext = data.schema === "hq-phase-envelope/v1"
+                    ? [
+                        `Story id: ${storyId}`,
+                        `Story title: ${String(data.story_title ?? "")}`,
+                        `Story description: ${String(data.story_description ?? "")}`,
+                        `Phase: ${String(data.phase)}`,
+                        `Working directory (worktree): ${worktree}`,
+                        `Incoming handoff: ${String(data.incoming_handoff ?? "None: this is the first phase")}`,
+                        "Acceptance criteria:",
+                        ...(Array.isArray(data.acceptance_criteria) ? data.acceptance_criteria.map((item, index) => `${index}. ${String(item)}`) : []),
+                        "Constraints:",
+                        ...(Array.isArray(data.constraints) ? data.constraints.map((item) => `- ${String(item)}`) : []),
+                    ].join("\n")
+                    : `Execute the ${String(data.phase ?? "requested")} phase for story ${storyId}.`;
+                const prompt = typeof data.prompt === "string" ? data.prompt :
+                    `${phaseContext}\n\nPhase envelope:\n${JSON.stringify(envelope, null, 2)}`;
+                const briefPath = path.join(runDir, "brief.md");
+                fs.writeFileSync(briefPath, [
+                    "Follow the lane worker instructions and complete this single bounded phase.",
+                    "Return the standard hq-lane-envelope.v1 envelope when the phase is complete. For a section 8 phase envelope, put a complete hq-phase-handoff/v1 object in artifacts; it must identify the requested story_id and phase and include worker_id, status, summary, files_changed, commits, back_pressure (tests/lint/typecheck/build), and context_for_next.",
+                    "",
+                    prompt,
+                ].join("\n"));
+                const admissionPath = loopAdmissionPath(current.state, current.pending_resume !== undefined, initialAdmission);
+                if (admissionPath === "initial") {
+                    initialAdmission = false;
+                    if (current.state === "running") {
+                        retryUpdateLane(hqRoot, laneId, "command", (record) => ({
+                            ...record,
+                            state: "queued",
+                            queued_reason: undefined,
+                            queued_details: undefined,
+                            admission_reserved_at: undefined,
+                        }));
+                    }
+                    await spawnLaneWorker(hqRoot, current, {
+                        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,
+                        workingDirectory: worktree,
+                    });
+                }
+                else if (admissionPath === "deferred") {
+                    retryUpdateLane(hqRoot, laneId, "command", (record) => ({
+                        ...record,
+                        pending_resume: record.pending_resume ? {
+                            ...record.pending_resume,
+                            ...(fresh ? { session_id: undefined, fresh_thread: true } : sessionId ? { session_id: sessionId, fresh_thread: undefined } : {}),
+                            working_directory: worktree,
+                        } : undefined,
+                    }));
+                }
+                else {
+                    await deps.resumeLane(laneId, {
+                        text: `Read ${briefPath} and follow it as the complete instruction for this phase.`,
+                        project: current.project_id,
+                        story: storyId,
+                        freshThread: fresh,
+                        ...(sessionId ? { loopSessionId: sessionId } : {}),
+                        workingDirectory: worktree,
+                    });
+                }
+                let interruptPromise;
+                const abortPhase = () => {
+                    interruptPromise = deps.interruptLane(laneId, "loop phase deadline exceeded", { preserveLoopQueue: true }).catch((error) => {
+                        process.stderr.write(`hq lanes: could not interrupt stalled loop phase ${laneId}: ${error instanceof Error ? error.message : String(error)}\n`);
+                    });
+                };
+                signal.addEventListener("abort", abortPhase, { once: true });
+                try {
+                    for (;;) {
+                        if (signal.aborted) {
+                            await interruptPromise;
+                            throw signal.reason ?? new Error("phase deadline exceeded");
+                        }
+                        const latest = readLane(hqRoot, laneId);
+                        if (latest.state === "done" || latest.state === "blocked" || latest.state === "awaiting_input" || isTerminalLaneState(latest.state)) {
+                            const envelopeRecord = readLatestEnvelopeRecord(hqRoot, laneId);
+                            if (latest.state !== "done" && latest.state !== "blocked" && latest.state !== "awaiting_input") {
+                                throw new Error(`lane phase ended in ${latest.state}${latest.terminal_reason ? ` (${latest.terminal_reason})` : ""}`);
+                            }
+                            if (!envelopeRecord)
+                                throw new Error(`lane ${laneId} ended without writing a phase envelope`);
+                            const handoff = envelopeRecord.envelope.artifacts.find((artifact) => typeof artifact === "object" && artifact !== null &&
+                                artifact.schema === "hq-phase-handoff/v1");
+                            if (data.schema === "hq-phase-envelope/v1" && !handoff) {
+                                throw new Error("section 8 phase requires an hq-phase-handoff/v1 object in the lane envelope artifacts");
+                            }
+                            return { output: JSON.stringify(handoff ?? envelopeRecord.envelope), ...(latest.provider_session_id ? { sessionId: latest.provider_session_id } : {}) };
+                        }
+                        await new Promise((resolve) => setTimeout(resolve, 250));
+                    }
+                }
+                finally {
+                    signal.removeEventListener("abort", abortPhase);
+                }
+            },
+            raiseQuestion: ({ envelope, envelopeId, attempt, error }) => {
+                const current = readLane(hqRoot, laneId);
+                const data = envelope;
+                raiseLaneQuestion({
+                    hqRoot,
+                    lane: current,
+                    raisedVia: "cli",
+                    at: ctx.now().toISOString(),
+                    body: {
+                        question: `Loop phase ${String(data.phase ?? envelopeId)} stalled twice. How should it proceed?`,
+                        context: `${error}\nThe phase is parked; later envelopes remain queued. Stall attempt: ${attempt}.`,
+                        options: ["Retry with a longer deadline", "Reroute to another worker", "Drop this phase and block the story"],
+                        recommended: "Retry with a longer deadline",
+                    },
+                });
+            },
+        });
+        if (result.state === "stopped") {
+            const stopped = retryUpdateLane(hqRoot, laneId, "command", (current) => ({
+                ...current,
+                state: "done",
+                queued_reason: undefined,
+                queued_details: undefined,
+                admission_reserved_at: undefined,
+                terminal_reason: "loop_stopped",
+            }));
+            await deps.emitTerminal(stopped);
+        }
+    }
+    finally {
+        process.removeListener("SIGTERM", onSignal);
+        process.removeListener("SIGINT", onSignal);
+        clearLoopControllerPid(runDir, laneId, process.pid);
+    }
+}
+//# sourceMappingURL=lanes-loop.js.map

package/dist/commands/lanes-questions.js

@@ -291,7 +291,7 @@ export function createLaneQuestionsHandlers(deps) {
         const body = parseOutpostQuestionBody(response.body, outpostId, question.question_id);
         return { question, audience, body };
     }
-    async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter) {
+    async function loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, companyFilter, questionId, visibilityFilter) {
         const hostedLanes = loadAllLanes(hqRoot).filter((lane) => lane.host.kind === "outpost" &&
             !laneIsHostedHere(ctx, lane) &&
             (!companyFilter ||
@@ -356,7 +356,7 @@ export function createLaneQuestionsHandlers(deps) {
                 };
             }
             try {
-                const remoteQuestions = await readOutpostQuestionRecords(ctx, outpostId, group.company);
+                const remoteQuestions = await readOutpostQuestionRecords(ctx, outpostId, group.company, questionId, visibilityFilter);
                 const localLanesById = new Map(group.lanes.map((lane) => [lane.lane_id, lane]));
                 const groupQuestions = [];
                 const seenQuestionIds = new Set();
@@ -595,8 +595,32 @@ export function createLaneQuestionsHandlers(deps) {
             }
             return true;
         });
+        const deliveredLocalQuestions = new Map();
+        const currentSessionId = sessionIdFromEnv(ctx.env);
+        if (currentSessionId) {
+            const deliveredAt = ctx.now().toISOString();
+            for (const question of localQuestions) {
+                if (question.status !== "pending")
+                    continue;
+                const audience = resolveAudience(hqRoot, question, ctx);
+                if (audience.kind !== "session" || audience.id !== currentSessionId)
+                    continue;
+                const delivered = casUpdateQuestion(hqRoot, question.question_id, (current) => current.status !== "pending" ||
+                    (current.seen_at && current.seen_session_id === currentSessionId)
+                    ? current
+                    : { ...current, seen_at: deliveredAt, seen_session_id: currentSessionId });
+                deliveredLocalQuestions.set(question.question_id, delivered);
+            }
+        }
         const outpostLoad = opts.allHosts
-            ? await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company)
+            ? await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company, undefined, {
+                sessionId: currentSessionId ?? undefined,
+                for: opts.for,
+                from: opts.from,
+                project: opts.project,
+                story: opts.story,
+                status: opts.status,
+            })
             : { questions: [], errors: [] };
         for (const owner of outpostLoad.questions) {
             assertQuestionCompanyAccess(owner.question, owner.lane, company, hqRoot);
@@ -607,12 +631,13 @@ export function createLaneQuestionsHandlers(deps) {
             ...localQuestions
                 .filter((q) => !remoteQuestionIds.has(q.question_id))
                 .map((q) => {
+                const visibleQuestion = deliveredLocalQuestions.get(q.question_id) ?? q;
                 const row = {
-                    ...q,
-                    priority: q.priority ?? null,
-                    priority_display: q.priority ?? "-",
-                    audience: resolveAudience(hqRoot, q, ctx),
-                    ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
+                    ...visibleQuestion,
+                    priority: visibleQuestion.priority ?? null,
+                    priority_display: visibleQuestion.priority ?? "-",
+                    audience: resolveAudience(hqRoot, visibleQuestion, ctx),
+                    ...(visibleQuestion.question_kind === "continue" ? { flag: "continue-loop" } : {}),
                 };
                 if (!opts.allHosts)
                     return row;
@@ -662,7 +687,7 @@ export function createLaneQuestionsHandlers(deps) {
         catch (err) {
             if (!isLanesError(err) || err.error !== "question_not_found")
                 throw err;
-            const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
+            const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, undefined, questionId);
             if (lookup.errors.length > 0) {
                 throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
                     question_id: questionId,
@@ -717,7 +742,7 @@ export function createLaneQuestionsHandlers(deps) {
             if (!isLanesError(err) || err.error !== "question_not_found")
                 throw err;
             const company = explicitCompany ?? await resolveActiveQuestionCompany(ctx, "Cannot look up this lane question because the active HQ company could not be resolved; re-run with --company <slug>");
-            const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company);
+            const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, company, questionId);
             const matches = lookup.questions.filter((entry) => entry.question.question_id === questionId);
             if (matches.length === 0 && lookup.errors.length > 0) {
                 throw new LanesError("outpost_question_lookup_unavailable", `Could not verify whether Outposts own question ${questionId}`, {
@@ -726,7 +751,7 @@ export function createLaneQuestionsHandlers(deps) {
                 });
             }
             if (matches.length === 0) {
-                const allCompanyLookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
+                const allCompanyLookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot, undefined, questionId);
                 const otherCompanyMatch = allCompanyLookup.questions.find((entry) => entry.question.question_id === questionId);
                 if (otherCompanyMatch) {
                     assertQuestionCompanyAccess(otherCompanyMatch.question, otherCompanyMatch.lane, company, hqRoot);
@@ -818,6 +843,7 @@ export function createLaneQuestionsHandlers(deps) {
                 company: recordedCompany,
                 body: nextBody,
                 status: "answered",
+                delivered_at: null,
                 answer: {
                     choice,
                     answer_kind: freeform ? "freeform" : "option",

package/dist/commands/lanes-resume.js

@@ -91,6 +91,9 @@ export function createLaneResumeHandlers(deps) {
         const hqRoot = ctx.hqRoot();
         const resolution = await deps.resolveCommandLane(ctx, laneId);
         let lane = resolution.lane;
+        if (opts.freshThread === true && lane.loop_mode !== true) {
+            throw new LanesError("fresh_thread_loop_only", "--fresh-thread is reserved for loop-lane phases", { lane_id: laneId });
+        }
         const failedResumeReason = opts.reason?.trim();
         if (opts.reason !== undefined && opts.fromFailed !== true) {
             throw new LanesError("failed_resume_reason_requires_flag", "--reason on hq lanes resume requires --from-failed", { lane_id: laneId });
@@ -153,6 +156,9 @@ export function createLaneResumeHandlers(deps) {
             throw new LanesError("effort_resume_unsupported", `Provider ${lane.provider} cannot change effort on a resumed session`, { lane_id: laneId, provider: lane.provider });
         }
         lane = laneWithRecoveredProviderSession(hqRoot, lane);
+        if (opts.loopSessionId !== undefined && opts.loopSessionId !== lane.provider_session_id) {
+            lane = casUpdateLane(hqRoot, laneId, (current) => ({ ...current, provider_session_id: opts.loopSessionId }));
+        }
         if (opts.model !== undefined && opts.account === undefined) {
             throw new LanesError("model_requires_account", "--model on hq lanes resume is only accepted together with --account", {});
         }
@@ -233,7 +239,7 @@ export function createLaneResumeHandlers(deps) {
         }
         const refusal = queuedProfileRecovery || lane.state === "awaiting_input"
             ? null
-            : resumeCommandRefusal(lane, { allowFailed: opts.fromFailed === true || isFailedQuotaKeepAliveLane(lane) });
+            : resumeCommandRefusal(lane, { allowFailed: opts.fromFailed === true || isFailedQuotaKeepAliveLane(lane), allowFresh: opts.freshThread === true });
         if (refusal !== null) {
             throw new LanesError(refusal.error, refusal.message, {
                 lane_id: laneId,
@@ -435,6 +441,8 @@ export function createLaneResumeHandlers(deps) {
                         ...(deliveryText !== undefined ? { text: deliveryText } : {}),
                         ...(messageId !== undefined ? { message_id: messageId } : {}),
                         compact: opts.compact !== false,
+                        ...(opts.freshThread === true ? { fresh_thread: true } : {}),
+                        ...(opts.workingDirectory ? { working_directory: opts.workingDirectory } : {}),
                     },
                 });
                 lane = move.lane;
@@ -469,6 +477,8 @@ export function createLaneResumeHandlers(deps) {
                             ...(deliveryText !== undefined ? { text: deliveryText } : {}),
                             ...(messageId !== undefined ? { message_id: messageId } : {}),
                             compact: opts.compact !== false,
+                            ...(opts.freshThread === true ? { fresh_thread: true } : {}),
+                            ...(opts.workingDirectory ? { working_directory: opts.workingDirectory } : {}),
                         },
                         accountSelection: selection,
                     });
@@ -496,6 +506,8 @@ export function createLaneResumeHandlers(deps) {
                         ...(deliveryText !== undefined ? { text: deliveryText } : {}),
                         ...(messageId !== undefined ? { message_id: messageId } : {}),
                         compact: opts.compact !== false,
+                        ...(opts.freshThread === true ? { fresh_thread: true } : {}),
+                        ...(opts.workingDirectory ? { working_directory: opts.workingDirectory } : {}),
                     },
                 });
                 lane = move.lane;
@@ -535,6 +547,8 @@ export function createLaneResumeHandlers(deps) {
                     ...(deliveryText !== undefined ? { text: deliveryText } : {}),
                     ...(messageId !== undefined ? { message_id: messageId } : {}),
                     compact: opts.compact !== false,
+                    ...(opts.freshThread === true ? { fresh_thread: true } : {}),
+                    ...(opts.workingDirectory ? { working_directory: opts.workingDirectory } : {}),
                     at: quotaHoldAt,
                 };
                 resumed = markSpawnFailure(hqRoot, laneId, "account_quota_exhausted", {
@@ -590,6 +604,8 @@ export function createLaneResumeHandlers(deps) {
                                         ...(deliveryText !== undefined ? { text: deliveryText } : {}),
                                         ...(messageId !== undefined ? { message_id: messageId } : {}),
                                         compact: opts.compact !== false,
+                                        ...(opts.freshThread === true ? { fresh_thread: true } : {}),
+                                        ...(opts.workingDirectory ? { working_directory: opts.workingDirectory } : {}),
                                         at,
                                     },
                                 };
@@ -610,10 +626,12 @@ export function createLaneResumeHandlers(deps) {
                             resolveMachineIdentity: ctx.resolveMachineIdentity,
                             runCompaction: ctx.runCompaction,
                             locateTranscript: ctx.locateTranscript,
+                            ...(opts.workingDirectory ? { workingDirectory: opts.workingDirectory } : {}),
                         }, {
                             trigger: {
                                 kind: "resume",
                                 from: resumedFrom,
+                                ...(opts.freshThread === true ? { fresh: true } : {}),
                                 ...(resumedFrom === "awaiting_input" && pendingQuestions.length === 0 ? { allowAwaitingInput: true } : {}),
                                 ...(opts.fromFailed === true ? { fromFailed: true } : {}),
                                 ...(failedResumeExpectedSenior !== undefined