@indigoai-us/hq-cli 5.345.58 → 5.345.59

package/dist/lib/agent-kit/run/stop-signals.d.ts

@@ -0,0 +1,14 @@
+import { EventEmitter } from "node:events";
+export declare const KIT_STOP_GRACE_MS = 10000;
+interface KitStopControllerOptions {
+    emitter?: Pick<EventEmitter, "once" | "removeListener">;
+    forceExit?: (code: number) => void;
+    timeoutMs?: number;
+}
+/** Abort service work on stop, with a deadline if an awaited operation stalls. */
+export declare function createKitStopController(options?: KitStopControllerOptions): {
+    signal: AbortSignal;
+    dispose(): void;
+};
+export {};
+//# sourceMappingURL=stop-signals.d.ts.map

package/dist/lib/agent-kit/run/stop-signals.js

@@ -0,0 +1,26 @@
+export const KIT_STOP_GRACE_MS = 10_000;
+/** Abort service work on stop, with a deadline if an awaited operation stalls. */
+export function createKitStopController(options = {}) {
+    const emitter = options.emitter ?? process;
+    const forceExit = options.forceExit ?? ((code) => process.exit(code));
+    const controller = new AbortController();
+    let deadline;
+    const stop = () => {
+        if (controller.signal.aborted)
+            return;
+        controller.abort();
+        deadline = setTimeout(() => forceExit(0), options.timeoutMs ?? KIT_STOP_GRACE_MS);
+    };
+    emitter.once("SIGTERM", stop);
+    emitter.once("SIGINT", stop);
+    return {
+        signal: controller.signal,
+        dispose() {
+            if (deadline)
+                clearTimeout(deadline);
+            emitter.removeListener("SIGTERM", stop);
+            emitter.removeListener("SIGINT", stop);
+        },
+    };
+}
+//# sourceMappingURL=stop-signals.js.map

package/dist/lib/agent-kit/services.d.ts

@@ -14,8 +14,8 @@ export declare function isKitService(value: string): value is KitService;
  * file a loud error instead of a browser-login hang; HQ_AGENT_DIR keeps a
  * relocated kit consistent across restarts.
  */
-export declare function kitServiceEnv(paths: AgentKitPaths): Record<string, string>;
-export declare function kitServiceSpec(service: KitService, paths: AgentKitPaths): ServiceSpec;
+export declare function kitServiceEnv(paths: AgentKitPaths, env?: NodeJS.ProcessEnv): Record<string, string>;
+export declare function kitServiceSpec(service: KitService, paths: AgentKitPaths, env?: NodeJS.ProcessEnv): ServiceSpec;
 /**
  * Services to install. `sync` is included only when the kit is configured to
  * mirror the vault to disk; by default a bot reads files on demand through the

package/dist/lib/agent-kit/services.js

@@ -20,14 +20,16 @@ const DESCRIPTIONS = {
  * file a loud error instead of a browser-login hang; HQ_AGENT_DIR keeps a
  * relocated kit consistent across restarts.
  */
