@indigoai-us/hq-cli 5.345.55 → 5.345.57

package/dist/commands/lanes.js

@@ -38,12 +38,18 @@ import { laneDepthCap } from "../lib/lanes/depth-cap.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { runResidentCommandWithPackageLease } from "../utils/resident-package-preload.js";
 import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff, readLanesRegistryFlagFailOpen } from "../lib/lanes/registry-flag.js";
+import { readLaneStatusRowFields } from "../lib/lanes/status-fields.js";
 import { appendProjectFocusOverride, readProjectStoryFocusData, removeProjectFocusOverride } from "../lib/lanes/story-ledger.js";
 import { appendLaneFocusOverride, assertFocusGuardAllows, makeFocusOverride } from "../lib/lanes/focus-guard.js";
-import { LANE_FOCUS_GUARD_FLAG, LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, } from "../lib/lanes/flag-keys.js";
+import { LANE_FOCUS_GUARD_FLAG, LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_STATUS_ROW_FIELDS_FLAG, LANE_REAP_STOP_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, LANE_WORKER_CONTINUITY_FLAG, LANE_CONDUCT_LOOP_FLAG, } from "../lib/lanes/flag-keys.js";
+import { findWorkerContinuityLane, sameLaneHost, workerContinuityPrompt } from "../lib/lanes/worker-continuity.js";
+import { enqueueLoopEnvelope, interruptLoopQueue, loopControllerIsAlive, loopStatus, validateLoopEnvelope } from "../lib/lanes/loop.js";
+import { runLaneLoopController, startLaneLoopController } from "./lanes-loop.js";
 import { configuredCodexRolloutHomes, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
+import { appendDropboxMessageOnce, appendDropboxMessageOnceAtPath } from "../lib/lanes/dropbox.js";
+import { monitorSessionDir } from "../lib/monitor.js";
 import { syncOutpostLeadRegistries } from "../lib/lanes/autopilot-registry.js";
 import { OutpostSnapshotInvocationMemo } from "../lib/lanes/outpost-snapshot-memo.js";
 import { createOutpostHireGrantContext, parseOutpostHireGrantContext, selectOutpostHireGrantHierarchy, sameHireGrantSenior, } from "../lib/lanes/hire-grant-dispatch.js";
@@ -462,6 +468,7 @@ function resolveDeps(deps = {}) {
         focusGuardEnabled: deps.focusGuardEnabled,
         isSsmOwnerDispatch: deps.isSsmOwnerDispatch ?? (() => isSsmRunCommandProcess()),
         withGrantHireLocks: deps.withGrantHireLocks ?? withLaneHireLocks,
+        withAdmissionLock: deps.withAdmissionLock ?? withLaneAdmissionLock,
         mergeReviewEnabled: deps.mergeReviewEnabled,
         mergeHoldEnabled: deps.mergeHoldEnabled,
     };
@@ -3323,6 +3330,16 @@ async function runCreate(ctx, opts) {
         }
         meshCompany = resolvedMeshCompany;
     }
+    if (opts.loop === true && !(await readLanesRegistryFlagFailOpen(LANE_CONDUCT_LOOP_FLAG, {
+        company: company ?? meshCompany,
+        defaultValue: true,
+        env: ctx.env,
+    }))) {
+        throw new LanesError("loop_lanes_disabled", `Loop lanes are disabled by the ${LANE_CONDUCT_LOOP_FLAG} kill switch`, {});
+    }
+    if (opts.loop === true && (opts.outpost?.trim() || requestedPlacement?.kind === "outpost" || defaultPlacement?.kind === "outpost")) {
+        throw new LanesError("loop_lane_outpost_unsupported", "Loop lanes currently require the local host", { outpost_id: opts.outpost?.trim() ?? (requestedPlacement?.kind === "outpost" ? requestedPlacement.id : defaultPlacement?.kind === "outpost" ? defaultPlacement.id : undefined) });
+    }
     let placementCompanyResolved = false;
     let placementCompany;
     let placementGate;
