@indigoai-us/hq-cli 5.300.0 → 5.302.0

package/dist/lib/core-utils/token-usage-report.js

@@ -120,7 +120,7 @@ function comparison(projectDirs, before, after, minHours, json, stdout) {
 /** Print token usage totals from Claude session JSONL files. */
 export function tokenUsageReport(args = [], options = {}) {
     const { stdout, stderr } = ioFor(options);
-    let lastDays = 7, since = "", json = false, before = "", after = "", minHours = 0;
+    let lastDays = 7, since = "", json = false, before = "", after = "", minHours = 0, projectDir = options.projectDir, projectDirSeen = false;
     for (let index = 0; index < args.length;) {
         const arg = args[index];
         if (arg === "--last") {
@@ -149,8 +149,22 @@ export function tokenUsageReport(args = [], options = {}) {
             minHours = Number.parseFloat(args[index + 1] ?? "");
             index += 2;
         }
+        else if (arg === "--project-dir") {
+            const value = args[index + 1];
+            if (!value || value.startsWith("--")) {
+                line(stderr, "--project-dir requires a path");
+                return 1;
+            }
+            if (projectDirSeen) {
+                line(stderr, "--project-dir may be specified only once");
+                return 1;
+            }
+            projectDir = value;
+            projectDirSeen = true;
+            index += 2;
+        }
         else if (arg === "-h" || arg === "--help") {
-            stdout("token-usage-report.sh — Daily effective-token totals + top burners from Claude Code session JSONLs.\nUsage:\n  scripts/token-usage-report.sh                # last 7 days, table\n  scripts/token-usage-report.sh --last 14      # last 14 days\n  scripts/token-usage-report.sh --since 2026-05-01\n  scripts/token-usage-report.sh --json         # machine-readable\nEffective tokens weighting (matches weekly rate-limit volume):\n  input + 5×output + 1.25×cache_creation + 0.1×cache_read\n--- Compare-windows mode (US-011) ---\nFormat: --before YYYY-MM-DD:YYYY-MM-DD --after YYYY-MM-DD:YYYY-MM-DD\n");
+            stdout("token-usage-report.sh — Daily effective-token totals + top burners from Claude Code session JSONLs.\nUsage:\n  scripts/token-usage-report.sh                # last 7 days, table\n  scripts/token-usage-report.sh --last 14      # last 14 days\n  scripts/token-usage-report.sh --since 2026-05-01\n  scripts/token-usage-report.sh --json         # machine-readable\n  scripts/token-usage-report.sh --project-dir <path> # use one Claude activity folder\nEffective tokens weighting (matches weekly rate-limit volume):\n  input + 5×output + 1.25×cache_creation + 0.1×cache_read\n--- Compare-windows mode (US-011) ---\nFormat: --before YYYY-MM-DD:YYYY-MM-DD --after YYYY-MM-DD:YYYY-MM-DD\n");
             return 0;
         }
         else {
@@ -158,7 +172,7 @@ export function tokenUsageReport(args = [], options = {}) {
             return 1;
         }
     }
-    const projectDirs = resolveProjectDirs(options).filter((dir) => fs.existsSync(dir) && fs.statSync(dir).isDirectory());
+    const projectDirs = resolveProjectDirs({ ...options, projectDir }).filter((dir) => fs.existsSync(dir) && fs.statSync(dir).isDirectory());
     if (before && after) {
         comparison(projectDirs, before, after, minHours, json, stdout);
         return 0;

package/dist/lib/deploy-apps.d.ts

@@ -0,0 +1,13 @@
+/** Pagination for org-scoped hq-deploy app listings. */
+export declare const MAX_DEPLOY_APPS_PAGES = 100;
+export interface DeployAppsPage<T> {
+    apps?: unknown;
+    nextCursor?: unknown;
+}
+/**
+ * Collect every page from GET /api/apps. Older hq-deploy versions omit
+ * nextCursor, which remains a valid single-page response. The cap prevents a
+ * bad cursor response from creating an unbounded CLI request loop.
+ */
+export declare function listDeployApps<T>(fetchPage: (cursor?: string) => Promise<DeployAppsPage<T>>): Promise<T[]>;
+//# sourceMappingURL=deploy-apps.d.ts.map

package/dist/lib/deploy-apps.js

@@ -0,0 +1,24 @@
+/** Pagination for org-scoped hq-deploy app listings. */
+export const MAX_DEPLOY_APPS_PAGES = 100;
+/**
+ * Collect every page from GET /api/apps. Older hq-deploy versions omit
+ * nextCursor, which remains a valid single-page response. The cap prevents a
+ * bad cursor response from creating an unbounded CLI request loop.
+ */
+export async function listDeployApps(fetchPage) {
+    const apps = [];
+    let cursor;
+    for (let page = 0; page < MAX_DEPLOY_APPS_PAGES; page += 1) {
+        const result = await fetchPage(cursor);
+        if (Array.isArray(result.apps))
+            apps.push(...result.apps);
+        if (result.nextCursor === undefined || result.nextCursor === null)
+            return apps;
+        if (typeof result.nextCursor !== "string" || result.nextCursor.length === 0) {
+            throw new Error("hq-deploy returned an invalid apps-list cursor.");
+        }
+        cursor = result.nextCursor;
+    }
+    throw new Error(`hq-deploy apps list exceeded the ${MAX_DEPLOY_APPS_PAGES}-page safety cap.`);
+}
+//# sourceMappingURL=deploy-apps.js.map

package/dist/lib/index-render/companies.d.ts

@@ -1,3 +1,6 @@
 import { RenderContext, RenderResult } from "./shared.js";
-export declare function renderCompanies(context: RenderContext): RenderResult;
+export declare class CompanyIndexUserError extends Error {
+    constructor(message: string);
+}
+export declare function renderCompanies(context: RenderContext, args?: string[]): RenderResult;
 //# sourceMappingURL=companies.d.ts.map

package/dist/lib/index-render/companies.js

@@ -1,6 +1,12 @@
 import * as fs from "fs";
 import * as path from "path";
 import { basename, countImmediate, date, exists, immediateEntries, isHidden, log, projectStatus, readJson, sanitize, titleize, truncate, write } from "./shared.js";
+export class CompanyIndexUserError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CompanyIndexUserError";
+    }
+}
 function description(root, company, name) {
     const base = `companies/${company}/${name}`;
     const nonHidden = (child) => !isHidden(child);
@@ -17,9 +23,66 @@ function description(root, company, name) {
         default: return "—";
     }
 }
-export function renderCompanies(context) {
+export function renderCompanies(context, args = []) {
+    if (args.some((arg) => arg === "--help" || arg === "-h")) {
+        (context.output ?? ((message) => process.stdout.write(message)))("Usage: hq core rebuild-index companies [--company <slug>]\n\n" +
+            "Regenerate company root INDEX.md files. Without --company, all companies are regenerated.\n" +
+            "--company <slug> regenerates only that company's index.\n" +
+            "Company-scoped writes require the cli.rebuild-index-company-scope flag.\n");
+        return { written: [] };
+    }
+    let selectedCompany;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--company") {
+            if (selectedCompany !== undefined)
+                throw new CompanyIndexUserError("rebuild-index companies: --company may be supplied once");
+            const value = args[index + 1];
+            if (!value || value.startsWith("--"))
+                throw new CompanyIndexUserError("rebuild-index companies: --company requires a company slug");
+            selectedCompany = value;
+            index += 1;
+        }
+        else if (arg.startsWith("--company=")) {
+            if (selectedCompany !== undefined)
+                throw new CompanyIndexUserError("rebuild-index companies: --company may be supplied once");
+            selectedCompany = arg.slice("--company=".length);
+            if (!selectedCompany)
+                throw new CompanyIndexUserError("rebuild-index companies: --company requires a company slug");
+        }
+        else {
+            throw new CompanyIndexUserError(`rebuild-index companies: unknown option ${arg}`);
+        }
+    }
     const written = [];
-    for (const directory of immediateEntries(context.root, "companies", "dir")) {
+    let scopedDirectories;
+    if (selectedCompany === undefined) {
+        scopedDirectories = immediateEntries(context.root, "companies", "dir");
+    }
+    else {
+        if (selectedCompany === "." || selectedCompany === ".." ||
+            selectedCompany.includes("/") || selectedCompany.includes("\\") ||
+            path.basename(selectedCompany) !== selectedCompany ||
+            selectedCompany.startsWith("_") || isHidden(selectedCompany)) {
+            throw new CompanyIndexUserError(`rebuild-index companies: invalid company slug "${selectedCompany}"`);
+        }
+        const companiesRoot = path.resolve(context.root, "companies");
+        const selectedDirectory = path.resolve(companiesRoot, selectedCompany);
+        let selectedStat;
+        try {
+            selectedStat = fs.lstatSync(selectedDirectory);
+        }
+        catch (cause) {
+            if (cause.code !== "ENOENT")
+                throw cause;
+            throw new CompanyIndexUserError(`rebuild-index companies: no company directory named "${selectedCompany}"`);
+        }
+        if (!selectedStat.isDirectory()) {
+            throw new CompanyIndexUserError(`rebuild-index companies: no company directory named "${selectedCompany}"`);
+        }
+        scopedDirectories = [selectedDirectory];
+    }
+    for (const directory of scopedDirectories) {
         const company = basename(directory);
         if (company.startsWith("_") || isHidden(company))
             continue;
@@ -40,7 +103,7 @@ export function renderCompanies(context) {
                 const parsed = readJson(prd);
                 let text = typeof parsed?.description === "string" ? parsed.description : "";
                 text = truncate(sanitize(text), 110) || "—";
-                lines.push(`| \`${project}\` | ${projectStatus(context.root, project, prd, "active")} | ${text} |`);
+                lines.push(`| \`${project}\` | ${projectStatus(context.root, project, prd, "active", prd)} | ${text} |`);
             }
         }
         else

package/dist/lib/index-render/index.d.ts

@@ -2,4 +2,5 @@ import { RenderContext, RenderResult } from "./shared.js";
 export type IndexTarget = "all" | "companies" | "company-knowledge" | "orchestrator" | "projects" | "public-knowledge" | "reports" | "social-drafts" | "threads" | "workers";
 export declare function renderIndexTarget(target: IndexTarget, context: RenderContext, args?: string[]): RenderResult;
 export { atomicWrite, comparePath, immediateEntries, type RenderContext, type RenderResult } from "./shared.js";
+export { CompanyIndexUserError } from "./companies.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/index-render/index.js

@@ -10,7 +10,7 @@ import { renderWorkers } from "./workers.js";
 const allOrder = ["threads", "orchestrator", "companies", "projects", "company-knowledge", "public-knowledge", "workers", "reports", "social-drafts"];
 export function renderIndexTarget(target, context, args = []) {
     switch (target) {
-        case "companies": return renderCompanies(context);
+        case "companies": return renderCompanies(context, args);
         case "company-knowledge": return renderCompanyKnowledge(context);
         case "orchestrator": return renderOrchestrator(context);
         case "projects": return renderProjects(context);
@@ -40,4 +40,5 @@ export function renderIndexTarget(target, context, args = []) {
     }
 }
 export { atomicWrite, comparePath, immediateEntries } from "./shared.js";
+export { CompanyIndexUserError } from "./companies.js";
 //# sourceMappingURL=index.js.map

package/dist/lib/index-render/projects.js

@@ -1,16 +1,92 @@
+import * as fs from "fs";
 import * as path from "path";
-import { basename, date, exists, immediateEntries, isHidden, log, projectStatus, readJson, sanitize, truncate, write } from "./shared.js";
+import { at, basename, date, exists, extractKeepFences, generatedFingerprint, generatedStamp, hasUnclosedKeepMarker, immediateEntries, isHidden, log, looksAutoGenerated, projectStatus, readJson, readText, sanitize, stampGenerated, titleize, truncate, write, } from "./shared.js";
+function composeCompanyProjectsIndex(raw, existing) {
+    const stamped = stampGenerated(raw);
+    const fences = existing === undefined ? "" : extractKeepFences(existing);
+    if (!fences)
+        return stamped;
+    return `${stamped.replace(/\n+$/, "\n")}\n${fences}\n`;
+}
+function shouldOverwriteCompanyProjectsIndex(context, existing, next) {
+    if (existing === undefined)
+        return "write";
+    if (context.force)
+        return "write";
+    if (hasUnclosedKeepMarker(existing))
+        return "skip";
+    const stored = generatedStamp(existing);
+    if (stored && stored === generatedFingerprint(existing))
+        return "write";
+    if (stored)
+        return "refuse";
+    if (looksAutoGenerated(existing))
+        return "write";
+    if (generatedFingerprint(existing) === generatedFingerprint(next))
+        return "write";
+    return "refuse";
+}
+function renderCompanyProjects(context, company, projectRoot) {
+    const written = [];
+    const lines = [`# ${titleize(company)} Projects`, "", `> Auto-generated. Updated: ${date(context.now)}`, "", "| Project | Status | Description |", "|---------|--------|-------------|"];
+    for (const directory of immediateEntries(context.root, projectRoot, "dir")) {
+        const name = basename(directory);
+        if (name.startsWith("_") || isHidden(name))
+            continue;
+        const prd = path.join(directory, "prd.json");
+        const parsed = readJson(prd);
+        const description = truncate(sanitize(typeof parsed?.description === "string" ? parsed.description : ""), 110) || "—";
+        lines.push(`| \`${name}\` | ${projectStatus(context.root, name, prd, "active", prd)} | ${description} |`);
+    }
+    lines.push("");
+    const output = `${projectRoot}/INDEX.md`;
+    const existing = readText(at(context.root, output));
+    // An unreadable existing file is not an invitation to replace it.
+    if (existing === undefined && fs.existsSync(at(context.root, output))) {
+        context.refused?.push(output);
+        log(context, `rebuild-projects-index: refused to overwrite unreadable ${output}`);
+        return written;
+    }
+    const next = composeCompanyProjectsIndex(lines.join("\n"), existing);
+    const decision = shouldOverwriteCompanyProjectsIndex(context, existing, next);
+    if (decision === "skip") {
+        log(context, `rebuild-projects-index: skipped ${output} (<!-- hq:keep -->)`);
+        return written;
+    }
+    if (decision === "refuse") {
+        context.refused?.push(output);
+        log(context, `rebuild-projects-index: refused ${output} (hand-written or edited; differs from last generated output)`);
+        log(context, "Re-run with --accept to overwrite, or add <!-- hq:keep --> to opt out.");
+        return written;
+    }
+    write(context, output, next);
+    written.push(output);
+    log(context, `rebuild-projects-index: wrote ${output}`);
+    return written;
+}
 export function renderProjects(context) {
+    const written = [];
+    const companyDirectories = immediateEntries(context.root, "companies", "dir");
+    for (const companyDirectory of companyDirectories) {
+        const company = basename(companyDirectory);
+        if (company.startsWith("_") || isHidden(company))
+            continue;
+        const projectRoot = ["companies", company, "projects"].join("/");
+        if (immediateEntries(context.root, projectRoot, "dir").length > 0 || fs.existsSync(at(context.root, projectRoot))) {
+            written.push(...renderCompanyProjects(context, company, projectRoot));
+        }
+    }
     const base = "personal/projects";
     if (!exists(context.root, base)) {
         log(context, "rebuild-projects-index: personal/projects/ missing, skipping");
-        return { written: [] };
+        return { written };
     }
     const lines = ["# Projects", "", `> Auto-generated. Updated: ${date(context.now)}`, "", "Personal/HQ projects only. Company-scoped projects live in `companies/{co}/projects/`.", "", "## Company Project Directories", "", "| Company | Path |", "|---------|------|"];
-    for (const companyDirectory of immediateEntries(context.root, "companies", "dir")) {
+    for (const companyDirectory of companyDirectories) {
         const company = basename(companyDirectory);
-        if (!company.startsWith("_") && !isHidden(company) && exists(context.root, `companies/${company}/projects`))
+        if (!company.startsWith("_") && !isHidden(company) && fs.existsSync(at(context.root, ["companies", company, "projects"].join("/")))) {
             lines.push(`| ${company} | \`companies/${company}/projects/\` |`);
+        }
     }
     lines.push("", "## Personal/HQ Projects", "", "Projects here are HQ infrastructure or cross-company tools.", "", "| Project | Stories | Status | Description |", "|---------|---------|--------|-------------|");
     const projects = immediateEntries(context.root, base, "dir");
@@ -27,7 +103,8 @@ export function renderProjects(context) {
     lines.push("");
     const output = `${base}/INDEX.md`;
     write(context, output, lines.join("\n"));
+    written.push(output);
     log(context, `rebuild-projects-index: wrote ${output} (${projects.length} HQ project(s))`);
-    return { written: [output] };
+    return { written };
 }
 //# sourceMappingURL=projects.js.map

package/dist/lib/index-render/shared.d.ts

@@ -39,7 +39,7 @@ export declare function hasUnclosedKeepMarker(content: string): boolean;
 export declare function looksAutoGenerated(content: string): boolean;
 export declare function generatedStamp(content: string): string | undefined;
 export declare function log(context: RenderContext, message: string): void;
-export declare function projectStatus(root: string, project: string, prdPath: string, fallback: string): string;
+export declare function projectStatus(root: string, project: string, prdPath: string, fallback: string, expectedStatePrdPath?: string): string;
 export declare function basename(file: string): string;
 export declare function isHidden(name: string): boolean;
 export declare function mtime(file: string): number;

package/dist/lib/index-render/shared.js

@@ -134,9 +134,11 @@ export function generatedStamp(content) {
     return content.match(/^<!-- hq-generated-sha256: ([a-f0-9]{64}) -->/m)?.[1];
 }
 export function log(context, message) { context.log?.(message); }
-export function projectStatus(root, project, prdPath, fallback) {
+export function projectStatus(root, project, prdPath, fallback, expectedStatePrdPath) {
     const state = readJson(at(root, `workspace/orchestrator/${project}/state.json`));
-    if (state) {
+    const stateMatchesPrd = expectedStatePrdPath === undefined || (typeof state?.prd_path === "string" &&
+        path.resolve(root, state.prd_path) === path.resolve(root, expectedStatePrdPath));
+    if (state && stateMatchesPrd) {
         const raw = typeof state.status === "string" ? state.status : "active";
         if (["completed", "complete"].includes(raw))
             return "complete";

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

@@ -41,8 +41,8 @@ export declare function sessionNotPortableMessage(provider: LaneProvider): strin
  * is not terminal (spec §6.7) and nothing stopped the lane deliberately.
  *
  * Refused by `hq lanes message`:
- * `awaiting_input` has its own path, `hq lanes questions answer`, and the
- * reconcile pass resumes it once every question is answered. `killed` and
+ * `awaiting_input` has its own path, `hq lanes questions answer`, while a
+ * senior may resume it when no answerable pending question remains. `killed` and
  * `cancelled` were stopped on purpose by the operator; a message must not
  * silently restart them. `failed` means the run ended without an envelope or
  * never started; only the lane's senior can explicitly recover it with
@@ -66,6 +66,8 @@ export type ResumeCommandState = (typeof RESUME_COMMAND_STATES)[number];
 export declare function isResumeCommandState(state: LaneState): state is ResumeCommandState;
 export declare const LANE_DELIVERY_MECHANISMS: readonly ["dropbox", "resume", "none"];
 export type LaneDeliveryMechanism = (typeof LANE_DELIVERY_MECHANISMS)[number];
+/** Additional presentation-only result used by `hq lanes show`. */
+export type LaneShowDeliveryMechanism = LaneDeliveryMechanism | "questions";
 export type DeliveryLane = Pick<LaneRecord, "state" | "provider" | "provider_session_id" | "terminal_reason" | "envelope_repair">;
 /** Only the terminal result of a failed automatic envelope repair is recoverable. */
 export declare function isFailedEnvelopeRepairLane(lane: DeliveryLane): boolean;
@@ -139,7 +141,8 @@ export type LaunchTrigger = {
     /** `hq lanes resume`: the operator's explicit opt-in to continue an exited lane. */
     kind: "resume";
     /** Lane state at the moment of the command; recorded as `last_resume.resumed_from`. */
-    from: ResumeCommandState | "failed";
+    from: ResumeCommandState | "failed" | "awaiting_input";
+    allowAwaitingInput?: true;
     fromFailed?: true;
     /** Senior that authorized a failed-lane resume, rechecked at the claim CAS. */
     expectedSenior?: SeniorRef;
@@ -158,6 +161,7 @@ export type LaunchPlan = {
  */
 export declare function resumeCommandRefusal(lane: DeliveryLane, options?: {
     allowFailed?: boolean;
+    allowAwaitingInput?: boolean;
 }): {
     error: "lane_not_resumable" | "resume_unsupported" | "no_provider_session";
     message: string;

package/dist/lib/lanes/delivery.js

@@ -61,8 +61,8 @@ export function sessionNotPortableMessage(provider) {
  * is not terminal (spec §6.7) and nothing stopped the lane deliberately.
  *
  * Refused by `hq lanes message`:
- * `awaiting_input` has its own path, `hq lanes questions answer`, and the
- * reconcile pass resumes it once every question is answered. `killed` and
+ * `awaiting_input` has its own path, `hq lanes questions answer`, while a
+ * senior may resume it when no answerable pending question remains. `killed` and
  * `cancelled` were stopped on purpose by the operator; a message must not
  * silently restart them. `failed` means the run ended without an envelope or
  * never started; only the lane's senior can explicitly recover it with
@@ -104,7 +104,7 @@ export function laneDeliveryMechanism(lane) {
     if (lane.state === "queued" || lane.state === "running")
         return "dropbox";
     if (providerSupportsSessionResume(lane.provider) &&
-        (isResumableLaneState(lane.state) || isFailedEnvelopeRepairLane(lane)) &&
+        (isResumableLaneState(lane.state) || lane.state === "awaiting_input" || isFailedEnvelopeRepairLane(lane)) &&
         hasRecordedSessionId(lane)) {
         return "resume";
     }
@@ -348,6 +348,7 @@ export const LAUNCH_TRIGGERS = ["admit", "answered_questions", "message", "resum
  */
 export function resumeCommandRefusal(lane, options = {}) {
     if (!isResumeCommandState(lane.state) &&
+        !(options.allowAwaitingInput === true && lane.state === "awaiting_input") &&
         !isFailedEnvelopeRepairLane(lane) &&
         !(options.allowFailed === true && lane.state === "failed")) {
         return {
@@ -398,7 +399,10 @@ export function planLaneLaunch(lane, trigger) {
             return { mode: "resume", session_id: lane.provider_session_id };
         }
         case "resume": {
-            const refusal = resumeCommandRefusal(lane, { allowFailed: trigger.fromFailed === true });
+            const refusal = resumeCommandRefusal(lane, {
+                allowFailed: trigger.fromFailed === true,
+                allowAwaitingInput: trigger.allowAwaitingInput === true,
+            });
             if (refusal !== null || !hasRecordedSessionId(lane)) {
                 throw new LanesError(refusal?.error ?? "no_provider_session", refusal?.message ?? `Lane is ${lane.state} and has no recorded provider session`, { state: lane.state, provider: lane.provider });
             }
@@ -419,11 +423,17 @@ export function claimableStatesFor(trigger, lane) {
         case "answered_questions":
             return ["awaiting_input"];
         case "message":
-            return envelopeRepairFailed ? [...RESUMABLE_LANE_STATES, "failed"] : RESUMABLE_LANE_STATES;
-        case "resume":
-            return trigger.fromFailed === true || envelopeRepairFailed
+            return envelopeRepairFailed
+                ? [...RESUMABLE_LANE_STATES, "failed"]
+                : lane?.state === "awaiting_input"
+                    ? [...RESUMABLE_LANE_STATES, "awaiting_input"]
+                    : RESUMABLE_LANE_STATES;
+        case "resume": {
+            const states = trigger.fromFailed === true || envelopeRepairFailed
                 ? [...RESUME_COMMAND_STATES, "failed"]
-                : RESUME_COMMAND_STATES;
+                : [...RESUME_COMMAND_STATES];
+            return lane?.state === "awaiting_input" ? [...states, "awaiting_input"] : states;
+        }
         default: {
             const _exhaustive = trigger;
             return _exhaustive;

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

@@ -64,7 +64,7 @@ export type { RegistryWorkerEntry, ResolvedLaneWorker, WorkerTenancy, WorkerYaml
 export { bodyStoreForLane, envelopeQuestionId, parseQuestionBodyStore, questionBodyAbsPath, questionBodyRef, raiseEnvelopeQuestions, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "./questions.js";
 export type { QuestionBody, RaiseLaneQuestionInput } from "./questions.js";
 export { LANE_DELIVERY_MECHANISMS, LAUNCH_TRIGGERS, PROVIDER_SESSION_RESUME, PROVIDER_SESSION_PORTABLE, providerSessionPortable, sessionNotPortableMessage, parseGrokResultOutput, RESUMABLE_LANE_STATES, RESUME_COMMAND_STATES, SESSION_ID_ABSENT_REASONS, claimableStatesFor, deliveryRefusalReason, hasRecordedSessionId, isResumableLaneState, isResumeCommandState, laneDeliveryMechanism, parseClaudeResultOutput, parseCodexEventOutput, parseWorkerRunOutput, planLaneLaunch, providerSupportsSessionResume, readWorkerRunResult, resumeCommandRefusal, } from "./delivery.js";
-export type { DeliveryLane, LaneDeliveryMechanism, LaunchPlan, LaunchTrigger, LaunchTriggerKind, ResumableLaneState, ResumeCommandState, SessionIdAbsentReason, WorkerRunResult, } from "./delivery.js";
+export type { DeliveryLane, LaneDeliveryMechanism, LaneShowDeliveryMechanism, LaunchPlan, LaunchTrigger, LaunchTriggerKind, ResumableLaneState, ResumeCommandState, SessionIdAbsentReason, WorkerRunResult, } from "./delivery.js";
 export { DROPBOX_DIR, INBOX_NAME, appendDropboxMessage, answerDropboxMessage, drainDropbox, dropboxDir, dropboxInboxPath, formatOperatorInstruction, hookAdditionalContextJson, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneIdForAnswerDelivery, operatorMessageRefusalReason, readToolActivity, recordToolActivity, runDrainHook, toolActivityPath, TOOL_ACTIVITY_NAME, } from "./dropbox.js";
 export type { DrainDeps, DrainHookResult, DropboxMessage, ToolActivityRecord, } from "./dropbox.js";
 export { DRAIN_HOOK_BASENAME, DRAIN_HOOK_REGISTRATION_KINDS, DRAIN_HOOK_TIMEOUT_SECONDS, PROVIDER_REGISTRATION_KIND, drainHookCommand, drainHookRegistrationPath, drainHookShPath, installDrainHook, lanesHookAssetsDir, mergeClaudeSettingsHook, mergeCodexConfigHook, probeDrainHookRegistration, renderDrainHookJson, } from "./hooks-install.js";

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

@@ -1,6 +1,9 @@
-import type { LaneRecord, ManagerStatusGateHistoryEntry, QuestionRecord } from "./types.js";
+import { type LaneRecord, type ManagerStatusGateHistoryEntry, type 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_NEXT_CHECK_FLAG = "lanes.keep-alive-next-check-at";
+export declare const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_DEFAULT_ENABLED = false;
+export declare const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS: number;
 export declare const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG = "lanes.keep-alive-resume-blocked";
 export declare const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_DEFAULT_ENABLED = false;
 export declare const LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS: number;
@@ -35,10 +38,17 @@ export type KeepAliveBlockedReason = NonNullable<LaneRecord["keep_alive_blocked_
 export interface KeepAliveDoneEnvelope {
     decision?: string;
     story_complete?: boolean;
+    next_check_at?: string;
 }
-export type DoneKeepAliveVerdict = "eligible" | "standing_idle" | "story_complete";
+export type DoneKeepAliveVerdict = "eligible" | "standing_idle" | "story_complete" | "next_check_at";
+export declare function keepAliveNextCheckAtMs(value: unknown, nowMs: number, anchorMs?: number): number | undefined;
 /** Shared done-state policy used by watch, reconcile, and the show command. */
-export declare function doneKeepAliveVerdict(lane: Pick<LaneRecord, "keep_alive_standing">, envelope: KeepAliveDoneEnvelope, hasQueuedWork: boolean): DoneKeepAliveVerdict | null;
+export declare function doneKeepAliveVerdict(lane: Pick<LaneRecord, "keep_alive_standing">, envelope: KeepAliveDoneEnvelope, hasQueuedWork: boolean, options?: {
+    nextCheckAtEnabled?: boolean;
+    hasPendingWork?: boolean;
+    nowMs?: number;
+    nextCheckAnchorMs?: number;
+}): DoneKeepAliveVerdict | null;
 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;

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

@@ -3,8 +3,12 @@ import * as path from "node:path";
 import { LanesError } from "./errors.js";
 import { dropboxInboxHasMessages } from "./dropbox.js";
 import { appendCappedHistory, listQuestionIds, readQuestion, retryUpdateLane } from "./store.js";
+import { isIsoDateTime } from "./types.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_NEXT_CHECK_FLAG = "lanes.keep-alive-next-check-at";
+export const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_DEFAULT_ENABLED = false;
+export const LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS = 24 * 60 * 60 * 1000;
 export const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_FLAG = "lanes.keep-alive-resume-blocked";
 export const LEAD_LANE_KEEP_ALIVE_RESUME_BLOCKED_DEFAULT_ENABLED = false;
 export const LEAD_LANE_KEEP_ALIVE_BLOCKED_GRACE_MS = 15 * 60 * 1000;
@@ -98,15 +102,35 @@ export function queueManagerStatusGateResume(hqRoot, laneId, entry, resumeText)
 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_BLOCKED_RESUME_TEXT = "You ended blocked with no pending question. Record the event you wait on in waiting_on, re-check each blocker, and continue the next unblocked story.";
 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.";
+export function keepAliveNextCheckAtMs(value, nowMs, anchorMs = nowMs) {
+    if (typeof value !== "string" || !isIsoDateTime(value))
+        return undefined;
+    const parsed = Date.parse(value);
+    if (parsed <= nowMs)
+        return undefined;
+    const stableAnchorMs = Number.isFinite(anchorMs) ? anchorMs : nowMs;
+    const capped = Math.min(parsed, stableAnchorMs + LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_MAX_DELAY_MS);
+    return capped > nowMs ? capped : undefined;
+}
 /** Shared done-state policy used by watch, reconcile, and the show command. */
-export function doneKeepAliveVerdict(lane, envelope, hasQueuedWork) {
+export function doneKeepAliveVerdict(lane, envelope, hasQueuedWork, options = {}) {
     if (envelope.decision !== "done")
         return null;
+    let verdict;
     if (envelope.story_complete !== true)
-        return "eligible";
-    if (lane.keep_alive_standing !== true)
-        return "story_complete";
-    return hasQueuedWork ? "eligible" : "standing_idle";
+        verdict = "eligible";
+    else if (lane.keep_alive_standing !== true)
+        verdict = "story_complete";
+    else
+        verdict = hasQueuedWork ? "eligible" : "standing_idle";
+    if (verdict === "eligible" && options.nextCheckAtEnabled === true && options.hasPendingWork !== true) {
+        const nowMs = options.nowMs ?? Date.now();
+        const anchorMs = options.nextCheckAnchorMs ?? nowMs;
+        const nextCheckAtMs = keepAliveNextCheckAtMs(envelope.next_check_at, nowMs, anchorMs);
+        if (nextCheckAtMs !== undefined)
+            return "next_check_at";
+    }
+    return verdict;
 }
 export function canResumeDoneKeepAliveLane(lane, envelope, hasQueuedWork) {
     return doneKeepAliveVerdict(lane, envelope, hasQueuedWork) === "eligible";

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -105,6 +105,11 @@ export declare function buildOutpostQuestionListCommand(input?: {
 }): string;
 /** Read one question's body and owner-computed audience from its Outpost. */
 export declare function buildOutpostQuestionShowCommand(questionId: string): string;
+/** Cancel an owner-hosted question through the existing questions command. */
+export declare function buildOutpostQuestionCancelCommand(input: {
+    questionId: string;
+    reason: string;
+}): string;
 /** Commit a queued lane move on the host that currently owns its state. */
 export declare function buildOutpostMoveTargetCommand(input: {
     laneId: string;

package/dist/lib/lanes/outpost-dispatch.js

@@ -113,6 +113,18 @@ export function buildOutpostQuestionShowCommand(questionId) {
         questionId,
     ]));
 }
+/** Cancel an owner-hosted question through the existing questions command. */
+export function buildOutpostQuestionCancelCommand(input) {
+    return withRemoteHqDir(joinCommandParts([
+        "hq",
+        "lanes",
+        "questions",
+        "cancel",
+        input.questionId,
+        "--reason",
+        input.reason,
+    ]));
+}
 /** Commit a queued lane move on the host that currently owns its state. */
 export function buildOutpostMoveTargetCommand(input) {
     return withRemoteHqDir(joinCommandParts([

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

@@ -24,6 +24,7 @@ export declare const RECONCILE_LOCK_TIMEOUT_MS = 5000;
 /** A pickup probe that has not cleared its marker within this window is abandoned. */
 export declare const PICKUP_VALIDATION_MAX_AGE_MS: number;
 export declare const PICKUP_VALIDATION_TIMEOUT_REASON: "pickup_validation_timeout";
+export declare const CLOSE_INTERRUPTED_DONE_STORY_WORKERS_FLAG = "lanes.close-interrupted-done-story-workers";
 export declare const RECONCILE_UNIT_NAME = "hq-lanes-reconcile.service";
 export declare const RECONCILE_TIMER_NAME = "hq-lanes-reconcile.timer";
 export interface ReconcileSkip {