@indigoai-us/hq-cli 5.345.55 → 5.345.57

package/dist/commands/lanes-checks.js

@@ -13,6 +13,7 @@ import { LANES_RUNS_REL } from "../lib/lanes/spawn.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { checkCompanyPath } from "../lib/lanes/checked-company-path.js";
 import { findOrphanedBareIdDropboxes } from "../lib/lanes/orphaned-dropbox.js";
+import { parseReapMinAge, reapLocalLanes } from "../lib/lanes/reaper.js";
 export function mappingIncludesStory(mapping, storyId) {
     return (mapping.storyPrefix === undefined || storyId.startsWith(mapping.storyPrefix))
         && (mapping.excludePrefix === undefined || !storyId.startsWith(mapping.excludePrefix));
@@ -905,6 +906,39 @@ async function orphanReport(root, company, now, minAgeMinutes, userIdleHours, de
     output("orphans.stop", stopped);
 }
 export function registerLaneChecksCommand(parent, deps, wrap) {
+    parent.command("reap")
+        // CL-5's SessionStart hook launches this alias detached and does not wait for it.
+        .alias("_reap")
+        .description("Classify local lanes whose session senior has ended; report only by default")
+        .option("--min-age <minutes>", "Minimum lane age in minutes (default: 120)")
+        .option("--apply-stale-state", "Remove stale worker and watcher pid markers")
+        .option("--stop", "Stop candidate process trees when the hq-flags stop key is enabled")
+        .option("--reason <text>", "Required audit reason when --stop is set")
+        .option("--json", "Print machine-readable JSON (default)")
+        .action(wrap(async (options) => {
+        const reason = options.reason?.trim();
+        if (options.stop && !reason)
+            fail("lane_reap_reason_required", "--stop requires a non-empty --reason", {});
+        if (!options.stop && options.reason !== undefined)
+            fail("lane_reap_reason_requires_stop", "--reason can only be used with --stop", {});
+        if (reason)
+            assertNoSecretText("stop reason", reason);
+        const minAgeMinutes = parseReapMinAge(options.minAge);
+        const report = await reapLocalLanes(deps.hqRoot(), {
+            minAgeMinutes,
+            stop: options.stop === true,
+            applyStaleState: options.applyStaleState === true,
+            reason: reason ?? "Orphaned lane: owning session is confirmed ended",
+            json: true,
+        }, {
+            ...deps.reaperDeps,
+            now: deps.now,
+            sessionState: deps.sessionState,
+            stopEnabled: deps.stopEnabled,
+            stopLane: deps.stopLane,
+        });
+        console.log(JSON.stringify(report, null, 2));
+    }));
     parent.command("checks")
         .description("Evaluate tracker and lane health checks")
         .option("--company <slug>", "Select the company by slug")

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

package/dist/commands/lanes-session-start.d.ts

@@ -7,16 +7,11 @@ export interface SessionStartOptions {
     stdout?: Pick<NodeJS.WriteStream, "write">;
     stderr?: Pick<NodeJS.WriteStream, "write">;
     resolveRoot?: (env: NodeJS.ProcessEnv, cwd?: string) => string;
-    startSweep?: (root: string, env: NodeJS.ProcessEnv, context: SessionStartContext) => void;
-}
-interface SessionStartContext {
-    sessionId?: string;
-    companySlug?: string;
+    startSweep?: (root: string, env: NodeJS.ProcessEnv) => void;
 }
 /** Starts the CL-4 read-only orphan report once per host, without holding SessionStart open. */
-export declare function startSessionStartOrphanSweep(root: string, env?: NodeJS.ProcessEnv, spawnDetached?: typeof spawn, context?: SessionStartContext): void;
+export declare function startSessionStartOrphanSweep(root: string, env?: NodeJS.ProcessEnv, spawnDetached?: typeof spawn): void;
 /** SessionStart-compatible, fail-open conduct bootstrap. */
 export declare function runLaneSessionStart(options?: SessionStartOptions): Promise<void>;
 export declare function registerLaneSessionStartCommand(lanes: Command): void;
-export {};
 //# sourceMappingURL=lanes-session-start.d.ts.map

package/dist/commands/lanes-session-start.js

@@ -27,22 +27,6 @@ function sessionWasDisabled(root, env, payloadSessionId) {
     return /^\s*(?:conduct_mode|conduct_enabled|conduct_default):\s*(?:off|false|no|0)\s*(?:#.*)?$/mi.test(text) ||
         /^\s*conduct_engine:\s*(?:""|''|#.*)?\s*$/mi.test(text);
 }
-function sessionStartContext(root, env, payloadSessionId) {
-    const sessionId = payloadSessionId || env.HQ_SESSION_ID;
-    let companySlug = "";
-    if (sessionId && /^[A-Za-z0-9_-]+$/.test(sessionId)) {
-        const meta = path.join(root, "workspace", "sessions", sessionId, "meta.yaml");
-        if (fs.existsSync(meta)) {
-            const text = fs.readFileSync(meta, "utf8");
-            companySlug = /^\s*company_slug:\s*["']?([A-Za-z0-9][A-Za-z0-9-]*)["']?\s*(?:#.*)?$/mi.exec(text)?.[1] ?? "";
-        }
-    }
-    if (!companySlug)
-        companySlug = env.HQ_COMPANY_SLUG?.trim() ?? "";
-    if (!/^[A-Za-z0-9][A-Za-z0-9-]*$/.test(companySlug))
-        companySlug = "";
-    return { ...(sessionId ? { sessionId } : {}), ...(companySlug ? { companySlug } : {}) };
-}
 function extractConductorBlock(core) {
     const start = core.indexOf("<!-- inject:start -->");
     const end = core.indexOf("<!-- inject:end -->");
@@ -52,15 +36,12 @@ function extractConductorBlock(core) {
 }
 const ORPHAN_SWEEP_LOCK_TTL_MS = 15 * 60_000;
 /** Starts the CL-4 read-only orphan report once per host, without holding SessionStart open. */
-export function startSessionStartOrphanSweep(root, env = process.env, spawnDetached = spawn, context = {}) {
-    // The orphan command resolves company membership when --company is absent;
-    // skip here if this session has no tenant context rather than risk ambiguity.
-    if (!context.companySlug)
-        return;
+export function startSessionStartOrphanSweep(root, env = process.env, spawnDetached = spawn) {
     const stateRoot = env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
-    const stateDir = path.join(stateRoot, "hq-cli");
-    const lockPath = path.join(stateDir, "lanes-session-start-orphan-sweep.json");
-    const reportDir = path.join(stateDir, "lanes-orphan-reports", context.companySlug);
+    const host = os.hostname().replace(/[^A-Za-z0-9._-]/g, "_") || "unknown-host";
+    const stateDir = path.join(stateRoot, "hq-cli", "lanes-session-start", host);
+    const lockPath = path.join(stateDir, "orphan-sweep.lock");
+    const reportDir = path.join(stateRoot, "hq-cli", "lanes-orphan-reports", host);
     const ownerToken = randomUUID();
     try {
         fs.mkdirSync(stateDir, { recursive: true, mode: 0o700 });
@@ -108,17 +89,17 @@ export function startSessionStartOrphanSweep(root, env = process.env, spawnDetac
         }
         const wrapper = [
             "const cp=require('node:child_process'),fs=require('node:fs'),path=require('node:path');",
-            "const [cli,lock,root,token,report,company]=process.argv.slice(1);",
+            "const [cli,lock,root,token,report]=process.argv.slice(1);",
             "const cleanup=()=>{try{const lease=JSON.parse(fs.readFileSync(lock,'utf8'));if(lease.owner_token===token)fs.rmSync(lock,{force:true})}catch{}};",
             "const start=()=>{let lease;try{lease=JSON.parse(fs.readFileSync(lock,'utf8'))}catch{}if(lease?.owner_token!==token){if(Date.now()<Number(lease?.started_at||0)+1000)return setTimeout(start,10);process.exit(0)}",
             "try{fs.writeFileSync(lock,JSON.stringify({...lease,pid:process.pid}))}catch{}",
             "const tmp=report+'.tmp';let output;try{output=fs.createWriteStream(tmp,{flags:'wx',mode:0o600})}catch{cleanup();process.exit(0)}",
-            "const child=cp.spawn(process.execPath,[cli,'lanes','orphans','--company',company,'--json'],{stdio:['ignore','pipe','ignore'],env:{...process.env,HQ_ROOT:root,HQ_NO_UPDATE_CHECK:'1'}});",
+            "const child=cp.spawn(process.execPath,[cli,'lanes','_reap','--json'],{stdio:['ignore','pipe','ignore'],env:{...process.env,HQ_ROOT:root,HQ_NO_UPDATE_CHECK:'1'}});",
             "child.stdout.pipe(output);child.on('error',()=>{output.destroy();try{fs.rmSync(tmp,{force:true})}catch{}cleanup()});",
             "child.on('exit',(code)=>output.end(()=>{try{if(code===0)fs.renameSync(tmp,report);else fs.rmSync(tmp,{force:true})}catch{}cleanup()}));};start();",
         ].join("");
         const reportPath = path.join(reportDir, `orphans-${startedAt}-${ownerToken}.json`);
-        const launcher = spawnDetached(process.execPath, ["-e", wrapper, cli, lockPath, root, ownerToken, reportPath, context.companySlug], {
+        const launcher = spawnDetached(process.execPath, ["-e", wrapper, cli, lockPath, root, ownerToken, reportPath], {
             detached: true,
             stdio: "ignore",
             env: { ...env, HQ_ROOT: root, HQ_NO_UPDATE_CHECK: "1" },
@@ -185,8 +166,7 @@ export async function runLaneSessionStart(options = {}) {
         });
         if (!flagEnabled)
             return;
-        const context = sessionStartContext(root, env, payloadSessionId);
-        (options.startSweep ?? ((r, e, c) => startSessionStartOrphanSweep(r, e, spawn, c)))(root, env, context);
+        (options.startSweep ?? ((r, e) => startSessionStartOrphanSweep(r, e, spawn)))(root, env);
         if (sessionWasDisabled(root, env, payloadSessionId))
             return;
         let enabled = enabledFromSettings(root);

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

@@ -1,4 +1,4 @@
-import type { LaneCompanyRef, LanePlacementPolicy, LaneRecord, LanesConfig, QuestionAnswer, QuestionBody, QuestionRecord, SeniorRef, AccountHistoryEntry, LaneAccountSelection, PendingResume, QueuedReason, ResolvedLaneWorker, LivenessDeps, MachineIdentity, MonitorEvidenceReader, ReconcileHost, RunCommand, ThrottleDeps, withLaneHireLocks } from "../lib/lanes/index.js";
+import type { LaneCompanyRef, LanePlacementPolicy, LaneRecord, LanesConfig, QuestionAnswer, QuestionBody, QuestionRecord, SeniorRef, AccountHistoryEntry, LaneAccountSelection, PendingResume, QueuedReason, ResolvedLaneWorker, LivenessDeps, MachineIdentity, MonitorEvidenceReader, ReconcileHost, RunCommand, ThrottleDeps, withLaneAdmissionLock, withLaneHireLocks } from "../lib/lanes/index.js";
 import type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 import type { OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
 import type { CpuBusySource } from "../lib/lanes/throttle.js";
@@ -77,6 +77,10 @@ export interface LaneResumeOptions {
     effort?: string;
     worker?: string;
     keepAlive?: boolean;
+    freshThread?: boolean;
+    workingDirectory?: string;
+    /** Internal loop runner session; selects this story's saved provider session. */
+    loopSessionId?: string;
     meshCompany?: string;
     profileRepinContext?: string;
     grantContext?: string;
@@ -313,6 +317,7 @@ export interface Ctx {
     storyLedgerEnabled: () => boolean;
     isSsmOwnerDispatch: () => boolean;
     withGrantHireLocks: typeof withLaneHireLocks;
+    withAdmissionLock: typeof withLaneAdmissionLock;
     mergeHoldEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     mergeReviewEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
 }
@@ -457,7 +462,14 @@ export interface LaneQuestionsHandlerDeps {
     questionCompanyForLane(question: QuestionRecord, lane: Pick<LaneRecord, "company" | "mesh_company" | "project_id" | "lane_id">, hqRoot?: string): LaneCompanyRef | null;
     questionCompanyRefMatches(recordCompany: LaneCompanyRef | null | undefined, filter: LaneCompanyRef): boolean;
     questionListCompanyArg(company: LaneCompanyRef | null): string | undefined;
-    readOutpostQuestionRecords(ctx: Ctx, outpostId: string, company: LaneCompanyRef | null): Promise<OutpostQuestionRow[]>;
+    readOutpostQuestionRecords(ctx: Ctx, outpostId: string, company: LaneCompanyRef | null, questionId?: string, visibilityFilter?: {
+        sessionId?: string;
+        for?: string;
+        from?: string;
+        project?: string;
+        story?: string;
+        status?: string;
+    }): Promise<OutpostQuestionRow[]>;
     readQuestionBody(hqRoot: string, question: QuestionRecord): QuestionBody | null;
     printJson(value: unknown): void;
     readSessionMeta(hqRoot: string, sessionId: string, ctx: Ctx): Record<string, unknown> | null;

package/dist/commands/lanes.d.ts

@@ -17,7 +17,7 @@ export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/
 export type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 import { type OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
 import { emitLaneDecisionEvents } from "../lib/lanes/mesh-events.js";
-import { MAX_LANE_DEPTH, withLaneHireLocks, type LaneCompanyRef, type QuestionBody, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type MonitorEvidenceReader, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
+import { MAX_LANE_DEPTH, withLaneAdmissionLock, withLaneHireLocks, type LaneCompanyRef, type QuestionBody, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type MonitorEvidenceReader, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { type RunCompactionFn } from "../lib/lanes/compaction.js";
 import type { WatcherLoopDeps } from "../lib/lanes/watcher.js";
@@ -106,6 +106,8 @@ export interface LanesCommandDeps {
     isSsmOwnerDispatch?: () => boolean;
     /** Test seam for changing a lane between pre-lock and locked grant reads. */
     withGrantHireLocks?: typeof withLaneHireLocks;
+    /** Test seam proving create admission encloses the worker busy check. */
+    withAdmissionLock?: typeof withLaneAdmissionLock;
     /** Test seam for the review-before-merge registry flag. */
     mergeReviewEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     /** Test seam for the repository-merge-hold registry flag. */