@indigoai-us/hq-cli 5.315.0 → 5.317.0

package/dist/commands/lanes.js

@@ -45,7 +45,7 @@ import { createOutpostProfileRepinContext, parseOutpostProfileRepinContext, } fr
 import { createOutpostRegistryWorkerApprovalContext, parseOutpostRegistryWorkerApprovalContext, } from "../lib/lanes/outpost-registry-worker-approval.js";
 import { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
-import { buildOutpostCapacityCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostQuestionListCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, REMOTE_LANE_READ_ENV, outpostRejectedEffortOption, parseOutpostPickupPayload, PICKUP_WAIT_MS, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { buildOutpostCapacityCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostQuestionListCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, buildOutpostLegacyLaneUlidListCommand, REMOTE_LANE_READ_ENV, outpostRejectedEffortOption, parseOutpostPickupPayload, PICKUP_WAIT_MS, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
 import { outpostHireSummaryCacheKey, OUTPOST_HIRE_SUMMARY_CACHE_TTL_MS, readOutpostHireSummaryCache, readOutpostHireSummaryCacheIncludingStale, writeOutpostHireSummaryCache, } from "../lib/lanes/outpost-hire-cache.js";
 import { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "../lib/lanes/host-capacity.js";
 import { BALANCE_MOVABLE_STATES, selectClaudeAccount, } from "../lib/lanes/claude-balance.js";
@@ -781,6 +781,7 @@ function validateOwnerLaneHireSummary(input) {
 function laneListQueryFlags(query) {
     return [
         ...(query.laneIds?.length ? ["--lane"] : []),
+        ...(query.laneUlids?.length ? ["--lane-ulid"] : []),
         ...(query.active ? ["--active"] : []),
         ...(query.hierarchy?.length ? ["--hierarchy"] : []),
         ...(query.snapshot ? ["--snapshot"] : []),
@@ -804,6 +805,14 @@ async function dispatchOutpostLaneList(ctx, outpostId, query, timeoutSeconds, wa
     });
     if (query.strictSnapshot || !rejectedLaneListFlag(filtered, query))
         return filtered;
+    if (rejectedLaneListFlag(filtered, query) === "--lane-ulid" && query.laneUlids?.length === 1) {
+        return ctx.dispatchOutpostExec({
+            outpostId,
+            command: buildOutpostLegacyLaneUlidListCommand({ hqBinary, ulid: query.laneUlids[0] }),
+            timeoutSeconds,
+            waitMs,
+        });
+    }
     return ctx.dispatchOutpostExec({
         outpostId,
         command: buildOutpostLaneListCommand({ hqBinary }),
@@ -1206,15 +1215,20 @@ async function loadHostCapacitySnapshots(ctx, hqRoot, config = loadLanesConfig(h
     };
 }
 const outpostLaneListMemo = new WeakMap();
+const MAX_OUTPOST_LANE_LIST_BYTES = 480 * 1024;
 function normalizedLaneListQuery(query) {
     const laneIds = query.laneIds === undefined
         ? undefined
         : [...new Set(query.laneIds)].sort((a, b) => a.localeCompare(b));
+    const laneUlids = query.laneUlids === undefined
+        ? undefined
+        : [...new Set(query.laneUlids.map((ulid) => ulid.toUpperCase()))].sort((a, b) => a.localeCompare(b));
     const hierarchy = query.hierarchy === undefined
         ? undefined
         : [...new Set(query.hierarchy)].sort((a, b) => a.localeCompare(b));
     return {
         ...(laneIds === undefined ? {} : { laneIds }),
+        ...(laneUlids === undefined ? {} : { laneUlids }),
         ...(query.active ? { active: true } : {}),
         ...(hierarchy === undefined ? {} : { hierarchy }),
         ...(query.snapshot ? { snapshot: true } : {}),
@@ -1223,7 +1237,7 @@ function normalizedLaneListQuery(query) {
     };
 }
 async function readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOptions = {}) {
-    const targetedLookup = query.hierarchy !== undefined || query.laneIds !== undefined;
+    const targetedLookup = query.hierarchy !== undefined || query.laneIds !== undefined || query.laneUlids !== undefined;
     const waitMs = targetedLookup ? outpostSingleLaneWaitMs(ctx.env) : CAPACITY_PROBE_TIMEOUT_MS;
     const dispatchWaitMs = dispatchOptions.waitMs ?? waitMs;
     const dispatchTimeoutSeconds = dispatchOptions.timeoutSeconds ?? Math.ceil(dispatchWaitMs / 1000);
@@ -1249,6 +1263,10 @@ async function readOutpostLaneRecordsUncached(ctx, outpostId, query, dispatchOpt
             exit_code: result.exitCode,
         });
     }
+    const stdoutBytes = Buffer.byteLength(result.stdout, "utf8");
+    if (stdoutBytes >= MAX_OUTPOST_LANE_LIST_BYTES) {
+        throw new LanesError("outpost_lane_list_too_large", `Outpost ${outpostId} lane-list response reached the ${Math.floor(MAX_OUTPOST_LANE_LIST_BYTES / 1024)} KiB Outpost exec output limit`, { outpost_id: outpostId, command_id: result.commandId, stdout_bytes: stdoutBytes });
+    }
     let body;
     try {
         body = JSON.parse(result.stdout);
@@ -1625,7 +1643,7 @@ async function resolveCommandLaneTarget(ctx, laneId, options = {}) {
         let ownerLanes;
         try {
             ownerLanes = await readOutpostLaneRecords(ctx, outpostId, hostlessUlidLookup
-                ? { snapshot: true }
+                ? { laneUlids: [requestedUlid], snapshot: true }
                 : { hierarchy: [laneId], snapshot: true });
             probedOutpostIds.push(outpostId);
         }
@@ -4849,6 +4867,12 @@ async function runList(ctx, opts) {
         new Set(requestedLaneIds).size !== requestedLaneIds.length) {
         throw new LanesError("lane_list_filter_invalid", "--lane must be repeated with distinct, non-empty lane ids", { lane_ids: requestedLaneIds });
     }
+    const requestedLaneUlids = opts.laneUlid ?? [];
+    if (!Array.isArray(requestedLaneUlids) ||
+        requestedLaneUlids.some((ulid) => typeof ulid !== "string" || laneUlidPart(ulid) !== ulid.toUpperCase()) ||
+        new Set(requestedLaneUlids.map((ulid) => ulid.toUpperCase())).size !== requestedLaneUlids.length) {
+        throw new LanesError("lane_list_ulid_filter_invalid", "--lane-ulid must be repeated with distinct 26-character ULIDs", { lane_ulids: requestedLaneUlids });
+    }
     if (opts.hierarchy !== undefined &&
         (!Array.isArray(opts.hierarchy) || opts.hierarchy.length === 0 ||
             opts.hierarchy.some((laneId) => typeof laneId !== "string" || !laneId.trim() || laneId.trim() !== laneId) ||
@@ -4869,11 +4893,13 @@ async function runList(ctx, opts) {
         company = await ctx.resolveCompany(opts.company);
     }
     const requestedIds = new Set(requestedLaneIds);
-    const canReadOnlyRequestedIds = opts.snapshot && requestedLaneIds.length > 0 &&
+    const requestedUlidSet = new Set(requestedLaneUlids.map((ulid) => ulid.toUpperCase()));
+    const canReadOnlyRequestedIds = opts.snapshot && (requestedLaneIds.length > 0 || requestedLaneUlids.length > 0) &&
         !opts.active && opts.hierarchy === undefined;
     const laneSource = canReadOnlyRequestedIds
         ? listLaneIds(hqRoot)
-            .filter((laneId) => requestedIds.has(laneId))
+            .filter((laneId) => requestedIds.has(laneId) ||
+            (laneUlidPart(laneId) !== undefined && requestedUlidSet.has(laneUlidPart(laneId))))
             .map((laneId) => readLane(hqRoot, laneId))
         : loadAllLanes(hqRoot);
     const hierarchyIds = opts.hierarchy === undefined
@@ -4882,6 +4908,8 @@ async function runList(ctx, opts) {
     const matchesLaneFilters = (lane, includeState) => {
         if (requestedLaneIds.length > 0 && !requestedIds.has(lane.lane_id))
             return false;
+        if (requestedUlidSet.size > 0 && !requestedUlidSet.has(laneUlidPart(lane.lane_id) ?? ""))
+            return false;
         if (includeState && opts.active && isTerminalLaneState(lane.state))
             return false;
         if (hierarchyIds && !hierarchyIds.has(lane.lane_id))
@@ -8424,6 +8452,8 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--state <state>", `Filter by state (${LANE_STATES.join("|")})`)
         .option("--senior <ref>", "Filter by senior ref")
         .option("--lane <id>", "Filter by lane id (repeatable)", (value, previous = []) => [...previous, value], [])
+        .addOption(new Option("--lane-ulid <ulid>", "Filter by lane ULID for internal owner lookup").hideHelp()
+        .argParser((value, previous = []) => [...previous, value]))
         .option("--active", "Include only lanes that are not terminal")
         .addOption(new Option("--hierarchy <lane-id>").hideHelp()
         .argParser((value, previous = []) => [...previous, value]))

package/dist/fast-core.d.ts

@@ -6,6 +6,7 @@
  * entries use the bundled-script runner; native entries import their one handler
  * module. The registration in `core.ts` remains the complete fallback path.
  */
+export declare function readStdinIfPiped(stream: NodeJS.ReadStream): Promise<string>;
 /**
  * Run the fast-path core command named in `argv` and exit with its code.
  * Only call when {@link isFastCoreRequest} is true; a non-match returns without

package/dist/fast-core.js

@@ -9,6 +9,14 @@
 import { resolveLiveRoot } from "./utils/hq-roots.js";
 import { runBundledScript } from "./utils/run-bundled-script.js";
 import { parseFastCore } from "./fast-scaffold.js";
+export async function readStdinIfPiped(stream) {
+    if (stream.isTTY)
+        return "";
+    const chunks = [];
+    for await (const chunk of stream)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString("utf8");
+}
 /**
  * Run the fast-path core command named in `argv` and exit with its code.
  * Only call when {@link isFastCoreRequest} is true; a non-match returns without
@@ -60,12 +68,8 @@ export async function runFastCore(argv) {
             throw new Error(`Native fast handler ${entry.exportName} was not exported`);
         }
         const readsStdin = entry.readsStdinFor?.(parsed.args) ?? entry.readsStdin ?? false;
-        const chunks = [];
-        if (readsStdin) {
-            for await (const chunk of process.stdin)
-                chunks.push(chunk);
-        }
-        const code = await handler(parsed.args, readsStdin ? Buffer.concat(chunks).toString("utf8") : "", process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg);
+        const stdin = readsStdin ? await readStdinIfPiped(process.stdin) : "";
+        const code = await handler(parsed.args, stdin, process.cwd(), hqRoot, entry.name.split(" ").at(-1) ?? entry.name, parsed.hqRootArg);
         // Let Node drain handler output before terminating. The timeout guard's
         // stderr message must survive the native route's process boundary.
         process.exitCode = code;

package/dist/fast-scaffold.js

@@ -172,6 +172,23 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellCwd: "caller",
         shellHqRoot: name === "reconcile" ? "reconcile-default" : "none",
     })),
+    ...["share-suggestion-state", "repo-run-registry", "detect-stale-review-base"].map((name) => ({
+        name,
+        kind: "native",
+        modulePath: "./commands/core-hook-state-helpers-native.js",
+        exportName: name === "share-suggestion-state"
+            ? "runShareSuggestionStateFast"
+            : name === "repo-run-registry"
+                ? "runRepoRunRegistryFast"
+                : "runDetectStaleReviewBaseFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-hook-helpers",
+        asset: `core/scripts/${name}.sh`,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+        ...(name === "share-suggestion-state" ? { readsStdin: true } : {}),
+    })),
     {
         name: "resolve-company",
         kind: "native",
@@ -184,6 +201,22 @@ export const FAST_SCAFFOLD_SCRIPTS = [
         shellCwd: "live",
         shellHqRoot: "live",
     },
+    ...["session-journal", "session-project", "session-title", "session-title-config"].map((name) => ({
+        name,
+        kind: "native",
+        modulePath: `./commands/core-${name}-native.js`,
+        exportName: name === "session-journal" ? "runSessionJournalFast"
+            : name === "session-project" ? "runSessionProjectFast"
+                : name === "session-title" ? "runSessionTitleFast"
+                    : "runSessionTitleConfigFast",
+        flagKey: "hq-core-native-fast-route",
+        familyFlagKey: "core-native-hook-helpers",
+        asset: `core/scripts/${name}.sh`,
+        root: "live",
+        shellCwd: "live",
+        shellHqRoot: "live",
+        ...(name === "session-project" ? { readsStdin: true, readsStdinFor: (args) => args[0] === "ingest-plan" } : {}),
+    })),
     ...[
         { name: "eval-trigger", modulePath: "./commands/core-eval-trigger-native.js", exportName: "runEvalTriggerFast", asset: "core/scripts/eval-trigger.sh", root: "cwd", shellCwd: "caller", shellHqRoot: "none", readsStdinFor: (args) => args[0] === "--check" },
         { name: "migrate-policy-triggers", modulePath: "./commands/core-migrate-policy-triggers-native.js", exportName: "runMigratePolicyTriggersFast", asset: "core/scripts/migrate-policy-triggers.sh", root: "live", shellCwd: "caller", shellHqRoot: "live" },

package/dist/lib/bot/job-quiet-flag.d.ts

@@ -0,0 +1,4 @@
+/** Default-off rollout gate for per-job quiet success delivery. */
+export declare const BOT_JOB_QUIET_OPTION_FLAG = "cli.bot-job-quiet-option";
+export declare function botJobQuietOptionEnabled(): Promise<boolean>;
+//# sourceMappingURL=job-quiet-flag.d.ts.map

package/dist/lib/bot/job-quiet-flag.js

@@ -0,0 +1,14 @@
+/** Default-off rollout gate for per-job quiet success delivery. */
+export const BOT_JOB_QUIET_OPTION_FLAG = "cli.bot-job-quiet-option";
+export async function botJobQuietOptionEnabled() {
+    try {
+        const { resolveProcessFlagGate } = await import("../flag-registry.js");
+        return resolveProcessFlagGate(BOT_JOB_QUIET_OPTION_FLAG, { fallback: false }, () => false);
+    }
+    catch (error) {
+        const errorClass = error instanceof Error ? error.name : "unknown";
+        console.warn(`hq: Could not resolve ${BOT_JOB_QUIET_OPTION_FLAG} (${errorClass}); quiet jobs stay disabled.`);
+        return false;
+    }
+}
+//# sourceMappingURL=job-quiet-flag.js.map

package/dist/lib/bot/job-run.d.ts

@@ -20,6 +20,9 @@
  * Everything in this file is pure so the rules are unit-testable.
  */
 import type { InboxItem } from "./api.js";
+/** Private metadata persisted in the job's existing opaque context object. */
+export declare const JOB_RUN_OPTIONS_CONTEXT_KEY = "__hq_cli_job_options_v1";
+export declare function isQuietJobContext(context: unknown): boolean;
 /** The job fields an inbox item carries when `channel === "job"`. */
 export interface JobRunFields {
     jobId: string;
@@ -32,6 +35,8 @@ export interface JobRunFields {
     /** Delivery deadline (ISO-8601); past it, this is a catch-up. */
     staleAfter?: string;
     requestId?: string;
+    /** Whether successful runs should be silent when the local rollout flag is on. */
+    quiet?: boolean;
 }
 export declare function isJobItem(item: Pick<InboxItem, "channel">): boolean;
 /**

package/dist/lib/bot/job-run.js

@@ -19,6 +19,25 @@
  *
  * Everything in this file is pure so the rules are unit-testable.
  */
+/** Private metadata persisted in the job's existing opaque context object. */
+export const JOB_RUN_OPTIONS_CONTEXT_KEY = "__hq_cli_job_options_v1";
+function objectRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+export function isQuietJobContext(context) {
+    const options = objectRecord(objectRecord(context)?.[JOB_RUN_OPTIONS_CONTEXT_KEY]);
+    return options?.quiet === true;
+}
+function visibleJobContext(context) {
+    if (!(JOB_RUN_OPTIONS_CONTEXT_KEY in context)) {
+        return Object.keys(context).length ? context : null;
+    }
+    const visible = { ...context };
+    delete visible[JOB_RUN_OPTIONS_CONTEXT_KEY];
+    return Object.keys(visible).length ? visible : null;
+}
 export function isJobItem(item) {
     return item.channel === "job";
 }
@@ -37,6 +56,7 @@ export function readJobRun(item) {
     return {
         jobId,
         prompt,
+        ...(isQuietJobContext(item.context) ? { quiet: true } : {}),
         ...(item.context !== undefined && item.context !== null ? { context: item.context } : {}),
         ...(typeof item.script === "string" && item.script.trim() ? { script: item.script } : {}),
         ...(typeof item.firedAt === "string" && item.firedAt.trim() ? { firedAt: item.firedAt.trim() } : {}),
@@ -51,10 +71,10 @@ export function jobContextText(context) {
     if (typeof context === "string")
         return context.trim() || null;
     try {
-        const keys = Object.keys(context);
-        if (keys.length === 0)
+        const visible = visibleJobContext(context);
+        if (!visible)
             return null;
-        return JSON.stringify(context, null, 2);
+        return JSON.stringify(visible, null, 2);
     }
     catch {
         return null;

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

@@ -120,6 +120,8 @@ export interface BotRunDeps {
     inboxIntervalMs?: number;
     /** Cached, default-off reader for the local inbox polling gate. */
     inboxPollBackoffEnabled?: () => Promise<boolean>;
+    /** Default-off gate for the per-job quiet-success option. */
+    jobQuietOptionEnabled?: () => boolean | Promise<boolean>;
     heartbeatIntervalMs?: number;
     /** Override the rendered system prompt (tests). */
     systemPromptOverride?: string;

package/dist/lib/bot/run.js

@@ -69,6 +69,7 @@ import { attachmentTurnBlock, downloadTurnAttachments } from "./attachments.js";
 import { inboxEntryAttachments } from "../agent-kit/inbox-state.js";
 import { isAgentSender, isDmItem, isMetaNonReply, resolveReplyTarget } from "./room-policy.js";
 import { buildJobTurnPrompt, isCatchUpRun, isJobItem, jobReportHeader, jobRunOutput, machineTimeZone, planJobRuns, stripJobHeader, SUPERSEDED_DISPOSITION } from "./job-run.js";
+import { botJobQuietOptionEnabled } from "./job-quiet-flag.js";
 import { clearPendingJobCompletion, isCompletionDue, isCompletionExpired, isCompletionForOtherAgent, readPendingJobCompletions, recordPendingJobCompletion } from "./job-completions.js";
 import { isRuntimeSignInFailure, SIGN_IN_RETRY_MS, signInNeededText } from "./runtime-sign-in.js";
 import { HQ_BOT_AGENT_UID_ENV } from "../../commands/onboard-bot-membership.js";
@@ -277,6 +278,7 @@ export async function runBot(deps) {
     const runTurn = deps.runTurn ?? ((rt, input) => runRuntimeTurn(rt, input));
     const inboxIntervalMs = deps.inboxIntervalMs ?? INBOX_POLL_INTERVAL_MS;
     const inboxPollBackoffEnabled = deps.inboxPollBackoffEnabled ?? createInboxPollBackoffFlagReader(config);
+    const jobQuietOptionEnabled = deps.jobQuietOptionEnabled ?? botJobQuietOptionEnabled;
     const heartbeatIntervalMs = deps.heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS;
     const exit = deps.exit ?? ((code) => process.exit(code));
     const fallback = () => defaultBotStatus(pid, config.runtime, now);
@@ -763,7 +765,7 @@ export async function runBot(deps) {
             ...(isSetupBot ? { dropPreToolMessages: true } : {}),
             ...deps.progress,
             ...(args.workingNotice === false || silenceable || isSetupBot ? { workingNoticeMs: 0 } : {}),
-            ...(silenceable ? { buffer: true } : {}),
+            ...(silenceable || args.suppressOutput ? { buffer: true } : {}),
             send: makeSendFn(args.send),
             ...(args.sendFinal ? { sendFinal: makeSendFn(args.sendFinal) } : {}),
         });
@@ -788,6 +790,11 @@ export async function runBot(deps) {
             // meta chatter that let two bots loop on 2026-09-25.
             const stayQuiet = silenceable && isMetaNonReply(turn.text);
             const sentinelOrEmpty = containsNoReplySentinel(turn.text) || !turn.text.trim() || stayQuiet;
+            if (args.suppressOutput) {
+                await poster.abandon();
+                const finalText = sentinelOrEmpty ? "" : turn.text;
+                return { outcome: { ok: true, reply: finalText.trim(), ...(sentinelOrEmpty ? { silent: true } : {}) }, poster };
+            }
             // Unmentioned room turn: a no_reply sentinel (bare, fenced, or with
             // preamble), an empty/whitespace reply, or a stay-quiet phrase means stay
             // quiet. Abandon the poster (it posts nothing) and return a silent outcome;
@@ -1182,6 +1189,7 @@ export async function runBot(deps) {
             return;
         }
         const catchUp = isCatchUpRun(job, now());
+        const quietJob = target.job.quiet === true && await jobQuietOptionEnabled();
         const attempt = (attempts.get(id) ?? 0) + 1;
         attempts.set(id, attempt);
         const tReceived = now().getTime();
@@ -1268,9 +1276,10 @@ export async function runBot(deps) {
             sendFinal,
             // A scheduled run has nobody waiting in a chat: no "working on it" filler.
             workingNotice: false,
+            ...(quietJob ? { suppressOutput: true } : {}),
         });
         if (outcome.ok) {
-            if (!reportDelivered(outcome.reply)) {
+            if (!quietJob && !reportDelivered(outcome.reply)) {
                 // The work finished but the REPORT did not fully reach the DM — even if
                 // a progress post did. Keep it (and the run un-reported and un-acked)
                 // so the next poll delivers it, resuming at the parts already read,
@@ -1285,7 +1294,10 @@ export async function runBot(deps) {
             await api.ackInbox(config.agentUid, id);
             clearInflight(dir, id);
             attempts.delete(id);
-            setStatus({ repliesSent: (readStatus()?.repliesSent ?? 0) + 1, lastActivityAt: now().toISOString() });
+            setStatus({
+                ...(!quietJob ? { repliesSent: (readStatus()?.repliesSent ?? 0) + 1 } : {}),
+                lastActivityAt: now().toISOString(),
+            });
             log("info", `job ${jobId} run ${id} done (${outcome.reply.length} chars${catchUp ? ", catch-up" : ""})`);
             return;
         }

package/dist/lib/core-utils/common.d.ts

@@ -10,5 +10,4 @@ export declare function command(command: string, args: string[], cwd?: string):
     stdout: string;
     stderr: string;
 };
-export declare function exists(pathname: string): boolean;
 //# sourceMappingURL=common.d.ts.map

package/dist/lib/core-utils/common.js

@@ -1,5 +1,4 @@
 import { spawnSync } from "node:child_process";
-import * as fs from "node:fs";
 export function ioFor(io = {}) {
     return {
         stdout: io.stdout ?? ((text) => process.stdout.write(text)),
@@ -39,12 +38,4 @@ export function command(command, args, cwd) {
     }
     return { status: result.status ?? 1, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }
-export function exists(pathname) {
-    try {
-        return Boolean(fs.lstatSync(pathname));
-    }
-    catch {
-        return false;
-    }
-}
 //# sourceMappingURL=common.js.map

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

@@ -13,6 +13,7 @@ export declare const LEAD_AUTOPILOT_REVIEW_DELAY_MS: number;
 export declare const LEAD_AUTOPILOT_FILL_DELAY_MS: number;
 export declare const LEAD_AUTOPILOT_PROMPT_LOOP = "personal/knowledge/team-lead-operating-loop.md";
 export declare const LEAD_AUTOPILOT_KPI_STALE_AFTER_MINUTES = 55;
+export declare const LEAD_AUTOPILOT_HEADLINE_STALE_AFTER_MINUTES = 55;
 export declare const LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG = "lanes.autopilot-per-lead-errors";
 export declare const LEAD_AUTOPILOT_PER_LEAD_ERRORS_DEFAULT_ENABLED = false;
 export interface RegisteredLead {
@@ -22,7 +23,7 @@ export interface RegisteredLead {
     status: string;
     prd: string;
 }
-export type AutopilotCondition = "review_finished_worker" | "fill_grant" | "plan_free_slots" | "flat_kpi" | "stale_kpi" | "blocker_record_needs_update" | "project_ready_to_close" | "stale_worker_ledger" | "story_without_live_lane" | "missed_deadline";
+export type AutopilotCondition = "review_finished_worker" | "fill_grant" | "plan_free_slots" | "flat_kpi" | "stale_kpi" | "stale_headline" | "blocker_record_needs_update" | "project_ready_to_close" | "stale_worker_ledger" | "story_without_live_lane" | "missed_deadline";
 export interface AutopilotWake {
     condition: AutopilotCondition;
     lead_lane: string;
@@ -31,6 +32,8 @@ export interface AutopilotWake {
     prompt: string;
     fingerprint: string;
     kpi_id?: string;
+    /** Headline episode represented inside the KPI batch notice, if any. */
+    headline_fingerprint?: string;
 }
 export interface AutopilotKpiStatus {
     lead_lane: string;
@@ -109,6 +112,7 @@ export declare function planLeadAutopilotWakes(input: {
     keepAliveResumed?: boolean;
     kpiStalenessEnabled?: boolean;
     kpiStalenessBatchEnabled?: boolean;
+    headlineStalenessEnabled?: boolean;
 }): AutopilotWake[];
 export declare function runLeadAutopilotPass(input: {
     hqRoot: string;

package/dist/lib/lanes/autopilot.js

@@ -6,7 +6,7 @@ import { isControllerAliasOutpostId } from "./admission-host.js";
 import { LEAD_REGISTRY_REL, validateOutpostLeadRegistry } from "./autopilot-registry.js";
 import { appendDropboxMessage } from "./dropbox.js";
 import { LanesError } from "./errors.js";
-import { LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG, LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG, LEAD_AUTOPILOT_KPI_STALENESS_BATCH_FLAG, LEAD_AUTOPILOT_KPI_STALENESS_FLAG, LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG as PER_LEAD_ERRORS_FLAG, } from "./flag-keys.js";
+import { LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG, LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG, LEAD_AUTOPILOT_KPI_STALENESS_BATCH_FLAG, LEAD_AUTOPILOT_KPI_STALENESS_FLAG, LEAD_AUTOPILOT_HEADLINE_STALENESS_FLAG, LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG as PER_LEAD_ERRORS_FLAG, } from "./flag-keys.js";
 import { resolveLaneCompany } from "./lane-company.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
 import { readAllLanes } from "./store.js";
@@ -24,6 +24,7 @@ export const LEAD_AUTOPILOT_REVIEW_DELAY_MS = 15 * 60_000;
 export const LEAD_AUTOPILOT_FILL_DELAY_MS = 15 * 60_000;
 export const LEAD_AUTOPILOT_PROMPT_LOOP = "personal/knowledge/team-lead-operating-loop.md";
 export const LEAD_AUTOPILOT_KPI_STALE_AFTER_MINUTES = 55;
+export const LEAD_AUTOPILOT_HEADLINE_STALE_AFTER_MINUTES = 55;
 export const LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG = PER_LEAD_ERRORS_FLAG;
 export const LEAD_AUTOPILOT_PER_LEAD_ERRORS_DEFAULT_ENABLED = false;
 const LIVE_STATES = new Set(["running", "queued", "awaiting_input", "blocked"]);
@@ -414,6 +415,33 @@ function managerKpiFreshness(status, now) {
         };
     });
 }
+function managerHeadlineFreshness(status, now) {
+    let field;
+    let rawTimestamp;
+    if (typeof status.headline_at === "string" && status.headline_at.trim()) {
+        field = "headline_at";
+        rawTimestamp = status.headline_at;
+    }
+    else if (status.headline_at === undefined || status.headline_at === null) {
+        if (typeof status.now !== "string")
+            return undefined;
+        const prefix = status.now.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2}))/)?.[1];
+        if (!prefix)
+            return undefined;
+        field = "now";
+        rawTimestamp = prefix;
+    }
+    else {
+        return undefined;
+    }
+    const timestamp = Date.parse(rawTimestamp);
+    if (!Number.isFinite(timestamp))
+        return undefined;
+    const ageMinutes = Math.floor(Math.max(0, now.getTime() - timestamp) / 60_000);
+    if (now.getTime() - timestamp <= LEAD_AUTOPILOT_HEADLINE_STALE_AFTER_MINUTES * 60_000)
+        return undefined;
+    return { field, measuredAt: new Date(timestamp).toISOString(), ageMinutes };
+}
 function leastMoved(lines, priorLines = []) {
     const priorById = new Map(priorLines.map((line) => [line.id, line]));
     return [...lines].sort((a, b) => {
@@ -431,6 +459,19 @@ export function planLeadAutopilotWakes(input) {
     const blockers = statusBlockers(status);
     const byStory = new Map(stories.map((story) => [story.id, story]));
     const wakes = [];
+    if (input.headlineStalenessEnabled && !(lead.story_status === "done" && lead.story_complete === true)) {
+        const headline = managerHeadlineFreshness(status, now);
+        if (headline) {
+            const fingerprint = `stale-headline:${createHash("sha256").update(JSON.stringify([headline.field, headline.measuredAt])).digest("hex")}`;
+            wakes.push({
+                condition: "stale_headline",
+                lead_lane: lead.lane_id,
+                story_id: "headline-staleness",
+                fingerprint,
+                prompt: `The dashboard ${headline.field} field is ${headline.ageMinutes} minutes old. Rewrite headline, headline_at, and now in manager-status.json so the team status is current. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.`,
+            });
+        }
+    }
     if (input.kpiStalenessEnabled) {
         const staleKpis = managerKpiFreshness(status, now).filter((kpi) => kpi.stale);
         if (input.kpiStalenessBatchEnabled && staleKpis.length > 0) {
@@ -748,6 +789,7 @@ async function runLeadAutopilotPassUnlocked(input) {
             const status = readStatus(hqRoot, registered.status, company.slug);
             const kpiStalenessEnabled = await (input.readFlag ?? readLanesRegistryFlag)(LEAD_AUTOPILOT_KPI_STALENESS_FLAG, { company });
             const kpiStalenessBatchEnabled = kpiStalenessEnabled && await (input.readFlag ?? readLanesRegistryFlag)(LEAD_AUTOPILOT_KPI_STALENESS_BATCH_FLAG, { company });
+            const headlineStalenessEnabled = await (input.readFlag ?? readLanesRegistryFlag)(LEAD_AUTOPILOT_HEADLINE_STALENESS_FLAG, { company });
             if (kpiStalenessEnabled) {
                 result.kpi_status ??= [];
                 result.kpi_status.push(...managerKpiFreshness(status, now).map((kpi) => ({
@@ -772,7 +814,7 @@ async function runLeadAutopilotPassUnlocked(input) {
             if (nudgeDedupeEnabled && pruneDeliveredIds(state, now))
                 stateChanged = true;
             currentInputPath = registered.status;
-            const planned = planLeadAutopilotWakes({
+            let planned = planLeadAutopilotWakes({
                 lead,
                 children,
                 stories,
@@ -780,10 +822,26 @@ async function runLeadAutopilotPassUnlocked(input) {
                 managerStatus: status,
                 kpiStalenessEnabled,
                 kpiStalenessBatchEnabled,
+                headlineStalenessEnabled,
                 keepAliveResumed: input.keepAliveResumedLeads?.has(lead.lane_id) === true,
             });
+            if (kpiStalenessBatchEnabled) {
+                const batch = planned.find((wake) => wake.condition === "stale_kpi" && wake.kpi_id === "batch");
+                const headline = planned.find((wake) => wake.condition === "stale_headline");
+                if (batch && headline) {
+                    const priorHeadline = state.sent[`${lead.lane_id}:stale_headline`];
+                    if (priorHeadline?.fingerprint !== headline.fingerprint) {
+                        batch.prompt += `\n\n${headline.prompt}`;
+                        batch.headline_fingerprint = headline.fingerprint;
+                    }
+                    planned = planned.filter((wake) => wake !== headline);
+                }
+            }
             const stateKey = (wake) => `${lead.lane_id}:${wake.condition}${wake.condition === "stale_kpi" ? `:${wake.kpi_id}` : ""}`;
-            const activeKeys = new Set(planned.map(stateKey));
+            const activeKeys = new Set(planned.flatMap((wake) => [
+                stateKey(wake),
+                ...(wake.headline_fingerprint ? [`${lead.lane_id}:stale_headline`] : []),
+            ]));
             const suppressedKeys = new Set();
             for (const key of Object.keys(state.sent)) {
                 if (!key.startsWith(`${lead.lane_id}:`))
@@ -890,6 +948,8 @@ async function runLeadAutopilotPassUnlocked(input) {
                     // repeated wake/escalation cadence used by other conditions.
                     if (wake.condition === "stale_kpi")
                         continue;
+                    if (wake.condition === "stale_headline")
+                        continue;
                     const redeliveryDelay = nudgeDedupeEnabled ? LEAD_AUTOPILOT_NUDGE_REDELIVERY_DELAY_MS : LEAD_AUTOPILOT_FILL_DELAY_MS;
                     if (!current.acted && !current.auto_started && current.escalated_at === undefined && now.getTime() - lastWakeAt >= redeliveryDelay) {
                         const wakeCount = current.wake_count ?? 1;
@@ -931,6 +991,15 @@ async function runLeadAutopilotPassUnlocked(input) {
                         wake_count: 1,
                         last_wake_at: now.toISOString(),
                     };
+                    if (wake.headline_fingerprint) {
+                        state.sent[`${lead.lane_id}:stale_headline`] = {
+                            fingerprint: wake.headline_fingerprint,
+                            at: now.toISOString(),
+                            ...(statusUpdatedAt ? { status_updated_at: statusUpdatedAt } : {}),
+                            wake_count: 1,
+                            last_wake_at: now.toISOString(),
+                        };
+                    }
                     stateChanged = true;
                     if (!delivered)
                         continue;

package/dist/lib/lanes/disk-guard.d.ts

@@ -3,10 +3,8 @@ import { type ReadLanesFlagOptions } from "./registry-flag.js";
 import type { LaneRecord, LanesConfig } from "./types.js";
 export declare const LOW_DISK_GUARD_FLAG = "lanes.low-disk-guard";
 export declare const CODEX_ROLLOUT_RETENTION_FLAG = "lanes.codex-rollout-retention";
-export declare const DEFAULT_LOW_DISK_FREE_BYTES: number;
-export declare const DEFAULT_LOW_DISK_FRACTION = 0.02;
 export declare function lowDiskGuardEnabledForLane(hqRoot: string, lane: LaneRecord, readFlag?: (key: string, options: ReadLanesFlagOptions) => Promise<boolean>): Promise<boolean>;
-export interface DiskStats {
+interface DiskStats {
     bsize: number;
     blocks: number;
     bavail: number;
@@ -25,7 +23,7 @@ export declare function checkLaneDiskSpace(hqRoot: string, providerHome: string,
     hq: DiskSpaceMeasurement;
     provider: DiskSpaceMeasurement;
 };
-export interface RolloutLane {
+interface RolloutLane {
     provider: string;
     state: string;
     provider_session_id?: string;
@@ -63,4 +61,5 @@ export interface RolloutRetentionResult {
 export declare function configuredCodexRolloutHomes(hqRoot: string, config: LanesConfig, hostname: string): string[];
 /** Operates only on rollout files under configured Codex `sessions/` trees. */
 export declare function retainCodexRollouts(options: RolloutRetentionOptions): Promise<RolloutRetentionResult>;
+export {};
 //# sourceMappingURL=disk-guard.d.ts.map

package/dist/lib/lanes/disk-guard.js

@@ -9,8 +9,8 @@ import { effectiveAccountHome } from "./account-home.js";
 import { lanesConfigPath } from "./config.js";
 export const LOW_DISK_GUARD_FLAG = "lanes.low-disk-guard";
 export const CODEX_ROLLOUT_RETENTION_FLAG = "lanes.codex-rollout-retention";
-export const DEFAULT_LOW_DISK_FREE_BYTES = 5 * 1024 ** 3;
-export const DEFAULT_LOW_DISK_FRACTION = 0.02;
+const DEFAULT_LOW_DISK_FREE_BYTES = 5 * 1024 ** 3;
+const DEFAULT_LOW_DISK_FRACTION = 0.02;
 const EXCLUDED_SESSION_FILES = new Set(["auth.json", ".credentials.json", "thread_history.sqlite"]);
 export async function lowDiskGuardEnabledForLane(hqRoot, lane, readFlag = readLanesRegistryFlag) {
     const company = resolveLaneCompany(hqRoot, lane).company;

package/dist/lib/lanes/flag-keys.d.ts

@@ -19,4 +19,7 @@ export declare const LEAD_AUTOPILOT_PER_LEAD_ERRORS_DEFAULT_ENABLED = false;
 /** Batches stale manager-status KPI notices into one lead message per pass. */
 export declare const LEAD_AUTOPILOT_KPI_STALENESS_BATCH_FLAG = "lanes.autopilot-kpi-staleness-batch";
 export declare const LEAD_AUTOPILOT_KPI_STALENESS_BATCH_DEFAULT_ENABLED = false;
+/** Enables staleness notices for a registered lead's dashboard headline. */
+export declare const LEAD_AUTOPILOT_HEADLINE_STALENESS_FLAG = "lanes.autopilot-headline-staleness";
+export declare const LEAD_AUTOPILOT_HEADLINE_STALENESS_DEFAULT_ENABLED = false;
 //# sourceMappingURL=flag-keys.d.ts.map

package/dist/lib/lanes/flag-keys.js

@@ -19,4 +19,7 @@ export const LEAD_AUTOPILOT_PER_LEAD_ERRORS_DEFAULT_ENABLED = false;
 /** Batches stale manager-status KPI notices into one lead message per pass. */
 export const LEAD_AUTOPILOT_KPI_STALENESS_BATCH_FLAG = "lanes.autopilot-kpi-staleness-batch";
 export const LEAD_AUTOPILOT_KPI_STALENESS_BATCH_DEFAULT_ENABLED = false;
+/** Enables staleness notices for a registered lead's dashboard headline. */
+export const LEAD_AUTOPILOT_HEADLINE_STALENESS_FLAG = "lanes.autopilot-headline-staleness";
+export const LEAD_AUTOPILOT_HEADLINE_STALENESS_DEFAULT_ENABLED = false;
 //# sourceMappingURL=flag-keys.js.map