@indigoai-us/hq-cli 5.345.56 → 5.345.57

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

@@ -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;
@@ -458,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.js

@@ -41,11 +41,15 @@ import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFla
 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_STATUS_ROW_FIELDS_FLAG, LANE_REAP_STOP_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, LANE_WORKER_CONTINUITY_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";
@@ -3326,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;
@@ -3388,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 });
     }
@@ -3755,6 +3772,9 @@ async function runCreate(ctx, opts) {
         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) {
@@ -3914,6 +3934,7 @@ 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
@@ -4113,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: {
@@ -4169,6 +4204,7 @@ 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,
@@ -5511,10 +5547,11 @@ async function runList(ctx, opts) {
             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, ...fields };
+                    return { ...lane, ...fields, ...loop };
                 const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
-                return { ...lane, ...fields, ...(envelope?.summary ? { envelope_summary: envelope.summary } : {}) };
+                return { ...lane, ...fields, ...loop, ...(envelope?.summary ? { envelope_summary: envelope.summary } : {}) };
             }),
         });
         return;
@@ -5620,6 +5657,7 @@ async function runList(ctx, opts) {
             ...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),
@@ -5991,6 +6029,7 @@ async function runShow(ctx, laneId, hasPendingQuestionForLane, resolveLaneTarget
     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({
@@ -7785,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 });
@@ -7849,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",
+                    }),
             };
         });
     }
@@ -8470,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) {
@@ -8482,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 });
     }
@@ -8537,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", {});
@@ -8550,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"
@@ -8592,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
@@ -8762,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,
         });
@@ -8801,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);
@@ -8930,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,
@@ -8937,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 }
             : {}),
