@indigoai-us/hq-cli 5.345.58 → 5.345.60

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)

package/dist/lib/lanes/story-ledger.js

@@ -9,7 +9,8 @@ const LOCK_TIMEOUT_MS = 10_000;
 const LOCK_STALE_MS = 60_000;
 const LOCK_RETRY_MS = 10;
 const STORY_STATES = ["todo", "in_progress", "review", "waiting", "blocked", "done", "dropped"];
-const MANAGER_OWNED_STATES = new Set(["review", "done", "dropped"]);
+const LEAD_CONTROLLED_STATES = new Set(["waiting", "blocked", "dropped"]);
+const STORY_STATE_ORDER = ["todo", "in_progress", "review", "done"];
 const TERMINAL_STATES = new Set(["done", "failed", "interrupted", "cancelled", "killed"]);
 function projectFocusOverrides(value) {
     if (value === undefined)
@@ -561,6 +562,13 @@ function validPriorQuestions(value, storyId) {
     }
     return value;
 }
+function canonicalStoryState(value) {
+    if (value === "in_review" || value === "verification")
+        return "review";
+    return typeof value === "string" && STORY_STATES.includes(value)
+        ? value
+        : undefined;
+}
 function setLaneStatusFields(story, lane, laneStoryStatus, isCurrentAttribution) {
     const laneStatus = story.lane_status;
     if (laneStatus !== undefined && !isJsonObject(laneStatus)) {
@@ -615,29 +623,31 @@ function setLaneStatusFields(story, lane, laneStoryStatus, isCurrentAttribution)
     else {
         delete story.pending_questions;
     }
-    if (story.state === "in_review" || story.state === "verification") {
-        story.state = "review";
-    }
-    if (MANAGER_OWNED_STATES.has(String(story.state))) {
-        // A manager decision always wins over lane-derived status.
-    }
-    else if (blockers.length > 0) {
-        story.state = "blocked";
-    }
-    else if (laneStoryStatus === "review") {
-        story.state = "review";
-    }
-    else if (laneStoryStatus === "done") {
+    const currentState = canonicalStoryState(story.state) ?? canonicalStoryState(story.status);
+    const currentStates = currentState === undefined ? [] : [currentState];
+    const laneProgressState = laneStoryStatus === "review"
+        ? "review"
+        : laneStoryStatus === "done"
+            ? "done"
+            : laneStoryStatus === "in_progress" || lane.state === "queued" || lane.state === "running" || lane.state === "awaiting_input"
+                ? "in_progress"
+                : undefined;
+    const currentProgressState = STORY_STATE_ORDER.reduce((highest, state) => currentStates.includes(state) || laneProgressState === state ? state : highest, undefined);
+    const laneManagedBlocked = isJsonObject(laneStatus) && isJsonObject(laneStatus.saved);
+    const leadControlledState = currentStates.find((state) => LEAD_CONTROLLED_STATES.has(state) && !(state === "blocked" && laneManagedBlocked));
+    if (currentStates.includes("done"))
         story.state = "done";
+    else if (leadControlledState !== undefined)
+        story.state = leadControlledState;
+    else if (blockers.length > 0 && currentProgressState !== "review" && currentProgressState !== "done") {
+        story.state = "blocked";
     }
-    else if (laneStoryStatus === "in_progress" || lane.state === "queued" || lane.state === "running" || lane.state === "awaiting_input") {
-        story.state = "in_progress";
+    else if (currentProgressState !== undefined) {
+        story.state = currentProgressState;
     }
     else if (saved !== undefined && story.state === "blocked") {
-        const previous = saved.state;
-        story.state = typeof previous === "string" && STORY_STATES.includes(previous)
-            ? previous
-            : "in_progress";
+        const previous = canonicalStoryState(saved.state);
+        story.state = previous ?? "in_progress";
     }
     if (typeof story.state === "string" && STORY_STATES.includes(story.state)) {
         story.status = story.state;

package/dist/lib/lanes/types.js

@@ -236,7 +236,7 @@ export const LANE_FIELD_WRITERS = {
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], registry_worker: ["creator", "command", "spawn"], registry_worker_approval_history: ["command", "watcher", "reconcile"], worker_profile_repin_history: ["command"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
     keep_alive: ["creator", "command"], keep_alive_standing: ["command"], keep_alive_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], keep_alive_resume_count: ["command", "reconcile", "spawn"], keep_alive_history: ["reconcile"], keep_alive_blocked_resume_streak: ["reconcile", "spawn", "watcher"], keep_alive_last_resume_at: ["command", "reconcile", "spawn"], keep_alive_next_eligible_at: ["command", "reconcile", "spawn"], keep_alive_exhausted_at: ["command", "reconcile", "spawn"], loop_mode: ["creator"],
     provider: ["creator", "command"], provider_source: ["creator", "command"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_source: ["creator", "command"], profile_settings_pinned: ["command"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["command"], fallback_question_cancellation_failures: ["command"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
-    version: ["creator"], created_at: ["creator"], updated_at: ["creator"], ended_at: ["reconcile"], envelope_summary: ["reconcile"], attribution_history: ["command", "watcher", "reconcile"], story_switch_pending: ["command", "watcher", "reconcile"], story_switch_unacknowledged: ["watcher", "reconcile"],
+    version: ["creator"], created_at: ["creator"], updated_at: ["creator"], ended_at: ["reconcile"], envelope_summary: ["reconcile"], attribution_history: ["command", "watcher", "reconcile"], story_switch_pending: ["command", "watcher", "reconcile"], story_switch_unacknowledged: ["command", "watcher", "reconcile"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn", "command"], effort_source: ["creator", "spawn", "command"], fast_mode: ["spawn"],
     last_message_at: ["creator", "command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher", "reconcile"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.58",
+  "version": "5.345.60",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {