@indigoai-us/hq-cli 5.344.1 → 5.345.1

package/dist/lib/bot/run.js

@@ -62,6 +62,8 @@ import { splitBody } from "./split.js";
 import { createBotLogger } from "./log.js";
 import { buildSystemPrompt, introDmText, readPromptSources } from "./prompt.js";
 import { loadSetupExplainer, patchSetupIntroState, readSetupIntroState, readSetupProgressIntro, replyOffersExplain, SETUP_EXPLAINED_NOTE, setupExplainDue, } from "./setup-explain.js";
+import { detectCodingToolActivity, SIGNIFICANT_CODING_TOOL_ACTIVITY, } from "./coding-tool-activity.js";
+import { setupKeptHereNote, setupOfferAnsweredInWordsNote, setupToolOfferAnswer, setupToolOfferText, setupWelcomeOpening, } from "./setup-tool-offer.js";
 import { FALLBACK_CLAUDE_PERMISSION_MODE, isClaudeBypassDisabled } from "./runtime/claude.js";
 import { runRuntimeTurn, RuntimeError } from "./runtime/index.js";
 import { botAttachmentsDir, dmSessionScope } from "./paths.js";
@@ -319,6 +321,57 @@ export async function runBot(deps) {
             log("warn", `setup intro state not updated: ${err instanceof Error ? err.message : String(err)}`);
         }
     };
