@phnx-labs/agents-cli 1.20.85 → 1.20.86

package/CHANGELOG.md

@@ -1,5 +1,61 @@
 # Changelog
 
+## 1.20.86
+
+- **`agents sessions` now shows a Kimi session's todo list and its file-touching
+  tool calls.** Kimi writes its checklist with `TodoList` (items shaped
+  `{title, status}`, where finished is `done`) rather than Claude's `TodoWrite`
+  (`{content, status: "completed"}`), so the checklist registry matched nothing
+  and every Kimi session rendered with no todos — in the picker preview, the
+  session detail, and the `--active` fan-out that carries progress off remote
+  devices. Kimi also names the file argument `path` where Claude names it
+  `file_path`, so `Read`/`Write`/`Edit` calls summarized as a bare `Read ` with
+  no file. Both spellings are now handled, and the snapshot-checklist tool names
+  live in one exported registry (`SNAPSHOT_TODO_TOOLS`) that the picker and the
+  state engine share instead of each hardcoding its own pair. Source:
+  `apps/cli/src/lib/session/parse.ts`, `apps/cli/src/lib/session/state.ts`,
+  `apps/cli/src/commands/sessions-picker.ts`.
+
+- **`agents view` now shows Grok's default model (e.g. `grok-4.5`).** Claude,
+  Codex, Antigravity, and Kimi already filled the model column via their
+  catalogs; Grok was missing from `locateModelSource`, so
+  `resolveConfiguredModel` returned null and the column stayed blank. Grok has
+  no `settings.json` `model` field (its config is `config.toml` +
+  `models_cache.json`); the authoritative default is `grok models` →
+  `Default model: <id>`. The catalog extractor now spawns that command against
+  the version-home binary (skipping failed-download stubs) and flags the
+  default, so `agents view`, `agents view --json` (`configuredModel`), and the
+  other identity-cluster surfaces show it. Source: `apps/cli/src/lib/models.ts`,
+  `apps/cli/src/commands/models.ts`.
+
+- **`agents events --limit 0` now reads the whole stream, and a capped read says
+  so.** `--limit` parsed as `Math.max(1, parseInt(raw) || 50)`, so `--limit 0`
+  collapsed back to `50` (`0 || 50`) and there was no way to read past the default
+  cap at all. The cap is applied after filtering and before the caller sees
+  anything, so every aggregation over `--json` silently ranked the newest 50
+  records instead of the matching set — measured against a real 7-day corpus of
+  2,135 CLI failures in 9 classes, 8 of 9 ranks came out wrong with counts off by
+  roughly 100x, and nothing warned. `--limit 0` now means no cap (29,649 records
+  on a 30-day stream here, against 50 before), a truncated read prints
+  `Showing the newest 50 — more events matched. Pass --limit 0 for all.` (on
+  stderr under `--json`, so a `| jq` pipeline still receives clean JSON), and a
+  non-numeric, negative, or empty `--limit` exits 2 rather than quietly becoming
+  50 — an empty one (`--limit "$LIMIT"` with the variable unset) would otherwise
+  have read as "no cap" and returned the whole stream unannounced.
+  Source: `apps/cli/src/commands/events.ts`, `apps/cli/tests/events-limit.test.ts`,
+  `apps/cli/docs/06-observability.md`.
+
+- **Desktop notifications now show the current agents-cli mark, not the old
+  logo.** The menu-bar helper's app icon — the icon macOS puts on the left of
+  every notification banner it posts (the menu bar helper's own notices and every
+  `agents run --notify` finish notice) — was generated from the retired gradient
+  "A" logo, so notifications carried stale branding while the menu-bar status
+  item already used the new lowercase `a`. The shared master logo
+  (`assets/logo.png`) is now the current `a` mark, so the menu-bar helper, the
+  `agents computer` helper, and the keychain helper all regenerate their
+  `AppIcon.icns` from it on the next build. Source: `assets/logo.png`,
+  `apps/cli/menubar/scripts/build.sh`.
+
 ## 1.20.85
 
 - **`agents feed post` can now be mirrored to the systems you actually watch.**

