@indigoai-us/hq-cli 5.295.0 → 5.296.0

package/dist/commands/core.js

@@ -36,7 +36,7 @@ import { registerCoreHandoffCommand } from "./core-handoff.js";
 import { registerCoreOntologyCommand } from "./core-ontology.js";
 import { registerCoreKnowledgePrefsCommand } from "./core-knowledge-prefs.js";
 import { registerCorePolicyCommand } from "./core-policy.js";
-import { registerCoreJobsNativeCommand } from "./core-jobs-native.js";
+import { registerCoreJobsNativeCommand } from "./core-job-native.js";
 import { registerCoreCheckpointGateSettingCommand } from "./core-checkpoint-gate-setting.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { interpreterFor, runBundledScript } from "../utils/run-bundled-script.js";

package/dist/commands/lanes-message.js

@@ -530,6 +530,7 @@ export function createLaneMessageHandlers(deps) {
                                             pending_resume: {
                                                 session_id: sessionId,
                                                 trigger: "message",
+                                                caller: ctx.env.HQ_LANE_ID?.trim() || "user",
                                                 text: deliveryText,
                                                 ...(opts.monitorEvent === undefined ? {} : { monitor_event: true }),
                                                 message_id: messageId,

package/dist/commands/lanes-resume.js

@@ -359,6 +359,7 @@ export function createLaneResumeHandlers(deps) {
                                 pending_resume: {
                                     session_id: sessionId,
                                     trigger: "resume",
+                                    caller: ctx.env.HQ_LANE_ID?.trim() || "user",
                                     resumed_from: resumedFrom,
                                     ...(opts.fromFailed === true ? { from_failed: true } : {}),
                                     ...(failedResumeExpectedSenior !== undefined

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

@@ -8,6 +8,7 @@ export declare function createLaneStoryHandlers(deps: LaneStoryHandlerDeps): {
     runStoryList: (ctx: Ctx, laneId: string) => Promise<void>;
     runStoryAdd: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
     runStoryStart: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
+    runStoryReview: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
     runStoryBlock: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
     runStoryDone: (ctx: Ctx, laneId: string, storyId: string, opts: StoryCommandOptions) => Promise<void>;
 };

package/dist/commands/lanes-stories.js

@@ -18,6 +18,13 @@ export function createLaneStoryHandlers(deps) {
         }
         return { projectId, storyId: normalizedStoryId, story };
     }
+    function reviewableStoryTarget(lane, storyId, project) {
+        const target = storyCommandTarget(lane, storyId, project);
+        if (target.story.status === "done") {
+            throw new LanesError("story_already_done", `Story ${target.projectId}/${target.storyId} is done and cannot be moved to review`, { lane_id: lane.lane_id, project_id: target.projectId, story_id: target.storyId });
+        }
+        return target;
+    }
     function updateCarriedStory(lane, projectId, storyId, status, at, extras = {}) {
         const stories = laneStories(lane).map((story) => story.project_id === projectId && story.story_id === storyId
             ? {
@@ -229,6 +236,38 @@ export function createLaneStoryHandlers(deps) {
         const finalLane = readLane(hqRoot, laneId);
         printJson({ ok: true, action: "story.start", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "in_progress", story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
     }
+    async function runStoryReview(ctx, laneId, storyId, opts) {
+        const hqRoot = ctx.hqRoot();
+        let lane = readLane(hqRoot, laneId);
+        assertLaneRunsHereForOperatorMutation(ctx, lane, "update story status for");
+        const target = reviewableStoryTarget(lane, storyId, opts.project);
+        const at = ctx.now().toISOString();
+        const warnings = [];
+        const thread = await ensureStoryThreadForTransition(ctx, lane, target.projectId, target.storyId);
+        lane = thread.lane;
+        if (thread.warning !== undefined)
+            warnings.push(thread.warning);
+        const before = lane;
+        const next = casUpdateLane(hqRoot, laneId, (current) => {
+            assertLaneRunsHereForOperatorMutation(ctx, current, "update story status for");
+            reviewableStoryTarget(current, target.storyId, target.projectId);
+            return updateCarriedStory(current, target.projectId, target.storyId, "review", at);
+        });
+        const transitionWarning = await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_progress", "review", { detail: "Story moved to review" });
+        if (transitionWarning !== undefined)
+            warnings.push(transitionWarning);
+        const finalLane = readLane(hqRoot, laneId);
+        printJson({
+            ok: true,
+            action: "story.review",
+            lane_id: laneId,
+            project_id: target.projectId,
+            story_id: target.storyId,
+            status: "review",
+            story_warning: combinedStoryWarning(finalLane, warnings),
+            lane: finalLane,
+        });
+    }
     async function runStoryBlock(ctx, laneId, storyId, opts) {
         const hqRoot = ctx.hqRoot();
         let lane = readLane(hqRoot, laneId);
@@ -303,6 +342,6 @@ export function createLaneStoryHandlers(deps) {
         const finalLane = readLane(hqRoot, laneId);
         printJson({ ok: true, action: "story.done", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "done", verified: true, story_warning: combinedStoryWarning(finalLane, warnings), lane: finalLane });
     }
-    return { runStoryList, runStoryAdd, runStoryStart, runStoryBlock, runStoryDone };
+    return { runStoryList, runStoryAdd, runStoryStart, runStoryReview, runStoryBlock, runStoryDone };
 }
 //# sourceMappingURL=lanes-stories.js.map

package/dist/commands/lanes.js

@@ -5062,10 +5062,12 @@ async function runShow(ctx, laneId) {
     })
         .slice(0, 20)
         .map(({ repo, pr, head_sha, recorded_at }) => ({ repo, pr, head_sha, recorded_at }));
+    const laneForShow = { ...lane };
+    delete laneForShow.resume_history;
     printJson({
         ok: true,
         action: "show",
-        lane,
+        lane: laneForShow,
         ...(laneIsSenior ? { reviews: recentReviews, reviews_skipped: reviewListing.skipped } : {}),
         ...hire,
         overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, ctx.now()),
@@ -5079,6 +5081,8 @@ async function runShow(ctx, laneId) {
         envelope_repair_mode: lane.envelope_repair?.mode ?? null,
         envelope_validation_errors: lane.envelope_validation_errors ?? [],
         last_resume: lane.last_resume ?? null,
+        // Public JSON key for the bounded start audit; `last_resume` remains unchanged.
+        resume_history: lane.resume_history ?? [],
         keep_alive_history: lane.keep_alive_history ?? [],
         account: lane.account ?? null,
         account_history: lane.account_history ?? [],
@@ -6191,7 +6195,12 @@ async function prepareAccountMove(ctx, lane, input) {
                 }),
                 pending_resume: input.deferTurnStart
                     ? undefined
-                    : { session_id: sessionId, at, ...input.pending },
+                    : {
+                        session_id: sessionId,
+                        at,
+                        caller: ctx.env.HQ_LANE_ID?.trim() || "user",
+                        ...input.pending,
+                    },
             };
             applyResumeProfileAndEffort(current, next, {
                 ...(input.workerProfile !== undefined ? { profile: input.workerProfile } : {}),
@@ -8171,6 +8180,15 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (laneId, storyId, opts) => {
         await storyHandlers.runStoryStart(ctx, laneId, storyId, opts);
     }));
+    stories
+        .command("review")
+        .description("Move a carried story to review")
+        .argument("<lane-id>", "Lane id")
+        .argument("<story-id>", "Story id")
+        .option("--project <slug>", "Project id; defaults to the lane's current project")
+        .action(wrap(async (laneId, storyId, opts) => {
+        await storyHandlers.runStoryReview(ctx, laneId, storyId, opts);
+    }));
     stories
         .command("block")
         .description("Mark one carried story blocked")

package/dist/commands/run.js

@@ -128,6 +128,11 @@ export function registerRunCommand(program) {
             let state;
             const graph = await internal.loadEnvGraph({
                 entryFilePaths: paths,
+                // hq run owns its short-lived in-memory resolution. Varlock's default
+                // cache auto-detection can write ~/.config/varlock and initialize
+                // the native local-encryption helper, neither of which belongs on
+                // this command path.
+                skipCache: true,
                 afterInit: async (g) => { state = installHqPlugin(g, pluginOpts); },
             });
             // Refuse to resolve a graph varlock never finished loading (a malformed

package/dist/lib/lanes/mesh-events.js

@@ -44,6 +44,7 @@
  */
 import { appendThreadEvent, clamp, ensureLaneMeshThread, ensureProjectThread, getProjectView, patchStoryStatus, putProjectView, requireToken, registerMeshProject, resolveMeshCompany, } from "../mesh/api.js";
 import { LanesError } from "./errors.js";
+import { terminalEnvelopeStoryStatus } from "./stories.js";
 export const LANE_MESH_EVENTS = [
     "lane_started",
     "lane_progress",
@@ -454,6 +455,8 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
     const patchStoryStatus = async (status) => {
         if (!lane.project_id?.trim() || !lane.story_id?.trim())
             return;
+        if (terminalEnvelopeStoryStatus(lane, envelope.decision) === undefined)
+            return;
         const suppressions = opts.storyStatusSuppressions;
         const key = laneStoryStatusSuppressionKey(company, lane.project_id, lane.story_id);
         if (suppressions?.has(key))

package/dist/lib/lanes/reconcile.js

@@ -31,7 +31,7 @@ import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./qu
 import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
 import { SILENCE_MS, appendWatcherEvent, classifyLaneExit, isPidAlive, missingExpectedEnvelopeFile, readLatestEnvelopeFile, readLatestEnvelopeRecord, watcherEventsPath, watcherOutLogPath, writeWatcherDecision, } from "./watcher.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshCompany, } from "./mesh-events.js";
-import { activeLaneStories, laneStories, storyStatusForEnvelope } from "./stories.js";
+import { activeLaneStories, laneStories, terminalEnvelopeStoryStatus } from "./stories.js";
 import { decideEnvelopeRepair, envelopeQuestionIds, routeProviderFailure } from "./watcher.js";
 import { PROVIDER_REJECTED_REASON, providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
 /** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
@@ -50,6 +50,7 @@ export const RECONCILE_TIMER_NAME = "hq-lanes-reconcile.timer";
 function spawnDepsForHost(deps) {
     return {
         ...(deps.spawnLaneDeps ?? {}),
+        env: deps.spawnLaneDeps?.env ?? deps.env ?? process.env,
         hostname: deps.host.hostname,
         admissionHost: deps.host,
     };
@@ -1270,24 +1271,22 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     }
                     if (terminalEnvelope && latest) {
                         const envelope = terminalEnvelope;
-                        next.story_status = envelope.story_status;
-                        next.story_complete = envelope.story_complete;
-                        next.story_complete_reason = envelope.story_complete_reason;
-                        const storyStatus = envelope.decision === "blocked"
-                            ? "blocked"
-                            : envelope.decision === "done"
-                                ? "review"
-                                : storyStatusForEnvelope(envelope.story_status);
-                        next.stories = laneStories(current).map((story) => story.project_id === current.project_id && story.story_id === current.story_id
-                            ? {
-                                ...story,
-                                status: storyStatus,
-                                updated_at: nowIso,
-                                ...(envelope.decision === "blocked"
-                                    ? { blocked_reason: envelope.blocked_reason ?? "" }
-                                    : { blocked_reason: undefined }),
-                            }
-                            : story);
+                        const storyStatus = terminalEnvelopeStoryStatus(current, envelope.decision, envelope.story_status);
+                        if (storyStatus !== undefined) {
+                            next.story_status = envelope.story_status;
+                            next.story_complete = envelope.story_complete;
+                            next.story_complete_reason = envelope.story_complete_reason;
+                            next.stories = laneStories(current).map((story) => story.project_id === current.project_id && story.story_id === current.story_id
+                                ? {
+                                    ...story,
+                                    status: storyStatus,
+                                    updated_at: nowIso,
+                                    ...(envelope.decision === "blocked"
+                                        ? { blocked_reason: envelope.blocked_reason ?? "" }
+                                        : { blocked_reason: undefined }),
+                                }
+                                : story);
+                        }
                         if (approvalGate?.violation) {
                             next.last_envelope = {
                                 ref: latest.ref,
@@ -2682,6 +2681,10 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
             if (!deps.dryRun)
                 writeAnsweredQuestions(hqRoot, current, questions);
             if (queueReason !== undefined) {
+                const answerEnv = deps.spawnLaneDeps?.env ?? deps.env ?? process.env;
+                const answerCaller = typeof answerEnv.HQ_LANE_ID === "string"
+                    ? answerEnv.HQ_LANE_ID.trim() || "user"
+                    : "user";
                 const queued = casLaneIf(hqRoot, current.lane_id, (latest) => latest.state === "awaiting_input", (latest) => ({
                     ...latest,
                     state: "queued",
@@ -2693,6 +2696,7 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneI
                             ? { session_id: latest.provider_session_id }
                             : {}),
                         trigger: "answered_questions",
+                        caller: answerCaller,
                         at: answeredAt,
                     },
                 }), deps.dryRun);

package/dist/lib/lanes/spawn.js

@@ -2005,6 +2005,18 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     // Claim running before spawning. Two callers that both observe queued must
     // not both start processes; the CAS loser returns without spawn.
     const nowIso = (deps.now ?? (() => new Date()))().toISOString();
+    const resumeHistoryTrigger = pendingResume?.keep_alive === true
+        ? "keep_alive"
+        : pendingResume?.trigger === "message" || trigger.kind === "message"
+            ? "message"
+            : pendingResume?.trigger === "resume" || trigger.kind === "resume"
+                ? "resume_cli"
+                : "reconcile";
+    const resumeHistoryCaller = pendingResume?.caller ||
+        (typeof env.HQ_LANE_ID === "string" ? env.HQ_LANE_ID.trim() : "") ||
+        (trigger.kind === "answered_questions" || trigger.kind === "resume" || trigger.kind === "message"
+            ? "user"
+            : undefined);
     let statusGateHeartbeat;
     try {
         statusGateHeartbeat = managerStatusGateHeartbeat(hqRoot, existing, laneTurnId, nowIso);
@@ -2016,6 +2028,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         statusGateHeartbeat = undefined;
     }
     let claimed = false;
+    let priorStartRecorded = false;
     const claimedRecord = retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => {
         claimed = false;
         if (current.state === "running" && current.account === resolved.id) {
@@ -2027,6 +2040,12 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         if (!claimableStatesFor(trigger, current).includes(current.state)) {
             throw new LanesError("spawn_state_mismatch", `Cannot mark ${current.lane_id} running from ${current.state}`, { lane_id: current.lane_id, state: current.state, trigger: trigger.kind });
         }
+        // The host report is written in the claim CAS before exec proves that a
+        // worker started. Use the prior spawn manifest's turn id (written only
+        // after detachment is proven), with last_resume for legacy manifests.
+        priorStartRecorded = previousSpawn.turn_id !== undefined ||
+            current.last_resume !== undefined ||
+            (current.resume_history?.length ?? 0) > 0;
         if (failedResumeClaim &&
             (failedResumeExpectedSenior === undefined ||
                 !sameSeniorRef(current.senior, failedResumeExpectedSenior))) {
@@ -2260,6 +2279,16 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         }
         throw err;
     }
+    if (priorStartRecorded) {
+        retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => ({
+            ...current,
+            resume_history: appendCappedHistory(current.resume_history ?? [], {
+                at: nowIso,
+                trigger: resumeHistoryTrigger,
+                ...(resumeHistoryCaller ? { caller: resumeHistoryCaller } : {}),
+            }),
+        }));
+    }
     return laneLaunchResult(readLane(hqRoot, lane.lane_id));
 }
 /**
@@ -2563,6 +2592,16 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
             killQuietly(killProcess, workerPid, "worker");
         throw err;
     }
+    const startedAt = (deps.now ?? (() => new Date()))().toISOString();
+    const callerLaneId = typeof env.HQ_LANE_ID === "string" ? env.HQ_LANE_ID.trim() : "";
+    retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => ({
+        ...current,
+        resume_history: appendCappedHistory(current.resume_history ?? [], {
+            at: startedAt,
+            trigger: "envelope_repair",
+            ...(callerLaneId ? { caller: callerLaneId } : {}),
+        }),
+    }));
     return workerPid;
 }
 export { PROVIDER_HOME_ENV, PROVIDER_COMMAND };

package/dist/lib/lanes/store.js

@@ -751,6 +751,10 @@ export function parseLaneRecord(raw, filePath) {
             path: filePath,
         });
     }
+    if (isPlainObject(raw.pending_resume) &&
+        raw.pending_resume.caller !== undefined) {
+        requireString(raw.pending_resume.caller, "pending_resume.caller");
+    }
     if (raw.keep_alive_history !== undefined) {
         if (!Array.isArray(raw.keep_alive_history) || raw.keep_alive_history.length > HISTORY_CAP) {
             throw new LaneSchemaError(`keep_alive_history must be an array capped at ${HISTORY_CAP} entries`, {
@@ -773,6 +777,29 @@ export function parseLaneRecord(raw, filePath) {
             requireTimestamp(value.at, `${field}.at`, filePath);
         }
     }
+    if (raw.resume_history !== undefined) {
+        if (!Array.isArray(raw.resume_history) || raw.resume_history.length > HISTORY_CAP) {
+            throw new LaneSchemaError(`resume_history must be an array capped at ${HISTORY_CAP} entries`, {
+                path: filePath,
+                field: "resume_history",
+            });
+        }
+        for (const [index, value] of raw.resume_history.entries()) {
+            const field = `resume_history[${index}]`;
+            if (!isPlainObject(value) ||
+                Object.keys(value).some((key) => !["at", "trigger", "caller"].includes(key))) {
+                throw new LaneSchemaError(`${field} must be a resume history entry`, {
+                    path: filePath,
+                    field,
+                    value,
+                });
+            }
+            requireTimestamp(value.at, `${field}.at`, filePath);
+            requireString(value.trigger, `${field}.trigger`);
+            if (value.caller !== undefined)
+                requireString(value.caller, `${field}.caller`);
+        }
+    }
     if (raw.stop_history !== undefined) {
         if (!Array.isArray(raw.stop_history)) {
             throw new LaneSchemaError("stop_history must be an array when present", {
@@ -1163,6 +1190,11 @@ export function mergeLaneRecords(live, sidecars) {
                 failed_resume_history: unionHistory(all.map((record) => record.failed_resume_history ?? []), entryIdentity, base.failed_resume_history ?? []),
             }
             : {}),
+        ...(all.some((record) => record.resume_history !== undefined)
+            ? {
+                resume_history: unionHistory(all.map((record) => record.resume_history ?? []), entryIdentity, base.resume_history ?? []),
+            }
+            : {}),
         ...(all.some((record) => record.settings_history !== undefined)
             ? {
                 settings_history: unionHistory(all.map((record) => record.settings_history ?? []), entryIdentity, base.settings_history ?? []),

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

@@ -1,4 +1,4 @@
-import type { LaneRecord, LaneStory } from "./types.js";
+import type { LaneRecord, LaneStory, LaneStoryStatus } from "./types.js";
 /** Board-facing states for the stories a lane currently carries. */
 export declare const ACTIVE_LANE_STORY_STATUSES: readonly ["in_progress", "blocked", "review"];
 export declare function storyKey(projectId: string, storyId: string): string;
@@ -14,4 +14,10 @@ export declare function storyWarning(lane: LaneRecord): string | undefined;
 export declare function withCurrentStory(lane: LaneRecord, projectId: string, storyId: string): LaneRecord;
 export declare function withLaneStories(lane: LaneRecord, stories: LaneStory[]): LaneRecord;
 export declare function storyStatusForEnvelope(status: string): "in_progress" | "review";
+/**
+ * Resolve the story status requested by a terminal envelope. Already-final
+ * carried stories are immutable through the envelope path; senior verification
+ * and explicit story commands own those transitions.
+ */
+export declare function terminalEnvelopeStoryStatus(lane: LaneRecord, decision: "done" | "blocked" | "ask", envelopeStatus?: string): LaneStoryStatus | undefined;
 //# sourceMappingURL=stories.d.ts.map

package/dist/lib/lanes/stories.js

@@ -73,4 +73,20 @@ export function storyStatusForEnvelope(status) {
         return "review";
     return "in_progress";
 }
+/**
+ * Resolve the story status requested by a terminal envelope. Already-final
+ * carried stories are immutable through the envelope path; senior verification
+ * and explicit story commands own those transitions.
+ */
+export function terminalEnvelopeStoryStatus(lane, decision, envelopeStatus = "in_progress") {
+    const primary = laneStory(lane, lane.project_id, lane.story_id);
+    if (primary && (String(primary.status) === "done" || String(primary.status) === "dropped")) {
+        return undefined;
+    }
+    if (decision === "blocked")
+        return "blocked";
+    if (decision === "done")
+        return "review";
+    return storyStatusForEnvelope(envelopeStatus);
+}
 //# sourceMappingURL=stories.js.map

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

@@ -412,6 +412,14 @@ export interface KeepAliveResumeHistoryEntry {
     resumed_from: "done" | "interrupted" | "blocked";
     account: string | null;
 }
+/** Bounded audit entry for every lane worker start after its first start. */
+export interface LaneResumeHistoryEntry {
+    at: string;
+    /** Stable trigger class; path-specific starts may use their path name. */
+    trigger: string;
+    /** HQ lane id for an agent caller, or `user` for an explicit human CLI action. */
+    caller?: string;
+}
 export interface KrFreshnessHistoryEntry {
     event: "kr_stalled";
     turn_id: string;
@@ -659,6 +667,8 @@ export interface LaneRecord {
     provider_home_at_spawn?: string;
     /** Set at spawn when this run continued a recorded session instead of starting fresh. */
     last_resume?: LaneResumeRecord;
+    /** Last 50 lane worker starts after the initial start, including actor provenance. */
+    resume_history?: LaneResumeHistoryEntry[];
     /** Cache counters from the last exited run's result. Nothing else from the payload. */
     last_run_usage?: LaneRunUsage;
     /** Completion time paired with last_run_usage; written by the watcher. */
@@ -723,6 +733,8 @@ export interface PendingResume {
     message_id?: string;
     /** The text is already framed as untrusted monitor data, not an operator instruction. */
     monitor_event?: true;
+    /** Caller identity captured when a deferred start was requested, when known. */
+    caller?: string;
     /** False when the command passed --no-compact; the deferred spawn honours it. */
     compact?: boolean;
     at: string;

package/dist/lib/lanes/types.js

@@ -233,7 +233,7 @@ export const LANE_FIELD_WRITERS = {
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], stop_history: ["command", "reconcile"], settings_history: ["command"], pending_settings: ["command", "spawn"], interrupted_at: ["command", "watcher", "reconcile"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],
-    provider_session_id: ["watcher", "command", "spawn"], provider_session_id_absent: ["watcher", "command"], provider_home_at_spawn: ["spawn"], last_resume: ["spawn"], last_run_usage: ["watcher"], last_run_usage_at: ["watcher"], envelope_repair: ["watcher", "reconcile"], envelope_validation_errors: ["watcher"], last_progress_event_at: ["watcher"],
+    provider_session_id: ["watcher", "command", "spawn"], provider_session_id_absent: ["watcher", "command"], provider_home_at_spawn: ["spawn"], last_resume: ["spawn"], resume_history: ["spawn", "watcher"], last_run_usage: ["watcher"], last_run_usage_at: ["watcher"], envelope_repair: ["watcher", "reconcile"], envelope_validation_errors: ["watcher"], last_progress_event_at: ["watcher"],
 };
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);

package/dist/lib/lanes/watcher.js

@@ -36,7 +36,7 @@ import * as path from "node:path";
 import { LanesError } from "./errors.js";
 import { questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
 import { isTerminalLaneState, ENVELOPE_INVALID_REASON, parseLaneEnvelope, STORY_STATUSES, LANE_PROVIDERS, } from "./types.js";
-import { laneStories, storyStatusForEnvelope } from "./stories.js";
+import { laneStories, terminalEnvelopeStoryStatus } from "./stories.js";
 import { appendCappedHistory, listQuestionIds, readLane, readQuestion, retryUpdateLane, withLaneHireLocks } from "./store.js";
 import { enforceRegistryApprovalGate } from "./approval-gate.js";
 import { readWorkerRunResult } from "./delivery.js";
@@ -423,27 +423,25 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
                 artifacts: envelope.artifacts,
                 ...(envelope.blocked_reason !== undefined ? { blocked_reason: envelope.blocked_reason } : {}),
             };
-            next.story_status = envelope.story_status;
-            next.story_complete = envelope.story_complete;
-            next.story_complete_reason = envelope.story_complete_reason;
-            const currentProject = current.project_id;
-            const currentStory = current.story_id;
-            const storyStatus = envelope.decision === "blocked"
-                ? "blocked"
-                : envelope.decision === "done"
-                    ? "review"
-                    : storyStatusForEnvelope(envelope.story_status);
-            const updatedStories = laneStories(current).map((story) => story.project_id === currentProject && story.story_id === currentStory
-                ? {
-                    ...story,
-                    status: storyStatus,
-                    updated_at: at,
-                    ...(envelope.decision === "blocked"
-                        ? { blocked_reason: envelope.blocked_reason ?? "" }
-                        : { blocked_reason: undefined }),
-                }
-                : story);
-            next.stories = updatedStories;
+            const storyStatus = terminalEnvelopeStoryStatus(current, envelope.decision, envelope.story_status);
+            if (storyStatus !== undefined) {
+                next.story_status = envelope.story_status;
+                next.story_complete = envelope.story_complete;
+                next.story_complete_reason = envelope.story_complete_reason;
+                const currentProject = current.project_id;
+                const currentStory = current.story_id;
+                const updatedStories = laneStories(current).map((story) => story.project_id === currentProject && story.story_id === currentStory
+                    ? {
+                        ...story,
+                        status: storyStatus,
+                        updated_at: at,
+                        ...(envelope.decision === "blocked"
+                            ? { blocked_reason: envelope.blocked_reason ?? "" }
+                            : { blocked_reason: undefined }),
+                    }
+                    : story);
+                next.stories = updatedStories;
+            }
         }
         return next;
     });

package/dist/run/env-graph-guard.d.ts

@@ -1,5 +1,5 @@
 /** The varlock version hq-cli is pinned to (package.json `dependencies`). */
-export declare const VARLOCK_PINNED_VERSION = "1.0.0";
+export declare const VARLOCK_PINNED_VERSION = "1.21.1";
 /** A schema/plugin source varlock could not finish loading. */
 interface GuardDataSource {
     readonly isValid: boolean;
@@ -68,7 +68,7 @@ export declare function assertEnvGraphLoaded(graph: LoadedEnvGraph): void;
  * rejection into a thrown EnvResolutionError instead of hanging on the promise
  * that never settles.
  *
- * varlock@1.0.0's resolveEnvValues dispatches its per-item resolver un-awaited
+ * varlock's resolveEnvValues dispatches its per-item resolver un-awaited
  * and with a dead `_reject`, so a throw inside it becomes a process-level
  * unhandled rejection AND leaves the returned promise permanently pending. We
  * race the resolve against a scoped `unhandledRejection` listener: whichever

package/dist/run/env-graph-guard.js

@@ -34,7 +34,7 @@
 // actionable `hq: …` line WITHOUT a Sentry capture (see isVarlockEnvError).
 import { claimRejection, releaseRejection, } from "../unhandled-rejection-boundary.js";
 /** The varlock version hq-cli is pinned to (package.json `dependencies`). */
-export const VARLOCK_PINNED_VERSION = "1.0.0";
+export const VARLOCK_PINNED_VERSION = "1.21.1";
 /**
  * A schema/entry file could not be loaded, so the env graph never finished
  * processing. Carries an actionable, file-naming message; classified by
@@ -114,7 +114,7 @@ export function assertEnvGraphLoaded(graph) {
  * rejection into a thrown EnvResolutionError instead of hanging on the promise
  * that never settles.
  *
- * varlock@1.0.0's resolveEnvValues dispatches its per-item resolver un-awaited
+ * varlock's resolveEnvValues dispatches its per-item resolver un-awaited
  * and with a dead `_reject`, so a throw inside it becomes a process-level
  * unhandled rejection AND leaves the returned promise permanently pending. We
  * race the resolve against a scoped `unhandledRejection` listener: whichever
@@ -143,6 +143,9 @@ export async function resolveEnvValuesOrThrow(graph) {
     });
     process.prependOnceListener("unhandledRejection", onRejection);
     try {
+        // Preserve current varlock's direct rejection unchanged. The race only
+        // turns a floated rejection (the 1.0.0 behavior) into a typed error rather
+        // than leaving the caller waiting on a promise that never settles.
         await Promise.race([graph.resolveEnvValues(), rejection]);
     }
     finally {

package/dist/run/hq-plugin.js

@@ -23,8 +23,9 @@ export function installHqPlugin(graph /* EnvGraph */, opts) {
         errorsByName: new Map(),
         loadedSecretsByName: new Map(),
     };
-    // varlock@1.0.0's plugin-lib.js omits the Resolver export (d.ts/JS mismatch);
-    // extract it at runtime from any already-registered built-in resolver's prototype.
+    // In varlock@1.21.1, Resolver remains declared in plugin-lib's .d.mts but
+    // is not exported from its runtime module. Derive the runtime base class from
+    // a built-in resolver registered on the graph; the shape test pins this API.
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let RuntimeResolver;
     try {
@@ -39,8 +40,8 @@ export function installHqPlugin(graph /* EnvGraph */, opts) {
         RuntimeResolver = proto;
     }
     catch (e) {
-        throw new Error('varlock Resolver base class extraction failed — the varlock@1.0.0 d.ts/JS mismatch ' +
-            'may have been resolved; switch to `import { Resolver } from "varlock/plugin-lib"`. ' +
+        throw new Error('varlock Resolver base class extraction failed — varlock@1.21.1 still declares ' +
+            'Resolver in plugin-lib types without exporting it at runtime. ' +
             `Underlying: ${e instanceof Error ? e.message : String(e)}`);
     }
     // HqResolver is declared INSIDE installHqPlugin so its static def.resolve
@@ -96,7 +97,7 @@ export function installHqPlugin(graph /* EnvGraph */, opts) {
             }
         }
     }
-    // varlock@1.0.0's env-spec parser rejects dots in decorator names ([a-zA-Z0-9_] only),
+    // Varlock's env-spec parser rejects dots in decorator names ([a-zA-Z0-9_] only),
     // so `@hq.company` is not valid syntax. We register as `@hqCompany` (camelCase) instead.
     // Schema files must use `# @hqCompany("slug")` followed by a blank line so the parser
     // treats it as a file-level root decorator rather than an item decorator for the next var.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.295.0",
+  "version": "5.296.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {
@@ -58,7 +58,7 @@
     "semver": "^7.6.3",
     "simple-git": "^3.27.0",
     "smol-toml": "1.6.1",
-    "varlock": "1.0.0"
+    "varlock": "1.21.1"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",