@phnx-labs/agents-cli 1.20.84 → 1.20.86

package/dist/lib/feed-broadcast.js

@@ -0,0 +1,131 @@
+/**
+ * Fan an `agents feed post` out to the systems the operator actually watches.
+ *
+ * A post is already durable — it lands in the append-only activity log and shows
+ * up in `agents feed --filter updates`. But an operator who is away from every
+ * terminal never sees it, and the tracker that owns the work (a Linear ticket,
+ * a GitHub issue) hears nothing at all. So a post can also be mirrored outward.
+ *
+ * Sinks are **argv templates from config**, never hardcoded integrations. This
+ * CLI ships Apache-2.0 and must not depend on one person's tracker or messaging
+ * stack; declaring `[linear, update, "{ticket}", --comment, "{text}"]` in
+ * `agents.yaml` keeps the coupling in the operator's config where it belongs,
+ * and lets someone else point the same mechanism at `jira`, `gh issue comment`,
+ * or a webhook script.
+ *
+ * Two rules decide whether a sink runs, both derived from the post itself:
+ *
+ *   - **Level.** `minLevel: important` keeps a sink for the posts worth
+ *     interrupting someone over, so a routine "CI green" does not buzz a phone.
+ *   - **Placeholders.** A template that references `{ticket}` is skipped when no
+ *     ticket is known. The template declares what it needs; nothing has to
+ *     restate it as a flag, and a sink can never fire with a hole in its argv.
+ *
+ * Delivery is best-effort and reported: a sink that fails prints a warning and
+ * the post still stands. Losing a mirror must never cost the operator the post.
+ */
+import { spawnSync } from 'child_process';
+const LEVEL_RANK = { milestone: 0, important: 1 };
+/** Parse a `--level` value; anything unrecognized is a usage error, not a default. */
+export function parseFeedPostLevel(raw) {
+    const v = (raw ?? '').trim().toLowerCase();
+    if (!v || v === 'milestone')
+        return 'milestone';
+    if (v === 'important')
+        return 'important';
+    throw new Error(`Unknown --level '${raw}'. Use milestone or important.`);
+}
+const PLACEHOLDER = /\{([a-z]+)\}/g;
+/**
+ * A human-facing one-liner for a messaging sink: what project, what happened,
+ * and the link to go read more. Leading with the project is deliberate — a
+ * message that opens with an agent name tells the reader nothing about which of
+ * their projects just moved.
+ */
+export function composeBroadcastMessage(ctx) {
+    const head = ctx.project ? `${ctx.project} · ${ctx.text}` : ctx.text;
+    const link = ctx.links?.find((l) => /^https?:\/\//i.test(l));
+    return link ? `${head}\n${link}` : head;
+}
+/** The values a template may reference, resolved once per post. */
+function templateVars(ctx) {
+    return {
+        text: ctx.text,
+        ticket: ctx.ticket,
+        project: ctx.project,
+        agent: ctx.agent,
+        host: ctx.host,
+        session: ctx.session,
+        level: ctx.level,
+        links: ctx.links?.length ? ctx.links.join(' ') : undefined,
+        message: composeBroadcastMessage(ctx),
+    };
+}
+/**
+ * Substitute `{placeholder}` tokens in an argv template. Returns undefined when
+ * the template needs a value this post does not have — the sink is then skipped
+ * rather than run with an empty argument, which is how a `linear update --comment`
+ * would otherwise comment on nothing.
+ */
+export function renderSinkArgv(template, ctx) {
+    const vars = templateVars(ctx);
+    const argv = [];
+    for (const token of template) {
+        let missing = false;
+        const rendered = token.replace(PLACEHOLDER, (whole, key) => {
+            const value = vars[key];
+            if (value === undefined || value === '') {
+                missing = true;
+                return whole;
+            }
+            return value;
+        });
+        if (missing)
+            return undefined;
+        argv.push(rendered);
+    }
+    return argv.length > 0 ? argv : undefined;
+}
+/**
+ * Which sinks this post reaches, in config order. Pure — the dry-run listing and
+ * the real fan-out plan through here, so what `--dry-run` shows is what runs.
+ */
+export function planFeedBroadcast(config, ctx) {
+    if (!config)
+        return [];
+    const planned = [];
+    for (const [name, sink] of Object.entries(config)) {
+        if (!Array.isArray(sink?.command) || sink.command.length === 0)
+            continue;
+        const min = sink.minLevel ?? 'milestone';
+        if (LEVEL_RANK[ctx.level] < LEVEL_RANK[min])
+            continue;
+        const argv = renderSinkArgv(sink.command, ctx);
+        if (!argv)
+            continue;
+        planned.push({ name, argv });
+    }
+    return planned;
+}
+/**
+ * Run the planned sinks. Each is a direct spawn with a bounded lifetime; a sink
+ * that fails or is not installed is reported, never thrown — the post is already
+ * written and must not be undone by a mirror that could not be reached.
+ */
+export function runFeedBroadcast(planned, timeoutMs = 20_000) {
+    return planned.map(({ name, argv }) => {
+        const result = spawnSync(argv[0], argv.slice(1), {
+            encoding: 'utf-8',
+            timeout: timeoutMs,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        if (result.error) {
+            return { name, ok: false, error: result.error.message };
+        }
+        if (result.status !== 0) {
+            const tail = (result.stderr || result.stdout || '').trim().split('\n').slice(-1)[0];
+            return { name, ok: false, error: tail || `exited ${result.status}` };
+        }
+        return { name, ok: true };
+    });
+}

package/dist/lib/hosts/remote-cmd.js

@@ -116,6 +116,11 @@ export const RUN_OPTION_FORWARDING = {
     tailscale: 'local-only', // --tailscale/--no-tailscale gate the lease net mode; never forwarded
     copyCreds: 'local-only', // copies creds TO the host before dispatch — local concern only
     authCheck: 'local-only', // --no-auth-check gates the local interactive login preflight; --host runs skip that preflight entirely
+    // The notification must land on the box the PERSON is at — the one that
+    // dispatched — not on a headless worker with no desktop to post to. The local
+    // process follows the remote run to completion, so its exit handler fires at
+    // the right moment anyway.
+    notify: 'local-only',
     // Deprecated alias for --device auto; resolved on the launching box before SSH.
     smart: 'local-only',
 };

package/dist/lib/menubar/MenubarHelper.app/Contents/_CodeSignature/CodeResources

@@ -6,7 +6,7 @@
 	<dict>
 		<key>Resources/AppIcon.icns</key>
 		<data>
-		Vd5nfogg74zSRNspluv4uvDecUA=
+		DFq5H08EkhgWIC3UvGMR9B58BZw=
 		</data>
 	</dict>
 	<key>files2</key>
@@ -15,7 +15,7 @@
 		<dict>
 			<key>hash2</key>
 			<data>
-			DznVe0VgYOux7+B/aiHNgGYLCvSJKzgXDTPJn2jNkNg=
+			mBSjM6jlvN7J1jQowsvqTl7CHM0pur0e6qsHMuzk5k0=
 			</data>
 		</dict>
 	</dict>

package/dist/lib/models.d.ts

@@ -57,6 +57,27 @@ export interface ModelSource {
  * Returns null if nothing usable is found.
  */
 export declare function locateModelSource(agent: AgentId, version: string): ModelSource | null;
+/**
+ * Parse `grok models` stdout into a catalog. Exported for unit tests.
+ *
+ * Output shape (verified 0.2.118):
+ *   You are logged in with grok.com.
+ *
+ *   Default model: grok-4.5
+ *
+ *   Available models:
+ *     * grok-4.5 (default)
+ *
+ * The `Default model:` line is authoritative; rows may also carry a leading `*`
+ * and a `(default)` flag. Grok has no `--json` on this subcommand. Settings live
+ * in `config.toml` / `models_cache.json`, not `settings.json`, so the native
+ * settings.json reader cannot surface the default — the catalog is the source
+ * that makes `resolveConfiguredModel` return a cli-default for Grok.
+ */
+export declare function parseGrokModelsStdout(stdout: string): {
+    models: ModelInfo[];
+    aliases: Record<string, string>;
+};
 /**
  * Build (or load from cache) the model catalog for a specific (agent, version).
  * Cache is keyed on source-file mtime (binary or js module), so re-extracts

package/dist/lib/models.js

@@ -3,15 +3,15 @@
  *
  * Each agent ships its model list differently -- Claude and Codex embed it in
  * compiled bundles/binaries, Gemini exports it from a JS module, and OpenCode/
- * Cursor/OpenClaw expose it via CLI commands. This module provides a unified
- * `getModelCatalog()` and `resolveModel()` interface over all of them, backed
- * by a file-system cache keyed on source mtime.
+ * Cursor/OpenClaw/Antigravity/Kimi/Grok expose it via CLI commands. This
+ * module provides a unified `getModelCatalog()` and `resolveModel()` interface
+ * over all of them, backed by a file-system cache keyed on source mtime.
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import { execFileSync } from 'child_process';
 import chalk from 'chalk';
-import { getVersionDir, getVersionHomePath } from './versions.js';
+import { getVersionDir, getVersionHomePath, getBinaryPath } from './versions.js';
 import { getModelsCachePath } from './state.js';
 import { agentConfigDirName } from './agents.js';
 import { resolveRunDefaults } from './run-defaults.js';
@@ -188,6 +188,36 @@ export function locateModelSource(agent, version) {
             return { path: pathBin, kind: 'cli' };
         return null;
     }
+    if (agent === 'grok') {
+        // Grok ships a native binary under the version home's `.grok/downloads/`,
+        // not node_modules/.bin. Prefer a real binary over a failed-download stub
+        // (a 99-byte placeholder sometimes left beside a prior good download).
+        const preferred = getBinaryPath('grok', version);
+        if (isUsableGrokBinary(preferred))
+            return { path: preferred, kind: 'cli' };
+        const downloads = path.join(getVersionHomePath('grok', version), '.grok', 'downloads');
+        try {
+            const candidates = fs
+                .readdirSync(downloads)
+                .filter((e) => e.startsWith('grok-'))
+                .map((e) => path.join(downloads, e))
+                .filter(isUsableGrokBinary)
+                .sort((a, b) => {
+                try {
+                    return fs.statSync(b).size - fs.statSync(a).size;
+                }
+                catch {
+                    return 0;
+                }
+            });
+            if (candidates[0])
+                return { path: candidates[0], kind: 'cli' };
+        }
+        catch {
+            /* empty downloads */
+        }
+        return null;
+    }
     if (agent === 'cursor') {
         // cursor-agent is installed via curl script, not agents-cli. Version argument
         // is accepted for API symmetry but ignored -- cursor lives on PATH.
@@ -198,6 +228,16 @@ export function locateModelSource(agent, version) {
     }
     return null;
 }
+/** Real Grok binaries are ~100MB+; failed-download stubs are tens of bytes. */
+function isUsableGrokBinary(filePath) {
+    try {
+        const st = fs.statSync(filePath);
+        return st.isFile() && st.size > 1024 * 1024;
+    }
+    catch {
+        return false;
+    }
+}
 /** Search PATH for a command and return its absolute path, or null. */
 function findOnPath(command) {
     const pathEnv = process.env.PATH || '';
@@ -679,6 +719,93 @@ function extractAntigravityCatalog(binaryPath) {
     }
     return { models, aliases: {} };
 }
+/**
+ * Parse `grok models` stdout into a catalog. Exported for unit tests.
+ *
+ * Output shape (verified 0.2.118):
+ *   You are logged in with grok.com.
+ *
+ *   Default model: grok-4.5
+ *
+ *   Available models:
+ *     * grok-4.5 (default)
+ *
+ * The `Default model:` line is authoritative; rows may also carry a leading `*`
+ * and a `(default)` flag. Grok has no `--json` on this subcommand. Settings live
+ * in `config.toml` / `models_cache.json`, not `settings.json`, so the native
+ * settings.json reader cannot surface the default — the catalog is the source
+ * that makes `resolveConfiguredModel` return a cli-default for Grok.
+ */
+export function parseGrokModelsStdout(stdout) {
+    // Strip ANSI in case a spinner or color codes slip through.
+    // eslint-disable-next-line no-control-regex
+    const plain = stdout.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+    let defaultId = null;
+    const defaultLine = plain.match(/Default model:\s*(\S+)/i);
+    if (defaultLine)
+        defaultId = defaultLine[1];
+    const models = [];
+    const seen = new Set();
+    for (const raw of plain.split('\n')) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        // Rows: "* grok-4.5 (default)" or "grok-4.5" or "  grok-code-fast-1"
+        const m = line.match(/^\*?\s*([A-Za-z0-9][A-Za-z0-9._-]*)(?:\s+\(([^)]*)\))?\s*$/);
+        if (!m)
+            continue;
+        const id = m[1];
+        // Real model ids are grok-* (or match the Default model: line). Skip banner words.
+        if (!/^grok[-_]/i.test(id) && id !== defaultId)
+            continue;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const flags = (m[2] ?? '').split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+        models.push({
+            id,
+            isDefault: (defaultId != null && id === defaultId) || flags.includes('default'),
+        });
+    }
+    // If Default model was set but did not appear as a row, still surface it.
+    if (defaultId && !seen.has(defaultId)) {
+        models.unshift({ id: defaultId, isDefault: true });
+    }
+    // Normalize: exactly one default when we know the Default model: id.
+    if (defaultId) {
+        for (const model of models)
+            model.isDefault = model.id === defaultId;
+    }
+    else if (models.length > 0 && !models.some((model) => model.isDefault)) {
+        models[0].isDefault = true;
+    }
+    return { models, aliases: {} };
+}
+/** Extract Grok's catalog via `grok models` (see parseGrokModelsStdout). */
+function extractGrokCatalog(binaryPath) {
+    const env = { ...process.env };
+    // Point GROK_HOME at the version home that owns this binary so auth +
+    // models_cache come from the right install, not a host ~/.grok symlink.
+    // binary: <home>/.grok/downloads/grok-<ver>-...
+    const downloadsDir = path.dirname(binaryPath);
+    if (path.basename(downloadsDir) === 'downloads') {
+        env.GROK_HOME = path.dirname(downloadsDir);
+    }
+    let stdout;
+    try {
+        stdout = execFileSync(binaryPath, ['models'], {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 15_000,
+            maxBuffer: 8 * 1024 * 1024,
+            env,
+        });
+    }
+    catch {
+        return { models: [], aliases: {} };
+    }
+    return parseGrokModelsStdout(stdout);
+}
 /**
  * Extract Kimi's catalog via `kimi provider list --json`, which emits the raw
  * providers/models config. Model ids are the `models` object keys (e.g.
@@ -789,6 +916,8 @@ export function getModelCatalog(agent, version) {
             ({ models, aliases } = extractAntigravityCatalog(src.path));
         else if (agent === 'kimi')
             ({ models, aliases } = extractKimiCatalog(src.path));
+        else if (agent === 'grok')
+            ({ models, aliases } = extractGrokCatalog(src.path));
     }
     const catalog = {
         agent,

package/dist/lib/run-notify.d.ts

@@ -0,0 +1,27 @@
+import { type DesktopNotification } from './menubar/notify-desktop.js';
+export interface RunNotifyContext {
+    /** Agent that ran, e.g. `claude`. */
+    agent: string;
+    /** `--name` slug when the caller named the run; falls back to the agent. */
+    name?: string;
+    /** The prompt, used for a one-line reminder of what the run was about. */
+    prompt?: string;
+    /** Working directory the run was scoped to; its basename names the project. */
+    cwd?: string;
+    /** Machine the run executed on, when it was dispatched off-box. */
+    host?: string;
+    /** Clickable target — a PR/ticket URL the caller already knows. */
+    url?: string;
+}
+/**
+ * The finish notification for one run. Pure — the exit handler and the tests
+ * both build through here, so what ships is what is asserted.
+ */
+export declare function buildRunFinishNotification(ctx: RunNotifyContext, exitCode: number): DesktopNotification;
+/**
+ * Post the finish notification when this process exits. Best-effort by
+ * construction: `notifyDesktop` swallows its own failures, and a run killed
+ * outright (SIGKILL) never reaches an exit handler — that is the documented
+ * limit, not a case to paper over.
+ */
+export declare function armRunFinishNotification(ctx: RunNotifyContext): void;