package/dist/commands/events.d.ts

@@ -14,4 +14,20 @@
  * today's operational log live.
  */
 import type { Command } from 'commander';
+/**
+ * Resolve `--limit` into a record cap. `0` means "no cap" — without it there is
+ * no way to read the whole stream, and any aggregation (group-by failure, count
+ * per module) silently ranks the newest 50 records instead of the real set.
+ * A non-numeric or negative value is a usage error, not a quiet fallback.
+ */
+export declare function resolveEventsLimit(raw: string | undefined): number | undefined;
+/**
+ * Cap `fetched` (read with `limit + 1`) to `limit`, reporting whether records
+ * were dropped. The caller announces the cap so a truncated read is never
+ * mistaken for the complete set.
+ */
+export declare function capRecords<T>(fetched: T[], limit: number | undefined): {
+    records: T[];
+    truncated: boolean;
+};
 export declare function registerEventsCommand(program: Command): void;

package/dist/commands/events.js

@@ -17,6 +17,33 @@ import chalk from 'chalk';
 import * as fs from 'fs';
 import { getLogsPath } from '../lib/events.js';
 import { readUnifiedEvents } from '../lib/event-stream.js';
+/**
+ * Resolve `--limit` into a record cap. `0` means "no cap" — without it there is
+ * no way to read the whole stream, and any aggregation (group-by failure, count
+ * per module) silently ranks the newest 50 records instead of the real set.
+ * A non-numeric or negative value is a usage error, not a quiet fallback.
+ */
+export function resolveEventsLimit(raw) {
+    const token = raw ?? '50';
+    // Number('') and Number('   ') are both 0, which would read as "no cap" — an
+    // empty --limit (an unset "$LIMIT" in a script) must be rejected, not silently
+    // turned into the unbounded read.
+    const value = token.trim() === '' ? NaN : Number(token);
+    if (!Number.isInteger(value) || value < 0) {
+        throw new RangeError(`Invalid --limit ${raw} — pass a whole number, or 0 for no cap.`);
+    }
+    return value === 0 ? undefined : value;
+}
+/**
+ * Cap `fetched` (read with `limit + 1`) to `limit`, reporting whether records
+ * were dropped. The caller announces the cap so a truncated read is never
+ * mistaken for the complete set.
+ */
+export function capRecords(fetched, limit) {
+    if (limit === undefined || fetched.length <= limit)
+        return { records: fetched, truncated: false };
+    return { records: fetched.slice(0, limit), truncated: true };
+}
 /** Parse `--since`: relative offsets (30s/5m/2h/7d/4w) or an ISO/absolute date. */
 function parseSince(s) {
     const m = s.match(/^(\d+)([smhdw])$/);
@@ -80,7 +107,7 @@ export function registerEventsCommand(program) {
         .option('--agent <name>', 'Only events tagged with this agent')
         .option('--since <time>', 'Only events newer than this (e.g. 2h, 7d, or ISO date)')
         .option('--audit', 'Operational events only (skip agent activity)')
-        .option('--limit <n>', 'Max records to show (default 50)', '50')
+        .option('--limit <n>', 'Max records to show; 0 for no cap (default 50)', '50')
         .option('--json', 'Output raw records as JSON')
         .option('-f, --follow', "Tail today's operational log live")
         .addHelpText('after', `
@@ -90,31 +117,41 @@ Examples:
   agents events --audit                  Operational events only (secrets / teams / ...)
   agents events --event pr.opened --since 7d
   agents events --module secrets         Every secret accessed or revealed
-  agents events -f                       Live tail (operational)`)
+  agents events -f                       Live tail (operational)
+  agents events --event pr.opened --since 30d --limit 0 --json
+                                         Every match — use --limit 0 whenever you
+                                         aggregate, or you rank only the newest 50`)
         .action(async (options) => {
         if (options.follow) {
             await followLog();
             return;
         }
-        const limit = Math.max(1, parseInt(options.limit ?? '50', 10) || 50);
+        let limit;
         let startDate;
         try {
+            limit = resolveEventsLimit(options.limit);
             startDate = options.since ? parseSince(options.since) : undefined;
         }
         catch (err) {
             console.error(chalk.red(err.message));
             process.exit(2);
         }
-        const records = readUnifiedEvents({
+        // Read one past the cap so we can tell a full result from a clipped one.
+        const fetched = readUnifiedEvents({
             startDate,
             eventTypes: options.event && options.event.length ? options.event : undefined,
             agent: options.agent,
             command: options.command,
             module: options.module,
-            limit,
+            limit: limit === undefined ? undefined : limit + 1,
             includeActivity: !options.audit,
         });
+        const { records, truncated } = capRecords(fetched, limit);
+        const capNote = `Showing the newest ${limit} — more events matched. Pass --limit 0 for all.`;
         if (options.json) {
+            // Notice goes to stderr so `--json | jq` still receives clean JSON.
+            if (truncated)
+                console.error(chalk.yellow(capNote));
             console.log(JSON.stringify(records, null, 2));
             return;
         }
@@ -126,6 +163,8 @@ Examples:
         for (const r of records.slice().reverse())
             console.log(renderRow(r));
         console.log(chalk.gray(`\n${records.length} event(s). Log: ${getLogsPath()}`));
+        if (truncated)
+            console.log(chalk.yellow(capNote));
     });
 }
 /** commander repeatable-option collector. */

package/dist/commands/models.js

@@ -13,7 +13,7 @@ import { listInstalledVersions, getGlobalDefault, resolveVersion, resolveVersion
 import { getModelCatalog, locateModelSource } from '../lib/models.js';
 import { terminalWidth, truncateToWidth, stringWidth } from '../lib/session/width.js';
 import { wrapJoined } from './inspect.js';
-const MODEL_CAPABLE_AGENTS = ['claude', 'codex', 'opencode', 'cursor', 'openclaw', 'antigravity', 'kimi'];
+const MODEL_CAPABLE_AGENTS = ['claude', 'codex', 'opencode', 'cursor', 'openclaw', 'antigravity', 'kimi', 'grok'];
 /**
  * Agents that don't necessarily install under ~/.agents/versions (cursor ships
  * via a curl script). For these, fall back to the PATH binary and synthesize

package/dist/commands/sessions-picker.js

@@ -9,7 +9,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
 import { truncate, humanDuration } from '../lib/format.js';
-import { parseSession, sanitizeForTerminal } from '../lib/session/parse.js';
+import { parseSession, sanitizeForTerminal, SNAPSHOT_TODO_TOOLS } from '../lib/session/parse.js';
 import { cleanSessionPrompt, extractSessionTopic } from '../lib/session/prompt.js';
 import { linkPath, linkUrl, relativeToCwd, shortenModel } from '../lib/session/render.js';
 import { linearIssueUrl } from '../lib/session/linear.js';
@@ -312,9 +312,10 @@ function formatCompactPreview(events, session) {
             if (!planFile && p && /\/plans\/[^/]+\.md$/.test(p)) {
                 planFile = p;
             }
-            // Claude TodoWrite (`todos`) and Codex update_plan (`plan`) — same source as
-            // extractTodoProgress in the state engine. Prefer the most recent write.
-            if (tool === 'TodoWrite' || tool === 'update_plan') {
+            // Every harness's checklist-snapshot tool (Claude TodoWrite, Kimi TodoList,
+            // Codex update_plan, …) — the same registry the state engine folds through
+            // extractTodoProgress. Prefer the most recent write.
+            if (SNAPSHOT_TODO_TOOLS.has(tool)) {
                 const progress = extractTodoProgress(event.args);
                 if (progress)
                     latestTodos = progress;

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.85",
+  "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",