@indigoai-us/hq-cli 5.344.1 → 5.345.0

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [5.345.0] — 2026-10-05
+- Apply Codex rollout retention, batched stale KPI notices, per-lead error isolation, and autopilot nudge deduplication without rollout gates.
+
+- On a Mac with the Claude app or the Codex app installed and used a lot lately (at least 5 of that app's own sessions on 3 different days in the last 14 days; sessions from the `claude` and `codex` commands do not count, and neither do HQ's own bot sessions), the setup bot's welcome now leads straight into "Looks like you use the Claude app. Want to continue setup there?" (or the Codex app), and the HQ desktop app shows a button to open that app in your HQ folder next to a "Keep going here" button. Only a few metadata fields of each session are read: when it was used and which app ran it. Otherwise setup starts as before.
+
 ## [5.344.1] — 2026-10-05
 - Release the MCP server's package lease after its resident modules preload and record a bounded command purpose on CLI package leases.
 

package/assets/bot-workers/setup/worker.yaml

@@ -165,6 +165,27 @@ instructions: |
   short: say what you can do for them and give one concrete example drawn from
   their HQ. Still no open "what can I help you with".
 
+  ## When the app offered their coding tool first
+
+  Before your first message, the HQ app checks whether the person has the
+  Claude app or the Codex app on this computer and has used it a lot lately.
+  When they have, the app sends the first message for you: the opening of
+  your welcome, then one line asking whether they want to continue setup in
+  that app, with a button that opens the app in their HQ folder with setup
+  ready to go, and a "Keep going here" button. You did not write that
+  message, and the kickoff waits for their answer.
+
+  - When they click "Keep going here", your turn starts with a note from the
+    app saying so, followed by the kickoff. Do the kickoff exactly as "When
+    you receive the kickoff" says, and do not mention the offer.
+  - When they write something else instead, your turn starts with a note
+    from the app saying the offer was made and setup has not started. If they
+    want to continue in that app, tell them in plain words to click
+    the button above your message; never tell them to type a command.
+    Otherwise open the walkthrough as "Your very first message" says.
+  - If they went to that app and come back here later, work out
+    where you are as always: some steps may already be done there.
+
   ## Your progress note
 
   You are a fresh conversation every turn. The only thing that carries across is

package/dist/commands/lanes.js

@@ -37,7 +37,7 @@ import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { runResidentCommandWithPackageLease } from "../utils/resident-package-preload.js";
 import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff } from "../lib/lanes/registry-flag.js";
 import { LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, } from "../lib/lanes/flag-keys.js";
