@indigoai-us/hq-cli 5.345.56 → 5.345.58

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [5.345.58] — 2026-10-09
+- hq access now accepts `--as <member>` to view another member's access, read-only.
+
+## [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

@@ -2871,6 +2871,10 @@ export declare const COMMAND_CATALOG: readonly [{
         readonly flags: "--company <slug>";
         readonly description: "Company slug";
         readonly hidden: false;
+    }, {
+        readonly flags: "--as <person-uid>";
+        readonly description: "Check a person's access (exact prs_ or agt_ UID; self or owner/admin)";
+        readonly hidden: false;
     }, {
         readonly flags: "--json";
         readonly description: "Print a single JSON object";
@@ -11654,6 +11658,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 +11742,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 +12660,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

@@ -3462,6 +3462,11 @@ export const COMMAND_CATALOG = [
                 "description": "Company slug",
                 "hidden": false
             },
+            {
+                "flags": "--as <person-uid>",
+                "description": "Check a person's access (exact prs_ or agt_ UID; self or owner/admin)",
+                "hidden": false
+            },
             {
                 "flags": "--json",
                 "description": "Print a single JSON object",
@@ -14162,6 +14167,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 +14272,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 +15401,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/access.d.ts

@@ -135,6 +135,15 @@ export interface RunAccessResult {
     alreadyAskedAt?: string;
     requestNote?: string;
 }
+export interface AccessAsResult {
+    personUid: string;
+    company: string;
+    path: string;
+    permission: "read" | "write" | "admin" | null;
+    canRead: boolean;
+    roleBypass: boolean;
+    exitCode: 0 | 3;
+}
 export declare function outcomeExitCode(outcome: AccessOutcome): 0 | 2 | 3 | 4;
 export declare function formatAccessOutcome(result: RunAccessResult): string;
 export declare function resolveGrantor(tree: AccessAclTree | null, members: AccessMember[]): AccessGrantor | null;
@@ -149,6 +158,11 @@ export declare function resolveAccessCompany(target: string, opts?: {
     company?: string;
     hqRoot?: string;
 }): string | undefined;
+export declare function runAccessForPerson(rawPath: string, personUid: string, opts?: {
+    company?: string;
+    hqRoot?: string;
+}): Promise<AccessAsResult>;
+export declare function formatAccessForPerson(result: AccessAsResult): string;
 export declare function runAccessForPath(path: string, opts?: {
     company?: string;
     hqRoot?: string;

package/dist/commands/access.js

@@ -20,7 +20,7 @@ import * as readline from "node:readline";
 import { ListObjectsV2Command, } from "@aws-sdk/client-s3";
 import { DEFAULT_HQ_ROOT } from "../utils/cognito-session.js";
 import { getCompanyUid, vaultApiFetch, resolveCallerUid } from "../utils/vault-api.js";
-import { parseCompanySlugFromPath, resolveBrowseSession, makeCompanyPresignFactory, runGet, } from "./files-browse.js";
+import { parseCompanySlugFromPath, classifyAclSource, resolveBrowseSession, makeCompanyPresignFactory, runGet, toBucketRelative, } from "./files-browse.js";
 import { listJournals, syncDoctor, } from "@indigoai-us/hq-cloud";
 import { listActiveMembers } from "./members.js";
 import { buildDmBody } from "./dm.js";
@@ -87,6 +87,10 @@ function normalizeTarget(raw, slug) {
         t = t.slice(anchor.length);
     return t;
 }
+function fileGrantCoversPath(grantPath, targetPath) {
+    return classifyAclSource(targetPath, [grantPath]) !== "role-bypass";
+}
+const FILE_PERMISSION_RANK = { read: 1, write: 2, admin: 3 };
 function httpStatusOf(err) {
     if (!err || typeof err !== "object")
         return undefined;
@@ -637,6 +641,7 @@ export function registerAccessCommand(program) {
         .command("access <path-or-query>")
         .description("Tell whether a vault file exists and whether you can read it. Never a bare not-found. Exit codes: 0 local/not-synced, 2 never-existed, 3 no-access, 4 ambiguous.")
         .option("--company <slug>", "Company slug")
+        .option("--as <person-uid>", "Check a person's access (exact prs_ or agt_ UID; self or owner/admin)")
         .option("--json", "Print a single JSON object")
         .option("--no-fix", "Diagnose only: do not fetch, pin, or repair sync")
         .option("--yes", "Answer the one send-confirmation yes (hosts must pass this explicitly)")
@@ -650,6 +655,12 @@ Exit codes:
 `)
         .action(async (target, opts) => {
         try {
+            if (opts.as) {
+                const result = await runAccessForPerson(target, opts.as, opts);
+                console.log(opts.json ? JSON.stringify(result) : formatAccessForPerson(result));
+                process.exitCode = result.exitCode;
+                return;
+            }
             const result = await runAccessForPath(target, opts);
             process.exitCode = result.exitCode;
         }
@@ -669,6 +680,63 @@ export function resolveAccessCompany(target, opts) {
     const hqRoot = opts?.hqRoot ?? DEFAULT_HQ_ROOT;
     return opts?.company ?? slugFromTarget(target) ?? readActiveCompany(hqRoot);
 }
+export async function runAccessForPerson(rawPath, personUid, opts) {
+    const uid = personUid.trim();
+    if (!/^(?:prs|agt)_[A-Za-z0-9_-]+$/.test(uid)) {
+        throw new Error("Pass the person's exact prs_ or agt_ UID to --as.");
+    }
+    const pathSlug = slugFromTarget(rawPath);
+    if (opts?.company && pathSlug && opts.company !== pathSlug) {
+        throw new Error("The --company value does not match the company in the path.");
+    }
+    const company = resolveAccessCompany(rawPath, opts);
+    if (!company)
+        throw new Error("Pass --company <slug> or an anchored company path.");
+    const relativePath = normalizeTarget(rawPath, company);
+    if (!relativePath || relativePath.split(/[\\/]/).includes("..")) {
+        throw new Error("Pass a company-relative path without parent-directory segments.");
+    }
+    const { token } = await resolveBrowseSession();
+    const companyUid = await getCompanyUid(token, company);
+    const response = await vaultApiFetch({
+        token,
+        path: `/files/${encodeURIComponent(companyUid)}/members/${encodeURIComponent(uid)}/access`,
+        method: "GET",
+    });
+    if (!response.ok) {
+        if (response.status === 403) {
+            throw new Error("Only the person themself or a company owner/admin can check this access.");
+        }
+        if (response.status === 404) {
+            throw new Error("That person is not an active member of this company.");
+        }
+        throw new Error(`Member access check failed (${response.status}).`);
+    }
+    const projection = (await response.json());
+    if (projection.personUid !== uid || !projection.files) {
+        throw new Error("The member access response did not match the requested person.");
+    }
+    const roleBypass = projection.files.roleBypass === true;
+    const grants = Array.isArray(projection.files.grants) ? projection.files.grants : [];
+    const matchingPermissions = grants
+        .filter((grant) => typeof grant.path === "string" && typeof grant.permission === "string" &&
+        grant.permission in FILE_PERMISSION_RANK &&
+        fileGrantCoversPath(toBucketRelative(grant.path, company), relativePath))
+        .map((grant) => grant.permission);
+    const permission = roleBypass ? "admin" : matchingPermissions.reduce((best, candidate) => best === null || FILE_PERMISSION_RANK[candidate] > FILE_PERMISSION_RANK[best] ? candidate : best, null);
+    return {
+        personUid: uid,
+        company,
+        path: `companies/${company}/${relativePath}`,
+        permission,
+        canRead: permission !== null,
+        roleBypass,
+        exitCode: permission === null ? 3 : 0,
+    };
+}
+export function formatAccessForPerson(result) {
+    return `${result.personUid} has ${result.permission ?? "no access"} access to ${result.path}.`;
+}
 export async function runAccessForPath(path, opts) {
     const target = path;
     const hqRoot = opts?.hqRoot ?? DEFAULT_HQ_ROOT;

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