@phnx-labs/agents-cli 1.20.61 → 1.20.62

package/dist/lib/hooks.js

@@ -1006,6 +1006,9 @@ export function registerHooksToSettings(agentId, versionHome, hookManifest, agen
     if (agentId === 'cursor') {
         return registerHooksForCursor(versionHome, manifest, resolveScript, managedPrefixes);
     }
+    if (agentId === 'hermes') {
+        return registerHooksForHermes(versionHome, manifest, resolveScript, managedPrefixes);
+    }
     return { registered: [], errors: [] };
 }
 /**
@@ -2186,3 +2189,134 @@ function registerHooksForCursor(versionHome, manifest, resolveScript, managedPre
     }
     return { registered, errors };
 }
+/**
+ * Canonical → Hermes (Nous Research) snake_case lifecycle events.
+ *
+ * Hermes ≥ 0.11.0 runs configurable hooks declared under `hooks:` in
+ * ~/.hermes/config.yaml. Only events with a documented Hermes equivalent are
+ * mapped; unmapped canonical events (the manifest may declare events for other
+ * agents) are skipped silently. UserPromptSubmit maps to `pre_llm_call` (the
+ * closest pre-turn phase) and Stop to `on_session_finalize`.
+ */
+const HERMES_EVENT_MAP = {
+    SessionStart: 'on_session_start',
+    SessionEnd: 'on_session_end',
+    PreToolUse: 'pre_tool_call',
+    PostToolUse: 'post_tool_call',
+    SubagentStop: 'subagent_stop',
+    UserPromptSubmit: 'pre_llm_call',
+    Stop: 'on_session_finalize',
+};
+/** Hermes caps hook timeouts at 300s (default 60s). */
+const HERMES_TIMEOUT_CAP = 300;
+const HERMES_TIMEOUT_DEFAULT = 60;
+/**
+ * Register hooks for Hermes Agent (Nous Research ≥ 0.11.0).
+ *
+ * Read-modify-writes the shared `~/.hermes/config.yaml` (under the version
+ * home): it merges a `hooks:` block of the form
+ *   hooks: { <event>: [ { command, timeout, matcher? } ] }
+ * into the YAML doc WITHOUT touching sibling keys (`mcp_servers` in
+ * particular — a naive overwrite would wipe the user's MCP servers). No
+ * `version` wrapper: Hermes' config is a flat YAML map.
+ *
+ * GC: rewrite managed entries by command path under managedPrefixes; preserve
+ * user-authored entries whose command is outside managed roots. Keyed by
+ * event|command|matcher so a matcher or event change drops the stale entry.
+ */
+function registerHooksForHermes(versionHome, manifest, resolveScript, managedPrefixes) {
+    const registered = [];
+    const errors = [];
+    const configDir = path.join(versionHome, '.hermes');
+    const configPath = path.join(configDir, 'config.yaml');
+    // Read-modify-write: preserve the full existing YAML doc (mcp_servers, etc.).
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        try {
+            const parsed = yaml.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                config = parsed;
+            }
+        }
+        catch {
+            errors.push('Failed to parse existing config.yaml');
+            return { registered, errors };
+        }
+    }
+    const existingHooks = config.hooks && typeof config.hooks === 'object' && !Array.isArray(config.hooks)
+        ? config.hooks
+        : {};
+    // Desired managed entries keyed by event|command|matcher so a matcher or
+    // event change drops the stale entry instead of retaining it by command alone.
+    const desiredManaged = new Set();
+    for (const [hookName, hookDef] of Object.entries(manifest)) {
+        if (!hookDef.events || hookDef.events.length === 0)
+            continue;
+        const resolved = resolveHookCommand(hookName, hookDef, resolveScript);
+        if (!resolved)
+            continue;
+        for (const event of hookDef.events) {
+            const hermesEvent = HERMES_EVENT_MAP[event];
+            if (!hermesEvent)
+                continue;
+            desiredManaged.add(`${hermesEvent}|${resolved}|${hookDef.matcher ?? ''}`);
+        }
+    }
+    // GC managed entries that are no longer in the manifest; preserve user entries.
+    const hooks = {};
+    for (const [event, entries] of Object.entries(existingHooks)) {
+        if (!Array.isArray(entries))
+            continue;
+        hooks[event] = entries.filter((e) => {
+            if (typeof e?.command !== 'string')
+                return true;
+            if (!isManagedHookCommand(e.command, managedPrefixes))
+                return true;
+            return desiredManaged.has(`${event}|${e.command}|${e.matcher ?? ''}`);
+        });
+        if (hooks[event].length === 0)
+            delete hooks[event];
+    }
+    for (const [name, hookDef] of Object.entries(manifest)) {
+        if (!hookDef.events || hookDef.events.length === 0)
+            continue;
+        const commandPath = resolveHookCommand(name, hookDef, resolveScript);
+        if (!commandPath) {
+            errors.push(`${name}: script not found in user or system hooks dir`);
+            continue;
+        }
+        const timeout = Math.min(HERMES_TIMEOUT_CAP, hookDef.timeout ?? HERMES_TIMEOUT_DEFAULT);
+        for (const event of hookDef.events) {
+            const hermesEvent = HERMES_EVENT_MAP[event];
+            if (!hermesEvent)
+                continue;
+            if (!hooks[hermesEvent])
+                hooks[hermesEvent] = [];
+            const entry = { command: commandPath, timeout };
+            if (hookDef.matcher)
+                entry.matcher = hookDef.matcher;
+            const existingIdx = hooks[hermesEvent].findIndex((h) => h.command === entry.command && (h.matcher ?? '') === (entry.matcher ?? ''));
+            if (existingIdx >= 0) {
+                hooks[hermesEvent][existingIdx] = entry;
+            }
+            else {
+                hooks[hermesEvent].push(entry);
+            }
+            registered.push(`${name} -> ${hermesEvent}`);
+        }
+    }
+    if (Object.keys(hooks).length > 0) {
+        config.hooks = hooks;
+    }
+    else {
+        delete config.hooks;
+    }
+    try {
+        fs.mkdirSync(configDir, { recursive: true });
+        fs.writeFileSync(configPath, yaml.stringify(config), 'utf-8');
+    }
+    catch (err) {
+        errors.push(`Failed to write config.yaml: ${err.message}`);
+    }
+    return { registered, errors };
+}