@@ -3365,6 +3382,16 @@ async function runCreate(ctx, opts) {
     const provider = explicitProvider ??
         profile?.meta.provider ??
         parseLaneProvider("codex");
+    const continuityEnabled = opts.worker !== undefined && await readLanesRegistryFlagFailOpen(LANE_WORKER_CONTINUITY_FLAG, { company: company ?? meshCompany, env: ctx.env });
+    let workerContinuity = continuityEnabled
+        ? findWorkerContinuityLane(loadAllLanes(hqRoot), {
+            senior,
+            worker: resolvedWorker?.id ?? opts.worker,
+            provider,
+            company: company ?? meshCompany,
+            freshThread: opts.freshThread,
+        })
+        : { resumable: false };
     const profileDefaultsApply = profile !== undefined && profile.meta.provider === provider;
     const cliModel = parseCliModel(opts.model);
     // Validated here because `claude --effort <unknown>` only warns and runs.
@@ -3375,6 +3402,9 @@ async function runCreate(ctx, opts) {
     const profileAccounts = profileDefaultsApply ? profile?.meta.accounts : undefined;
     const keepAlive = opts.keepAlive === true ||
         (profileDefaultsApply && profile?.meta.keep_alive === true);
+    if (opts.loop === true && keepAlive) {
+        throw new LanesError("loop_keep_alive_conflict", "Loop lanes cannot use keep-alive", { worker: resolvedWorker?.id ?? opts.worker ?? null });
+    }
     if (keepAlive && !providerSupportsSessionResume(provider)) {
         throw new LanesError("keep_alive_provider_unsupported", `Provider ${provider} cannot resume recorded sessions, so keep-alive is unavailable`, { provider });
     }
@@ -3739,6 +3769,27 @@ async function runCreate(ctx, opts) {
     // The lane id is created in `persist`; its Work Mesh thread is ensured
     // immediately afterward from that stable identity.
     const persist = async () => {
+        const host = placementHostOverride ?? (outpostId !== undefined
+            ? { kind: "outpost", id: outpostId }
+            : { kind: "local", id: ctx.hostname() });
+        if (opts.loop === true && host.kind === "outpost") {
+            throw new LanesError("loop_lane_outpost_unsupported", "Loop lanes currently require the local host", { outpost_id: host.id });
+        }
+        // Repeat the busy check while holding provider admission serialization so
+        // two concurrent creates cannot both claim one worker's provider thread.
+        if (continuityEnabled) {
+            workerContinuity = findWorkerContinuityLane(loadAllLanes(hqRoot), {
+                senior,
+                worker: resolvedWorker?.id ?? opts.worker,
+                provider,
+                company: company ?? meshCompany,
+                freshThread: opts.freshThread,
+            });
+            if (workerContinuity.resumable && workerContinuity.previous &&
+                !sameLaneHost(workerContinuity.previous.host, host)) {
+                workerContinuity = { previous: workerContinuity.previous, resumable: false, fallbackReason: "host_mismatch" };
+            }
+        }
         let admission;
         let validation;
         if (!outpostId && provider === "claude" && explicitBalanceAccount === undefined &&
@@ -3842,9 +3893,6 @@ async function runCreate(ctx, opts) {
                 throw admission.error;
             }
         }
-        const host = placementHostOverride ?? (outpostId !== undefined
-            ? { kind: "outpost", id: outpostId }
-            : { kind: "local", id: ctx.hostname() });
         const queuedReason = admission.action === "queue" ? admission.reason : undefined;
         const admissionReservedAt = admission.action === "start" ? ctx.now().toISOString() : undefined;
         const laneInit = {
@@ -3886,8 +3934,21 @@ async function runCreate(ctx, opts) {
                 }
                 : {}),
             keep_alive: keepAlive,
+            ...(opts.loop === true ? { loop_mode: true } : {}),
             ...(keepAlive ? { keep_alive_opted_in_at: createdAt } : {}),
             provider,
+            ...(workerContinuity.resumable && workerContinuity.previous
+                ? {
+                    provider_session_id: workerContinuity.previous.provider_session_id,
+                    last_message_at: workerContinuity.previous.last_message_at ?? workerContinuity.previous.created_at,
+                    pending_resume: {
+                        session_id: workerContinuity.previous.provider_session_id,
+                        at: createdAt,
+                        trigger: "resume",
+                        resumed_from: workerContinuity.previous.state,
+                    },
+                }
+                : {}),
             provider_source: explicitProvider !== undefined
                 ? "cli"
                 : profile?.meta.provider !== undefined
@@ -3957,12 +4018,7 @@ async function runCreate(ctx, opts) {
         return { lane, admission, validation };
     };
     let persisted;
-    if (outpostId) {
-        persisted = await persist();
-    }
-    else {
-        persisted = await withLaneAdmissionLock(hqRoot, provider, persist, ctx.sleep);
-    }
+    persisted = await ctx.withAdmissionLock(hqRoot, provider, persist, ctx.sleep);
     let lane = persisted.lane;
     const { admission, validation } = persisted;
     if (focusAssessment.enabled && opts.focusOverride !== undefined) {
@@ -4052,10 +4108,25 @@ async function runCreate(ctx, opts) {
     ensureDir(path.join(dest, "dropbox"));
     ensureDir(path.join(dest, "questions"));
     const taskBrief = fs.readFileSync(briefAbs, "utf8");
-    const briefText = resolvedWorker
+    const previousResult = workerContinuity.previous
+        ? readLatestEnvelopeRecord(hqRoot, workerContinuity.previous.lane_id)
+        : undefined;
+    const briefText = `${workerContinuity.resumable && workerContinuity.previous
+        ? workerContinuityPrompt(workerContinuity.previous, previousResult?.envelope.summary, previousResult?.ref)
+        : ""}${resolvedWorker
         ? composeWorkerBrief(resolvedWorker, taskBrief)
-        : composeGeneralBrief(taskBrief);
+        : composeGeneralBrief(taskBrief)}`;
     fs.writeFileSync(path.join(dest, "brief.md"), briefText);
+    if (workerContinuity.resumable && lane.pending_resume) {
+        const newBriefPath = path.join(dest, "brief.md");
+        lane = casUpdateLane(hqRoot, lane.lane_id, (current) => ({
+            ...current,
+            pending_resume: current.pending_resume ? {
+                ...current.pending_resume,
+                text: `The new brief at ${newBriefPath} is the instruction for this turn. Read and follow it.`,
+            } : undefined,
+        }));
+    }
     if (timeoutSecs !== undefined) {
         writeJsonFile(timeoutPath(hqRoot, lane.lane_id), {
             timeout_secs: timeoutSecs,
@@ -4063,7 +4134,21 @@ async function runCreate(ctx, opts) {
         });
     }
     let started = lane;
-    if (admission.action === "start") {
+    let loopControllerPid;
+    if (opts.loop === true) {
+        lane = casUpdateLane(hqRoot, lane.lane_id, (current) => admission.action === "start"
+            ? {
+                ...current,
+                state: "running",
+                queued_reason: undefined,
+                queued_details: undefined,
+            }
+            : { ...current });
+        started = lane;
+        if (admission.action === "start")
+            loopControllerPid = startLaneLoopController(ctx, lane.lane_id, true);
+    }
+    else if (admission.action === "start") {
         started = spawnLaneWorker(hqRoot, lane, {
             env: ctx.env,
             modelDeps: {
@@ -4119,9 +4204,20 @@ async function runCreate(ctx, opts) {
             company: started.company,
             project_id: started.project_id,
             story_id: started.story_id,
+            ...(started.loop_mode ? { loop: loopStatus(runDir(hqRoot, started.lane_id), started.lane_id), loop_pid: loopControllerPid ?? null } : {}),
             stories: laneStories(started),
             story_warning: combinedStoryWarning(started, createStoryWarnings),
             thread_id: started.thread_id ?? null,
+            ...(continuityEnabled ? {
+                worker_continuity: workerContinuity.resumable
+                    ? { action: "resume", previous_lane_id: workerContinuity.previous?.lane_id }
+                    : {
+                        action: "fresh",
+                        ...(workerContinuity.previous ? { previous_lane_id: workerContinuity.previous.lane_id } : {}),
+                        ...(opts.freshThread ? { reason: "fresh_thread_requested" } : {}),
+                        ...(workerContinuity.fallbackReason ? { reason: workerContinuity.fallbackReason } : {}),
+                    },
+            } : {}),
             senior: started.senior,
             depth: started.depth,
             timeout_secs: timeoutSecs ?? null,
@@ -5343,6 +5439,24 @@ async function runPickup(ctx, opts) {
         lane: started,
     });
 }
+async function laneStatusFieldsForCommand(ctx, hqRoot, lane, now) {
+    const resolved = resolveLaneCompany(hqRoot, lane).company;
+    let enabled = true;
+    try {
+        enabled = await readLanesRegistryFlagFailOpen(LANE_STATUS_ROW_FIELDS_FLAG, {
+            ...(resolved ? { company: resolved } : {}),
+            env: ctx.env,
+        });
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: status row fields flag read failed open: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+    if (!enabled)
+        return {};
+    const host = reconcileHostFromCtx(ctx);
+    const local = laneRunsHere(lane, host);
+    return { ...readLaneStatusRowFields(hqRoot, lane, now.getTime(), local) };
+}
 async function runList(ctx, opts) {
     if (opts.json && opts.human) {
         throw new LanesError("conflicting_output_format", "Use either --json or --human for hq lanes list", { json: true, human: true });
@@ -5365,7 +5479,7 @@ async function runList(ctx, opts) {
             new Set(opts.hierarchy).size !== opts.hierarchy.length)) {
         throw new LanesError("lane_list_hierarchy_invalid", "--hierarchy must be repeated with distinct, non-empty lane ids without surrounding whitespace", {});
     }
-    if (opts.snapshot && (opts.human || opts.company || opts.project || opts.story || opts.state || opts.senior)) {
+    if (opts.snapshot && (opts.human || opts.company || opts.project || opts.story || opts.state || opts.senior || opts.worker)) {
         throw new LanesError("lane_list_snapshot_invalid", "--snapshot only supports owner lane filters and JSON output", {});
     }
     if (opts.hierarchy !== undefined && !opts.snapshot) {
@@ -5414,21 +5528,30 @@ async function runList(ctx, opts) {
         }
         if (senior && seniorKey(lane.senior) !== seniorKey(senior))
             return false;
+        if (opts.worker && lane.worker !== opts.worker)
+            return false;
         return true;
     };
     const selectLanes = () => laneSource
         .filter((lane) => matchesLaneFilters(lane, true))
         .sort(compareLaneQueueOrder);
     let selectedLanes = selectLanes();
+    const statusFieldsByLane = new Map();
+    const statusNow = ctx.now();
+    await Promise.all(selectedLanes.map(async (lane) => {
+        statusFieldsByLane.set(lane.lane_id, await laneStatusFieldsForCommand(ctx, hqRoot, lane, statusNow));
+    }));
     if (opts.snapshot) {
         printJson({
             ok: true,
             action: "list",
             lanes: selectedLanes.map((lane) => {
+                const fields = statusFieldsByLane.get(lane.lane_id) ?? {};
+                const loop = lane.loop_mode === true ? { loop: loopStatus(runDir(hqRoot, lane.lane_id), lane.lane_id) } : {};
                 if (!isTerminalLaneState(lane.state))
-                    return lane;
+                    return { ...lane, ...fields, ...loop };
                 const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
-                return envelope?.summary ? { ...lane, envelope_summary: envelope.summary } : lane;
+                return { ...lane, ...fields, ...loop, ...(envelope?.summary ? { envelope_summary: envelope.summary } : {}) };
             }),
         });
         return;
@@ -5532,7 +5655,9 @@ async function runList(ctx, opts) {
             !laneRunsHere(lane, host);
         return {
             ...lane,
+            ...statusFieldsByLane.get(lane.lane_id),
             ...hireByLane.get(lane.lane_id),
+            ...(lane.loop_mode === true ? { loop: loopStatus(runDir(hqRoot, lane.lane_id), lane.lane_id) } : {}),
             ...(remoteRefresh.unverifiedRemote.has(lane.lane_id) ? { unverified_remote: true } : {}),
             stories: laneStories(lane),
             story_ids: laneStories(lane).map((story) => story.story_id),
@@ -5901,7 +6026,11 @@ async function runShow(ctx, laneId, hasPendingQuestionForLane, resolveLaneTarget
     })
         .slice(0, 20)
         .map(({ repo, pr, head_sha, recorded_at }) => ({ repo, pr, head_sha, recorded_at }));
-    const laneForShow = { ...lane };
+    const laneForShow = {
+        ...lane,
+        ...await laneStatusFieldsForCommand(ctx, hqRoot, storedLane, ctx.now()),
+        ...(storedLane.loop_mode === true ? { loop: loopStatus(runDir(hqRoot, laneId), laneId) } : {}),
+    };
     delete laneForShow.resume_history;
     printJson({
         ok: true,
@@ -7695,6 +7824,7 @@ async function runReparentLocked(ctx, laneId, opts, finishedChildrenDoNotCount =
     }
     assertLaneNotRunningForReparent(lane);
     const pending = pendingQuestionsForLane(hqRoot, laneId);
+    const pendingAudiences = new Map(pending.map((question) => [question.question_id, resolveAudience(hqRoot, question, ctx)]));
     const oldDepth = derivedLaneDepth(hqRoot, lane.senior, ctx);
     if (newDepth > oldDepth && pending.length > 0) {
         throw new LanesError("demotion_with_pending_questions", "Cannot increase a lane's depth while it has pending questions", { lane_id: laneId, from_depth: oldDepth, to_depth: newDepth });
@@ -7759,17 +7889,24 @@ async function runReparentLocked(ctx, laneId, opts, finishedChildrenDoNotCount =
     }
     for (const question of pending) {
         casUpdateQuestion(hqRoot, question.question_id, (current) => {
+            const previousAudience = pendingAudiences.get(current.question_id);
+            const nextAudience = resolveAudience(hqRoot, current, ctx);
+            const audienceChanged = previousAudience !== undefined &&
+                seniorKey(previousAudience) !== seniorKey(nextAudience);
             const already = current.routing_history.some((entry) => entry.reason === "reparented" && entry.at === at);
-            if (already)
+            if (already && !audienceChanged)
                 return current;
             return {
                 ...current,
-                routing_history: appendCappedHistory(current.routing_history, {
-                    hop: current.hop,
-                    audience: resolveAudience(hqRoot, current, ctx),
-                    at,
-                    reason: "reparented",
-                }),
+                ...(audienceChanged ? { seen_at: null, seen_session_id: null } : {}),
+                routing_history: already
+                    ? current.routing_history
+                    : appendCappedHistory(current.routing_history, {
+                        hop: current.hop,
+                        audience: nextAudience,
+                        at,
+                        reason: "reparented",
+                    }),
             };
         });
     }
@@ -8380,7 +8517,7 @@ async function runStop(ctx, laneId, reason, quiet = false) {
     const hqRoot = ctx.hqRoot();
     const target = await resolveCommandLaneTarget(ctx, laneId);
     const lane = target.lane;
-    if (!quiet && lane.state !== "queued" && !isTerminalLaneState(lane.state)) {
+    if (!quiet && lane.loop_mode !== true && lane.state !== "queued" && !isTerminalLaneState(lane.state)) {
         process.stderr.write(stopTerminalWarning(lane.lane_id));
     }
     if (target.remoteOnly) {
@@ -8392,6 +8529,23 @@ async function runStop(ctx, laneId, reason, quiet = false) {
         return;
     }
     assertLaneRunsHereForOperatorMutation(ctx, lane, "stop");
+    if (lane.loop_mode === true) {
+        const runDirPath = runDir(hqRoot, lane.lane_id);
+        const loop = loopStatus(runDirPath, lane.lane_id);
+        if (loop.state === "stopped" || loop.state === "failed") {
+            throw new LanesError("already_terminal", `Loop lane ${lane.lane_id} is already ${lane.state}`, { lane_id: lane.lane_id, state: lane.state });
+        }
+        const controllerAlive = loopControllerIsAlive(runDirPath);
+        if (!controllerAlive && lane.state === "running") {
+            await runInterrupt(ctx, lane.lane_id, "loop controller exited; recovering queued work before stop", { preserveLoopQueue: true, quiet: true });
+        }
+        const queued = enqueueLoopEnvelope({ runDir: runDirPath, laneId: lane.lane_id, envelope: { kind: "stop" }, now: ctx.now });
+        if (!controllerAlive && lane.state !== "queued")
+            startLaneLoopController(ctx, lane.lane_id);
+        if (!quiet)
+            printJson({ ok: true, action: "stop", lane_id: lane.lane_id, terminal: false, queued_stop: queued });
+        return;
+    }
     if (isTerminalLaneState(lane.state)) {
         throw new LanesError("already_terminal", `Lane ${laneId} is already ${lane.state}`, { lane_id: laneId, state: lane.state });
     }
@@ -8447,7 +8601,7 @@ function stopTerminalWarning(laneId) {
  * session so `hq lanes resume` continues it. Keep-alive resumes only
  * `exited_with_partial_output` interruptions, so it leaves this lane alone.
  */
-async function runInterrupt(ctx, laneId, reason) {
+async function runInterrupt(ctx, laneId, reason, options = {}) {
     const operatorReason = reason?.trim();
     if (reason !== undefined && !operatorReason) {
         throw new LanesError("lane_interrupt_reason_invalid", "Interrupt reason must not be empty", {});
@@ -8460,6 +8614,14 @@ async function runInterrupt(ctx, laneId, reason) {
         throw new LanesError("interrupt_remote_unsupported", `Lane ${laneId} runs on Outpost ${lane.host.id}; run hq lanes interrupt on that Outpost`, { lane_id: laneId, outpost_id: lane.host.id });
     }
     assertLaneRunsHereForOperatorMutation(ctx, lane, "interrupt");
+    const queueInterrupt = lane.loop_mode === true && options.preserveLoopQueue !== true
+        ? interruptLoopQueue(runDir(hqRoot, lane.lane_id))
+        : undefined;
+    if (lane.loop_mode === true && lane.state !== "running") {
+        if (!options.quiet)
+            printJson({ ok: true, action: "interrupt", lane_id: lane.lane_id, terminal: false, resumable: true, ...queueInterrupt });
+        return;
+    }
     const assertInterruptible = (current) => {
         if (current.state !== "running") {
             throw new LanesError("lane_not_running", current.state === "queued"
@@ -8502,13 +8664,15 @@ async function runInterrupt(ctx, laneId, reason) {
     const resumable = resumeCommandRefusal(laneWithRecoveredProviderSession(hqRoot, updated)) === null;
     if (!resumable)
         process.stderr.write(interruptNotResumableWarning(laneId));
-    printJson({
-        ok: true,
-        action: "interrupt",
-        lane: updated,
-        terminal: false,
-        resumable,
-    });
+    if (!options.quiet)
+        printJson({
+            ok: true,
+            action: "interrupt",
+            lane: updated,
+            terminal: false,
+            resumable,
+            ...(queueInterrupt === undefined ? {} : queueInterrupt),
+        });
 }
 /**
  * The watcher skips lanes that are already terminal, so it never records the
@@ -8672,13 +8836,13 @@ function questionListCompanyArg(company) {
     }
     return value;
 }
-async function readOutpostQuestionRecords(ctx, outpostId, company) {
+async function readOutpostQuestionRecords(ctx, outpostId, company, questionId, visibilityFilter) {
     const companyArg = questionListCompanyArg(company);
     let result;
     try {
         result = await ctx.dispatchOutpostExec({
             outpostId,
-            command: buildOutpostQuestionListCommand({ company: companyArg }),
+            command: buildOutpostQuestionListCommand({ company: companyArg, ...visibilityFilter }),
             timeoutSeconds: CAPACITY_PROBE_TIMEOUT_MS / 1000,
             waitMs: CAPACITY_PROBE_TIMEOUT_MS,
         });
@@ -8711,6 +8875,8 @@ async function readOutpostQuestionRecords(ctx, outpostId, company) {
             throw new LanesError("outpost_question_list_invalid", `Outpost ${outpostId} returned an invalid question record`, { outpost_id: outpostId, index });
         }
         const rowObject = row;
+        if (questionId !== undefined && rowObject.question_id !== questionId)
+            continue;
         let question;
         try {
             question = parseQuestionRecord(row);
@@ -8840,6 +9006,31 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
             runCompaction: ctx.runCompaction,
             locateTranscript: ctx.locateTranscript,
         },
+        spawn: (root, candidate) => {
+            if (candidate.loop_mode !== true || candidate.state !== "queued") {
+                return spawnLaneWorker(root, candidate, {
+                    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,
+                });
+            }
+            const admitted = casUpdateLane(root, candidate.lane_id, (current) => ({
+                ...current,
+                state: "running",
+                queued_reason: undefined,
+                queued_details: undefined,
+                admission_reserved_at: undefined,
+            }));
+            startLaneLoopController(ctx, candidate.lane_id, true);
+            return admitted;
+        },
         throttleDeps: ctx.throttleDeps,
         livenessDeps: livenessDepsFromCtx(ctx),
         presenceConnected: ctx.presenceConnected,
@@ -8847,6 +9038,63 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
         recoverQueuedMessages,
         mesh: ctx.mesh,
         env: ctx.env,
+        deliverBlockedEscalation: async (delivery) => {
+            const currentHost = reconcileHostFromCtx(ctx);
+            const targetOutpostId = delivery.recipient_host?.kind === "outpost"
+                ? delivery.recipient_host.id
+                : "primary";
+            const targetIsCurrent = targetOutpostId === (currentHost.outpostId ?? "primary");
+            if (targetIsCurrent)
+                throw new LanesError("blocked_escalation_local_delivery_misrouted", "Local blocked escalations must use the durable local inbox path");
+            if (!delivery.recipient.id)
+                throw new LanesError("blocked_escalation_recipient_invalid", "Escalation recipient has no id");
+            const waitMs = outpostSingleLaneWaitMs(ctx.env);
+            const dispatched = await ctx.dispatchOutpostExec({
+                outpostId: targetOutpostId,
+                timeoutSeconds: Math.ceil(waitMs / 1000),
+                waitMs,
+                command: buildOutpostLaneCommand({
+                    action: "blocked-escalation-target",
+                    laneId: delivery.recipient.id,
+                    recipientKind: delivery.recipient.kind === "session" ? "session" : "lane",
+                    text: delivery.text,
+                    messageId: delivery.message_id,
+                }),
+            });
+            if (dispatched.exitCode !== 0)
+                throw new LanesError("blocked_escalation_remote_delivery_failed", dispatchErrorMessage(dispatched), { outpost_id: targetOutpostId });
+        },
+        resolveEscalationLane: async (laneId) => {
+            const currentHost = reconcileHostFromCtx(ctx);
+            if (currentHost.outpostId === null)
+                return null;
+            const waitMs = outpostSingleLaneWaitMs(ctx.env);
+            const dispatched = await ctx.dispatchOutpostExec({
+                outpostId: "primary",
+                command: buildOutpostLaneCommand({ action: "show", laneId }),
+                timeoutSeconds: Math.ceil(waitMs / 1000),
+                waitMs,
+            });
+            if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
+                throw new LanesError("blocked_escalation_ancestor_unavailable", `Could not read ancestor lane ${laneId} from the primary hierarchy`, {
+                    lane_id: laneId,
+                    command_id: dispatched.commandId,
+                    exit_code: dispatched.exitCode,
+                });
+            }
+            const remote = parseRemoteJson(dispatched.stdout, "Blocked escalation ancestor");
+            if (remote?.ok !== true || remote.action !== "show" || remote.lane === undefined) {
+                throw new LanesError("blocked_escalation_ancestor_invalid", `Primary did not return ancestor lane ${laneId}`, { lane_id: laneId });
+            }
+            const ancestor = parseLaneRecord(normalizeLaneRecordView(remote.lane));
+            if (ancestor.lane_id !== laneId) {
+                throw new LanesError("blocked_escalation_ancestor_invalid", `Primary returned a different lane for ancestor lookup ${laneId}`, {
+                    requested_lane_id: laneId,
+                    returned_lane_id: ancestor.lane_id,
+                });
+            }
+            return ancestor;
+        },
         ...(opts.terminalKeepAliveCandidate !== undefined
             ? { terminalKeepAliveCandidate: opts.terminalKeepAliveCandidate }
             : {}),
@@ -9248,6 +9496,15 @@ export function registerLanesCommand(parent, deps = {}) {
             presenceConnected: ctx.presenceConnected ?? false,
             deps: ctx.livenessDeps,
         }),
+        stopEnabled: (lane) => {
+            const resolution = resolveLaneCompany(ctx.hqRoot(), lane);
+            const company = resolution.company ?? undefined;
+            return readLanesRegistryFlag(LANE_REAP_STOP_FLAG, {
+                company,
+                ...(company ? { companyUidSource: laneCompanyUidSource(resolution.source) } : {}),
+                env: ctx.env,
+            });
+        },
     }, wrap);
     registerLaneDropboxRepairCommand(lanes, {
         hqRoot: ctx.hqRoot,
@@ -9313,6 +9570,8 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--additional-story <id>", "Additional story carried by this lane; repeatable and discouraged when active", collectRepeatable)
         .requiredOption("--brief-file <path>", "Path to the lane brief")
         .option("--worker <name>", "HQ worker or reusable profile id")
+        .option("--fresh-thread", "Skip worker continuity and start a cold provider session")
+        .option("--loop", "Keep one worker lane registered to process queued phase envelopes")
         .option("--provider <name>", "claude | codex | grok")
         .option("--account <id>", "Provider account id")
         .option("--model <id>", "Model id for the provider CLI")
@@ -9335,6 +9594,62 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (laneId, opts) => {
         await runApproveOwnerTarget(ctx, laneId, opts);
     }));
+    lanes
+        .command("_loop-worker", { hidden: true })
+        .argument("<lane-id>", "Loop lane id")
+        .action(wrap(async (laneId) => {
+        await runLaneLoopController(ctx, laneId, {
+            resumeLane: (id, options) => resumeHandlers.runResume(ctx, id, options),
+            interruptLane: (id, reason, options) => runInterrupt(ctx, id, reason, options),
+            emitTerminal: (lane) => emitLaneTerminalStateSoft(ctx, lane),
+        });
+    }));
+    lanes
+        .command("enqueue")
+        .description("Validate and queue one phase envelope for a loop lane")
+        .argument("<lane-id>", "Loop lane id")
+        .requiredOption("--envelope <file>", "Generic phase or hq-phase-envelope/v1 JSON file")
+        .action(wrap(async (laneId, opts) => {
+        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 authorization = callerSeniorAuthorization(ctx, lane.senior);
+        if (!authorization.authorized)
+            throw new LanesError("lane_enqueue_unauthorized", `Only the lane's senior may enqueue phases`, { lane_id: laneId, reason: authorization.reason });
+        assertLaneRunsHereForAdmission(ctx, lane);
+        const enabled = await readLanesRegistryFlagFailOpen(LANE_CONDUCT_LOOP_FLAG, { company: lane.company ?? lane.mesh_company, defaultValue: true, env: ctx.env });
+        if (!enabled)
+            throw new LanesError("loop_lanes_disabled", `Loop lanes are disabled by the ${LANE_CONDUCT_LOOP_FLAG} kill switch`, { lane_id: laneId });
+        const source = resolveCallerPath(ctx.callerCwd(), opts.envelope ?? "");
+        let envelope;
+        try {
+            envelope = validateLoopEnvelope(JSON.parse(fs.readFileSync(source, "utf8")));
+        }
+        catch (error) {
+            throw new LanesError("loop_envelope_invalid", `Could not read a valid JSON envelope from ${source}: ${error instanceof Error ? error.message : String(error)}`, { lane_id: laneId, path: source });
+        }
+        const envelopeData = envelope;
+        if (envelopeData.engine !== undefined && envelopeData.engine !== lane.provider) {
+            throw new LanesError("loop_envelope_engine_mismatch", `Envelope engine ${String(envelopeData.engine)} does not match lane provider ${lane.provider}`, { lane_id: lane.lane_id, provider: lane.provider });
+        }
+        if (envelopeData.schema === "hq-phase-envelope/v1" && envelopeData.worker_id !== lane.worker) {
+            throw new LanesError("loop_envelope_worker_mismatch", `Envelope worker ${String(envelopeData.worker_id)} does not match lane worker ${lane.worker ?? "<none>"}`, { lane_id: lane.lane_id, worker: lane.worker ?? null });
+        }
+        const runDirPath = runDir(hqRoot, lane.lane_id);
+        const loop = loopStatus(runDirPath, lane.lane_id);
+        if (loop.state === "stopped" || loop.state === "failed") {
+            throw new LanesError("loop_not_running", `Loop lane ${lane.lane_id} is ${loop.state}`, { lane_id: lane.lane_id, loop_state: loop.state });
+        }
+        const controllerAlive = loopControllerIsAlive(runDirPath);
+        const result = enqueueLoopEnvelope({ runDir: runDirPath, laneId: lane.lane_id, envelope, now: ctx.now });
+        if (!controllerAlive && lane.state === "running") {
+            await runInterrupt(ctx, lane.lane_id, "loop controller exited; recovering the queued phase", { preserveLoopQueue: true, quiet: true });
+        }
+        const shouldRestart = !controllerAlive && lane.state !== "queued";
+        const controllerPid = shouldRestart ? startLaneLoopController(ctx, lane.lane_id) : undefined;
+        printJson({ ok: true, action: "enqueue", ...result, lane: lane.lane_id, ...(controllerPid ? { controller_pid: controllerPid } : {}) });
+    }));
     lanes
         .command("reparent-target", { hidden: true })
         .argument("<lane-id>", "Lane id")
@@ -9412,6 +9727,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--story <id>", "Filter by story")
         .option("--state <state>", `Filter by state (${LANE_STATES.join("|")})`)
         .option("--senior <ref>", "Filter by senior ref")
+        .option("--worker <id>", "Filter by worker id")
         .option("--lane <id>", "Filter by lane id (repeatable)", (value, previous = []) => [...previous, value], [])
         .addOption(new Option("--lane-ulid <ulid>", "Filter by lane ULID for internal owner lookup").hideHelp()
         .argParser((value, previous = []) => [...previous, value]))
@@ -9600,6 +9916,31 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (laneId) => {
         printJson(await messageHandlers.recoverQueuedMessages(ctx, laneId));
     }));
+    lanes
+        .command("_enqueue-blocked-escalation <recipient-kind> <recipient-id>", { hidden: true })
+        .option("--text <text>", "Escalation notice")
+        .option("--message-id <id>", "Idempotency key")
+        .action(wrap(async (recipientKind, recipientId, opts) => {
+        if (!ctx.isSsmOwnerDispatch())
+            throw new LanesError("blocked_escalation_dispatch_forbidden", "Blocked escalation inbox writes require owner dispatch");
+        if (recipientKind !== "lane" && recipientKind !== "session")
+            throw new LanesError("blocked_escalation_recipient_invalid", `Unknown recipient kind ${recipientKind}`);
+        if (!opts.text?.trim() || !opts.messageId?.trim())
+            throw new LanesError("blocked_escalation_payload_invalid", "Escalation inbox write requires text and message id");
+        const message = { at: ctx.now().toISOString(), message_id: opts.messageId, kind: "blocked_escalation", text: opts.text };
+        if (recipientKind === "lane") {
+            appendDropboxMessageOnce(ctx.hqRoot(), recipientId, message);
+        }
+        else {
+            const dirs = ["claude", "codex", "grok"]
+                .map((provider) => monitorSessionDir(ctx.hqRoot(), provider, recipientId))
+                .filter((dir) => ctx.existsSync(dir));
+            if (dirs.length !== 1)
+                throw new LanesError("blocked_escalation_recipient_unavailable", `Expected one durable inbox for session ${recipientId}; found ${dirs.length}`);
+            appendDropboxMessageOnceAtPath(path.join(dirs[0], "dropbox"), message);
+        }
+        printJson({ ok: true, recipient_kind: recipientKind, recipient_id: recipientId, message_id: opts.messageId });
+    }));
     lanes
         .command("_spawn-envelope-repair", { hidden: true })
         .action(wrap(async () => {