+    /** The tool the pending "continue setup there?" offer named, while the kickoff waits on it. */
+    const pendingToolOffer = () => {
+        try {
+            const current = readSetupIntroState(dir);
+            return current.kickoffDeferred && current.toolOffer ? current.toolOffer.tool : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    /**
+     * Setup bot, first message: when the person has the Claude app or the Codex
+     * app and uses it a lot (coding-tool-activity.ts), the first message is the
+     * fixed "continue setup there?" offer instead of the kickoff turn, and the
+     * kickoff waits for their answer (setup-tool-offer.ts). Made once, and only
+     * before setup has started. Null (run the kickoff as usual) when nothing
+     * qualifies or anything goes wrong.
+     */
+    const codingToolToOffer = () => {
+        if (!isSetupBot || !(config.kickoff ?? "").trim())
+            return null;
+        try {
+            if (readSetupIntroState(dir).toolOffer)
+                return null;
+            if (readSetupProgressIntro(resolveBotMemoryDir(config)) !== null)
+                return null;
+            const detect = deps.detectCodingToolActivity ?? detectCodingToolActivity;
+            const activity = detect({ now: now(), extraHqRoots: [config.hqRoot] });
+            const describe = (a) => a.installed ? `${a.sessions} sessions on ${a.days} days` : "not installed";
+            log("info", `desktop app use in the last ${SIGNIFICANT_CODING_TOOL_ACTIVITY.windowDays} days: ` +
+                `Claude ${describe(activity.claude)}, Codex ${describe(activity.codex)}`);
+            return activity.pick;
+        }
+        catch (err) {
+            log("warn", `coding tool check failed (${err instanceof Error ? err.message : String(err)}); running the kickoff`);
+            return null;
+        }
+    };
+    /** The offer went out: the kickoff now waits for the answer. */
+    const recordToolOffer = (tool) => {
+        try {
+            patchSetupIntroState(dir, { toolOffer: { tool, offeredAt: now().toISOString() }, kickoffDeferred: true });
+        }
+        catch (err) {
+            log("warn", `setup intro state not updated: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (readBotConfig(dir)?.kickoffPendingSignIn)
+            patchBotConfig(dir, { kickoffPendingSignIn: false });
+        setStatus({ repliesSent: (readStatus()?.repliesSent ?? 0) + 1, lastActivityAt: now().toISOString() });
+        log("info", `offered to continue setup in the ${tool} app (no model turn); the kickoff waits for the answer`);
+    };
     // Scheduled runs are reported in the owner's own zone: "every weekday at 9am"
     // was set up here, so "due 13:00 UTC" would read as the wrong time.
     const timeZone = machineTimeZone();
@@ -455,16 +508,33 @@ export async function runBot(deps) {
         kickoffAfterIntro = {};
     }
     else if (!config.introSentAt) {
-        try {
-            const sent = await api.sendDm({ toPersonUid: config.ownerUid, body: introDmText(config.name, config.runtime, config.intro, { kind: effectiveBotKind(config), companies: effectiveBotCompanies(config) }) });
-            patchBotConfig(dir, { introSentAt: now().toISOString() });
-            log("info", "intro DM sent to owner");
-            if (config.kickoff?.trim())
-                kickoffAfterIntro = { ...(sent?.eventId ? { introEventId: sent.eventId } : {}) };
-        }
-        catch (err) {
-            log("warn", `intro DM failed (will retry next start): ${err instanceof Error ? err.message : String(err)}`);
+        // Setup bot with an app to offer: the welcome leads straight into the
+        // offer, without its "checking your computer" and Launch-button lines.
+        const offerTool = codingToolToOffer();
+        let offered = false;
+        if (offerTool) {
+            try {
+                await api.sendDm({ toPersonUid: config.ownerUid, body: setupToolOfferText(offerTool, setupWelcomeOpening(config.intro)) });
+                patchBotConfig(dir, { introSentAt: now().toISOString() });
+                log("info", "intro DM sent to owner, leading into the app offer");
+                recordToolOffer(offerTool);
+                offered = true;
+            }
+            catch (err) {
+                log("warn", `coding tool offer could not be sent as the welcome (${err instanceof Error ? err.message : String(err)}); sending the usual welcome`);
+            }
         }
+        if (!offered)
+            try {
+                const sent = await api.sendDm({ toPersonUid: config.ownerUid, body: introDmText(config.name, config.runtime, config.intro, { kind: effectiveBotKind(config), companies: effectiveBotCompanies(config) }) });
+                patchBotConfig(dir, { introSentAt: now().toISOString() });
+                log("info", "intro DM sent to owner");
+                if (config.kickoff?.trim())
+                    kickoffAfterIntro = { ...(sent?.eventId ? { introEventId: sent.eventId } : {}) };
+            }
+            catch (err) {
+                log("warn", `intro DM failed (will retry next start): ${err instanceof Error ? err.message : String(err)}`);
+            }
     }
     // ── Heartbeat loop ─────────────────────────────────────────────────────────
     const failures = new FailureWindow(FAILURE_WINDOW_MS, FAILURE_LIMIT);
@@ -1097,10 +1167,31 @@ export async function runBot(deps) {
      * in-between messages). The thinking reaction goes on the intro message
      * (there is no owner message to mark). A failure never crashes the loop.
      */
+    /**
+     * Setup bot whose welcome already went out (a kickoff held for a sign-in):
+     * the offer as its own message instead of the kickoff turn. False (run the
+     * kickoff) when there is nothing to offer or it cannot be sent.
+     */
+    const offerCodingTool = async () => {
+        const tool = codingToolToOffer();
+        if (!tool)
+            return false;
+        try {
+            await sendToTarget({ kind: "dm", peerUid: config.ownerUid }, setupToolOfferText(tool), undefined, "human");
+        }
+        catch (err) {
+            log("warn", `coding tool offer could not be sent (${err instanceof Error ? err.message : String(err)}); running the kickoff`);
+            return false;
+        }
+        recordToolOffer(tool);
+        return true;
+    };
     const runKickoff = async (introEventId) => {
         const prompt = (config.kickoff ?? "").trim();
         if (!prompt || stopping || state !== "running")
             return;
+        if (isSetupBot && (await offerCodingTool()))
+            return;
         const peerUid = config.ownerUid;
         const tReceived = now().getTime();
         log("info", `kickoff turn starting (${prompt.length} chars)`);
@@ -1530,7 +1621,18 @@ export async function runBot(deps) {
         const sessionScope = target.kind === "room" ? target.sessionScope : dmSessionScope(target.peerUid, config.ownerUid);
         // The turn after the app sent the explanation: tell the model it went out.
         const setupNote = isSetupBot && ownerDm && readSetupIntroState(dir).notePending === true;
-        const ownerText = setupNote ? `${SETUP_EXPLAINED_NOTE}\n\n${text}` : text;
+        // The first answer to the coding tool offer: "Keep going here" runs the
+        // waiting kickoff; anything else runs with a note that setup has not started.
+        const toolOffer = isSetupBot && ownerDm ? pendingToolOffer() : null;
+        const toolAnswer = toolOffer ? setupToolOfferAnswer(messageText, attachmentRefs.length) : null;
+        const kickoffPrompt = (config.kickoff ?? "").trim();
+        const ownerText = toolOffer && toolAnswer === "kept_here" && kickoffPrompt
+            ? `${setupKeptHereNote(toolOffer)}\n\n${kickoffPrompt}`
+            : toolOffer
+                ? `${setupOfferAnsweredInWordsNote(toolOffer)}\n\n${text}`
+                : setupNote
+                    ? `${SETUP_EXPLAINED_NOTE}\n\n${text}`
+                    : text;
         const prompt = target.kind === "room" ? await buildRoomTurn(item, target, text) : target.peerUid === config.ownerUid ? ownerText :
             `[HQ DM sender: ${target.peerUid}; owner: ${config.ownerUid}; sender is not the owner.]\n\n${text}`;
         const markerTarget = target.kind === "dm" ? { kind: "dm", peerUid: target.peerUid } : { kind: "room", channelId: target.channelId };
@@ -1555,7 +1657,7 @@ export async function runBot(deps) {
         });
         // The model saw the note once its turn ran. A turn that never started, or
         // one held for a coding-tool sign-in, runs again and keeps the note for it.
-        if (setupNote && (outcome.ok || (outcome.started && !isRuntimeSignInFailure(outcome.excerpt)))) {
+        if (setupNote && !toolOffer && (outcome.ok || (outcome.started && !isRuntimeSignInFailure(outcome.excerpt)))) {
             try {
                 patchSetupIntroState(dir, { notePending: false });
             }
@@ -1563,6 +1665,16 @@ export async function runBot(deps) {
                 log("warn", `setup intro state not updated: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
+        // Same rule for the offer: answered once the model saw the answer.
+        if (toolOffer && toolAnswer && (outcome.ok || (outcome.started && !isRuntimeSignInFailure(outcome.excerpt)))) {
+            try {
+                patchSetupIntroState(dir, { kickoffDeferred: false, toolOfferAnswer: toolAnswer });
+                log("info", `coding tool offer answered (${toolAnswer === "kept_here" ? "kept setup here" : "wrote a message"}); setup runs here`);
+            }
+            catch (err) {
+                log("warn", `setup intro state not updated: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
         if (outcome.ok && ownerDm)
             noteSetupReply(outcome.reply);
         if (outcome.ok) {

package/dist/lib/bot/setup-explain.d.ts

@@ -44,6 +44,18 @@ export interface SetupIntroState {
     explainedAt?: string;
     /** The model has not yet been told that the explanation went out. */
     notePending?: boolean;
+    /**
+     * The first message offered to continue setup in this coding tool
+     * (setup-tool-offer.ts). Set once; the offer is never made again.
+     */
+    toolOffer?: {
+        tool: "claude" | "codex";
+        offeredAt: string;
+    };
+    /** The kickoff turn is waiting for the person's answer to that offer. */
+    kickoffDeferred?: boolean;
+    /** How the person answered the offer: the "Keep going here" button, or a message of their own. */
+    toolOfferAnswer?: "kept_here" | "wrote";
 }
 export declare function readSetupIntroState(dir: string): SetupIntroState;
 export declare function patchSetupIntroState(dir: string, patch: Partial<Omit<SetupIntroState, "v">>): SetupIntroState;

package/dist/lib/bot/setup-tool-offer.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The setup bot's "continue in your coding tool" offer.
+ *
+ * Before the setup bot's first message, the runner checks whether the person
+ * has the Claude app or the Codex app installed and has used it a lot lately
+ * (coding-tool-activity.ts). When one qualifies, the first message is not a
+ * model turn: in place of the usual welcome, the runner sends the welcome's
+ * opening sentence and one fixed line,
+ *
+ *   "Looks like you use the Claude app. Want to continue setup there?"
+ *
+ * with an hq-block the HQ desktop app draws as two buttons: "Continue in
+ * Claude" (the app opens that desktop app in the HQ folder with the setup
+ * request ready) and "Keep going here". The kickoff turn waits:
+ *
+ * - "Keep going here" (exactly that, nothing attached) runs the waiting
+ *   kickoff as the reply to it, so setup carries on as it always did.
+ * - Any other message from the person runs as a normal turn, with a note
+ *   saying the offer was made and setup has not started yet.
+ *
+ * The offer is made once per bot, only when setup has not started (no
+ * progress note). Anything unexpected falls back to the normal kickoff turn.
+ */
+import type { CodingTool } from "./coding-tool-activity.js";
+/** The reply that keeps setup in the HQ app. Exact match only. */
+export declare const KEEP_GOING_HERE_REPLY = "Keep going here";
+/** The hq-block kind the desktop app draws as the two-button card. */
+export declare const CONTINUE_IN_TOOL_BLOCK_KIND = "continueInTool";
+/** The desktop apps' product names. */
+export declare const CODING_TOOL_NAMES: Readonly<Record<CodingTool, string>>;
+/** The offer's one line. */
+export declare function setupToolOfferLine(tool: CodingTool): string;
+/**
+ * The opening of the app's welcome, kept when the offer replaces it: its
+ * first sentence (who the bot is and what setup covers). The rest of the
+ * welcome says the bot is checking the computer and will post its first
+ * question, and points at the Launch button; with the offer showing, none of
+ * that is true yet, so it is dropped. A first sentence that itself talks about
+ * checking or the Launch button is dropped too.
+ */
+export declare function setupWelcomeOpening(intro: string | undefined): string | null;
+/**
+ * The whole first message. The block also carries "Keep going here" as a
+ * suggested reply, so an app that predates the card still shows that button.
+ */
+export declare function setupToolOfferText(tool: CodingTool, welcome?: string | null): string;
+/** Put in front of the waiting kickoff when the person clicked "Keep going here". */
+export declare function setupKeptHereNote(tool: CodingTool): string;
+/** Put in front of the person's message when they wrote something instead of clicking. */
+export declare function setupOfferAnsweredInWordsNote(tool: CodingTool): string;
+export type SetupToolOfferAnswer = "kept_here" | "wrote";
+/** How the person answered a pending offer: the button, or anything else. */
+export declare function setupToolOfferAnswer(text: string, attachments: number): SetupToolOfferAnswer;
+//# sourceMappingURL=setup-tool-offer.d.ts.map

package/dist/lib/bot/setup-tool-offer.js

@@ -0,0 +1,91 @@
+/**
+ * The setup bot's "continue in your coding tool" offer.
+ *
+ * Before the setup bot's first message, the runner checks whether the person
+ * has the Claude app or the Codex app installed and has used it a lot lately
+ * (coding-tool-activity.ts). When one qualifies, the first message is not a
+ * model turn: in place of the usual welcome, the runner sends the welcome's
+ * opening sentence and one fixed line,
+ *
+ *   "Looks like you use the Claude app. Want to continue setup there?"
+ *
+ * with an hq-block the HQ desktop app draws as two buttons: "Continue in
+ * Claude" (the app opens that desktop app in the HQ folder with the setup
+ * request ready) and "Keep going here". The kickoff turn waits:
+ *
+ * - "Keep going here" (exactly that, nothing attached) runs the waiting
+ *   kickoff as the reply to it, so setup carries on as it always did.
+ * - Any other message from the person runs as a normal turn, with a note
+ *   saying the offer was made and setup has not started yet.
+ *
+ * The offer is made once per bot, only when setup has not started (no
+ * progress note). Anything unexpected falls back to the normal kickoff turn.
+ */
+/** The reply that keeps setup in the HQ app. Exact match only. */
+export const KEEP_GOING_HERE_REPLY = "Keep going here";
+/** The hq-block kind the desktop app draws as the two-button card. */
+export const CONTINUE_IN_TOOL_BLOCK_KIND = "continueInTool";
+/** The desktop apps' product names. */
+export const CODING_TOOL_NAMES = Object.freeze({
+    claude: "Claude",
+    codex: "Codex",
+});
+/** The offer's one line. */
+export function setupToolOfferLine(tool) {
+    return `Looks like you use the ${CODING_TOOL_NAMES[tool]} app. Want to continue setup there?`;
+}
+/**
+ * The opening of the app's welcome, kept when the offer replaces it: its
+ * first sentence (who the bot is and what setup covers). The rest of the
+ * welcome says the bot is checking the computer and will post its first
+ * question, and points at the Launch button; with the offer showing, none of
+ * that is true yet, so it is dropped. A first sentence that itself talks about
+ * checking or the Launch button is dropped too.
+ */
+export function setupWelcomeOpening(intro) {
+    const text = (intro ?? "").trim();
+    if (!text)
+        return null;
+    const m = /^[\s\S]*?[.!?](?=\s|$)/.exec(text);
+    const first = (m ? m[0] : text).trim();
+    if (!first || /\bcheck(ing)?\b|\blaunch\b|first question/i.test(first))
+        return null;
+    return first;
+}
+/**
+ * The whole first message. The block also carries "Keep going here" as a
+ * suggested reply, so an app that predates the card still shows that button.
+ */
+export function setupToolOfferText(tool, welcome) {
+    const envelope = {
+        v: 1,
+        blocks: [
+            { kind: CONTINUE_IN_TOOL_BLOCK_KIND, tool },
+            { kind: "suggestions", items: [KEEP_GOING_HERE_REPLY] },
+        ],
+    };
+    return ((welcome ? `${welcome}\n\n` : "") +
+        `${setupToolOfferLine(tool)}\n\n` +
+        "```hq-block\n" +
+        `${JSON.stringify(envelope)}\n` +
+        "```");
+}
+/** Put in front of the waiting kickoff when the person clicked "Keep going here". */
+export function setupKeptHereNote(tool) {
+    return (`[Note from the HQ app: before setup started, the app offered to continue setup in the ${CODING_TOOL_NAMES[tool]} app, ` +
+        `because the person uses that app a lot on this computer. They clicked "${KEEP_GOING_HERE_REPLY}", so setup happens here. ` +
+        "Do not mention the offer. The kickoff follows.]");
+}
+/** Put in front of the person's message when they wrote something instead of clicking. */
+export function setupOfferAnsweredInWordsNote(tool) {
+    return (`[Note from the HQ app: before setup started, the app said the person seems to use the ${CODING_TOOL_NAMES[tool]} app a lot ` +
+        `and offered to continue setup there, with a button that opens the ${CODING_TOOL_NAMES[tool]} app in their HQ folder and a "${KEEP_GOING_HERE_REPLY}" button. ` +
+        "They wrote the message below instead. Setup has not started and there was no kickoff. " +
+        `If they want to continue in the ${CODING_TOOL_NAMES[tool]} app, tell them in plain words to click the button above to open it. ` +
+        "Otherwise begin setup here as your instructions say for a first message.]");
+}
+/** How the person answered a pending offer: the button, or anything else. */
+export function setupToolOfferAnswer(text, attachments) {
+    return text === KEEP_GOING_HERE_REPLY && attachments === 0 ? "kept_here" : "wrote";
+}
+//# sourceMappingURL=setup-tool-offer.js.map

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

@@ -3,7 +3,6 @@ import type { LaneRecord } from "./types.js";
 export declare const LEAD_AUTOPILOT_FLAG = "lanes.lead-autopilot";
 export declare const LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = "lanes.autopilot-missed-deadline-escalation";
 export declare const LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_DELAY_MS: number;
-export declare const LEAD_AUTOPILOT_NUDGE_DEDUPE_FLAG = "lanes.autopilot-nudge-dedupe";
 export declare const LEAD_AUTOPILOT_NUDGE_REDELIVERY_DELAY_MS: number;
 export declare const LEAD_AUTOPILOT_NUDGE_STATE_RETENTION_MS: number;
 export declare const LEAD_AUTOPILOT_REVIEW_DELAY_MS: number;
@@ -11,8 +10,6 @@ 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 {
     team: string;
     lane: string;
@@ -115,7 +112,6 @@ export declare function planLeadAutopilotWakes(input: {
     managerStatus?: Record<string, unknown>;
     keepAliveResumed?: boolean;
     kpiStalenessEnabled?: boolean;
-    kpiStalenessBatchEnabled?: boolean;
     headlineStalenessEnabled?: boolean;
 }): AutopilotWake[];
 export declare function runLeadAutopilotPass(input: {
@@ -126,7 +122,6 @@ export declare function runLeadAutopilotPass(input: {
     now: Date;
     dryRun?: boolean;
     readFlag?: typeof readLanesRegistryFlag;
-    readNudgeDedupeFlag?: typeof readLanesRegistryFlag;
     readDeadlineFlag?: typeof readLanesRegistryFlag;
     keepAliveResumedLeads?: ReadonlySet<string>;
     missedDeadlineEscalationDelayMs?: number;

package/dist/lib/lanes/autopilot.js

@@ -6,14 +6,13 @@ 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_HEADLINE_STALENESS_FLAG, LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_FLAG, LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG as PER_LEAD_ERRORS_FLAG, } from "./flag-keys.js";
+import { LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG, LEAD_AUTOPILOT_KPI_STALENESS_FLAG, LEAD_AUTOPILOT_HEADLINE_STALENESS_FLAG, LEAD_AUTOPILOT_OUTPOST_NATIVE_LEADS_FLAG, } from "./flag-keys.js";
 import { resolveLaneCompany } from "./lane-company.js";
 import { readLanesRegistryFlag } from "./registry-flag.js";
 import { readAllLanes } from "./store.js";
 export const LEAD_AUTOPILOT_FLAG = "lanes.lead-autopilot";
 export const LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG;
 export const LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_DELAY_MS = 60 * 60_000;
-export const LEAD_AUTOPILOT_NUDGE_DEDUPE_FLAG = LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG;
 export const LEAD_AUTOPILOT_NUDGE_REDELIVERY_DELAY_MS = 30 * 60_000;
 export const LEAD_AUTOPILOT_NUDGE_STATE_RETENTION_MS = 24 * 60 * 60_000;
 const LEAD_AUTOPILOT_DELIVERED_ID_RETENTION_MS = 7 * 24 * 60 * 60_000;
@@ -22,8 +21,6 @@ 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"]);
 const OPEN_STORY_STATES = new Set(["todo", "queued", "in_progress", "review", "blocked"]);
 function isOpenProjectStory(story) {
@@ -478,7 +475,7 @@ export function planLeadAutopilotWakes(input) {
     }
     if (input.kpiStalenessEnabled) {
         const staleKpis = managerKpiFreshness(status, now).filter((kpi) => kpi.stale);
-        if (input.kpiStalenessBatchEnabled && staleKpis.length > 0) {
+        if (staleKpis.length > 0) {
             const byOldest = [...staleKpis].sort((a, b) => (b.ageMinutes ?? Number.MAX_SAFE_INTEGER) - (a.ageMinutes ?? Number.MAX_SAFE_INTEGER) ||
                 a.name.localeCompare(b.name));
             const identity = staleKpis
@@ -688,13 +685,11 @@ function readState(file) {
     };
 }
 function appendAutopilotMessage(input) {
-    if (input.dedupeEnabled && input.state.delivered_ids?.[input.message.message_id])
+    if (input.state.delivered_ids?.[input.message.message_id])
         return false;
     appendDropboxMessage(input.hqRoot, input.leadLane, input.message);
-    if (input.dedupeEnabled) {
-        input.state.delivered_ids ??= {};
-        input.state.delivered_ids[input.message.message_id] = input.message.at;
-    }
+    input.state.delivered_ids ??= {};
+    input.state.delivered_ids[input.message.message_id] = input.message.at;
     return true;
 }
 function removeDeliveredIdsForFingerprint(state, fingerprint) {
@@ -799,7 +794,6 @@ async function runLeadAutopilotPassUnlocked(input) {
             continue;
         }
         let stateChanged = false;
-        let perLeadErrorsEnabled = false;
         let currentInputPath = registered.status;
         try {
             const readFlag = input.readFlag ?? readLanesRegistryFlag;
@@ -808,11 +802,9 @@ async function runLeadAutopilotPassUnlocked(input) {
                 result.skipped.push({ lead_lane: lead.lane_id, reason: "flag_off" });
                 continue;
             }
-            perLeadErrorsEnabled = await readFlag(PER_LEAD_ERRORS_FLAG, { company });
             currentInputPath = registered.status;
             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 ??= [];
@@ -834,8 +826,7 @@ async function runLeadAutopilotPassUnlocked(input) {
             const stories = projectStories(hqRoot, registered.prd, company.slug, lead.project_id);
             const children = lanes.filter((lane) => lane.senior.kind === "lane" && lane.senior.id === lead.lane_id);
             const deadlineEscalationEnabled = await (input.readDeadlineFlag ?? readFlag)(LEAD_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG, { company });
-            const nudgeDedupeEnabled = await (input.readNudgeDedupeFlag ?? readFlag)(LEAD_AUTOPILOT_NUDGE_DEDUPE_FLAG, { company });
-            if (nudgeDedupeEnabled && pruneDeliveredIds(state, now))
+            if (pruneDeliveredIds(state, now))
                 stateChanged = true;
             currentInputPath = registered.status;
             let planned = planLeadAutopilotWakes({
@@ -845,11 +836,10 @@ async function runLeadAutopilotPassUnlocked(input) {
                 now,
                 managerStatus: status,
                 kpiStalenessEnabled,
-                kpiStalenessBatchEnabled,
                 headlineStalenessEnabled,
                 keepAliveResumed: input.keepAliveResumedLeads?.has(lead.lane_id) === true,
             });
-            if (kpiStalenessBatchEnabled) {
+            if (kpiStalenessEnabled) {
                 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) {
@@ -872,13 +862,6 @@ async function runLeadAutopilotPassUnlocked(input) {
                     continue;
                 const entry = state.sent[key];
                 const isActive = activeKeys.has(key);
-                if (!nudgeDedupeEnabled) {
-                    if (!isActive) {
-                        delete state.sent[key];
-                        stateChanged = true;
-                    }
-                    continue;
-                }
                 if (!isActive && entry.inactive_since === undefined) {
                     state.sent[key] = { ...entry, inactive_since: now.toISOString() };
                     stateChanged = true;
@@ -915,7 +898,7 @@ async function runLeadAutopilotPassUnlocked(input) {
                 if (suppressedKeys.has(key))
                     continue;
                 const prior = state.sent[key];
-                if (nudgeDedupeEnabled && prior && prior.fingerprint !== wake.fingerprint && !prior.acted) {
+                if (prior && prior.fingerprint !== wake.fingerprint && !prior.acted) {
                     const leadActedSincePrior = statusUpdatedAt !== undefined && prior.status_updated_at !== undefined &&
                         Date.parse(statusUpdatedAt) > Date.parse(prior.status_updated_at);
                     if (!leadActedSincePrior) {
@@ -974,11 +957,11 @@ async function runLeadAutopilotPassUnlocked(input) {
                         continue;
                     if (wake.condition === "stale_headline")
                         continue;
-                    const redeliveryDelay = nudgeDedupeEnabled ? LEAD_AUTOPILOT_NUDGE_REDELIVERY_DELAY_MS : LEAD_AUTOPILOT_FILL_DELAY_MS;
+                    const redeliveryDelay = LEAD_AUTOPILOT_NUDGE_REDELIVERY_DELAY_MS;
                     if (!current.acted && !current.auto_started && current.escalated_at === undefined && now.getTime() - lastWakeAt >= redeliveryDelay) {
                         const wakeCount = current.wake_count ?? 1;
                         if (wakeCount < 2) {
-                            const delivered = appendAutopilotMessage({ hqRoot, leadLane: lead.lane_id, state, dedupeEnabled: nudgeDedupeEnabled, message: {
+                            const delivered = appendAutopilotMessage({ hqRoot, leadLane: lead.lane_id, state, message: {
                                     at: now.toISOString(),
                                     message_id: `lead-autopilot:${wake.fingerprint}:wake-2`,
                                     kind: "system_notice",
@@ -1002,7 +985,7 @@ async function runLeadAutopilotPassUnlocked(input) {
                     continue;
                 }
                 if (!input.dryRun) {
-                    const delivered = appendAutopilotMessage({ hqRoot, leadLane: lead.lane_id, state, dedupeEnabled: nudgeDedupeEnabled, message: {
+                    const delivered = appendAutopilotMessage({ hqRoot, leadLane: lead.lane_id, state, message: {
                             at: now.toISOString(),
                             message_id: `lead-autopilot:${wake.fingerprint}`,
                             kind: "system_notice",
@@ -1093,7 +1076,7 @@ async function runLeadAutopilotPassUnlocked(input) {
                                 fingerprint,
                                 prompt: `Deadline missed for ${commitment.item} (${commitment.description}), owner ${commitment.owner}, due ${commitment.due}. Deliver it or re-date with a reason. Follow ${LEAD_AUTOPILOT_PROMPT_LOOP}.`,
                             };
-                            const delivered = appendAutopilotMessage({ hqRoot, leadLane: lead.lane_id, state, dedupeEnabled: nudgeDedupeEnabled, message: {
+                            const delivered = appendAutopilotMessage({ hqRoot, leadLane: lead.lane_id, state, message: {
                                     at: now.toISOString(),
                                     message_id: `lead-autopilot:${fingerprint}`,
                                     kind: "system_notice",
@@ -1160,7 +1143,7 @@ async function runLeadAutopilotPassUnlocked(input) {
         catch (error) {
             if (!input.dryRun && stateChanged)
                 writeState(stateFile, state);
-            if (perLeadErrorsEnabled && error instanceof LanesError && LEAD_AUTOPILOT_PER_LEAD_ERROR_CODES.has(error.error)) {
+            if (error instanceof LanesError && LEAD_AUTOPILOT_PER_LEAD_ERROR_CODES.has(error.error)) {
                 const errorPath = typeof error.details.path === "string" ? error.details.path : currentInputPath;
                 const messageId = `lead-autopilot-error:${error.error}:${createHash("sha256").update(`${error.error}\0${errorPath}`).digest("hex")}`;
                 result.skipped.push({ lane_id: lead.lane_id, error: error.error, path: errorPath, message: error.message });

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

@@ -2,7 +2,6 @@ import * as fs from "node:fs";
 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 function lowDiskGuardEnabledForLane(hqRoot: string, lane: LaneRecord, readFlag?: (key: string, options: ReadLanesFlagOptions) => Promise<boolean>): Promise<boolean>;
 interface DiskStats {
     bsize: number;

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

@@ -8,7 +8,6 @@ import { resolveLaneCompany } from "./lane-company.js";
 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";
 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"]);

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

@@ -12,17 +12,10 @@ export declare const LANE_HIRE_GRANT_FINISHED_LANES_FLAG = "lanes.hire-grant-cou
 export declare const LANE_LIST_SKIP_REMOTE_REFRESH_FLAG = "lanes.list-skip-remote-refresh";
 /** Enables missed-deadline lead nudges and second-miss operator escalation. */
 export declare const LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = "lanes.autopilot-missed-deadline-escalation";
-export declare const LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG = "lanes.autopilot-nudge-dedupe";
 /** Enables company-scoped lookup of a hostless lane ULID across Outpost indexes. */
 export declare const LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG = "lanes.message-route-owner-host";
 /** Enables stale manager-status KPI reporting and one-time lead nudges. */
 export declare const LEAD_AUTOPILOT_KPI_STALENESS_FLAG = "lanes.autopilot-kpi-staleness";
-/** Skips malformed lead inputs individually instead of aborting the pass. */
-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;
-/** 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";
 /** Lets an Outpost's autopilot wake leads created on that Outpost, which record a local host. */

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

@@ -12,17 +12,10 @@ export const LANE_HIRE_GRANT_FINISHED_LANES_FLAG = "lanes.hire-grant-count-live-
 export const LANE_LIST_SKIP_REMOTE_REFRESH_FLAG = "lanes.list-skip-remote-refresh";
 /** Enables missed-deadline lead nudges and second-miss operator escalation. */
 export const LANE_AUTOPILOT_MISSED_DEADLINE_ESCALATION_FLAG = "lanes.autopilot-missed-deadline-escalation";
-export const LANE_AUTOPILOT_NUDGE_DEDUPE_FLAG = "lanes.autopilot-nudge-dedupe";
 /** Enables company-scoped lookup of a hostless lane ULID across Outpost indexes. */
 export const LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG = "lanes.message-route-owner-host";
 /** Enables stale manager-status KPI reporting and one-time lead nudges. */
 export const LEAD_AUTOPILOT_KPI_STALENESS_FLAG = "lanes.autopilot-kpi-staleness";
-/** Skips malformed lead inputs individually instead of aborting the pass. */
-export const LEAD_AUTOPILOT_PER_LEAD_ERRORS_FLAG = "lanes.autopilot-per-lead-errors";
-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";
 /** Lets an Outpost's autopilot wake leads created on that Outpost, which record a local host. */

package/dist/lib/lanes/reconcile.js

@@ -955,21 +955,8 @@ export async function runPassBody(hqRoot, deps) {
     }
     const config = loadLanesConfig(hqRoot);
     try {
-        const companyRefs = new Map();
-        for (const lane of lanes) {
-            const company = resolveLaneCompany(hqRoot, lane).company;
-            if (company)
-                companyRefs.set(company.uid ?? company.slug, company);
-        }
-        const readFlag = deps.readRegistryFlag ?? readLanesRegistryFlag;
         const configuredHomes = configuredCodexRolloutHomes(hqRoot, config, deps.host.hostname);
-        let retentionEnabled = false;
-        for (const company of configuredHomes.length > 0 ? companyRefs.values() : []) {
-            retentionEnabled ||= await readFlag("lanes.codex-rollout-retention", { company });
-            if (retentionEnabled)
-                break;
-        }
-        if (retentionEnabled) {
+        if (configuredHomes.length > 0) {
             const presentHomes = [];
             for (const home of configuredHomes) {
                 try {