@@ -9413,6 +9571,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .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")
@@ -9435,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")
@@ -9701,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 () => {

package/dist/lib/lanes/delivery.d.ts

@@ -144,6 +144,8 @@ export type LaunchTrigger = {
     kind: "resume";
     /** Lane state at the moment of the command; recorded as `last_resume.resumed_from`. */
     from: ResumeCommandState | "failed" | "awaiting_input";
+    /** Loop phases may deliberately start a fresh session at a story boundary. */
+    fresh?: true;
     allowAwaitingInput?: true;
     fromFailed?: true;
     /** Senior that authorized a failed-lane resume, rechecked at the claim CAS. */
@@ -164,6 +166,7 @@ export type LaunchPlan = {
 export declare function resumeCommandRefusal(lane: DeliveryLane, options?: {
     allowFailed?: boolean;
     allowAwaitingInput?: boolean;
+    allowFresh?: boolean;
 }): {
     error: "lane_not_resumable" | "resume_unsupported" | "no_provider_session";
     message: string;

package/dist/lib/lanes/delivery.js

@@ -371,6 +371,8 @@ export function resumeCommandRefusal(lane, options = {}) {
                         : "a lane in this state is not resumed."}`,
         };
     }
+    if (options.allowFresh === true)
+        return null;
     if (!providerSupportsSessionResume(lane.provider)) {
         return {
             error: "resume_unsupported",
@@ -411,7 +413,10 @@ export function planLaneLaunch(lane, trigger) {
             const refusal = resumeCommandRefusal(lane, {
                 allowFailed: trigger.fromFailed === true || isFailedQuotaKeepAliveLane(lane),
                 allowAwaitingInput: trigger.allowAwaitingInput === true,
+                allowFresh: trigger.fresh === true,
             });
+            if (trigger.fresh === true && refusal === null)
+                return { mode: "fresh" };
             if (refusal !== null || !hasRecordedSessionId(lane)) {
                 throw new LanesError(refusal?.error ?? "no_provider_session", refusal?.message ?? `Lane is ${lane.state} and has no recorded provider session`, { state: lane.state, provider: lane.provider });
             }

package/dist/lib/lanes/dropbox.d.ts

@@ -90,8 +90,11 @@ export interface ToolActivityRecord {
 export declare function recordToolActivity(hqRoot: string, laneId: string, at?: string): ToolActivityRecord;
 export declare function readToolActivity(hqRoot: string, laneId: string): ToolActivityRecord | null;
 export declare function appendDropboxMessage(hqRoot: string, laneId: string, message: DropboxMessage): DropboxMessage;
+export declare function appendDropboxMessageOnce(hqRoot: string, laneId: string, message: DropboxMessage): DropboxMessage;
 /** Append using the same on-disk layout for lane and monitor-session inboxes. */
 export declare function appendDropboxMessageAtPath(box: string, message: DropboxMessage): DropboxMessage;
+/** Append an idempotent message once, including retries after its inbox was archived. */
+export declare function appendDropboxMessageOnceAtPath(box: string, message: DropboxMessage): DropboxMessage;
 /**
  * Drain this lane's inbox exactly once. Concurrent callers: one rename wins;
  * the loser sees ENOENT and returns whatever it separately claimed (usually

package/dist/lib/lanes/dropbox.js

@@ -7,7 +7,7 @@
  * A read-then-truncate is not this mechanism and loses or duplicates under
  * overlap.
  */
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { LanesError } from "./errors.js";
@@ -179,6 +179,9 @@ export function readToolActivity(hqRoot, laneId) {
 export function appendDropboxMessage(hqRoot, laneId, message) {
     return appendDropboxMessageAtPath(dropboxDir(hqRoot, laneId), message);
 }
+export function appendDropboxMessageOnce(hqRoot, laneId, message) {
+    return appendDropboxMessageOnceAtPath(dropboxDir(hqRoot, laneId), message);
+}
 /** Append using the same on-disk layout for lane and monitor-session inboxes. */
 export function appendDropboxMessageAtPath(box, message) {
     const inbox = path.join(box, INBOX_NAME);
@@ -186,6 +189,105 @@ export function appendDropboxMessageAtPath(box, message) {
     fs.appendFileSync(inbox, `${JSON.stringify(message)}\n`, "utf8");
     return message;
 }
+/** Append an idempotent message once, including retries after its inbox was archived. */
+export function appendDropboxMessageOnceAtPath(box, message) {
+    const messageId = message.message_id?.trim();
+    if (!messageId) {
+        throw new LanesError("dropbox_message_id_required", "Idempotent dropbox delivery requires a message id");
+    }
+    fs.mkdirSync(box, { recursive: true });
+    const digest = createHash("sha256").update(messageId).digest("hex");
+    const lockDir = path.join(box, `.message-${digest}.lock`);
+    const lockTimeoutAt = Date.now() + 5_000;
+    while (true) {
+        try {
+            fs.mkdirSync(lockDir);
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            try {
+                if (Date.now() - fs.statSync(lockDir).mtimeMs > 30_000) {
+                    fs.rmSync(lockDir, { recursive: true, force: true });
+                    continue;
+                }
+            }
+            catch (statError) {
+                if (statError.code === "ENOENT")
+                    continue;
+                throw statError;
+            }
+            if (Date.now() >= lockTimeoutAt) {
+                throw new LanesError("dropbox_message_claim_busy", `Timed out claiming message ${messageId}`, { message_id: messageId });
+            }
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+        }
+    }
+    try {
+        const inbox = path.join(box, INBOX_NAME);
+        const files = [inbox, ...messageHistoryFiles(box)];
+        for (const file of files) {
+            let content;
+            try {
+                content = fs.readFileSync(file, "utf8");
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            for (const line of content.split(/\r?\n/)) {
+                if (!line.trim())
+                    continue;
+                let parsed;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch (error) {
+                    throw new LanesError("dropbox_message_history_invalid", `Cannot verify message ${messageId} against ${file}`, {
+                        message_id: messageId,
+                        path: file,
+                        cause: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) &&
+                    parsed.message_id === messageId)
+                    return message;
+            }
+        }
+        fs.appendFileSync(inbox, `${JSON.stringify(message)}\n`, "utf8");
+        return message;
+    }
+    finally {
+        fs.rmSync(lockDir, { recursive: true, force: true });
+    }
+}
+function messageHistoryFiles(box) {
+    const files = [];
+    for (const directory of [DRAINING_DIR, INFLIGHT_DIR, DELIVERED_DIR]) {
+        const root = path.join(box, directory);
+        const visit = (current) => {
+            let entries;
+            try {
+                entries = fs.readdirSync(current, { withFileTypes: true });
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    return;
+                throw error;
+            }
+            for (const entry of entries) {
+                if (entry.isDirectory())
+                    visit(path.join(current, entry.name));
+                else if (entry.isFile())
+                    files.push(path.join(current, entry.name));
+            }
+        };
+        visit(root);
+    }
+    return files;
+}
 function listNames(dir, deps) {
     try {
         return deps.readdirSync(dir).filter((name) => !name.startsWith("."));