@phnx-labs/agents-cli 1.20.51 → 1.20.53

package/dist/lib/session/state.js

@@ -15,8 +15,35 @@
  * shape + mtime — same function, driven off the normalized events.
  */
 import { 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
+ * uses, plus common Claude/Codex/Gemini limit strings.
+ */
+export function detectRateLimited(text) {
+    if (!text)
+        return false;
+    const t = text.toLowerCase();
+    return (/\brate[- ]?limit(ed|s)?\b/.test(t) ||
+        /\btoo many requests\b/.test(t) ||
+        /\b429\b/.test(t) ||
+        /\busage[- ]?limit(ed)?\b/.test(t) ||
+        /\bhit your (usage |rate )?limit\b/.test(t) ||
+        /\byou('ve| have) (hit|reached|exceeded) (your |the )?(rate |usage )?limit\b/.test(t) ||
+        /\bout of (credits|quota)\b/.test(t) ||
+        /\bquota exceeded\b/.test(t) ||
+        /\btry again (in|later|after)\b/.test(t) && /\b(limit|rate|quota|throttl)\b/.test(t));
+}
 /** A healthy live session writes several times a minute; 2 min ⇒ "recently active". */
 const ACTIVE_WINDOW_MS = 2 * 60_000;
+/**
+ * A prose trailing question ("…?") is a HEURISTIC, so it decays: past this long
+ * with no session writes it stops classifying as waiting_input — otherwise a
+ * finished session that signed off with "anything else?" reads as needing input
+ * forever (RUSH-1522). The structural ExitPlanMode / AskUserQuestion signals are
+ * exempt: they are precise, still-unanswered decisions.
+ */
+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';
@@ -299,7 +326,11 @@ export function inferActivity(events, ctx = {}) {
         }
         // Assistant spoke last and stopped. A trailing question → waiting; else idle.
         // A prose question takes a free-text reply (no select-list), so no options/keys.
-        if (looksLikeQuestion(last.content ?? '')) {
+        // Unlike the structural plan/ask signals above, the prose heuristic DECAYS: a
+        // question nobody answered within PROSE_QUESTION_FRESH_MS is a session that
+        // ended, not one that needs you (RUSH-1522). Unknown mtime keeps the question.
+        const questionFresh = ctx.mtimeMs == null || Date.now() - ctx.mtimeMs < PROSE_QUESTION_FRESH_MS;
+        if (questionFresh && looksLikeQuestion(last.content ?? '')) {
             const text = oneLine(last.content ?? '');
             return { ...base, activity: 'waiting_input', awaitingReason: 'question', question: { text, reason: 'question' } };
         }
@@ -366,6 +397,23 @@ export function inferSessionState(events, ctx = {}) {
     const state = inferActivity(events, ctx);
     const { pr, ticket, createdTickets, spawnedTeam } = detectDurableSignals(events);
     const worktree = detectWorktree(ctx.cwd, ctx.gitBranch);
+    // Rate-limit: scan the most recent assistant messages + tool errors (tail-first).
+    let rateLimited = false;
+    for (let i = events.length - 1; i >= 0 && i >= events.length - 12; i--) {
+        const e = events[i];
+        if (!e)
+            continue;
+        if (e.type === 'message' && e.role === 'assistant' && detectRateLimited(e.content)) {
+            rateLimited = true;
+            break;
+        }
+        if (e.type === 'tool_result' && detectRateLimited(e.output)) {
+            rateLimited = true;
+            break;
+        }
+    }
+    if (!rateLimited && detectRateLimited(state.preview))
+        rateLimited = true;
     return {
         ...state,
         pr: pr ?? state.pr,
@@ -373,5 +421,6 @@ export function inferSessionState(events, ctx = {}) {
         ticket: ticket ?? detectTicket(undefined, ctx.gitBranch) ?? state.ticket,
         createdTickets,
         spawnedTeam,
+        rateLimited: rateLimited || undefined,
     };
 }

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

@@ -8,11 +8,30 @@
  * chunk to the existing content parsers so there's zero duplicated parse logic.
  */
 import type { SessionAgentId, SessionEvent } from './types.js';
+/** A tail read: the last few normalized events plus the raw text they came from. */
+export interface SessionTail {
+    events: SessionEvent[];
+    /** The raw JSONL chunk (leading partial line dropped), for content-level math. */
+    content: string;
+}
+/**
+ * Read the last `maxBytes` of a JSONL transcript as cleaned text. A tail that
+ * begins mid-file yields one malformed leading line, which is dropped here so
+ * downstream per-line parsers only see whole lines. Returns '' on any error or
+ * empty file.
+ */
+export declare function readSessionTailContent(filePath: string, maxBytes?: number): string;
 /**
  * Read the last `maxBytes` of a JSONL transcript and return its last
- * `maxEvents` normalized events. A tail that begins mid-line yields one
- * malformed leading line, which the per-line JSON try/catch in the content
- * parsers skips. Only Claude and Codex are supported (the prioritized harnesses
- * for live state); other agents return `[]`.
+ * `maxEvents` normalized events *and* the raw text they were parsed from — the
+ * raw text feeds content-level readouts (e.g. token throughput) that need the
+ * lines the event model discards (Codex `token_count`). Only Claude and Codex
+ * are supported (the prioritized harnesses for live state); other agents return
+ * an empty tail.
+ */
+export declare function readSessionTailWithRaw(filePath: string, agent: SessionAgentId, maxBytes?: number, maxEvents?: number): SessionTail;
+/**
+ * Read the last `maxEvents` normalized events from a JSONL transcript tail. Thin
+ * wrapper over {@link readSessionTailWithRaw} for callers that only need events.
  */
 export declare function readSessionTail(filePath: string, agent: SessionAgentId, maxBytes?: number, maxEvents?: number): SessionEvent[];

package/dist/lib/session/tail.js

@@ -12,26 +12,23 @@ import { parseClaudeContent, parseCodexContent, sanitizeEvents } from './parse.j
 const DEFAULT_MAX_BYTES = 128 * 1024;
 const DEFAULT_MAX_EVENTS = 60;
 /**
- * Read the last `maxBytes` of a JSONL transcript and return its last
- * `maxEvents` normalized events. A tail that begins mid-line yields one
- * malformed leading line, which the per-line JSON try/catch in the content
- * parsers skips. Only Claude and Codex are supported (the prioritized harnesses
- * for live state); other agents return `[]`.
+ * Read the last `maxBytes` of a JSONL transcript as cleaned text. A tail that
+ * begins mid-file yields one malformed leading line, which is dropped here so
+ * downstream per-line parsers only see whole lines. Returns '' on any error or
+ * empty file.
  */
-export function readSessionTail(filePath, agent, maxBytes = DEFAULT_MAX_BYTES, maxEvents = DEFAULT_MAX_EVENTS) {
-    if (agent !== 'claude' && agent !== 'codex')
-        return [];
+export function readSessionTailContent(filePath, maxBytes = DEFAULT_MAX_BYTES) {
     let fd;
     try {
         fd = fs.openSync(filePath, 'r');
     }
     catch {
-        return [];
+        return '';
     }
     try {
         const size = fs.fstatSync(fd).size;
         if (size === 0)
-            return [];
+            return '';
         const start = Math.max(0, size - maxBytes);
         const len = size - start;
         const buf = Buffer.alloc(len);
@@ -42,16 +39,37 @@ export function readSessionTail(filePath, agent, maxBytes = DEFAULT_MAX_BYTES, m
             const nl = content.indexOf('\n');
             content = nl >= 0 ? content.slice(nl + 1) : '';
         }
-        if (!content.trim())
-            return [];
-        const events = agent === 'codex' ? parseCodexContent(content) : parseClaudeContent(content);
-        sanitizeEvents(events);
-        return events.length > maxEvents ? events.slice(-maxEvents) : events;
+        return content;
     }
     catch {
-        return [];
+        return '';
     }
     finally {
         fs.closeSync(fd);
     }
 }
+/**
+ * Read the last `maxBytes` of a JSONL transcript and return its last
+ * `maxEvents` normalized events *and* the raw text they were parsed from — the
+ * raw text feeds content-level readouts (e.g. token throughput) that need the
+ * lines the event model discards (Codex `token_count`). Only Claude and Codex
+ * are supported (the prioritized harnesses for live state); other agents return
+ * an empty tail.
+ */
+export function readSessionTailWithRaw(filePath, agent, maxBytes = DEFAULT_MAX_BYTES, maxEvents = DEFAULT_MAX_EVENTS) {
+    if (agent !== 'claude' && agent !== 'codex')
+        return { events: [], content: '' };
+    const content = readSessionTailContent(filePath, maxBytes);
+    if (!content.trim())
+        return { events: [], content: '' };
+    const events = agent === 'codex' ? parseCodexContent(content) : parseClaudeContent(content);
+    sanitizeEvents(events);
+    return { events: events.length > maxEvents ? events.slice(-maxEvents) : events, content };
+}
+/**
+ * Read the last `maxEvents` normalized events from a JSONL transcript tail. Thin
+ * wrapper over {@link readSessionTailWithRaw} for callers that only need events.
+ */
+export function readSessionTail(filePath, agent, maxBytes = DEFAULT_MAX_BYTES, maxEvents = DEFAULT_MAX_EVENTS) {
+    return readSessionTailWithRaw(filePath, agent, maxBytes, maxEvents).events;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Live output-token throughput.
+ *
+ * Computes a rolling tokens-per-second readout from a session transcript's raw
+ * content. This is the single source of truth for the throughput number the
+ * Factory Floor shows next to a running agent — the extension used to carry its
+ * own copy of this math (`computeOutputTokensPerSec`); it now reads `tokPerSec`
+ * straight off `agents sessions --active --json` instead (issue #741).
+ */
+/** Agents whose transcript formats report per-turn output-token usage. */
+export type ThroughputAgent = 'claude' | 'codex' | 'gemini';
+/** Rolling window (seconds) the throughput average is computed over. */
+export declare const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
+/**
+ * Output-token throughput (tokens/sec) over the last `windowSec` seconds.
+ *
+ * Sums output tokens (plus reasoning/thoughts tokens when the format reports
+ * them separately) from entries whose timestamp falls within the window, and
+ * divides by the window length.
+ *
+ * Formats:
+ *   - Claude: JSONL. Each assistant turn is `{type: 'assistant', timestamp,
+ *     message: {usage: {output_tokens}}}`.
+ *   - Codex:  JSONL. Each token_count event is `{type: 'event_msg', timestamp,
+ *     payload: {type: 'token_count', info: {last_token_usage: {output_tokens,
+ *     reasoning_output_tokens}}}}`. `last_token_usage` is per-turn (not cumulative).
+ *   - Gemini: single JSON object. `{messages: [{type: 'gemini', timestamp,
+ *     tokens: {output, thoughts}}]}`. Caller must pass the whole file.
+ */
+export declare function computeTokPerSec(sessionContent: string, agent: ThroughputAgent, windowSec?: number, now?: number): number;

package/dist/lib/session/throughput.js

@@ -0,0 +1,86 @@
+/**
+ * Live output-token throughput.
+ *
+ * Computes a rolling tokens-per-second readout from a session transcript's raw
+ * content. This is the single source of truth for the throughput number the
+ * Factory Floor shows next to a running agent — the extension used to carry its
+ * own copy of this math (`computeOutputTokensPerSec`); it now reads `tokPerSec`
+ * straight off `agents sessions --active --json` instead (issue #741).
+ */
+/** Rolling window (seconds) the throughput average is computed over. */
+export const DEFAULT_THROUGHPUT_WINDOW_SEC = 60;
+/**
+ * Output-token throughput (tokens/sec) over the last `windowSec` seconds.
+ *
+ * Sums output tokens (plus reasoning/thoughts tokens when the format reports
+ * them separately) from entries whose timestamp falls within the window, and
+ * divides by the window length.
+ *
+ * Formats:
+ *   - Claude: JSONL. Each assistant turn is `{type: 'assistant', timestamp,
+ *     message: {usage: {output_tokens}}}`.
+ *   - Codex:  JSONL. Each token_count event is `{type: 'event_msg', timestamp,
+ *     payload: {type: 'token_count', info: {last_token_usage: {output_tokens,
+ *     reasoning_output_tokens}}}}`. `last_token_usage` is per-turn (not cumulative).
+ *   - Gemini: single JSON object. `{messages: [{type: 'gemini', timestamp,
+ *     tokens: {output, thoughts}}]}`. Caller must pass the whole file.
+ */
+export function computeTokPerSec(sessionContent, agent, windowSec = DEFAULT_THROUGHPUT_WINDOW_SEC, now = Date.now()) {
+    const cutoff = now - windowSec * 1000;
+    let total = 0;
+    if (agent === 'gemini') {
+        try {
+            const d = JSON.parse(sessionContent);
+            const messages = Array.isArray(d?.messages) ? d.messages : [];
+            for (const m of messages) {
+                if (m?.type !== 'gemini')
+                    continue;
+                const ts = typeof m.timestamp === 'string' ? Date.parse(m.timestamp) : 0;
+                if (!ts || ts < cutoff)
+                    continue;
+                const out = typeof m?.tokens?.output === 'number' ? m.tokens.output : 0;
+                const thoughts = typeof m?.tokens?.thoughts === 'number' ? m.tokens.thoughts : 0;
+                total += out + thoughts;
+            }
+        }
+        catch { /* malformed gemini file → 0 */ }
+        return total / windowSec;
+    }
+    const lines = sessionContent.split(/\r?\n/);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line || line[0] !== '{')
+            continue;
+        if (!line.includes('output_tokens'))
+            continue;
+        try {
+            const d = JSON.parse(line);
+            const ts = typeof d.timestamp === 'string' ? Date.parse(d.timestamp) : 0;
+            if (!ts)
+                continue;
+            if (ts < cutoff)
+                break;
+            if (agent === 'claude') {
+                if (d?.type !== 'assistant')
+                    continue;
+                const out = typeof d?.message?.usage?.output_tokens === 'number' ? d.message.usage.output_tokens : 0;
+                total += out;
+            }
+            else {
+                if (d?.type !== 'event_msg')
+                    continue;
+                const payload = d?.payload;
+                if (payload?.type !== 'token_count')
+                    continue;
+                const last = payload?.info?.last_token_usage;
+                if (!last)
+                    continue;
+                const out = typeof last.output_tokens === 'number' ? last.output_tokens : 0;
+                const reasoning = typeof last.reasoning_output_tokens === 'number' ? last.reasoning_output_tokens : 0;
+                total += out + reasoning;
+            }
+        }
+        catch { /* skip malformed line */ }
+    }
+    return total / windowSec;
+}

package/dist/lib/shim-heal.d.ts

@@ -1,7 +1,16 @@
+import type { SelfHealReport } from './self-heal/types.js';
+export interface InteractiveShimHealResult {
+    noticeLines: string[] | null;
+    report: SelfHealReport;
+}
 /**
- * Heal the shim/shadow/PATH conditions silently, then return the notice lines to
- * print ONCE for whatever is left (a real-binary shadow we won't move; a PATH entry
- * that was just added / needs a reload), or null when there's nothing new to say.
+ * Heal the shim/shadow/PATH conditions silently, then return both the raw report
+ * and the notice lines to print ONCE for whatever is left (a real-binary shadow we
+ * won't move; a PATH entry that was just added / needs a reload).
+ */
+export declare function runInteractiveShimHeal(): Promise<InteractiveShimHealResult>;
+/**
+ * Back-compat wrapper for callers that only need the persistent one-time notice.
  */
 export declare function healShimsInteractive(): Promise<string[] | null>;
 type PathNoticeState = 'ok' | 'added' | 'reload';

package/dist/lib/shim-heal.js

@@ -12,11 +12,11 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { getRuntimeStateDir } from './state.js';
 /**
- * Heal the shim/shadow/PATH conditions silently, then return the notice lines to
- * print ONCE for whatever is left (a real-binary shadow we won't move; a PATH entry
- * that was just added / needs a reload), or null when there's nothing new to say.
+ * Heal the shim/shadow/PATH conditions silently, then return both the raw report
+ * and the notice lines to print ONCE for whatever is left (a real-binary shadow we
+ * won't move; a PATH entry that was just added / needs a reload).
  */
-export async function healShimsInteractive() {
+export async function runInteractiveShimHeal() {
     const { runSelfHeal } = await import('./self-heal/registry.js');
     const report = await runSelfHeal({ checks: ['shims', 'shadowing', 'path'], mode: 'safe' });
     const shadowNotes = [];
@@ -37,7 +37,7 @@ export async function healShimsInteractive() {
     const pathState = pathAdded ? 'added' : pathReload ? 'reload' : 'ok';
     const signature = computeShimNoticeSignature({ shadowNotes, pathState });
     if (!shouldSurfaceShimNotice(signature))
-        return null;
+        return { noticeLines: null, report };
     const lines = [];
     if (pathAdded) {
         lines.push(pathAdded);
@@ -52,7 +52,13 @@ export async function healShimsInteractive() {
             lines.push(`  ${note}`);
         lines.push("It's a real binary (not a symlink), so agents-cli won't move it — reorder PATH or remove it to hand it over.");
     }
-    return lines.length > 0 ? lines : null;
+    return { noticeLines: lines.length > 0 ? lines : null, report };
+}
+/**
+ * Back-compat wrapper for callers that only need the persistent one-time notice.
+ */
+export async function healShimsInteractive() {
+    return (await runInteractiveShimHeal()).noticeLines;
 }
 function noticeStatePath() {
     return path.join(getRuntimeStateDir(), 'shim-notice.json');

package/dist/lib/staleness/detectors/subagents.js

@@ -1,5 +1,6 @@
 /**
  * Subagents detector. Claude: flat .md files under `<agentDir>/agents/`.
+ * Codex: flat .toml files under `<versionHome>/.codex/agents/`.
  * Droid: flat .md files under `<versionHome>/.factory/droids/`.
  * OpenClaw: subdirectories containing AGENTS.md under `<versionHome>/.openclaw/`.
  * Mirrors versions.ts:521-539.
@@ -8,12 +9,12 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { capableAgents } from '../../capabilities.js';
 import { lazyAgentMap } from '../writers/lazy-map.js';
-function buildClaudeDetector() {
+function buildFlatMdAgentsDetector(agent, agentsRoot) {
     return {
         kind: 'subagents',
-        agent: 'claude',
+        agent,
         list({ versionHome }) {
-            const agentsDir = path.join(versionHome, '.claude', 'agents');
+            const agentsDir = path.join(versionHome, agentsRoot, 'agents');
             if (!fs.existsSync(agentsDir))
                 return [];
             return fs.readdirSync(agentsDir)
@@ -22,6 +23,26 @@ function buildClaudeDetector() {
         },
     };
 }
+function buildClaudeDetector() {
+    return buildFlatMdAgentsDetector('claude', '.claude');
+}
+function buildGrokDetector() {
+    return buildFlatMdAgentsDetector('grok', '.grok');
+}
+function buildCodexDetector() {
+    return {
+        kind: 'subagents',
+        agent: 'codex',
+        list({ versionHome }) {
+            const agentsDir = path.join(versionHome, '.codex', 'agents');
+            if (!fs.existsSync(agentsDir))
+                return [];
+            return fs.readdirSync(agentsDir)
+                .filter(f => f.endsWith('.toml'))
+                .map(f => f.replace(/\.toml$/, ''));
+        },
+    };
+}
 function buildDroidDetector() {
     return {
         kind: 'subagents',
@@ -50,8 +71,41 @@ function buildOpenclawDetector() {
         },
     };
 }
+function buildKimiDetector() {
+    return {
+        kind: 'subagents',
+        agent: 'kimi',
+        list({ versionHome }) {
+            const agentsDir = path.join(versionHome, '.kimi-code', 'agents');
+            if (!fs.existsSync(agentsDir))
+                return [];
+            // Parent is `_agents-cli.yaml` (underscore-prefixed reserved name).
+            return fs.readdirSync(agentsDir)
+                .filter(f => f.endsWith('.yaml') && !f.startsWith('_'))
+                .map(f => f.replace(/\.yaml$/, ''));
+        },
+    };
+}
+function buildOpenCodeDetector() {
+    return {
+        kind: 'subagents',
+        agent: 'opencode',
+        list({ versionHome }) {
+            const agentsDir = path.join(versionHome, '.config', 'opencode', 'agents');
+            if (!fs.existsSync(agentsDir))
+                return [];
+            return fs.readdirSync(agentsDir)
+                .filter(f => f.endsWith('.md'))
+                .map(f => f.replace(/\.md$/, ''));
+        },
+    };
+}
 const handlers = {
     claude: buildClaudeDetector,
+    grok: buildGrokDetector,
+    codex: buildCodexDetector,
+    kimi: buildKimiDetector,
+    opencode: buildOpenCodeDetector,
     droid: buildDroidDetector,
     openclaw: buildOpenclawDetector,
 };

package/dist/lib/staleness/writers/hooks.js

@@ -30,9 +30,13 @@ function buildHooksWriter(agent) {
                 fs.chmodSync(destFile, 0o755);
                 synced.push(hook);
             }
-            // Native hook registration in settings.json/hooks.json. Grok auto-
-            // discovers from ~/.grok/hooks/ so the file copy is sufficient.
-            if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid') {
+            // Native hook registration in settings.json/hooks.json. Grok is included
+            // so subrule-bundled guards (absolute paths outside the central hooks/
+            // copy set) get registered into ~/.grok/hooks/hooks.json via
+            // registerHooksForGrok — file copy alone only sees top-level available.hooks
+            // names (RUSH-1353). Copilot/Kiro/Goose load managed *.json under their
+            // hooks dirs the same way.
+            if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'antigravity' || agent === 'kimi' || agent === 'droid' || agent === 'copilot' || agent === 'kiro' || agent === 'goose' || agent === 'cursor' || agent === 'grok') {
                 registerHooksToSettings(agent, versionHome);
             }
             return { synced };

package/dist/lib/staleness/writers/subagents.js

@@ -1,8 +1,9 @@
 /**
  * Subagents writer. Claude flattens each subagent into a single .md file
- * under `<agentDir>/agents/`. Droid (Factory AI) flattens each into a custom
- * droid .md under `<versionHome>/.factory/droids/`. OpenClaw copies the full
- * subagent directory (with AGENT.md renamed to AGENTS.md) into
+ * under `<agentDir>/agents/`. Codex writes TOML under `.codex/agents/`.
+ * Droid (Factory AI) flattens each into a custom droid .md under
+ * `<versionHome>/.factory/droids/`. OpenClaw copies the full subagent
+ * directory (with AGENT.md renamed to AGENTS.md) into
  * `<versionHome>/.openclaw/<name>/`.
  *
  * Source-side discovery is `listInstalledSubagents` from lib/subagents.ts —
@@ -12,7 +13,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { capableAgents } from '../../capabilities.js';
-import { listInstalledSubagents, transformSubagentForClaude, transformSubagentForDroid, syncSubagentToOpenclaw } from '../../subagents.js';
+import { listInstalledSubagents, transformSubagentForClaude, transformSubagentForCodex, writeKimiSubagentFiles, buildKimiSubagentsParentYaml, KIMI_SUBAGENTS_PARENT_FILE, transformSubagentForOpenCode, transformSubagentForDroid, syncSubagentToOpenclaw, parseSubagentFrontmatter, } from '../../subagents.js';
 import { safeJoin } from '../../paths.js';
 import { lazyAgentMap } from './lazy-map.js';
 function buildSubagentsWriter(agent) {
@@ -28,12 +29,28 @@ function buildSubagentsWriter(agent) {
                 if (!sub)
                     continue;
                 try {
-                    if (agent === 'claude') {
-                        const agentsDir = path.join(versionHome, '.claude', 'agents');
+                    if (agent === 'claude' || agent === 'grok') {
+                        const agentsDir = path.join(versionHome, agent === 'grok' ? '.grok' : '.claude', 'agents');
                         fs.mkdirSync(agentsDir, { recursive: true });
                         fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.md`), transformSubagentForClaude(sub.path));
                         synced.push(sub.name);
                     }
+                    else if (agent === 'codex') {
+                        const agentsDir = path.join(versionHome, '.codex', 'agents');
+                        fs.mkdirSync(agentsDir, { recursive: true });
+                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.toml`), transformSubagentForCodex(sub.path));
+                        synced.push(sub.name);
+                    }
+                    else if (agent === 'kimi') {
+                        writeKimiSubagentFiles(path.join(versionHome, '.kimi-code', 'agents'), sub.path, sub.name);
+                        synced.push(sub.name);
+                    }
+                    else if (agent === 'opencode') {
+                        const agentsDir = path.join(versionHome, '.config', 'opencode', 'agents');
+                        fs.mkdirSync(agentsDir, { recursive: true });
+                        fs.writeFileSync(safeJoin(agentsDir, `${sub.name}.md`), transformSubagentForOpenCode(sub.path));
+                        synced.push(sub.name);
+                    }
                     else if (agent === 'droid') {
                         const droidsDir = path.join(versionHome, '.factory', 'droids');
                         fs.mkdirSync(droidsDir, { recursive: true });
@@ -49,6 +66,20 @@ function buildSubagentsWriter(agent) {
                 }
                 catch { /* per-item sync failure: skip */ }
             }
+            // Kimi parent agent file listing all synced subagents for --agent-file.
+            if (agent === 'kimi' && synced.length > 0) {
+                const agentsDir = path.join(versionHome, '.kimi-code', 'agents');
+                const entries = synced.map((name) => {
+                    const sub = map.get(name);
+                    const fm = parseSubagentFrontmatter(path.join(sub.path, 'AGENT.md'));
+                    return {
+                        name,
+                        description: fm?.description ?? name,
+                        relativePath: `./${name}.yaml`,
+                    };
+                });
+                fs.writeFileSync(safeJoin(agentsDir, KIMI_SUBAGENTS_PARENT_FILE), buildKimiSubagentsParentYaml(entries));
+            }
             return { synced };
         },
     };

package/dist/lib/startup/command-registry.d.ts

@@ -30,6 +30,7 @@ export declare const loadCommands: ModuleLoader;
 export declare const loadHooks: ModuleLoader;
 export declare const loadSkills: ModuleLoader;
 export declare const loadRules: ModuleLoader;
+export declare const loadMemory: ModuleLoader;
 export declare const loadPermissions: ModuleLoader;
 export declare const loadMcp: ModuleLoader;
 export declare const loadCli: ModuleLoader;
@@ -83,6 +84,7 @@ export declare const loadSessions: ModuleLoader;
 export declare const loadTeams: ModuleLoader;
 export declare const loadCloud: ModuleLoader;
 export declare const loadMessage: ModuleLoader;
+export declare const loadFeed: ModuleLoader;
 export declare const loadServe: ModuleLoader;
 export declare const loadAudit: ModuleLoader;
 /**

package/dist/lib/startup/command-registry.js

@@ -8,6 +8,7 @@ export const loadCommands = async () => (await import('../../commands/commands.j
 export const loadHooks = async () => (await import('../../commands/hooks.js')).registerHooksCommands;
 export const loadSkills = async () => (await import('../../commands/skills.js')).registerSkillsCommands;
 export const loadRules = async () => (await import('../../commands/rules.js')).registerRulesCommands;
+export const loadMemory = async () => (await import('../../commands/memory.js')).registerMemoryCommands;
 export const loadPermissions = async () => (await import('../../commands/permissions.js')).registerPermissionsCommands;
 export const loadMcp = async () => (await import('../../commands/mcp.js')).registerMcpCommands;
 export const loadCli = async () => (await import('../../commands/cli.js')).registerCliCommands;
@@ -61,6 +62,7 @@ export const loadSessions = async () => (await import('../../commands/sessions.j
 export const loadTeams = async () => (await import('../../commands/teams.js')).registerTeamsCommands;
 export const loadCloud = async () => (await import('../../commands/cloud.js')).registerCloudCommands;
 export const loadMessage = async () => (await import('../../commands/message.js')).registerMessageCommand;
+export const loadFeed = async () => (await import('../../commands/feed.js')).registerFeedCommand;
 export const loadServe = async () => (await import('../../commands/serve.js')).registerServeCommand;
 export const loadAudit = async () => (await import('../../commands/audit.js')).registerAuditCommands;
 /**
@@ -93,6 +95,7 @@ export const COMMAND_LOADERS = {
     hooks: [loadHooks],
     skills: [loadSkills],
     rules: [loadRules],
+    memory: [loadMemory],
     permissions: [loadPermissions],
     mcp: [loadMcp],
     cli: [loadCli],
@@ -154,6 +157,7 @@ export const COMMAND_LOADERS = {
     teams: [loadTeams],
     cloud: [loadCloud],
     message: [loadMessage],
+    feed: [loadFeed],
     serve: [loadServe],
     audit: [loadAudit],
 };

package/dist/lib/state.d.ts

@@ -122,6 +122,8 @@ export declare function getProjectRoutinesDir(cwd?: string): string | null;
 export declare function getRunsDir(): string;
 /** Root for per-agent mailboxes (~/.agents/.history/mailbox/). */
 export declare function getMailboxRootDir(): string;
+/** Root for open-block feed records (~/.agents/.history/feed/). */
+export declare function getFeedDir(): string;
 /** Path to installed agent CLI binaries (~/.agents/.history/versions/). */
 export declare function getVersionsDir(): string;
 /** Path to version-switching shim scripts (~/.agents/.cache/shims/). */