package/dist/lib/run-notify.js

@@ -0,0 +1,54 @@
+/**
+ * Desktop notification when a headless `agents run` finishes (`--notify`).
+ *
+ * The notifying process is the one that OWNS the run. That is the whole point:
+ * the menu bar's quick dispatch used to post its completion notice from the
+ * dispatching MenubarHelper's process-termination callback, so a helper that
+ * restarted (an upgrade, a crash) took the callback with it — the run kept
+ * going, reparented to launchd, and no notification could ever fire. Posting
+ * from the run process instead means the notice survives anything that happens
+ * to the menu bar, and `notifyDesktop` spawns a FRESH one-shot notifier, so it
+ * does not need a helper to have been running at dispatch time either.
+ *
+ * Armed once via `process.on('exit')` so it covers every way the run command
+ * terminates — local spawn, `--host` dispatch, `--lease` box, the error path —
+ * rather than being sprinkled over ~50 `process.exit` call sites where the next
+ * new exit path would silently miss it.
+ */
+import * as path from 'path';
+import { notifyDesktop } from './menubar/notify-desktop.js';
+/** Notification body cap: a banner truncates anyway, and a wall of text is noise. */
+const BODY_MAX = 120;
+function shorten(text, max = BODY_MAX) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+/**
+ * The finish notification for one run. Pure — the exit handler and the tests
+ * both build through here, so what ships is what is asserted.
+ */
+export function buildRunFinishNotification(ctx, exitCode) {
+    const label = ctx.name?.trim() || ctx.agent;
+    const project = ctx.cwd ? path.basename(ctx.cwd) : undefined;
+    const where = [project, ctx.host].filter(Boolean).join(' · ');
+    const n = {
+        title: exitCode === 0 ? `${label} finished` : `${label} failed`,
+        body: shorten(ctx.prompt?.trim() || `${ctx.agent} run`),
+    };
+    if (where)
+        n.subtitle = where;
+    if (ctx.url)
+        n.action = `url:${ctx.url}`;
+    return n;
+}
+/**
+ * Post the finish notification when this process exits. Best-effort by
+ * construction: `notifyDesktop` swallows its own failures, and a run killed
+ * outright (SIGKILL) never reaches an exit handler — that is the documented
+ * limit, not a case to paper over.
+ */
+export function armRunFinishNotification(ctx) {
+    process.on('exit', (code) => {
+        notifyDesktop(buildRunFinishNotification(ctx, code));
+    });
+}