-import { CODEX_ROLLOUT_RETENTION_FLAG, configuredCodexRolloutHomes, lowDiskGuardEnabledForLane, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
+import { configuredCodexRolloutHomes, lowDiskGuardEnabledForLane, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
 import { syncOutpostLeadRegistries } from "../lib/lanes/autopilot-registry.js";
@@ -5263,30 +5263,6 @@ async function runCapacity(ctx) {
 async function runGcRollouts(ctx, opts) {
     const hqRoot = ctx.hqRoot();
     const lanes = readAllLanes(hqRoot);
-    const companies = new Map();
-    for (const lane of lanes) {
-        const company = resolveLaneCompany(hqRoot, lane).company;
-        if (company)
-            companies.set(company.uid ?? company.slug, company);
-    }
-    if (companies.size === 0) {
-        const company = await ctx.resolveCompany();
-        companies.set(company.uid ?? company.slug, company);
-    }
-    let enabled = false;
-    for (const company of companies.values()) {
-        enabled ||= await readLanesRegistryFlag(CODEX_ROLLOUT_RETENTION_FLAG, {
-            company,
-            companyUidSource: "resolved_lane_company",
-            env: ctx.env,
-        });
-        if (enabled)
-            break;
-    }
-    if (!enabled) {
-        printJson({ ok: true, action: "gc-rollouts", enabled: false, dry_run: Boolean(opts.dryRun), scanned: 0, compressed: [], deleted: [], bytes_freed: 0 });
-        return;
-    }
     const config = loadLanesConfig(hqRoot);
     const homes = configuredCodexRolloutHomes(hqRoot, config, ctx.hostname());
     const result = await retainCodexRollouts({

package/dist/lib/bot/coding-tool-activity.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Does the person already use the Claude app or the Codex app a lot on this
+ * computer?
+ *
+ * The setup bot asks this before its first message: someone who works in one
+ * of those desktop apps is offered to continue setup there. Only the desktop
+ * apps count, never the command-line tools, and only on macOS:
+ *
+ * 1. The app must be installed: `Claude.app` (bundle id
+ *    `com.anthropic.claudefordesktop`), or `ChatGPT.app` / `Codex.app`
+ *    carrying Codex (bundle id `com.openai.codex`), in `/Applications` or
+ *    `~/Applications`. The bundle id is checked, so another OpenAI app such as
+ *    ChatGPT Atlas (`com.openai.atlas`) never counts.
+ * 2. The app must have recent sessions of its own:
+ *    - Claude: the Claude app keeps one small record per Code session at
+ *      `~/Library/Application Support/Claude/claude-code-sessions/<account>/<org>/local_<id>.json`.
+ *      Sessions started with the `claude` command never get one, so CLI use
+ *      does not count. Only the record's `lastActivityAt` / `createdAt`
+ *      numbers and its `cwd` / `cliSessionId` (to skip HQ's bots) are read,
+ *      from the start of the file; the file's mtime is the fallback.
+ *    - Codex: the app and the CLI share `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl`
+ *      (`CODEX_HOME` moves `~/.codex`). The first line of each file is a
+ *      `session_meta` record; a session the app ran says
+ *      `"originator":"Codex Desktop"` with `"source":"vscode"`. Sessions from
+ *      `codex` / `codex exec` (other originators, or source `exec`) and
+ *      sub-agent threads (an object source) do not count. Only those two
+ *      fields are read, from the start of the first line; the file's mtime
+ *      is when it was last used.
+ *
+ * Nothing else in a session is read, and nothing about a session leaves this
+ * module except two numbers per app (sessions and distinct days in the window).
+ *
+ * HQ's own bots are not the person. Any session whose id a bot has on file
+ * (`session*.json` in each bot folder) is skipped, and so is a Claude session
+ * whose folder is under the bots' own folder.
+ */
+export type CodingTool = "claude" | "codex";
+export interface ActivityThreshold {
+    windowDays: number;
+    minSessions: number;
+    minDistinctDays: number;
+}
+/**
+ * "Significant recent activity": at least `minSessions` sessions, spread over
+ * at least `minDistinctDays` calendar days, within the last `windowDays` days.
+ */
+export declare const SIGNIFICANT_CODING_TOOL_ACTIVITY: Readonly<ActivityThreshold>;
+export interface ToolActivity {
+    /** Is the desktop app installed? */
+    installed: boolean;
+    /** App sessions used within the window (0 when the app is not installed). */
+    sessions: number;
+    /** Distinct local calendar days those sessions fall on. */
+    days: number;
+}
+export interface CodingToolActivity {
+    claude: ToolActivity;
+    codex: ToolActivity;
+    /** The app to offer, or null when neither qualifies. */
+    pick: CodingTool | null;
+}
+export interface HqBotExclusions {
+    /** HQ folders bots run their turns in (from each bot.json `hqRoot`). */
+    hqRoots: string[];
+    /** Model session ids the bots have on file. */
+    sessionIds: string[];
+}
+export interface DetectCodingToolActivityInput {
+    now: Date;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    /** Defaults to `process.platform`; the apps are only looked for on macOS. */
+    platform?: NodeJS.Platform;
+    /** Where apps are installed; defaults to `/Applications` and `~/Applications`. */
+    applicationsDirs?: string[];
+    /** Where the bots live; defaults to `botsRoot()`. */
+    botsDir?: string;
+    /** Kept for callers; HQ folders are not used to tell app sessions apart. */
+    extraHqRoots?: string[];
+    threshold?: ActivityThreshold;
+}
+/** The desktop apps, by bundle id, and the bundle names they ship under. */
+export declare const DESKTOP_APPS: Readonly<Record<CodingTool, {
+    bundleId: string;
+    bundles: readonly string[];
+}>>;
+/** `originator` the Codex app writes into its sessions' first line. */
+export declare const CODEX_APP_ORIGINATOR = "Codex Desktop";
+/** Claude Code's project folder name for a working directory. */
+export declare function claudeProjectDirName(cwd: string): string;
+/**
+ * Is `bundleId` this Info.plist's CFBundleIdentifier? An XML plist is read by
+ * key. A binary plist has no readable key/value pairing, so it matches when the
+ * whole id (not a prefix of a longer one, like `com.openai.codex.skill`)
+ * appears in it.
+ */
+export declare function plistBundleIdIs(plist: Buffer, bundleId: string): boolean;
+/**
+ * Is this desktop app installed? Looks for its bundle names in
+ * `/Applications` and `~/Applications` and checks the bundle id in each
+ * candidate's Info.plist (XML or binary: the id is stored as plain text in both).
+ */
+export declare function desktopAppInstalled(tool: CodingTool, opts: {
+    home: string;
+    applicationsDirs?: string[];
+}): boolean;
+/**
+ * The HQ folders and session ids that belong to HQ's bots on this computer.
+ * Reads only the bots' own small config and session files.
+ */
+export declare function collectHqBotExclusions(dir?: string): HqBotExclusions;
+/**
+ * Is this the Codex app's own session? Reads `originator` and `source` from
+ * the start of the rollout's first line (its `session_meta` record).
+ */
+export declare function isCodexAppSession(head: string): boolean;
+/** Sessions and distinct days within the window ending at `now`. */
+export declare function summarizeActivity(times: readonly number[], now: Date, windowDays: number): {
+    sessions: number;
+    days: number;
+};
+export declare function qualifies(activity: {
+    installed?: boolean;
+    sessions: number;
+    days: number;
+}, threshold?: ActivityThreshold): boolean;
+/**
+ * The app to offer: the one that qualifies, or, when both do, the one with
+ * more sessions in the window (Claude on a tie).
+ */
+export declare function pickCodingTool(claude: {
+    installed?: boolean;
+    sessions: number;
+    days: number;
+}, codex: {
+    installed?: boolean;
+    sessions: number;
+    days: number;
+}, threshold?: ActivityThreshold): CodingTool | null;
+/** Look for the Claude and Codex desktop apps and their recent sessions, and pick one to offer, if any. */
+export declare function detectCodingToolActivity(input: DetectCodingToolActivityInput): CodingToolActivity;
+//# sourceMappingURL=coding-tool-activity.d.ts.map

package/dist/lib/bot/coding-tool-activity.js

@@ -0,0 +1,372 @@
+/**
+ * Does the person already use the Claude app or the Codex app a lot on this
+ * computer?
+ *
+ * The setup bot asks this before its first message: someone who works in one
+ * of those desktop apps is offered to continue setup there. Only the desktop
+ * apps count, never the command-line tools, and only on macOS:
+ *
+ * 1. The app must be installed: `Claude.app` (bundle id
+ *    `com.anthropic.claudefordesktop`), or `ChatGPT.app` / `Codex.app`
+ *    carrying Codex (bundle id `com.openai.codex`), in `/Applications` or
+ *    `~/Applications`. The bundle id is checked, so another OpenAI app such as
+ *    ChatGPT Atlas (`com.openai.atlas`) never counts.
+ * 2. The app must have recent sessions of its own:
+ *    - Claude: the Claude app keeps one small record per Code session at
+ *      `~/Library/Application Support/Claude/claude-code-sessions/<account>/<org>/local_<id>.json`.
+ *      Sessions started with the `claude` command never get one, so CLI use
+ *      does not count. Only the record's `lastActivityAt` / `createdAt`
+ *      numbers and its `cwd` / `cliSessionId` (to skip HQ's bots) are read,
+ *      from the start of the file; the file's mtime is the fallback.
+ *    - Codex: the app and the CLI share `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl`
+ *      (`CODEX_HOME` moves `~/.codex`). The first line of each file is a
+ *      `session_meta` record; a session the app ran says
+ *      `"originator":"Codex Desktop"` with `"source":"vscode"`. Sessions from
+ *      `codex` / `codex exec` (other originators, or source `exec`) and
+ *      sub-agent threads (an object source) do not count. Only those two
+ *      fields are read, from the start of the first line; the file's mtime
+ *      is when it was last used.
+ *
+ * Nothing else in a session is read, and nothing about a session leaves this
+ * module except two numbers per app (sessions and distinct days in the window).
+ *
+ * HQ's own bots are not the person. Any session whose id a bot has on file
+ * (`session*.json` in each bot folder) is skipped, and so is a Claude session
+ * whose folder is under the bots' own folder.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { botsRoot } from "./paths.js";
+/**
+ * "Significant recent activity": at least `minSessions` sessions, spread over
+ * at least `minDistinctDays` calendar days, within the last `windowDays` days.
+ */
+export const SIGNIFICANT_CODING_TOOL_ACTIVITY = Object.freeze({
+    windowDays: 14,
+    minSessions: 5,
+    minDistinctDays: 3,
+});
+/** The desktop apps, by bundle id, and the bundle names they ship under. */
+export const DESKTOP_APPS = Object.freeze({
+    claude: { bundleId: "com.anthropic.claudefordesktop", bundles: ["Claude.app"] },
+    codex: { bundleId: "com.openai.codex", bundles: ["ChatGPT.app", "Codex.app"] },
+});
+/** `originator` the Codex app writes into its sessions' first line. */
+export const CODEX_APP_ORIGINATOR = "Codex Desktop";
+/** Stop counting after this many session files per app, so a huge history cannot stall a start. */
+const MAX_FILES_PER_TOOL = 20_000;
+/** How much of a file is read to find the few metadata fields used. */
+const HEAD_BYTES = 8 * 1024;
+const DAY_MS = 24 * 60 * 60 * 1000;
+/**
+ * A Codex session lives in the folder of the day it started, but a resumed one
+ * is still written to later. Dated folders are only skipped when they are this
+ * many days older than the window, so a resumed session is still counted.
+ */
+const CODEX_FOLDER_MARGIN_DAYS = 31;
+/** Claude Code's project folder name for a working directory. */
+export function claudeProjectDirName(cwd) {
+    return path.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
+}
+function codexHome(home, env) {
+    const override = env.CODEX_HOME?.trim();
+    return override ? override : path.join(home, ".codex");
+}
+function readDirSafe(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+function mtimeMs(file) {
+    try {
+        return fs.statSync(file).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+/** The first `HEAD_BYTES` of a file as text, or null. */
+function readHead(file) {
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+        const buf = Buffer.alloc(HEAD_BYTES);
+        const n = fs.readSync(fd, buf, 0, HEAD_BYTES, 0);
+        return buf.subarray(0, n).toString("utf8");
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch {
+                /* already closed */
+            }
+        }
+    }
+}
+function jsonString(head, key) {
+    const m = new RegExp(`"${key}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`).exec(head);
+    if (!m)
+        return null;
+    try {
+        return JSON.parse(`"${m[1]}"`);
+    }
+    catch {
+        return null;
+    }
+}
+function jsonNumber(head, key) {
+    const m = new RegExp(`"${key}"\\s*:\\s*(\\d+(?:\\.\\d+)?)`).exec(head);
+    return m ? Number(m[1]) : null;
+}
+/**
+ * Is `bundleId` this Info.plist's CFBundleIdentifier? An XML plist is read by
+ * key. A binary plist has no readable key/value pairing, so it matches when the
+ * whole id (not a prefix of a longer one, like `com.openai.codex.skill`)
+ * appears in it.
+ */
+export function plistBundleIdIs(plist, bundleId) {
+    if (plist.subarray(0, 6).toString("latin1") !== "bplist") {
+        const m = /<key>\s*CFBundleIdentifier\s*<\/key>\s*<string>\s*([^<\s]+)\s*<\/string>/.exec(plist.toString("utf8"));
+        return m?.[1] === bundleId;
+    }
+    const needle = Buffer.from(bundleId, "utf8");
+    for (let at = plist.indexOf(needle); at !== -1; at = plist.indexOf(needle, at + 1)) {
+        const next = plist[at + needle.length];
+        if (next === undefined || !/[A-Za-z0-9.-]/.test(String.fromCharCode(next)))
+            return true;
+    }
+    return false;
+}
+/**
+ * Is this desktop app installed? Looks for its bundle names in
+ * `/Applications` and `~/Applications` and checks the bundle id in each
+ * candidate's Info.plist (XML or binary: the id is stored as plain text in both).
+ */
+export function desktopAppInstalled(tool, opts) {
+    const { bundleId, bundles } = DESKTOP_APPS[tool];
+    const dirs = opts.applicationsDirs ?? ["/Applications", path.join(opts.home, "Applications")];
+    for (const dir of dirs) {
+        for (const bundle of bundles) {
+            try {
+                const plist = fs.readFileSync(path.join(dir, bundle, "Contents", "Info.plist"));
+                if (plistBundleIdIs(plist, bundleId))
+                    return true;
+            }
+            catch {
+                /* not there */
+            }
+        }
+    }
+    return false;
+}
+/**
+ * The HQ folders and session ids that belong to HQ's bots on this computer.
+ * Reads only the bots' own small config and session files.
+ */
+export function collectHqBotExclusions(dir = botsRoot()) {
+    const hqRoots = new Set();
+    const sessionIds = new Set();
+    for (const bot of readDirSafe(dir)) {
+        if (!bot.isDirectory())
+            continue;
+        const botDir = path.join(dir, bot.name);
+        try {
+            const config = JSON.parse(fs.readFileSync(path.join(botDir, "bot.json"), "utf8"));
+            if (typeof config.hqRoot === "string" && config.hqRoot.trim())
+                hqRoots.add(config.hqRoot.trim());
+        }
+        catch {
+            /* no usable bot.json */
+        }
+        for (const entry of readDirSafe(botDir)) {
+            if (!entry.isFile() || !/^session.*\.json$/.test(entry.name))
+                continue;
+            try {
+                const session = JSON.parse(fs.readFileSync(path.join(botDir, entry.name), "utf8"));
+                if (typeof session.sessionId === "string" && session.sessionId.trim())
+                    sessionIds.add(session.sessionId.trim());
+            }
+            catch {
+                /* unreadable session file */
+            }
+        }
+    }
+    return { hqRoots: [...hqRoots], sessionIds: [...sessionIds] };
+}
+function isBotSession(name, sessionIds) {
+    return sessionIds.some((id) => name.includes(id));
+}
+function isUnder(child, parent) {
+    const rel = path.relative(path.resolve(parent), path.resolve(child));
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+/** When each of the Claude app's own Code sessions was last used. */
+function claudeAppSessionTimes(home, bots, sessionIds, windowStart) {
+    const times = [];
+    const root = path.join(home, "Library", "Application Support", "Claude", "claude-code-sessions");
+    for (const account of readDirSafe(root)) {
+        if (!account.isDirectory())
+            continue;
+        for (const org of readDirSafe(path.join(root, account.name))) {
+            if (!org.isDirectory())
+                continue;
+            const orgDir = path.join(root, account.name, org.name);
+            for (const file of readDirSafe(orgDir)) {
+                if (!file.isFile() || !file.name.startsWith("local_") || !file.name.endsWith(".json"))
+                    continue;
+                const full = path.join(orgDir, file.name);
+                const mtime = mtimeMs(full);
+                // A record is rewritten whenever its session is used, so one untouched
+                // since before the window cannot hold a use inside it.
+                if (mtime === null || mtime < windowStart)
+                    continue;
+                if (isBotSession(file.name, sessionIds))
+                    continue;
+                const head = readHead(full) ?? "";
+                const cliSessionId = jsonString(head, "cliSessionId");
+                if (cliSessionId && sessionIds.includes(cliSessionId))
+                    continue;
+                const cwd = jsonString(head, "cwd");
+                if (cwd && isUnder(cwd, bots))
+                    continue;
+                const used = jsonNumber(head, "lastActivityAt") ?? jsonNumber(head, "createdAt") ?? mtime;
+                times.push(used);
+                if (times.length >= MAX_FILES_PER_TOOL)
+                    return times;
+            }
+        }
+    }
+    return times;
+}
+/**
+ * Is this the Codex app's own session? Reads `originator` and `source` from
+ * the start of the rollout's first line (its `session_meta` record).
+ */
+export function isCodexAppSession(head) {
+    const firstLine = head.split("\n", 1)[0] ?? "";
+    if (!/"type"\s*:\s*"session_meta"/.test(firstLine))
+        return false;
+    if (jsonString(firstLine, "originator") !== CODEX_APP_ORIGINATOR)
+        return false;
+    // A sub-agent thread has an object source; `codex exec` says "exec".
+    if (/"source"\s*:\s*\{/.test(firstLine))
+        return false;
+    const source = jsonString(firstLine, "source");
+    return source !== "exec";
+}
+/** Last-used times of the Codex app's own sessions. */
+function codexAppSessionTimes(root, sessionIds, oldestDay, windowStart) {
+    const times = [];
+    const walk = (dir, depth, datePrefix) => {
+        for (const entry of readDirSafe(dir)) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (depth >= 3)
+                    continue;
+                const dated = /^\d+$/.test(entry.name);
+                const prefix = dated ? (datePrefix ? `${datePrefix}-${entry.name}` : entry.name) : datePrefix;
+                // sessions/YYYY/MM/DD: a year, month or day wholly before the window is skipped.
+                if (dated && prefix < oldestDay.slice(0, prefix.length))
+                    continue;
+                if (!walk(full, depth + 1, prefix))
+                    return false;
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.startsWith("rollout-") || !entry.name.endsWith(".jsonl"))
+                continue;
+            if (isBotSession(entry.name, sessionIds))
+                continue;
+            const t = mtimeMs(full);
+            if (t === null || t < windowStart)
+                continue;
+            const head = readHead(full);
+            if (!head || !isCodexAppSession(head))
+                continue;
+            times.push(t);
+            if (times.length >= MAX_FILES_PER_TOOL)
+                return false;
+        }
+        return true;
+    };
+    walk(path.join(root, "sessions"), 0, "");
+    return times;
+}
+function localDay(ms) {
+    const d = new Date(ms);
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+/** Sessions and distinct days within the window ending at `now`. */
+export function summarizeActivity(times, now, windowDays) {
+    const end = now.getTime();
+    const start = end - windowDays * DAY_MS;
+    const days = new Set();
+    let sessions = 0;
+    for (const t of times) {
+        if (t < start || t > end)
+            continue;
+        sessions += 1;
+        days.add(localDay(t));
+    }
+    return { sessions, days: days.size };
+}
+export function qualifies(activity, threshold = SIGNIFICANT_CODING_TOOL_ACTIVITY) {
+    if (activity.installed === false)
+        return false;
+    return activity.sessions >= threshold.minSessions && activity.days >= threshold.minDistinctDays;
+}
+/**
+ * The app to offer: the one that qualifies, or, when both do, the one with
+ * more sessions in the window (Claude on a tie).
+ */
+export function pickCodingTool(claude, codex, threshold = SIGNIFICANT_CODING_TOOL_ACTIVITY) {
+    const c = qualifies(claude, threshold);
+    const x = qualifies(codex, threshold);
+    if (c && x)
+        return codex.sessions > claude.sessions ? "codex" : "claude";
+    if (c)
+        return "claude";
+    if (x)
+        return "codex";
+    return null;
+}
+/** Look for the Claude and Codex desktop apps and their recent sessions, and pick one to offer, if any. */
+export function detectCodingToolActivity(input) {
+    const home = input.home ?? os.homedir();
+    const env = input.env ?? process.env;
+    const platform = input.platform ?? process.platform;
+    const threshold = input.threshold ?? SIGNIFICANT_CODING_TOOL_ACTIVITY;
+    const none = { installed: false, sessions: 0, days: 0 };
+    if (platform !== "darwin")
+        return { claude: none, codex: none, pick: null };
+    const bots = input.botsDir ?? botsRoot(home, env);
+    const exclusions = collectHqBotExclusions(bots);
+    const windowStart = input.now.getTime() - threshold.windowDays * DAY_MS;
+    const apps = { home, ...(input.applicationsDirs ? { applicationsDirs: input.applicationsDirs } : {}) };
+    const claudeInstalled = desktopAppInstalled("claude", apps);
+    const codexInstalled = desktopAppInstalled("codex", apps);
+    const claude = claudeInstalled
+        ? {
+            installed: true,
+            ...summarizeActivity(claudeAppSessionTimes(home, bots, exclusions.sessionIds, windowStart), input.now, threshold.windowDays),
+        }
+        : none;
+    const oldestDay = localDay(input.now.getTime() - (threshold.windowDays + CODEX_FOLDER_MARGIN_DAYS) * DAY_MS);
+    const codex = codexInstalled
+        ? {
+            installed: true,
+            ...summarizeActivity(codexAppSessionTimes(codexHome(home, env), exclusions.sessionIds, oldestDay, windowStart), input.now, threshold.windowDays),
+        }
+        : none;
+    return { claude, codex, pick: pickCodingTool(claude, codex, threshold) };
+}
+//# sourceMappingURL=coding-tool-activity.js.map

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

@@ -49,6 +49,7 @@ import { type BotApi, type InboxItem } from "./api.js";
 import type { BotConfig, BotKind } from "./config.js";
 import { containsNoReplySentinel, type ProgressPosterOptions } from "./progress.js";
 import { type BotLogger } from "./log.js";
+import { type CodingToolActivity, type DetectCodingToolActivityInput } from "./coding-tool-activity.js";
 import { type BotRuntime, type RuntimeTurnInput, type RuntimeTurnResult } from "./runtime/index.js";
 import type { VaultObjectDownloader } from "../agent-kit/attachment-download.js";
 import { type HeartbeatAgentUidSource, type HeartbeatCredsSource, type HeartbeatIdentityMismatchReporter } from "../heartbeat-identity.js";
@@ -166,6 +167,12 @@ export interface BotRunDeps {
      * exit: the place to start a replacement when no supervisor will.
      */
     onCliUpdateRestart?: (update: CliUpdate, log: BotLogger) => void;
+    /**
+     * The setup bot's look at this computer's Claude Code and Codex use before
+     * its first message (coding-tool-activity.ts). Injected in tests so they
+     * never read the real home folder.
+     */
+    detectCodingToolActivity?: (input: DetectCodingToolActivityInput) => CodingToolActivity;
 }
 export declare const KICKOFF_MESSAGE_ID = "kickoff";
 /**

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 {

package/package.json

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