-export function kitServiceEnv(paths) {
+export function kitServiceEnv(paths, env = process.env) {
+    const flagsApiUrl = env.HQ_FLAGS_API_URL;
     return {
         HQ_AGENT_DIR: paths.agentDir,
         HQ_MACHINE_CREDS_FILE: paths.machineCredsPath,
         HQ_REQUIRE_MACHINE_IDENTITY: "1",
+        ...(flagsApiUrl?.trim() ? { HQ_FLAGS_API_URL: flagsApiUrl } : {}),
     };
 }
-export function kitServiceSpec(service, paths) {
+export function kitServiceSpec(service, paths, env = process.env) {
     return {
         name: service,
         label: `${KIT_LABEL_PREFIX}.${service}`,
@@ -35,7 +37,7 @@ export function kitServiceSpec(service, paths) {
         args: ["agent", "kit", "run", service],
         logPath: serviceLogPath(paths, service),
         workingDir: paths.agentDir,
-        env: kitServiceEnv(paths),
+        env: kitServiceEnv(paths, env),
         restartSec: 10,
     };
 }

package/dist/lib/anywhere-runtime-flag-key.d.ts

@@ -1,5 +1,6 @@
 /** hq-flags key for the staged HQ Anywhere runtime. The registry default is on. */
 export declare const HQ_ANYWHERE_RUNTIME_FLAG = "hq-anywhere-runtime";
+export declare const HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER = "hq-anywhere-runtime.revoked";
 /** The HQ Anywhere environment kill switch stays compatible with managed provider wrappers. */
 export declare function hqAnywhereRuntimeLocallyDisabled(env?: NodeJS.ProcessEnv): boolean;
 //# sourceMappingURL=anywhere-runtime-flag-key.d.ts.map

package/dist/lib/anywhere-runtime-flag-key.js

@@ -1,5 +1,6 @@
 /** hq-flags key for the staged HQ Anywhere runtime. The registry default is on. */
 export const HQ_ANYWHERE_RUNTIME_FLAG = "hq-anywhere-runtime";
+export const HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER = "hq-anywhere-runtime.revoked";
 /** The HQ Anywhere environment kill switch stays compatible with managed provider wrappers. */
 export function hqAnywhereRuntimeLocallyDisabled(env = process.env) {
     const value = env.HQ_FLAG_HQ_ANYWHERE_RUNTIME;

package/dist/lib/anywhere-runtime-revocation-marker.d.ts

@@ -0,0 +1,4 @@
+export declare function anywhereRuntimeRevocationMarkerPath(home?: string, env?: NodeJS.ProcessEnv): string;
+/** Keep installed wrappers aligned with the daemon's refreshed access decision. */
+export declare function updateAnywhereRuntimeRevocationMarker(enabled: boolean, home?: string, env?: NodeJS.ProcessEnv): void;
+//# sourceMappingURL=anywhere-runtime-revocation-marker.d.ts.map

package/dist/lib/anywhere-runtime-revocation-marker.js

@@ -0,0 +1,26 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER } from "./anywhere-runtime-flag-key.js";
+import { registryDir } from "./registry/registry.js";
+export function anywhereRuntimeRevocationMarkerPath(home = os.homedir(), env = process.env) {
+    return path.join(registryDir(home, env), HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER);
+}
+/** Keep installed wrappers aligned with the daemon's refreshed access decision. */
+export function updateAnywhereRuntimeRevocationMarker(enabled, home = os.homedir(), env = process.env) {
+    const marker = anywhereRuntimeRevocationMarkerPath(home, env);
+    if (!enabled) {
+        fs.mkdirSync(path.dirname(marker), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(marker, "revoked\n", { mode: 0o600 });
+        fs.chmodSync(marker, 0o600);
+        return;
+    }
+    try {
+        fs.unlinkSync(marker);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+//# sourceMappingURL=anywhere-runtime-revocation-marker.js.map

package/dist/lib/daemon/run.d.ts

@@ -29,6 +29,8 @@ export interface DaemonLockConflictOutcome {
 export declare function daemonLockConflictOutcome(lock: DaemonLockResult, anywhereEnabled: boolean): DaemonLockConflictOutcome | null;
 /** hqd is available on every platform while Anywhere is enabled; its listener fails closed if setup is unsafe. */
 export declare function shouldStartHqd(anywhereEnabled: boolean): boolean;
+/** Resolve the supervisor's runtime-access decision and reflect it in the local wrapper marker. */
+export declare function refreshHqdRuntimeDecision(readDecision: () => Promise<boolean>, home: string, env: NodeJS.ProcessEnv, onMarkerError?: (error: unknown) => void): Promise<boolean>;
 /** Route an updater request through the daemon's existing graceful handoff. */
 export declare function handoffForPackageUpdateRequest(requested: boolean, restartDaemon: () => void): void;
 export interface RunDaemonOptions {

package/dist/lib/daemon/run.js

@@ -30,6 +30,7 @@ import { retireLegacyMeshUnits } from "./migrate.js";
 import { daemonDir as meshDaemonDir, daemonPidPath as meshDaemonPidPath } from "../mesh/live/daemon/paths.js";
 import { readPidLock } from "../mesh/live/daemon/pid-lock.js";
 import { registryDir, registryFile } from "../registry/registry.js";
+import { updateAnywhereRuntimeRevocationMarker } from "../anywhere-runtime-revocation-marker.js";
 import { daemonRootRefusal } from "./install.js";
 import { detectMachineType } from "./machine-type.js";
 import { appendPrivate, daemonPaths, ensurePrivateDir, openPrivateAppend } from "./paths.js";
@@ -93,6 +94,17 @@ export function daemonLockConflictOutcome(lock, anywhereEnabled) {
 export function shouldStartHqd(anywhereEnabled) {
     return anywhereEnabled;
 }
+/** Resolve the supervisor's runtime-access decision and reflect it in the local wrapper marker. */
+export async function refreshHqdRuntimeDecision(readDecision, home, env, onMarkerError = () => { }) {
+    const enabled = await readDecision();
+    try {
+        updateAnywhereRuntimeRevocationMarker(enabled, home, env);
+    }
+    catch (error) {
+        onMarkerError(error);
+    }
+    return enabled;
+}
 /** Route an updater request through the daemon's existing graceful handoff. */
 export function handoffForPackageUpdateRequest(requested, restartDaemon) {
     if (requested)
@@ -897,13 +909,13 @@ export async function runDaemon(opts) {
         onError: (name) => log("warn", `hqd person setting read failed (${name}); keeping the last read value for up to ${HQD_PERSON_SETTING_GRACE_MS / 60_000} minutes`),
     }), { graceMs: HQD_PERSON_SETTING_GRACE_MS });
     const hqdListener = await startHqdRuntimeListener({
-        isEnabled: async () => shouldStartHqd(await anywhereRuntimeAllowed(env, {
+        isEnabled: async () => refreshHqdRuntimeDecision(async () => shouldStartHqd(await anywhereRuntimeAllowed(env, {
             refreshFlag: async () => {
                 const { refreshFlagRegistrySnapshot } = await import("../flag-registry.js");
                 await refreshFlagRegistrySnapshot(5_000);
             },
             readSetting: readPersonSetting,
-        })),
+        })), home, env, () => log("warn", "hqd runtime revocation marker update failed")),
         startServer: async () => {
             const startConfig = readDaemonConfig(paths.configPath);
             return startHqdServer({
@@ -959,8 +971,9 @@ export async function runDaemon(opts) {
                 releaseDaemonLock(paths.lockPath);
                 resolve(exitCode);
                 // Pipes, sockets and unrelated timers can outlive a clean shutdown.
-                // Keep restart and signal exits bounded just like the handoff path.
-                setTimeout(() => process.exit(exitCode), 5_000).unref();
+                // Services and the lock are already stopped; unrelated handles should
+                // not hold a restart or signal exit open for another service interval.
+                setTimeout(() => process.exit(exitCode), 1_000).unref();
             });
         };
         /** Exit for a restart but leave the services running for the next daemon to adopt. */

package/dist/lib/daemon/server.js

@@ -23,6 +23,7 @@ import { defaultMcpToken, HqMcpBridge, jsonResult, McpOpError, runWorker } from
 import { authenticateMachineCredentials, machineTokenExpiresAt, MachineLoginError, parseStdinMachineCredentials } from "./machine-login.js";
 import { HQ_MCP_TOOL_NAMES, HQD_NATIVE_TOOL_NAMES } from "../mcp/tools.js";
 import { HQ_ANYWHERE_RUNTIME_FLAG } from "../../commands/anywhere-runtime-flag.js";
+import { updateAnywhereRuntimeRevocationMarker } from "../anywhere-runtime-revocation-marker.js";
 import { readHqAnywherePersonSetting } from "../anywhere-person-setting.js";
 import { createBoundedDaemonFlagMonitor } from "./flag-monitor.js";
 import { readDaemonFlag } from "./flag.js";
@@ -416,6 +417,12 @@ export async function startHqdServer(opts) {
             return personSetting === true;
         },
         onChange: (enabled) => {
+            try {
+                updateAnywhereRuntimeRevocationMarker(enabled, env.HOME?.trim() || undefined, env);
+            }
+            catch (error) {
+                log("warn", `hqd runtime revocation marker update failed (${error instanceof Error ? error.name : "UnknownError"})`);
+            }
             if (!enabled) {
                 flagRevocationGeneration += 1;
                 ephemeralMachineToken = undefined;

package/dist/lib/db/control-plane.d.ts

@@ -71,7 +71,18 @@ export interface RemoteUsageResponse {
     apps?: RemoteAppUsage[];
 }
 /** Answer for one app: its own numbers, or the company numbers when it shares the company cluster. */
-export type RemoteAppUsageResponse = (RemoteAppUsage & {
+export interface RemoteRemovedAppUsage {
+    companyUid: string;
+    appId: string;
+    mode: "app-cluster" | "company-cluster";
+    status: "detached" | "purged";
+    removedAt: string;
+    retainUntil: string | null;
+    purgedAt: string | null;
+    billed: false;
+    exempt: boolean;
+}
+export type RemoteAppUsageResponse = RemoteRemovedAppUsage | (RemoteAppUsage & {
     companyUid: string;
     mode: "app-cluster";
     status?: string;

package/dist/lib/db/usage-format.d.ts

@@ -1,7 +1,8 @@
-import type { RemoteAppUsage, RemoteAppUsageResponse, RemoteUsageResponse } from "./control-plane.js";
+import type { RemoteAppUsage, RemoteAppUsageResponse, RemoteRemovedAppUsage, RemoteUsageResponse } from "./control-plane.js";
 export declare function formatBytes(bytes: number): string;
 export declare function formatUsage(usage: RemoteUsageResponse): string;
 export declare function formatAppUsage(usage: RemoteAppUsage): string;
+export declare function formatRemovedAppUsage(usage: RemoteRemovedAppUsage): string;
 export declare function formatAppUsageResponse(response: RemoteAppUsageResponse): string;
 export declare function formatCompanyApps(apps: RemoteAppUsage[]): string;
 //# sourceMappingURL=usage-format.d.ts.map

package/dist/lib/db/usage-format.js

@@ -80,7 +80,26 @@ export function formatAppUsage(usage) {
         : `Last measured ${usage.measuredAt}. Numbers can lag by a few minutes.`);
     return lines.join("\n");
 }
+function day(iso) {
+    return iso.slice(0, 10);
+}
+export function formatRemovedAppUsage(usage) {
+    const lines = [`The database for app ${usage.appId} was removed on ${day(usage.removedAt)}.`];
+    if (usage.purgedAt) {
+        lines.push(`Its data was deleted for good on ${day(usage.purgedAt)}.`);
+    }
+    else if (usage.retainUntil) {
+        lines.push(`Its data is kept until ${day(usage.retainUntil)}, then deleted for good.`);
+    }
+    lines.push("It is not billed.");
+    return lines.join("\n");
+}
+function isRemoved(response) {
+    return "status" in response && (response.status === "detached" || response.status === "purged");
+}
 export function formatAppUsageResponse(response) {
+    if (isRemoved(response))
+        return formatRemovedAppUsage(response);
     if (response.mode === "company-cluster") {
         return [
             `App ${response.appId} uses the shared company database, so these are the company numbers.`,

package/dist/lib/install/provider-wrappers.js

@@ -1,6 +1,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER } from '../anywhere-runtime-flag-key.js';
 const marker = '# hq-anywhere provider sign-in wrapper';
 const PROVIDER_PATH_RC_FILES = ['.bashrc', '.bash_profile', '.zshrc', '.zprofile', '.profile'];
 const wrapperHeader = (provider) => `#!/bin/sh\n${marker}: ${provider}\n`;
@@ -76,6 +77,18 @@ function wrapperSource(provider) {
         `  ${provider === 'claude' ? '/login|auth' : 'login'}) exec "$real" "$@" ;;`,
         'esac',
         '',
+        '# The local marker mirrors registryDir: trim the override and use ~/.hq when empty.',
+        'registry_dir=${HQ_REGISTRY_DIR:-}',
+        "registry_dir=$(printf '%s' \"$registry_dir\" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')",
+        'if [ -z "$registry_dir" ]; then',
+        '  registry_dir=${HOME:-}',
+        '  [ -n "$registry_dir" ] && registry_dir="$registry_dir/.hq"',
+        'fi',
+        'if [ -n "$registry_dir" ]; then',
+        '  case "$registry_dir" in /*) ;; *) registry_dir="$PWD/$registry_dir" ;; esac',
+        `  if [ -e "$registry_dir/${HQ_ANYWHERE_RUNTIME_REVOCATION_MARKER}" ]; then exec "$real" "$@"; fi`,
+        'fi',
+        '',
         'log_dir="$HOME/.hq/logs"',
         'mkdir -p "$log_dir" 2>/dev/null || :',
         'log_file="$log_dir/provider-auth.log"',

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

@@ -60,6 +60,13 @@ export interface LoopResult {
     session_id?: string;
     resumed?: boolean;
     fresh_fallback?: boolean;
+    question_id?: string;
+    decision?: {
+        question_id: string;
+        choice: string;
+        notes?: string;
+        at: string;
+    };
 }
 export interface Section8Handoff {
     schema: typeof PHASE_HANDOFF_SCHEMA;
@@ -103,6 +110,7 @@ export interface LoopRunnerOptions {
         envelopeId: string;
         attempt: number;
         error: string;
+        questionId: string;
     }): Promise<void> | void;
     defaultDeadlineSeconds?: number;
     now?: () => Date;
@@ -120,7 +128,6 @@ interface StoredEnvelope {
     envelope_id: string;
     queued_at: string;
     deadline_budget_seconds?: number;
-    deadline_at_ms?: number;
     envelope: LoopEnvelope;
 }
 /** Validate both hq-cli phase envelopes and the conduct protocol §8 shape. */
@@ -148,6 +155,21 @@ export declare function interruptLoopQueue(runDir: string): {
     withdrawn: string[];
     already_picked_up: string[];
 };
+export declare function interruptLoopQueueForStory(runDir: string, storyId: string, phase?: string): {
+    withdrawn: string[];
+    already_picked_up: string[];
+};
+export declare function applyLoopStallAnswer(input: {
+    runDir: string;
+    questionId: string;
+    choice: string;
+    notes?: string;
+    at: string;
+}): {
+    lane_id: string;
+    envelope_id: string;
+    action: "requeued" | "parked";
+} | undefined;
 export declare function loopStatus(runDir: string, laneId: string): LoopStatus;
 export declare function setLoopControllerPid(runDir: string, laneId: string, pid: number | undefined): void;
 export declare function clearLoopControllerPid(runDir: string, laneId: string, pid: number): void;

package/dist/lib/lanes/loop.js

@@ -14,6 +14,16 @@ export function loopAdmissionPath(state, hasPendingResume, initialAdmission) {
         return "deferred";
     return "resume";
 }
+function asidePath(file, marker) {
+    const parsed = path.parse(file);
+    let suffix = 1;
+    let candidate;
+    do {
+        candidate = path.join(parsed.dir, `${parsed.name}.${marker}.${suffix}${parsed.ext}`);
+        suffix += 1;
+    } while (fs.existsSync(candidate));
+    return candidate;
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -331,11 +341,49 @@ export function enqueueLoopEnvelope(input) {
             }
         })
             .filter((record) => record !== undefined);
-        if (records.some((record) => record.envelope_id === envelopeId) || fs.existsSync(path.join(resultsDir(input.runDir), resultName(envelopeId)))) {
+        const withdrawnDir = path.join(input.runDir, "loop", "withdrawn");
+        const stalledDir = path.join(input.runDir, "loop", "stalled");
+        const reusableRecords = records.filter((record) => record.envelope_id === envelopeId);
+        const terminalResult = fs.existsSync(path.join(resultsDir(input.runDir), resultName(envelopeId)))
+            ? readJson(path.join(resultsDir(input.runDir), resultName(envelopeId))) : undefined;
+        const reusable = reusableRecords.length > 0 && reusableRecords.every((record) => [stalledDir, withdrawnDir].some((dir) => envelopeFiles(dir).some((file) => {
+            try {
+                return fileEnvelope(file).envelope_id === record.envelope_id;
+            }
+            catch {
+                return false;
+            }
+        }))) && (!isRecord(terminalResult) || terminalResult.status === "stalled");
+        if ((records.some((record) => record.envelope_id === envelopeId) && !reusable) ||
+            (terminalResult !== undefined && (!reusable || !isRecord(terminalResult) || terminalResult.status !== "stalled"))) {
             throw new Error(`envelope id ${envelopeId} was already used in this loop lane`);
         }
+        if (reusable) {
+            for (const file of envelopeFiles(withdrawnDir).concat(envelopeFiles(stalledDir))) {
+                try {
+                    if (fileEnvelope(file).envelope_id === envelopeId)
+                        fs.renameSync(file, asidePath(file, path.basename(path.dirname(file))));
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                }
+            }
+            if (terminalResult !== undefined) {
+                const resultFile = path.join(resultsDir(input.runDir), resultName(envelopeId));
+                fs.renameSync(resultFile, asidePath(resultFile, "stalled"));
+            }
+        }
         const incomingStop = envelope.kind === "stop";
-        if (records.some((record) => record.envelope.kind === "stop")) {
+        const blockingStop = [pendingDir(input.runDir), activeDir(input.runDir)].some((scanDir) => envelopeFiles(scanDir).some((file) => {
+            try {
+                return fileEnvelope(file).envelope.kind === "stop";
+            }
+            catch {
+                return false;
+            }
+        }));
+        if (blockingStop) {
             throw new Error(incomingStop ? "a stop envelope is already queued or active" : "cannot enqueue a phase after a stop envelope");
         }
         const sequence = nextQueueSequence(input.runDir);
@@ -405,6 +453,77 @@ export function interruptLoopQueue(runDir) {
     }
     return { withdrawn, already_picked_up: alreadyPickedUp };
 }
+export function interruptLoopQueueForStory(runDir, storyId, phase) {
+    const withdrawn = [];
+    const alreadyPickedUp = [];
+    const matches = (record) => {
+        const envelope = record.envelope;
+        return envelope.story_id === storyId && (phase === undefined || envelope.phase === phase);
+    };
+    for (const file of envelopeFiles(pendingDir(runDir))) {
+        const record = fileEnvelope(file);
+        if (!matches(record))
+            continue;
+        const destination = path.join(runDir, "loop", "withdrawn", path.basename(file));
+        fs.mkdirSync(path.dirname(destination), { recursive: true });
+        fs.renameSync(file, destination);
+        withdrawn.push(record.envelope_id);
+    }
+    for (const file of envelopeFiles(activeDir(runDir))) {
+        const record = fileEnvelope(file);
+        if (matches(record))
+            alreadyPickedUp.push(record.envelope_id);
+    }
+    return { withdrawn, already_picked_up: alreadyPickedUp };
+}
+export function applyLoopStallAnswer(input) {
+    const results = fs.existsSync(resultsDir(input.runDir))
+        ? fs.readdirSync(resultsDir(input.runDir)).filter((name) => name.endsWith(".json")) : [];
+    const resultPath = results.map((name) => path.join(resultsDir(input.runDir), name)).find((file) => {
+        try {
+            const result = readJson(file);
+            return isRecord(result) && result.status === "stalled" && result.question_id === input.questionId;
+        }
+        catch (error) {
+            if (error instanceof SyntaxError)
+                return false;
+            throw error;
+        }
+    });
+    if (!resultPath)
+        return undefined;
+    const result = readJson(resultPath);
+    const envelopeFile = envelopeFiles(path.join(input.runDir, "loop", "stalled")).find((file) => {
+        try {
+            return fileEnvelope(file).envelope_id === result.envelope_id;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!envelopeFile)
+        throw new Error(`stalled loop envelope ${result.envelope_id} is missing`);
+    const record = fileEnvelope(envelopeFile);
+    const action = input.choice === "Retry with a longer deadline" ? "requeued" : "parked";
+    if (action === "requeued") {
+        record.deadline_budget_seconds = Math.max(1, record.deadline_budget_seconds ?? phaseDeadlineBudget(record.envelope, 3600)) * 2;
+        const head = path.join(pendingDir(input.runDir), `0000000000000-answer-${path.basename(envelopeFile)}`);
+        fs.mkdirSync(pendingDir(input.runDir), { recursive: true });
+        fs.renameSync(envelopeFile, head);
+        fs.renameSync(resultPath, asidePath(resultPath, "stalled"));
+        const pending = fileEnvelope(head);
+        pending.deadline_budget_seconds = record.deadline_budget_seconds;
+        atomicJson(head, pending);
+        persistStatus(input.runDir, path.basename(input.runDir), { stall_counts: { [record.envelope_id]: 0 } });
+    }
+    else {
+        atomicJson(resultPath, {
+            ...result,
+            decision: { question_id: input.questionId, choice: input.choice, ...(input.notes ? { notes: input.notes } : {}), at: input.at },
+        });
+    }
+    return { lane_id: path.basename(input.runDir), envelope_id: result.envelope_id, action };
+}
 export function loopStatus(runDir, laneId) {
     const loop = fs.existsSync(loopPath(runDir)) && isRecord(readJson(loopPath(runDir))) ? readJson(loopPath(runDir)) : {};
     const active = envelopeFiles(activeDir(runDir)).map(fileEnvelope)[0];
@@ -578,22 +697,16 @@ export async function runLoopLane(options) {
         const previousSession = sessions.get(sessionKey);
         const startedAt = now().toISOString();
         const startedAtMs = Date.parse(startedAt);
-        let deadlineAtMs = record.deadline_at_ms;
-        if (deadlineAtMs === undefined) {
-            const absoluteDeadline = envelope.deadline;
-            if (typeof absoluteDeadline === "string")
-                deadlineAtMs = Date.parse(absoluteDeadline);
-            else {
-                const budget = record.deadline_budget_seconds ?? firstDeadline.get(record.envelope_id) ?? phaseDeadlineBudget(envelope, defaultDeadlineSeconds);
-                firstDeadline.set(record.envelope_id, budget);
-                record.deadline_budget_seconds = budget;
-                deadlineAtMs = startedAtMs + budget * 1000;
-            }
-            record.deadline_at_ms = deadlineAtMs;
-        }
+        const absoluteDeadline = envelope.deadline;
+        const budget = record.deadline_budget_seconds ?? firstDeadline.get(record.envelope_id) ??
+            (typeof absoluteDeadline === "string"
+                ? Math.max(1, Math.round((Date.parse(absoluteDeadline) - startedAtMs) / 1000))
+                : phaseDeadlineBudget(envelope, defaultDeadlineSeconds));
+        firstDeadline.set(record.envelope_id, budget);
+        record.deadline_budget_seconds = budget;
         atomicJson(file, record);
         persistStatus(options.runDir, options.lane.lane_id, { state: "running", queue_depth: listLoopQueue(options.runDir).length, active_envelope_id: record.envelope_id, active_phase: phaseName(envelope, record.envelope_id), stall_counts: Object.fromEntries(stalls) });
-        const timer = abortAfter(deadlineAtMs - startedAtMs, options.signal);
+        const timer = abortAfter(budget * 1000, options.signal);
         try {
             let result;
             let fallback = false;
@@ -673,9 +786,11 @@ export async function runLoopLane(options) {
                 continue;
             }
             const message = error instanceof Error ? error.message : String(error);
-            const result = { schema_version: LOOP_SCHEMA, envelope_id: record.envelope_id, status: "stalled", started_at: startedAt, finished_at: now().toISOString(), error: message };
+            const questionId = options.raiseQuestion ? randomUUID() : undefined;
+            const result = { schema_version: LOOP_SCHEMA, envelope_id: record.envelope_id, status: "stalled", started_at: startedAt, finished_at: now().toISOString(), error: message, ...(questionId ? { question_id: questionId } : {}) };
             writeResultAt(options.runDir, file, record, result);
-            await options.raiseQuestion?.({ envelope, envelopeId: record.envelope_id, attempt, error: message });
+            if (questionId)
+                await options.raiseQuestion?.({ envelope, envelopeId: record.envelope_id, attempt, error: message, questionId });
             completed += 1;
             persistStatus(options.runDir, options.lane.lane_id, { state: "parked", queue_depth: listLoopQueue(options.runDir).length, active_envelope_id: null, active_phase: null, stall_counts: Object.fromEntries(stalls) });
             releaseRunner();
@@ -715,7 +830,7 @@ function writeResultAt(runDir, activeFile, record, result) {
                         summary: stalled ? "Phase stalled twice and needs operator direction." : "Phase execution failed.",
                         files_changed: [], commits: [],
                         back_pressure: { tests: "skip", lint: "skip", typecheck: "skip", build: "skip" },
-                        context_for_next: result.error ?? result.status,
+                        context_for_next: [result.error ?? result.status, ...(result.question_id ? [`Decision question: ${result.question_id}`] : [])].join("\n"),
                     };
                     atomicJson(path.resolve(externalPath), failure);
                 }

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

@@ -10,6 +10,11 @@ export interface QuestionBody {
     options: string[];
     recommended?: string;
     notes?: string;
+    loop_stall?: {
+        lane_id: string;
+        envelope_id: string;
+        attempt: number;
+    };
 }
 export declare function assertQuestionBodySecretSafe(body: QuestionBody): void;
 /** Errors that make an envelope ask unsafe or impossible to persist. */

package/dist/lib/lanes/reconcile.js

@@ -12,6 +12,7 @@ import { compareLaneQueueOrder, compareLaneQueueOrderWithLeads, freeClaudeAccoun
 import { accountStatus, isCredentialProven, resolveAccount } from "./accounts.js";
 import { effectiveAccountHome } from "./account-home.js";
 import { enforceRegistryApprovalGate } from "./approval-gate.js";
+import { loopStatus } from "./loop.js";
 import { loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
 import { MAX_LANE_DEPTH } from "./constants.js";
 import { laneDepthCap } from "./depth-cap.js";
@@ -3600,6 +3601,8 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
         const current = readLane(hqRoot, lane.lane_id);
         if (current.state !== "awaiting_input")
             continue;
+        if (current.loop_mode === true && loopStatus(laneRunDir(hqRoot, current.lane_id), current.lane_id).state === "parked")
+            continue;
         const pending = questions.filter((q) => q.origin.id === lane.lane_id && q.status === "pending");
         const answered = questions.filter((q) => q.origin.id === lane.lane_id && q.status === "answered");
         if (pending.length > 0 || answered.length === 0)