package/dist/lib/secrets/Agents CLI.app/Contents/_CodeSignature/CodeResources

@@ -6,7 +6,7 @@
 	<dict>
 		<key>Resources/AppIcon.icns</key>
 		<data>
-		Vd5nfogg74zSRNspluv4uvDecUA=
+		DFq5H08EkhgWIC3UvGMR9B58BZw=
 		</data>
 	</dict>
 	<key>files2</key>
@@ -15,7 +15,7 @@
 		<dict>
 			<key>hash2</key>
 			<data>
-			DznVe0VgYOux7+B/aiHNgGYLCvSJKzgXDTPJn2jNkNg=
+			mBSjM6jlvN7J1jQowsvqTl7CHM0pur0e6qsHMuzk5k0=
 			</data>
 		</dict>
 		<key>embedded.provisionprofile</key>

package/dist/lib/session/parse.d.ts

@@ -27,6 +27,17 @@ export declare function safeReadSessionFile(filePath: string, maxBytes?: number)
 export declare function parseSession(filePath: string, agent?: SessionAgentId): SessionEvent[];
 /** Infer the agent type from a session file path using known directory conventions. */
 export declare function detectAgent(filePath: string): SessionAgentId | null;
+/**
+ * Checklist-snapshot tool names across harnesses — each sends the WHOLE list on
+ * every write, so the last call is the current checklist. Claude `TodoWrite`,
+ * Kimi `TodoList`, Droid/OpenCode `todo_write`, Codex `update_plan`.
+ */
+export declare const SNAPSHOT_TODO_TOOLS: Set<string>;
+/**
+ * Whether a harness's checklist status means "finished". Claude/Codex write
+ * `completed`; Kimi writes `done`.
+ */
+export declare function isCompletedTodoStatus(status: unknown): boolean;
 /**
  * Summarize a tool_use into a one-liner string.
  */