package/dist/lib/permissions.d.ts

@@ -122,6 +122,21 @@ export declare function convertToDroidFormat(set: PermissionSet): {
     commandAllowlist: string[];
     commandDenylist: string[];
 };
+/**
+ * Convert canonical permission set to OpenClaw's `tools.alsoAllow`/`tools.deny`.
+ *
+ * OpenClaw's allowlist is tool-level only, so ONLY blanket (whole-tool) rules
+ * map — a rule is blanket iff it's a bare tool with no parens (`Bash`), it's in
+ * BLANKET_BASH_FORMS, or its pattern is `*`/`**` (`Read(**)`, `Write(*)`).
+ * Sub-command/path/domain rules (`Bash(git:*)`, `Write(secrets/**)`,
+ * `WebFetch(domain:x)`) are SKIPPED — coarse-mapping a specific deny to a whole
+ * tool would wrongly gate every use of that tool. Output arrays are deduped and
+ * sorted for deterministic writes/tests.
+ */
+export declare function convertToOpenClawFormat(set: PermissionSet): {
+    alsoAllow: string[];
+    deny: string[];
+};
 /**
  * Convert canonical permission set to Antigravity format.
  * Antigravity reads ~/.gemini/antigravity-cli/settings.json with

package/dist/lib/permissions.js

@@ -560,6 +560,60 @@ export function convertToDroidFormat(set) {
         commandDenylist: commands(set.deny ?? []),
     };
 }
+/**
+ * Canonical tool -> OpenClaw tool id. OpenClaw gates at TOOL granularity only
+ * (no sub-command/path/domain patterns), so only these whole-tool ids exist.
+ * Any canonical tool not in this map is unsupported and skipped.
+ */
+const CANONICAL_TO_OPENCLAW_TOOL = {
+    bash: 'exec',
+    read: 'read',
+    write: 'write',
+    edit: 'write',
+    webfetch: 'web_fetch',
+    websearch: 'web_search',
+};
+/**
+ * Convert canonical permission set to OpenClaw's `tools.alsoAllow`/`tools.deny`.
+ *
+ * OpenClaw's allowlist is tool-level only, so ONLY blanket (whole-tool) rules
+ * map — a rule is blanket iff it's a bare tool with no parens (`Bash`), it's in
+ * BLANKET_BASH_FORMS, or its pattern is `*`/`**` (`Read(**)`, `Write(*)`).
+ * Sub-command/path/domain rules (`Bash(git:*)`, `Write(secrets/**)`,
+ * `WebFetch(domain:x)`) are SKIPPED — coarse-mapping a specific deny to a whole
+ * tool would wrongly gate every use of that tool. Output arrays are deduped and
+ * sorted for deterministic writes/tests.
+ */
+export function convertToOpenClawFormat(set) {
+    const map = (permissions) => {
+        const tools = new Set();
+        for (const perm of permissions) {
+            // Bare tool name with no parens (e.g. "Bash", "Read") is a blanket grant;
+            // parseCanonicalPattern requires parens, so handle it first.
+            const bare = perm.match(/^(\w+)$/);
+            if (bare) {
+                const id = CANONICAL_TO_OPENCLAW_TOOL[bare[1].toLowerCase()];
+                if (id)
+                    tools.add(id);
+                continue;
+            }
+            const parsed = parseCanonicalPattern(perm);
+            if (!parsed)
+                continue;
+            const isBlanket = BLANKET_BASH_FORMS.has(perm) || parsed.pattern === '*' || parsed.pattern === '**';
+            if (!isBlanket)
+                continue;
+            const id = CANONICAL_TO_OPENCLAW_TOOL[parsed.tool];
+            if (id)
+                tools.add(id);
+        }
+        return Array.from(tools).sort();
+    };
+    return {
+        alsoAllow: map(set.allow),
+        deny: map(set.deny ?? []),
+    };
+}
 /**
  * Convert canonical permission set to Antigravity format.
  * Antigravity reads ~/.gemini/antigravity-cli/settings.json with
@@ -1570,6 +1624,51 @@ export function applyPermissionsToVersion(agentId, set, versionHome, merge = tru
             fs.writeFileSync(permissionsPath, yaml.stringify(config), 'utf-8');
             return { success: true };
         }
+        if (agentId === 'openclaw') {
+            // OpenClaw's allowlist lives in ~/.openclaw/openclaw.json under `tools`.
+            // Only blanket tool-level rules map (see convertToOpenClawFormat). We
+            // read-modify-write to preserve all other keys (mcp, exec, agents, …) and
+            // never touch `tools.allow` (the absolute allowlist that replaces defaults).
+            const configPath = path.join(versionHome, '.openclaw', 'openclaw.json');
+            let config = {};
+            if (fs.existsSync(configPath)) {
+                config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            }
+            const converted = convertToOpenClawFormat(set);
+            const existingTools = (typeof config.tools === 'object' && config.tools !== null && !Array.isArray(config.tools))
+                ? config.tools
+                : {};
+            let alsoAllow;
+            let deny;
+            if (merge) {
+                const existingAllow = Array.isArray(existingTools.alsoAllow) ? existingTools.alsoAllow : [];
+                const existingDeny = Array.isArray(existingTools.deny) ? existingTools.deny : [];
+                alsoAllow = Array.from(new Set([...existingAllow, ...converted.alsoAllow]));
+                deny = Array.from(new Set([...existingDeny, ...converted.deny]));
+            }
+            else {
+                alsoAllow = converted.alsoAllow;
+                deny = converted.deny;
+            }
+            // Set or delete each key: avoid writing empty arrays (churn). On a
+            // non-merge replace with nothing to write, delete the stale key.
+            const tools = { ...existingTools };
+            if (alsoAllow.length > 0)
+                tools.alsoAllow = alsoAllow;
+            else
+                delete tools.alsoAllow;
+            if (deny.length > 0)
+                tools.deny = deny;
+            else
+                delete tools.deny;
+            if (Object.keys(tools).length > 0)
+                config.tools = tools;
+            else
+                delete config.tools;
+            fs.mkdirSync(path.dirname(configPath), { recursive: true });
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+            return { success: true };
+        }
         return { success: false, error: `Agent '${agentId}' does not support permissions` };
     }
     catch (err) {

package/dist/lib/plugins.d.ts

@@ -211,6 +211,26 @@ export declare function goosePluginsDir(versionHome: string): string;
 export declare function installGoosePlugin(plugin: DiscoveredPlugin, versionHome: string): boolean;
 export declare function isGoosePluginInstalled(pluginName: string, versionHome: string): boolean;
 export declare function removeGoosePlugin(pluginName: string, versionHome: string): boolean;
+/**
+ * Hermes (Nous Research) loads plugins from a flat `$HOME/.hermes/plugins/<name>/`
+ * directory holding a `plugin.yaml` manifest — NOT the Claude marketplace layout.
+ * Under agents-cli version isolation HOME is the version home, so we install to:
+ *   {versionHome}/.hermes/plugins/<name>/
+ * A plugin does not load until its name is added to `plugins.enabled` (a YAML
+ * array) in `{versionHome}/.hermes/config.yaml`; a deny-list `plugins.disabled`
+ * wins on conflict, so agents-cli only manages the `enabled` allowlist and never
+ * touches `disabled` (user-owned).
+ */
+export declare function hermesPluginsDir(versionHome: string): string;
+/**
+ * Add or remove a plugin name in `plugins.enabled` within ~/.hermes/config.yaml,
+ * preserving every other key (read → mutate → write). Never touches
+ * `plugins.disabled`. No-op (no rewrite) when the desired state already holds.
+ */
+export declare function setHermesPluginEnabled(pluginName: string, versionHome: string, enabled: boolean): void;
+export declare function installHermesPlugin(plugin: DiscoveredPlugin, versionHome: string, enable: boolean): boolean;
+export declare function isHermesPluginInstalled(pluginName: string, versionHome: string): boolean;
+export declare function removeHermesPlugin(pluginName: string, versionHome: string): boolean;
 /**
  * Check if a plugin is synced to a version. True when the plugin lives at the
  * native marketplace install path. Legacy dual-dash entries are not counted —

package/dist/lib/plugins.js

@@ -10,6 +10,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import * as yaml from 'yaml';
 import { execFileSync } from 'child_process';
 import { getPluginsDir, getTrashPluginsDir, getExtraPluginsDir, getProjectPluginsDir, getSystemPluginsDir } from './state.js';
 import { IS_WINDOWS, isWindowsAbsolutePath, homeDir } from './platform/index.js';
@@ -22,6 +23,7 @@ import { copyPluginToMarketplace, syncMarketplaceManifest, registerMarketplace,
 const PLUGIN_MANIFEST_DIR = '.claude-plugin';
 const PLUGIN_MANIFEST_FILE = 'plugin.json';
 const GEMINI_EXTENSION_MANIFEST_FILE = 'gemini-extension.json';
+const HERMES_PLUGIN_MANIFEST_FILE = 'plugin.yaml';
 const USER_CONFIG_FILE = '.user-config.json';
 const SOURCE_FILE = '.source';
 export const PLUGIN_EXEC_SURFACE_LABELS = {
@@ -533,6 +535,16 @@ export function syncPluginToVersion(plugin, agent, versionHome, options = {}) {
             result.skills.push(plugin.name);
         return result;
     }
+    // Hermes loads plugins from a flat $HOME/.hermes/plugins/<name>/ dir with a
+    // plugin.yaml manifest, gated by a plugins.enabled allowlist in config.yaml.
+    if (agent === 'hermes') {
+        const enablePlugin = options.allowExecSurfaces === true || !hasPluginExecSurfaces(inspectPluginCapabilities(plugin.root));
+        const ok = installHermesPlugin(plugin, versionHome, enablePlugin);
+        result.success = ok;
+        if (ok)
+            result.skills.push(plugin.name);
+        return result;
+    }
     const userConfig = loadUserConfig(plugin.name);
     // Route every marketplace op through the plugin's own marketplace, so a plugin
     // discovered in an extra/project repo installs under its own
@@ -1035,6 +1047,102 @@ export function removeGoosePlugin(pluginName, versionHome) {
     fs.rmSync(destRoot, { recursive: true, force: true });
     return true;
 }
+// ─── Hermes plugins (flat ~/.hermes/plugins/ + config.yaml enable toggle) ─────
+/**
+ * Hermes (Nous Research) loads plugins from a flat `$HOME/.hermes/plugins/<name>/`
+ * directory holding a `plugin.yaml` manifest — NOT the Claude marketplace layout.
+ * Under agents-cli version isolation HOME is the version home, so we install to:
+ *   {versionHome}/.hermes/plugins/<name>/
+ * A plugin does not load until its name is added to `plugins.enabled` (a YAML
+ * array) in `{versionHome}/.hermes/config.yaml`; a deny-list `plugins.disabled`
+ * wins on conflict, so agents-cli only manages the `enabled` allowlist and never
+ * touches `disabled` (user-owned).
+ */
+export function hermesPluginsDir(versionHome) {
+    return path.join(versionHome, '.hermes', 'plugins');
+}
+function hermesConfigPath(versionHome) {
+    return path.join(versionHome, '.hermes', 'config.yaml');
+}
+function writeHermesPluginManifest(plugin, destRoot) {
+    const manifest = {
+        name: plugin.manifest.name,
+        version: plugin.manifest.version,
+        description: plugin.manifest.description,
+    };
+    fs.writeFileSync(path.join(destRoot, HERMES_PLUGIN_MANIFEST_FILE), yaml.stringify(manifest), 'utf-8');
+}
+/**
+ * Add or remove a plugin name in `plugins.enabled` within ~/.hermes/config.yaml,
+ * preserving every other key (read → mutate → write). Never touches
+ * `plugins.disabled`. No-op (no rewrite) when the desired state already holds.
+ */
+export function setHermesPluginEnabled(pluginName, versionHome, enabled) {
+    const configPath = hermesConfigPath(versionHome);
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        const parsed = yaml.parse(fs.readFileSync(configPath, 'utf-8'));
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            config = parsed;
+        }
+    }
+    if (!config.plugins || typeof config.plugins !== 'object' || Array.isArray(config.plugins)) {
+        config.plugins = {};
+    }
+    const plugins = config.plugins;
+    const current = Array.isArray(plugins.enabled) ? plugins.enabled.filter((n) => typeof n === 'string') : [];
+    const has = current.includes(pluginName);
+    if (enabled && !has) {
+        plugins.enabled = [...current, pluginName];
+    }
+    else if (!enabled && has) {
+        plugins.enabled = current.filter((n) => n !== pluginName);
+    }
+    else {
+        return; // desired state already holds — no rewrite
+    }
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, yaml.stringify(config), 'utf-8');
+}
+export function installHermesPlugin(plugin, versionHome, enable) {
+    const destRoot = path.join(hermesPluginsDir(versionHome), plugin.name);
+    try {
+        if (fs.existsSync(destRoot)) {
+            fs.rmSync(destRoot, { recursive: true, force: true });
+        }
+        fs.cpSync(plugin.root, destRoot, { recursive: true });
+        const userConfig = loadUserConfig(plugin.name);
+        if (Object.keys(userConfig).length > 0) {
+            expandUserConfigInDir(destRoot, userConfig);
+        }
+        writeHermesPluginManifest(plugin, destRoot);
+        fs.writeFileSync(path.join(destRoot, '.agents-cli-managed'), `plugin=${plugin.name}\n`, 'utf-8');
+        // Enable only when trusted — never DOWN-toggle here. An un-flagged background
+        // re-sync of an exec-surface plugin passes enable=false; forcing the allowlist
+        // to false then would clobber a plugin the user deliberately enabled with
+        // --allow-exec-surfaces. Mirror addPluginToSettings: add-if-trusted, else leave
+        // the existing enabled state untouched. (Removal still unregisters explicitly.)
+        if (enable) {
+            setHermesPluginEnabled(plugin.name, versionHome, true);
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isHermesPluginInstalled(pluginName, versionHome) {
+    return fs.existsSync(path.join(hermesPluginsDir(versionHome), pluginName, HERMES_PLUGIN_MANIFEST_FILE));
+}
+export function removeHermesPlugin(pluginName, versionHome) {
+    const destRoot = path.join(hermesPluginsDir(versionHome), pluginName);
+    const existed = fs.existsSync(destRoot);
+    if (existed)
+        fs.rmSync(destRoot, { recursive: true, force: true });
+    // Always drop it from the enabled allowlist, even if the dir was already gone.
+    setHermesPluginEnabled(pluginName, versionHome, false);
+    return existed;
+}
 // ─── Sync status ──────────────────────────────────────────────────────────────
 /**
  * Check if a plugin is synced to a version. True when the plugin lives at the
@@ -1053,6 +1161,9 @@ export function isPluginSynced(plugin, agent, versionHome) {
     if (agent === 'goose') {
         return isGoosePluginInstalled(plugin.name, versionHome);
     }
+    if (agent === 'hermes') {
+        return isHermesPluginInstalled(plugin.name, versionHome);
+    }
     const spec = marketplaceSpecForName(plugin.marketplace);
     if (!isInstalledInMarketplace(plugin.name, spec, agent, versionHome))
         return false;
@@ -1101,6 +1212,13 @@ export function removePluginFromVersion(pluginName, pluginRoot, agent, versionHo
         }
         return result;
     }
+    // Hermes: remove the flat plugin dir and drop it from config.yaml plugins.enabled.
+    if (agent === 'hermes') {
+        if (removeHermesPlugin(pluginName, versionHome)) {
+            result.skills.push(pluginName);
+        }
+        return result;
+    }
     // 1. Remove the plugin from every marketplace it's installed under. A name can
     //    appear in more than one (collision across repos), so we sweep them all.
     let removedAny = false;

package/dist/lib/resources/permissions.js

@@ -75,6 +75,8 @@ function getAgentConfigPath(agent, versionHome) {
             return path.join(versionHome, '.factory', 'settings.json');
         case 'kiro':
             return path.join(versionHome, '.kiro', 'settings', 'permissions.yaml');
+        case 'openclaw':
+            return path.join(versionHome, '.openclaw', 'openclaw.json');
         case 'goose':
             return path.join(versionHome, '.config', 'goose', 'permission.yaml');
         default:

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

@@ -1,6 +1,6 @@
 import type { CloudTaskStatus } from '../cloud/types.js';
 import { type PidSessionEntry } from './pid-registry.js';
-import { type SessionActivity, type AwaitingReason, type StructuredQuestion, type DetectedPr, type DetectedWorktree, type DetectedTicket } from './state.js';
+import { type SessionActivity, type AwaitingReason, type StructuredQuestion, type TodoProgress, type DetectedPr, type DetectedWorktree, type DetectedTicket } from './state.js';
 import type { SessionAttachment } from './types.js';
 import { type SessionProvenance } from './provenance.js';
 /**
@@ -46,6 +46,13 @@ export interface ActiveSession {
      * says whether it is still pending.
      */
     plan?: string;
+    /**
+     * Live plan progress from the most recent `TodoWrite` (RUSH-1380): the checklist
+     * items + a done/total tally + the current step. The Factory Floor renders this
+     * as an N/M pill + checklist for every session — including remote and
+     * device-dispatched agents that have no local tool-call stream to parse.
+     */
+    todos?: TodoProgress;
     /** Last few assistant turns (most-recent last), for at-a-glance context in the UI. */
     tail?: string[];
     /** PR opened during the session. */

package/dist/lib/session/active.js

@@ -267,6 +267,7 @@ function applyState(base, state, fallbackFile) {
         awaitingReason: state.awaitingReason,
         question: state.question,
         plan: state.plan,
+        todos: state.todos,
         tail: state.tail,
         // Prefer the live preview (latest turn); keep the first-prompt topic as a fallback.
         preview: state.preview ?? base.preview,

package/dist/lib/session/parse.js

@@ -225,6 +225,18 @@ 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': {
+            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 active = todos.find((t) => t?.status === 'in_progress');
+            const step = active?.activeForm || active?.content;
+            return step
+                ? `Plan ${done}/${todos.length}: ${truncate(String(step), 80)}`
+                : `Plan: ${done}/${todos.length} done`;
+        }
         // Codex tools
         case 'exec_command':
             return `Bash: ${truncate(String(args.command || args.cmd || '').replace(/\n/g, ' ').trim(), 120)}`;

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

@@ -41,6 +41,28 @@ export interface StructuredQuestion {
     reason: AwaitingReason;
     options?: QuestionOption[];
 }
+/** One `TodoWrite` checklist item, as Claude's plan tool emits it. */
+export interface TodoItem {
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    /** Present-continuous label shown while this item is the active step. */
+    activeForm?: string;
+}
+/**
+ * Live plan progress derived from the most recent `TodoWrite` in the transcript
+ * (RUSH-1380). Lets the Factory Floor show "N/M done" + the current step for any
+ * session — including remote / device-dispatched agents that carry no local
+ * tool-call stream — instead of only a coarse working/idle verb.
+ */
+export interface TodoProgress {
+    items: TodoItem[];
+    /** Count of completed items. */
+    done: number;
+    /** Total items. */
+    total: number;
+    /** The in-progress item's activeForm (falls back to its content). The live step. */
+    activeForm?: string;
+}
 export interface DetectedPr {
     url: string;
     number?: number;
@@ -88,6 +110,12 @@ export interface SessionState {
      * render the actual plan without re-parsing the transcript.
      */
     plan?: string;
+    /**
+     * Live plan progress from the most recent `TodoWrite` (RUSH-1380). Present when
+     * the session has written a todo list; drives the Factory Floor N/M pill +
+     * checklist, notably for remote/device-dispatched agents with no local stream.
+     */
+    todos?: TodoProgress;
     /** Last few assistant turns (most-recent last), one line each — panel context. */
     tail?: string[];
     lastActivityMs?: number;
@@ -111,6 +139,11 @@ export interface StateContext {
     /** Override the running window (defaults to 2 min, matching active.ts). */
     activeWindowMs?: number;
 }
+/**
+ * Derive live plan progress from a `TodoWrite` tool call's args. 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;
 /** Detect a worktree from the session cwd, per the `.agents/worktrees/<slug>/` convention. */
 export declare function detectWorktree(cwd?: string, branch?: string): DetectedWorktree | undefined;
 /** Detect a tracker ticket from free text (prompt/topic) then a branch name. */

package/dist/lib/session/state.js

@@ -47,6 +47,40 @@ 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';
+/** Claude's live plan/checklist tool. */
+const TODO_TOOL = 'TodoWrite';
+/**
+ * Derive live plan progress from a `TodoWrite` tool call's args. Returns undefined
+ * when there is no usable list, so a session with no plan carries no `todos` field.
+ */
+export function extractTodoProgress(args) {
+    const raw = args?.todos;
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    const items = [];
+    for (const t of raw) {
+        const activeForm = typeof t?.activeForm === 'string' && t.activeForm ? t.activeForm : undefined;
+        const content = typeof t?.content === 'string' && t.content
+            ? t.content
+            : typeof t?.text === 'string' && t.text
+                ? t.text
+                : activeForm ?? '';
+        if (!content)
+            continue;
+        const status = t?.status === 'completed' || t?.status === 'in_progress' ? t.status : 'pending';
+        items.push(activeForm ? { content, status, activeForm } : { content, status });
+    }
+    if (items.length === 0)
+        return undefined;
+    const done = items.filter(i => i.status === 'completed').length;
+    const inProgress = items.find(i => i.status === 'in_progress');
+    return {
+        items,
+        done,
+        total: items.length,
+        activeForm: inProgress ? inProgress.activeForm ?? inProgress.content : undefined,
+    };
+}
 /** Trailing '?' or a leading interrogative — a question aimed at the user. */
 const QUESTION_TRAILING = /\?["'”)\]]?\s*$/;
 const QUESTION_PHRASE = /\b(shall i|should i|do you want|would you like|which (?:one|option|approach|of)|can you (?:confirm|clarify)|please (?:confirm|clarify|advise)|let me know|are you (?:ok|okay|sure)|proceed\?)\b/i;
@@ -281,12 +315,18 @@ export function inferActivity(events, ctx = {}) {
         .slice(-3)
         .map(e => oneLine(e.content ?? ''))
         .filter(Boolean);
+    // Live plan progress: the most recent TodoWrite's checklist (RUSH-1380). Attached
+    // to `base` so every return path below carries it — a working, waiting, or idle
+    // session all keep showing how far the plan got.
+    const lastTodo = lastOf(meaningful, e => e.type === 'tool_use' && e.tool === TODO_TOOL);
+    const todos = lastTodo ? extractTodoProgress(lastTodo.args) : undefined;
     const base = {
         activity: 'idle',
         lastRole: lastMsg?.role,
         lastEventKind: last?.type,
         lastActivityMs: ctx.mtimeMs,
         preview: previewSource ? describeEvent(previewSource) : undefined,
+        todos,
         tail: tail.length ? tail : undefined,
     };
     if (!last)