@indigoai-us/hq-cli 5.229.1 → 5.230.0

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [5.230.0] — 2026-09-27
+
+### Added
+
+- Behind the off-by-default `checkpoint.ontology.no-link-aliases` flag, a
+  checkpoint ontology candidate that links to an existing entity no longer adds
+  aliases to that entity's file. The plan records `link_aliases: false` and
+  apply reports the link without writing. New entities keep their aliases.
+  Most aliases written through links were other names the text mentioned next
+  to the entity, such as `Publisher` on `indigo`.
+
+## [5.229.2] — 2026-09-27
+
+### Fixed
+
+- Standing keep-alive leads now wait after done turns for drop-box messages,
+  undelivered answers, or pending resumes; queued answers are included in the
+  next turn.
+- An unreadable question record no longer aborts reconciliation of other lanes.
+
 ## [5.229.1] — 2026-09-27
 
 ### Fixed

package/dist/command-catalog.generated.d.ts

@@ -7541,6 +7541,9 @@ export declare const COMMAND_CATALOG: readonly [{
         }, {
             readonly flags: "--off";
             readonly description: "Disable keep-alive for this lane";
+        }, {
+            readonly flags: "--standing";
+            readonly description: "Wait for queued work after every done turn; requires --on";
         }, {
             readonly flags: "--json";
             readonly description: "Emit JSON on stdout (default)";

package/dist/command-catalog.generated.js

@@ -9750,6 +9750,10 @@ export const COMMAND_CATALOG = [
                         "flags": "--off",
                         "description": "Disable keep-alive for this lane"
                     },
+                    {
+                        "flags": "--standing",
+                        "description": "Wait for queued work after every done turn; requires --on"
+                    },
                     {
                         "flags": "--json",
                         "description": "Emit JSON on stdout (default)"

package/dist/commands/lanes.js

@@ -4975,6 +4975,7 @@ async function runShow(ctx, laneId) {
         keep_alive_state: {
             enabled: keepAliveState.enabled,
             source: keepAliveState.source,
+            standing: storedLane.keep_alive_standing === true,
             opted_in_at: storedLane.keep_alive_opted_in_at ?? null,
             blocked_reason: storedLane.keep_alive_blocked_reason ??
                 (storedLane.keep_alive === true ? null : "not_opted_in"),
@@ -5104,6 +5105,9 @@ function printGrantResult(hqRoot, updated, hierarchy) {
     printJson({ ok: true, action: "grant", lane_id: updated.lane_id, lane: updated, ...fields });
 }
 async function runKeepAlive(ctx, laneId, opts) {
+    if (opts.standing && !opts.on) {
+        throw new LanesError("keep_alive_standing_requires_on", "Pass --standing together with --on", { lane_id: laneId });
+    }
     if (Boolean(opts.on) === Boolean(opts.off)) {
         throw new LanesError("keep_alive_mode_invalid", "Pass exactly one of --on or --off", { lane_id: laneId });
     }
@@ -5131,6 +5135,7 @@ async function runKeepAlive(ctx, laneId, opts) {
         return updateLane(hqRoot, laneId, lane.version, "command", (current) => ({
             ...current,
             keep_alive: Boolean(opts.on),
+            keep_alive_standing: Boolean(opts.on && opts.standing),
             keep_alive_opted_in_at: optedInAt,
             keep_alive_blocked_reason: undefined,
         }));
@@ -9329,6 +9334,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .argument("<lane-id>", "Lane id")
         .option("--on", "Enable explicit keep-alive for this lane")
         .option("--off", "Disable keep-alive for this lane")
+        .option("--standing", "Wait for queued work after every done turn; requires --on")
         .option("--json", "Emit JSON on stdout (default)")
         .action(wrap(async (laneId, opts) => {
         await runKeepAlive(ctx, laneId, opts);

package/dist/lib/checkpoint-ontology/apply.js

@@ -286,6 +286,9 @@ export function applyOntologyRun(options) {
                 report.suspect_duplicates.push({ name: canonical, type: candidate.type, paths: [resolved.target, ...resolved.duplicates] });
                 continue;
             }
+            // checkpoint.ontology.no-link-aliases: the link is reported and the entity file is left as it is.
+            if (plan.link_aliases === false)
+                continue;
             const pending = updates.get(resolved.target);
             if (!pending && updates.size >= CAPS.updates) {
                 note(report.deferred, "cap_updates");

package/dist/lib/checkpoint-ontology/plan.d.ts

@@ -39,6 +39,15 @@ export declare const MULTI_WRITER_FLAG = "checkpoint.ontology.multi-writer";
  * runs were model errors, 5 of them duplicates of an existing entity.
  */
 export declare const ENTITY_HINTS_FLAG = "checkpoint.ontology.entity-hints";
+/**
+ * A candidate that links to an existing entity adds no aliases to it; the plan
+ * carries `link_aliases: false` and apply honours it. CO-42: most aliases
+ * written through links on the CO-41 runs were other things the text named
+ * next to the entity (`Publisher` on indigo, `Stripe Connect` on Stripe), and
+ * entity-hints multiplied them (22 aliases on a flag-off run, 45 and 125 on two
+ * hinted runs).
+ */
+export declare const NO_LINK_ALIASES_FLAG = "checkpoint.ontology.no-link-aliases";
 export declare const PLAN_FILE = "ontology-plan.json";
 export declare const CANDIDATES_FILE = "ontology-candidates.json";
 export declare const REPORT_FILE = "ontology-report.json";
@@ -105,6 +114,8 @@ export interface OntologyPlan {
     };
     /** Present only when `checkpoint.ontology.multi-writer` was on for this plan. */
     multi_writer?: MultiWriterStart;
+    /** Present, as false, only when `checkpoint.ontology.no-link-aliases` was on for this plan. */
+    link_aliases?: false;
     inputs: PlanInput[];
     /** The session's summary, decisions and learnings, for the `session` input. */
     session_text: string | null;

package/dist/lib/checkpoint-ontology/plan.js

@@ -43,6 +43,15 @@ export const MULTI_WRITER_FLAG = "checkpoint.ontology.multi-writer";
  * runs were model errors, 5 of them duplicates of an existing entity.
  */
 export const ENTITY_HINTS_FLAG = "checkpoint.ontology.entity-hints";
+/**
+ * A candidate that links to an existing entity adds no aliases to it; the plan
+ * carries `link_aliases: false` and apply honours it. CO-42: most aliases
+ * written through links on the CO-41 runs were other things the text named
+ * next to the entity (`Publisher` on indigo, `Stripe Connect` on Stripe), and
+ * entity-hints multiplied them (22 aliases on a flag-off run, 45 and 125 on two
+ * hinted runs).
+ */
+export const NO_LINK_ALIASES_FLAG = "checkpoint.ontology.no-link-aliases";
 export const PLAN_FILE = "ontology-plan.json";
 export const CANDIDATES_FILE = "ontology-candidates.json";
 export const REPORT_FILE = "ontology-report.json";
@@ -219,6 +228,7 @@ export async function planOntologyRun(options) {
     recordBackendPreference(hqRoot, company, await options.readFlag(GROK_BACKEND_FLAG, company));
     const multiWriterOn = await options.readFlag(MULTI_WRITER_FLAG, company);
     const hintsOn = await options.readFlag(ENTITY_HINTS_FLAG, company);
+    const noLinkAliases = await options.readFlag(NO_LINK_ALIASES_FLAG, company);
     const touched = sessionTouched(hqRoot, company, payload.files);
     // A first run takes its boundary from the entity tree, so the ledger is
     // refreshed before merge-back moves any `last_updated` forward.
@@ -331,6 +341,7 @@ export async function planOntologyRun(options) {
             }
             : {}),
         ...(multiWriter ? { multi_writer: multiWriter } : {}),
+        ...(noLinkAliases ? { link_aliases: false } : {}),
         inputs,
         session_text: sessionText,
         pending_after_run: remaining,

package/dist/lib/lanes/keep-alive.d.ts

@@ -1,4 +1,4 @@
-import type { LaneRecord } from "./types.js";
+import type { LaneRecord, QuestionRecord } from "./types.js";
 export declare const LEAD_LANE_KEEP_ALIVE_FLAG = "lanes.lead-keep-alive";
 export declare const LEAD_LANE_KEEP_ALIVE_DEFAULT_ENABLED = false;
 export declare const LEAD_LANE_KEEP_ALIVE_MAX_RESUMES = 24;
@@ -7,6 +7,21 @@ export declare const LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS: number;
 export declare const LEAD_LANE_KEEP_ALIVE_RESUME_TEXT = "Automatic keep-alive resume: your last turn ended with decision done and story_complete false. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
 export declare const LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT = "Automatic keep-alive resume: your previous turn was interrupted by a provider process exit. Check your last state before continuing. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
 export type KeepAliveBlockedReason = NonNullable<LaneRecord["keep_alive_blocked_reason"]>;
+/** The latest terminal envelope fields used by both watch and reconcile. */
+export interface KeepAliveDoneEnvelope {
+    decision?: string;
+    story_complete?: boolean;
+}
+/**
+ * Shared done-state policy: ordinary opted-in lanes resume open stories;
+ * standing leads wait for queued work, even when each turn marks the story
+ * complete. Watch and reconcile both use this decision.
+ */
+export declare function canResumeDoneKeepAliveLane(lane: Pick<LaneRecord, "keep_alive_standing">, envelope: KeepAliveDoneEnvelope, hasQueuedWork: boolean): boolean;
+/** Work signals already persisted for a lane that ended its turn. */
+export declare function hasPendingKeepAliveWork(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "company" | "pending_resume">, questionRecords?: readonly QuestionRecord[]): boolean;
+/** Undelivered answers that belong to this lane and company. */
+export declare function undeliveredAnsweredQuestions(lane: Pick<LaneRecord, "lane_id" | "company">, questions: readonly QuestionRecord[]): QuestionRecord[];
 export declare function retiredLaneRegistryPath(hqRoot: string): string;
 /** Missing registry means no retired lanes; every present invalid file fails closed. */
 export declare function loadRetiredLaneIds(hqRoot: string): ReadonlySet<string>;

package/dist/lib/lanes/keep-alive.js

@@ -1,6 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { LanesError } from "./errors.js";
+import { dropboxInboxHasMessages } from "./dropbox.js";
+import { listQuestionIds, readQuestion } from "./store.js";
 export const LEAD_LANE_KEEP_ALIVE_FLAG = "lanes.lead-keep-alive";
 export const LEAD_LANE_KEEP_ALIVE_DEFAULT_ENABLED = false;
 export const LEAD_LANE_KEEP_ALIVE_MAX_RESUMES = 24;
@@ -8,6 +10,55 @@ export const LEAD_LANE_KEEP_ALIVE_BASE_BACKOFF_MS = 5 * 60 * 1000;
 export const LEAD_LANE_KEEP_ALIVE_MAX_BACKOFF_MS = 60 * 60 * 1000;
 export const LEAD_LANE_KEEP_ALIVE_RESUME_TEXT = "Automatic keep-alive resume: your last turn ended with decision done and story_complete false. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
 export const LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT = "Automatic keep-alive resume: your previous turn was interrupted by a provider process exit. Check your last state before continuing. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
+/**
+ * Shared done-state policy: ordinary opted-in lanes resume open stories;
+ * standing leads wait for queued work, even when each turn marks the story
+ * complete. Watch and reconcile both use this decision.
+ */
+export function canResumeDoneKeepAliveLane(lane, envelope, hasQueuedWork) {
+    if (envelope.decision !== "done")
+        return false;
+    return lane.keep_alive_standing === true
+        ? hasQueuedWork
+        : envelope.story_complete !== true;
+}
+/** Work signals already persisted for a lane that ended its turn. */
+export function hasPendingKeepAliveWork(hqRoot, lane, questionRecords) {
+    if (lane.pending_resume !== undefined)
+        return true;
+    if (dropboxInboxHasMessages(hqRoot, lane.lane_id))
+        return true;
+    const questions = questionRecords ?? readKeepAliveQuestionRecords(hqRoot);
+    return undeliveredAnsweredQuestions(lane, questions).length > 0;
+}
+/** Undelivered answers that belong to this lane and company. */
+export function undeliveredAnsweredQuestions(lane, questions) {
+    return questions.filter((question) => {
+        const sameCompany = question.company === null
+            ? lane.company === null
+            : lane.company !== null &&
+                question.company.uid === lane.company.uid &&
+                question.company.slug === lane.company.slug;
+        return (question.lane_id === lane.lane_id &&
+            question.origin.id === lane.lane_id &&
+            sameCompany &&
+            question.status === "answered" &&
+            question.answer !== undefined &&
+            (question.delivered_at === null || question.delivered_at === undefined));
+    });
+}
+function readKeepAliveQuestionRecords(hqRoot) {
+    const questions = [];
+    for (const questionId of listQuestionIds(hqRoot)) {
+        try {
+            questions.push(readQuestion(hqRoot, questionId));
+        }
+        catch (err) {
+            process.stderr.write(`hq lanes keep-alive: skipped unreadable question ${questionId}: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+    }
+    return questions;
+}
 export function retiredLaneRegistryPath(hqRoot) {
     return path.join(hqRoot, "workspace", "lane-briefs", "juniors.json");
 }

package/dist/lib/lanes/reconcile.js

@@ -21,7 +21,7 @@ import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecor
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.js";
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
-import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, } from "./keep-alive.js";
+import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, LEAD_LANE_KEEP_ALIVE_RESUME_TEXT, canResumeDoneKeepAliveLane, hasPendingKeepAliveWork, keepAliveExclusion, loadRetiredLaneIds, leadLaneKeepAliveBackoffMs, undeliveredAnsweredQuestions, } from "./keep-alive.js";
 import { providerSupportsSessionResume } from "./delivery.js";
 import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./quota.js";
 import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
@@ -818,7 +818,10 @@ export async function runPassBody(hqRoot, deps) {
             continue;
         if (lane.state === "done") {
             const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
-            if (!envelope || envelope.decision !== "done" || envelope.story_complete === true)
+            if (!envelope || envelope.decision !== "done")
+                continue;
+            const hasQueuedWork = lane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, lane, questions);
+            if (!canResumeDoneKeepAliveLane(lane, envelope, hasQueuedWork))
                 continue;
         }
         const key = keepAliveCompanyKey(lane.company);
@@ -834,9 +837,9 @@ export async function runPassBody(hqRoot, deps) {
     }));
     await withAllLaneAdmissionLocks(hqRoot, async () => {
         const freshLanes = loadLaneRecords(hqRoot, summary);
-        resumeKeepAlive(hqRoot, freshLanes, summary, deps, now, keepAliveFlagByCompany);
-        const drainLanes = loadLaneRecords(hqRoot, summary);
         const freshQuestions = loadQuestionRecords(hqRoot, summary);
+        resumeKeepAlive(hqRoot, freshLanes, freshQuestions, summary, deps, now, keepAliveFlagByCompany);
+        const drainLanes = loadLaneRecords(hqRoot, summary);
         await admitQueued(hqRoot, drainLanes, summary, deps, now);
         await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, deps);
     });
@@ -1532,7 +1535,7 @@ function latestEnvelopeMtimeMs(hqRoot, lane, ref) {
         throw new LanesError("keep_alive_envelope_timestamp_unavailable", `Cannot stat latest envelope for lane ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}`, { lane_id: lane.lane_id, path: filePath });
     }
 }
-function resumeKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany) {
+function resumeKeepAlive(hqRoot, lanes, questions, summary, deps, now, flagByCompany) {
     const nowMs = now.getTime();
     const nowIso = now.toISOString();
     const config = loadLanesConfig(hqRoot);
@@ -1566,8 +1569,9 @@ function resumeKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany) {
             const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
             if (!envelope || envelope.decision !== "done")
                 continue;
-            if (envelope.story_complete === true) {
-                if (hasKeepAliveProgress(lane)) {
+            const hasQueuedWork = lane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, lane, questions);
+            if (!canResumeDoneKeepAliveLane(lane, envelope, hasQueuedWork)) {
+                if (envelope.story_complete === true && lane.keep_alive_standing !== true && hasKeepAliveProgress(lane)) {
                     casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version &&
                         current.state === "done" &&
                         current.keep_alive === lane.keep_alive, (current) => ({ ...clearedKeepAliveProgress(current), keep_alive_blocked_reason: undefined }), deps.dryRun);
@@ -1652,7 +1656,10 @@ function resumeKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany) {
         let eligibilityAtMs;
         if (initialState === "done") {
             const latest = readLatestEnvelopeRecord(hqRoot, lane.lane_id);
-            if (!latest || latest.envelope.decision !== "done" || latest.envelope.story_complete === true)
+            if (!latest || latest.envelope.decision !== "done")
+                continue;
+            const hasQueuedWork = lane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, lane, questions);
+            if (!canResumeDoneKeepAliveLane(lane, latest.envelope, hasQueuedWork))
                 continue;
             try {
                 eligibilityAtMs = latestEnvelopeMtimeMs(hqRoot, lane, latest.ref);
@@ -1726,8 +1733,9 @@ function resumeKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany) {
             const currentEnvelope = readLatestEnvelopeRecord(hqRoot, current.lane_id);
             if (!currentEnvelope || currentEnvelope.envelope.decision !== "done")
                 continue;
-            if (currentEnvelope.envelope.story_complete === true) {
-                if (hasKeepAliveProgress(current)) {
+            const hasQueuedWork = current.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, current, questions);
+            if (!canResumeDoneKeepAliveLane(current, currentEnvelope.envelope, hasQueuedWork)) {
+                if (currentEnvelope.envelope.story_complete === true && current.keep_alive_standing !== true && hasKeepAliveProgress(current)) {
                     casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
                         latestLane.state === "done" &&
                         latestLane.keep_alive === true &&
@@ -1840,6 +1848,12 @@ function resumeKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany) {
         const resumeText = resumedFrom === "interrupted"
             ? LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT
             : LEAD_LANE_KEEP_ALIVE_RESUME_TEXT;
+        const carriesAnsweredQuestions = resumedFrom === "done" &&
+            current.keep_alive_standing === true &&
+            undeliveredAnsweredQuestions(current, questions).length > 0;
+        if (carriesAnsweredQuestions && !deps.dryRun) {
+            writeAnsweredQuestions(hqRoot, current, questions);
+        }
         const queue = (expectedSeniorId) => casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
             latestLane.state === current.state &&
             latestLane.keep_alive === true &&
@@ -1855,7 +1869,7 @@ function resumeKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany) {
             terminal_details: undefined,
             pending_resume: {
                 session_id: currentSessionId,
-                trigger: "resume",
+                trigger: carriesAnsweredQuestions ? "answered_questions" : "resume",
                 resumed_from: resumedFrom,
                 text: resumeText,
                 compact: true,

package/dist/lib/lanes/store.js

@@ -409,6 +409,13 @@ export function parseLaneRecord(raw, filePath) {
             value: raw.keep_alive,
         });
     }
+    if (raw.keep_alive_standing !== undefined && typeof raw.keep_alive_standing !== "boolean") {
+        throw new LaneSchemaError("keep_alive_standing must be a boolean", {
+            path: filePath,
+            field: "keep_alive_standing",
+            value: raw.keep_alive_standing,
+        });
+    }
     const keepAliveBlockedReason = raw.keep_alive_blocked_reason;
     const validKeepAliveBlockedReasons = [
         "not_opted_in",

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

@@ -364,6 +364,8 @@ export interface LaneRecord {
     worker_profile?: string;
     /** Whether this lead lane should resume completed turns while its story is open. */
     keep_alive?: boolean;
+    /** Whether a keep-alive lead waits for queued work after every done turn. */
+    keep_alive_standing?: boolean;
     /** Time this lane most recently explicitly opted into keep-alive. */
     keep_alive_opted_in_at?: string;
     /** Why reconcile declined to resume this lane most recently. */

package/dist/lib/lanes/types.js

@@ -224,7 +224,7 @@ export const LANE_FIELD_WRITERS = {
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], worker_profile_repin_history: ["command"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
-    keep_alive: ["creator", "command"], keep_alive_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], keep_alive_resume_count: ["command", "reconcile"], keep_alive_last_resume_at: ["command", "reconcile"], keep_alive_next_eligible_at: ["command", "reconcile"], keep_alive_exhausted_at: ["command", "reconcile"],
+    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"], keep_alive_last_resume_at: ["command", "reconcile"], keep_alive_next_eligible_at: ["command", "reconcile"], keep_alive_exhausted_at: ["command", "reconcile"],
     provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], 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"], attribution_history: ["command"],
     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"],

package/dist/lib/lanes/watch.js

@@ -1,7 +1,7 @@
 import { listQuestionIds, readLane, readQuestion, } from "./store.js";
 import { LaneNotFoundError, LanesError } from "./errors.js";
 import { providerSupportsSessionResume } from "./delivery.js";
-import { LEAD_LANE_KEEP_ALIVE_MAX_RESUMES } from "./keep-alive.js";
+import { canResumeDoneKeepAliveLane, hasPendingKeepAliveWork, LEAD_LANE_KEEP_ALIVE_MAX_RESUMES, } from "./keep-alive.js";
 import { isTerminalLaneState, } from "./types.js";
 export const DEFAULT_LANE_WATCH_INTERVAL_MS = 5_000;
 export const MAX_LANE_WATCH_INTERVAL_MS = 30_000;
@@ -32,7 +32,7 @@ function validateLaneIds(laneIds) {
     }
     return unique;
 }
-function canResumeKeepAliveLane(lane) {
+function canResumeKeepAliveLane(hqRoot, lane) {
     if (lane.keep_alive !== true ||
         lane.keep_alive_opted_in_at === undefined ||
         !Number.isFinite(Date.parse(lane.keep_alive_opted_in_at)) ||
@@ -49,8 +49,7 @@ function canResumeKeepAliveLane(lane) {
         return lane.terminal_reason === "exited_with_partial_output";
     }
     if (lane.state === "done") {
-        return lane.last_envelope?.decision === "done" &&
-            lane.story_complete !== true &&
+        return canResumeDoneKeepAliveLane(lane, { decision: lane.last_envelope?.decision, story_complete: lane.story_complete }, lane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, lane)) &&
             lane.terminal_reason !== "provider_rejected" &&
             lane.terminal_reason !== "account_not_logged_in";
     }
@@ -133,7 +132,7 @@ export async function runLaneWatch(hqRoot, laneIds, deps = {}) {
         if (deps.keepAliveEnabled !== undefined) {
             for (const record of records) {
                 if (isTerminalLaneState(record.state) &&
-                    canResumeKeepAliveLane(record) &&
+                    canResumeKeepAliveLane(hqRoot, record) &&
                     await deps.keepAliveEnabled(record))
                     keepAliveWaiting.add(record.lane_id);
             }

package/package.json

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