package/dist/lib/session/parse.js

@@ -205,6 +205,19 @@ export function detectAgent(filePath) {
         return 'gemini';
     return null;
 }
+/**
+ * Checklist-snapshot tool names across harnesses — each sends the WHOLE list on
+ * every write, so the last call is the current checklist. Claude `TodoWrite`,
+ * Kimi `TodoList`, Droid/OpenCode `todo_write`, Codex `update_plan`.
+ */
+export const SNAPSHOT_TODO_TOOLS = new Set(['TodoWrite', 'TodoList', 'todo_write', 'update_plan']);
+/**
+ * Whether a harness's checklist status means "finished". Claude/Codex write
+ * `completed`; Kimi writes `done`.
+ */
+export function isCompletedTodoStatus(status) {
+    return status === 'completed' || status === 'done';
+}
 /**
  * Summarize a tool_use into a one-liner string.
  */
@@ -214,12 +227,13 @@ export function summarizeToolUse(tool, args) {
     switch (tool) {
         case 'Bash':
             return `Bash: ${truncate(String(args.command || '').replace(/\n/g, ' ').trim(), 120)}`;
+        // `path` is the Kimi spelling of Claude's `file_path` for the same tools.
         case 'Read':
-            return `Read ${shortenPath(args.file_path || '')}`;
+            return `Read ${shortenPath(args.file_path || args.path || '')}`;
         case 'Write':
-            return `Write ${shortenPath(args.file_path || '')}`;
+            return `Write ${shortenPath(args.file_path || args.path || '')}`;
         case 'Edit':
-            return `Edit ${shortenPath(args.file_path || '')}`;
+            return `Edit ${shortenPath(args.file_path || args.path || '')}`;
         case 'Glob':
             return `Glob ${args.pattern || ''}`;
         case 'Grep':
@@ -234,14 +248,17 @@ export function summarizeToolUse(tool, args) {
             const steps = Array.isArray(args.plan) ? args.plan.length : 0;
             return `Plan: ${steps} step${steps === 1 ? '' : 's'}`;
         }
-        // Claude's live checklist: show progress + the current step, not a bare "TodoWrite".
-        case 'TodoWrite': {
+        // Live checklist: show progress + the current step, not a bare "TodoWrite".
+        // Claude writes `TodoWrite`, Kimi writes `TodoList`; both carry the whole list
+        // under `todos`, with Kimi spelling the item text `title` and "done" `done`.
+        case 'TodoWrite':
+        case 'TodoList': {
             const todos = Array.isArray(args.todos) ? args.todos : [];
             if (todos.length === 0)
                 return 'Plan: 0 steps';
-            const done = todos.filter((t) => t?.status === 'completed').length;
+            const done = todos.filter((t) => isCompletedTodoStatus(t?.status)).length;
             const active = todos.find((t) => t?.status === 'in_progress');
-            const step = active?.activeForm || active?.content;
+            const step = active?.activeForm || active?.content || active?.title;
             return step
                 ? `Plan ${done}/${todos.length}: ${truncate(String(step), 80)}`
                 : `Plan: ${done}/${todos.length} done`;

package/dist/lib/session/state.d.ts

@@ -119,11 +119,12 @@ export interface StateContext {
     activeWindowMs?: number;
 }
 /**
- * Derive live plan progress from a checklist tool call's args. Accepts both
- * Claude's `TodoWrite` (`todos: [{content,status,activeForm}]`) and Codex's
- * `update_plan` (`plan: [{step,status}]`) shapes, so the CLI is the single source
- * of checklist state for every agent. Returns undefined when there is no usable
- * list, so a session with no plan carries no `todos` field.
+ * Derive live plan progress from a checklist tool call's args. Accepts Claude's
+ * `TodoWrite` (`todos: [{content,status,activeForm}]`), Kimi's `TodoList`
+ * (`todos: [{title,status}]`, where finished is `done` rather than `completed`)
+ * and Codex's `update_plan` (`plan: [{step,status}]`) shapes, so the CLI is the
+ * single source of checklist state for every agent. Returns undefined when there
+ * is no usable list, so a session with no plan carries no `todos` field.
  */
 export declare function extractTodoProgress(args?: Record<string, any>): TodoProgress | undefined;
 /** Fold snapshot checklist tools and Claude TaskCreate/TaskUpdate event logs. */

package/dist/lib/session/state.js

@@ -15,7 +15,7 @@
  * shape + mtime — same function, driven off the normalized events.
  */
 import * as path from 'path';
-import { summarizeToolUse } from './parse.js';
+import { isCompletedTodoStatus, SNAPSHOT_TODO_TOOLS, summarizeToolUse } from './parse.js';
 /**
  * Detect per-session rate-limit / usage-limit signals in assistant or error
  * text (RUSH-1523). Matches the same shapes Factory's prewarm detectBlockingPrompt
@@ -48,15 +48,15 @@ const PROSE_QUESTION_FRESH_MS = 30 * 60_000;
 /** Claude tool names that structurally mean "the agent handed control back to you". */
 const PLAN_TOOL = 'ExitPlanMode';
 const ASK_TOOL = 'AskUserQuestion';
-const SNAPSHOT_TODO_TOOLS = new Set(['TodoWrite', 'todo_write', 'update_plan']);
 const TASK_CREATE_TOOL = 'TaskCreate';
 const TASK_UPDATE_TOOL = 'TaskUpdate';
 /**
- * Derive live plan progress from a checklist tool call's args. Accepts both
- * Claude's `TodoWrite` (`todos: [{content,status,activeForm}]`) and Codex's
- * `update_plan` (`plan: [{step,status}]`) shapes, so the CLI is the single source
- * of checklist state for every agent. Returns undefined when there is no usable
- * list, so a session with no plan carries no `todos` field.
+ * Derive live plan progress from a checklist tool call's args. Accepts Claude's
+ * `TodoWrite` (`todos: [{content,status,activeForm}]`), Kimi's `TodoList`
+ * (`todos: [{title,status}]`, where finished is `done` rather than `completed`)
+ * and Codex's `update_plan` (`plan: [{step,status}]`) shapes, so the CLI is the
+ * single source of checklist state for every agent. Returns undefined when there
+ * is no usable list, so a session with no plan carries no `todos` field.
  */
 export function extractTodoProgress(args) {
     const input = args?.input && typeof args.input === 'object' ? args.input : args;
@@ -76,10 +76,16 @@ export function extractTodoProgress(args) {
                 ? t.text
                 : typeof t?.step === 'string' && t.step
                     ? t.step
-                    : activeForm ?? '';
+                    : typeof t?.title === 'string' && t.title
+                        ? t.title
+                        : activeForm ?? '';
         if (!content)
             continue;
-        const status = t?.status === 'completed' || t?.status === 'in_progress' ? t.status : 'pending';
+        const status = isCompletedTodoStatus(t?.status)
+            ? 'completed'
+            : t?.status === 'in_progress'
+                ? 'in_progress'
+                : 'pending';
         const description = typeof t?.description === 'string' && t.description ? t.description : undefined;
         items.push({ content, status, ...(description ? { description } : {}), ...(activeForm ? { activeForm } : {}) });
     }

package/dist/lib/types.d.ts

@@ -6,6 +6,7 @@
  * formats for each supported agent.
  */
 import type { CloudProviderId } from './cloud/types.js';
+import type { FeedBroadcastConfig } from './feed-broadcast.js';
 /** Unique identifier for a current or legacy AI coding agent. */
 export type AgentId = 'claude' | 'codex' | 'gemini' | 'cursor' | 'opencode' | 'openclaw' | 'copilot' | 'amp' | 'kiro' | 'goose' | 'antigravity' | 'grok' | 'kimi' | 'droid' | 'hermes';
 /** How `agents run <agent>` chooses an installed version when none is pinned. */
@@ -762,6 +763,15 @@ export interface Meta {
     };
     /** Spend guardrails (issue #346). User-global caps; project agents.yaml overrides. */
     budget?: BudgetConfig;
+    /**
+     * `agents feed post` fan-out. `broadcast` maps a sink name to the argv template
+     * run for each post, so mirroring to a tracker or a messaging CLI is the
+     * operator's config rather than an integration compiled into this CLI. See
+     * lib/feed-broadcast.ts and docs/06-observability.md.
+     */
+    feed?: {
+        broadcast?: FeedBroadcastConfig;
+    };
     beta?: {
         enabled?: BetaFeatureName[];
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.84",
+  "version": "1.20.86",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",