@phnx-labs/agents-cli 1.20.5 → 1.20.6

package/dist/lib/run-defaults.js

@@ -0,0 +1,180 @@
+/**
+ * Selector-based defaults for `agents run`.
+ *
+ * Stored under agents.yaml:
+ *
+ *   run:
+ *     defaults:
+ *       "claude:*":
+ *         mode: auto
+ *         model: opus
+ *       "claude:2.1.45":
+ *         mode: plan
+ */
+import { ALL_MODES } from './types.js';
+import { AGENTS } from './agents.js';
+import { readMeta, updateMeta } from './state.js';
+import { getProjectRunConfigs } from './run-config.js';
+const VERSION_RE = /^(?:\*|latest|(?!.*\.\.)[A-Za-z0-9._+-]{1,64})$/;
+function isAgentId(value) {
+    return value in AGENTS;
+}
+export function normalizeRunDefaultMode(input) {
+    const mode = input.trim().toLowerCase();
+    if (mode === 'full')
+        return 'skip';
+    if (ALL_MODES.includes(mode))
+        return mode;
+    throw new Error(`Invalid mode '${input}'. Use one of: ${ALL_MODES.join(', ')} (or 'full' as an alias for 'skip').`);
+}
+function normalizeRunDefaults(defaults, selector) {
+    const out = {};
+    if (defaults.mode !== undefined) {
+        if (typeof defaults.mode !== 'string') {
+            throw new Error(`Invalid mode in run.defaults.${selector}: expected a string.`);
+        }
+        out.mode = normalizeRunDefaultMode(defaults.mode);
+    }
+    if (defaults.model !== undefined) {
+        if (typeof defaults.model !== 'string' || defaults.model.trim() === '') {
+            throw new Error(`Invalid model in run.defaults.${selector}: expected a non-empty string.`);
+        }
+        out.model = defaults.model.trim();
+    }
+    return out;
+}
+export function parseRunDefaultSelector(input) {
+    const raw = input.trim();
+    if (!raw)
+        throw new Error('Selector is required. Use <agent>:<version>, <agent>@<version>, or <agent>:*.');
+    let agentPart;
+    let versionPart;
+    if (raw.includes('@')) {
+        const parts = raw.split('@');
+        if (parts.length !== 2)
+            throw new Error(`Invalid selector '${input}'. Use <agent>@<version>.`);
+        [agentPart, versionPart] = parts;
+    }
+    else if (raw.includes(':')) {
+        const idx = raw.indexOf(':');
+        agentPart = raw.slice(0, idx);
+        versionPart = raw.slice(idx + 1);
+    }
+    else {
+        agentPart = raw;
+        versionPart = '*';
+    }
+    const agent = agentPart.toLowerCase();
+    if (!isAgentId(agent)) {
+        throw new Error(`Invalid agent '${agentPart}'. Available agents: ${Object.keys(AGENTS).join(', ')}.`);
+    }
+    if (!VERSION_RE.test(versionPart)) {
+        throw new Error(`Invalid selector version '${versionPart}'. Use *, latest, or [A-Za-z0-9._+-]{1,64}.`);
+    }
+    return {
+        agent,
+        version: versionPart,
+        selector: `${agent}:${versionPart}`,
+    };
+}
+function sortedDefaults(defaults) {
+    return Object.fromEntries(Object.entries(defaults).sort(([a], [b]) => a.localeCompare(b)));
+}
+export function resolveRunDefaultsFromConfig(runConfig, agent, version) {
+    const defaults = runConfig?.defaults ?? {};
+    const wildcardSelector = `${agent}:*`;
+    const exactSelector = version ? `${agent}:${version}` : null;
+    const resolved = { sources: {} };
+    const wildcard = defaults[wildcardSelector]
+        ? normalizeRunDefaults(defaults[wildcardSelector], wildcardSelector)
+        : null;
+    if (wildcard?.mode) {
+        resolved.mode = wildcard.mode;
+        resolved.sources.mode = wildcardSelector;
+    }
+    if (wildcard?.model) {
+        resolved.model = wildcard.model;
+        resolved.sources.model = wildcardSelector;
+    }
+    if (exactSelector && defaults[exactSelector]) {
+        const exact = normalizeRunDefaults(defaults[exactSelector], exactSelector);
+        if (exact.mode) {
+            resolved.mode = exact.mode;
+            resolved.sources.mode = exactSelector;
+        }
+        if (exact.model) {
+            resolved.model = exact.model;
+            resolved.sources.model = exactSelector;
+        }
+    }
+    return resolved;
+}
+export function resolveRunDefaultsFromConfigs(runConfigs, agent, version) {
+    const resolved = { sources: {} };
+    for (const runConfig of runConfigs) {
+        const next = resolveRunDefaultsFromConfig(runConfig, agent, version);
+        if (next.mode) {
+            resolved.mode = next.mode;
+            resolved.sources.mode = next.sources.mode;
+        }
+        if (next.model) {
+            resolved.model = next.model;
+            resolved.sources.model = next.sources.model;
+        }
+    }
+    return resolved;
+}
+export function resolveRunDefaults(agent, version, startPath = process.cwd()) {
+    const projectRunConfigs = getProjectRunConfigs(startPath).reverse();
+    return resolveRunDefaultsFromConfigs([readMeta().run, ...projectRunConfigs], agent, version);
+}
+export function listRunDefaults() {
+    const defaults = readMeta().run?.defaults ?? {};
+    return Object.entries(defaults)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([selector, value]) => ({
+        selector,
+        defaults: normalizeRunDefaults(value, selector),
+    }));
+}
+export function setRunDefault(selectorInput, defaultsInput) {
+    const parsed = parseRunDefaultSelector(selectorInput);
+    const defaults = normalizeRunDefaults(defaultsInput, parsed.selector);
+    if (!defaults.mode && !defaults.model) {
+        throw new Error('Set at least one default: --mode <mode> or --model <model>.');
+    }
+    updateMeta((meta) => {
+        const run = { ...(meta.run ?? {}) };
+        const currentDefaults = { ...(run.defaults ?? {}) };
+        currentDefaults[parsed.selector] = {
+            ...(currentDefaults[parsed.selector] ?? {}),
+            ...defaults,
+        };
+        run.defaults = sortedDefaults(currentDefaults);
+        return { ...meta, run };
+    });
+    return {
+        selector: parsed.selector,
+        defaults: {
+            ...(readMeta().run?.defaults?.[parsed.selector] ?? {}),
+        },
+    };
+}
+export function unsetRunDefault(selectorInput) {
+    const parsed = parseRunDefaultSelector(selectorInput);
+    let removed = false;
+    updateMeta((meta) => {
+        const run = { ...(meta.run ?? {}) };
+        const currentDefaults = { ...(run.defaults ?? {}) };
+        removed = Object.prototype.hasOwnProperty.call(currentDefaults, parsed.selector);
+        delete currentDefaults[parsed.selector];
+        if (Object.keys(currentDefaults).length > 0) {
+            run.defaults = sortedDefaults(currentDefaults);
+        }
+        else {
+            delete run.defaults;
+        }
+        return { ...meta, run };
+    });
+    return removed;
+}

package/dist/lib/secrets/install-helper.d.ts

@@ -12,10 +12,14 @@
  * modules in `src/lib/secrets/` must import `getKeychainHelperPath()` rather
  * than recomputing it.
  */
+/** Redirect the install root (test only). Returns the previous override so callers can restore. */
+export declare function setInstallRootForTest(dir: string | null): string | null;
 /**
  * Idempotent install. Copies the bundled `.app` to the stable user path. Skips
- * if the destination already exists and `codesign --verify` passes, unless
- * `forceReinstall=true`.
+ * if the destination already exists, `codesign --verify` passes, AND the
+ * installed executable matches the bundled one byte-for-byte — a valid
+ * signature alone is not enough, because an outdated helper signs clean too.
+ * `forceReinstall=true` skips all checks and always copies.
  *
  * Notarization is checked via `spctl --assess` after install — a failure is
  * logged as a warning but does NOT throw. Notarization checks require network
@@ -27,7 +31,11 @@ export declare function ensureKeychainHelperInstalled(opts?: {
 }): void;
 /**
  * Return the absolute path to the helper executable. If the installed bundle
- * is missing, performs a lazy install first.
+ * is missing, or is stale relative to the bundled source helper, performs a
+ * lazy (re)install first. The staleness check is what lets an upgraded CLI
+ * replace a helper a previous version installed — `agents helper install`
+ * never runs on `npm i -g`, so this call site is the only one every machine
+ * is guaranteed to pass through.
  *
  * Throws on non-darwin.
  */

package/dist/lib/secrets/install-helper.js

@@ -14,14 +14,23 @@
  */
 import { fileURLToPath } from 'url';
 import { spawnSync } from 'child_process';
+import { createHash } from 'crypto';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 const APP_BUNDLE_NAME = 'Agents CLI.app';
 const INSTALL_DIR_NAME = 'agents-cli';
+let installRootOverride = null;
+/** Redirect the install root (test only). Returns the previous override so callers can restore. */
+export function setInstallRootForTest(dir) {
+    const prev = installRootOverride;
+    installRootOverride = dir;
+    return prev;
+}
 /** Absolute path to the installed `.app` bundle directory (not the executable). */
 function installedAppPath() {
-    return path.join(os.homedir(), 'Library', 'Application Support', INSTALL_DIR_NAME, APP_BUNDLE_NAME);
+    const root = installRootOverride ?? os.homedir();
+    return path.join(root, 'Library', 'Application Support', INSTALL_DIR_NAME, APP_BUNDLE_NAME);
 }
 /** Absolute path to the executable inside the installed `.app` bundle. */
 function installedExecutablePath() {
@@ -57,6 +66,33 @@ function assertDarwin() {
         throw new Error('Keychain helper is macOS only.');
     }
 }
+function sha256File(filePath) {
+    return createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+/**
+ * True when the installed helper executable differs byte-for-byte from the
+ * bundled source helper. A stale-but-validly-signed helper is exactly how the
+ * broken 1.20.4 build (signed, but missing the keychain-access-groups
+ * entitlement) survived upgrades: codesign --verify passes on it, so the
+ * "exists and verifies" early-return kept it installed forever. Returns false
+ * when there is no bundled source to compare against (dev installs) or no
+ * installed copy yet — both cases are decided by the existence checks in the
+ * callers, not by staleness.
+ */
+function installedHelperIsStale() {
+    let srcApp;
+    try {
+        srcApp = sourceAppPath();
+    }
+    catch {
+        return false;
+    }
+    const srcExec = path.join(srcApp, 'Contents', 'MacOS', 'Agents CLI');
+    const destExec = installedExecutablePath();
+    if (!fs.existsSync(srcExec) || !fs.existsSync(destExec))
+        return false;
+    return sha256File(srcExec) !== sha256File(destExec);
+}
 function codesignVerify(appPath) {
     const r = spawnSync('codesign', ['--verify', '--deep', '--strict', appPath], {
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -86,8 +122,10 @@ function copyAppBundle(src, dest) {
 }
 /**
  * Idempotent install. Copies the bundled `.app` to the stable user path. Skips
- * if the destination already exists and `codesign --verify` passes, unless
- * `forceReinstall=true`.
+ * if the destination already exists, `codesign --verify` passes, AND the
+ * installed executable matches the bundled one byte-for-byte — a valid
+ * signature alone is not enough, because an outdated helper signs clean too.
+ * `forceReinstall=true` skips all checks and always copies.
  *
  * Notarization is checked via `spctl --assess` after install — a failure is
  * logged as a warning but does NOT throw. Notarization checks require network
@@ -99,7 +137,7 @@ export function ensureKeychainHelperInstalled(opts = {}) {
     const dest = installedAppPath();
     if (!opts.forceReinstall && fs.existsSync(dest)) {
         const { ok } = codesignVerify(dest);
-        if (ok)
+        if (ok && !installedHelperIsStale())
             return;
     }
     const src = sourceAppPath();
@@ -119,14 +157,18 @@ export function ensureKeychainHelperInstalled(opts = {}) {
 }
 /**
  * Return the absolute path to the helper executable. If the installed bundle
- * is missing, performs a lazy install first.
+ * is missing, or is stale relative to the bundled source helper, performs a
+ * lazy (re)install first. The staleness check is what lets an upgraded CLI
+ * replace a helper a previous version installed — `agents helper install`
+ * never runs on `npm i -g`, so this call site is the only one every machine
+ * is guaranteed to pass through.
  *
  * Throws on non-darwin.
  */
 export function getKeychainHelperPath() {
     assertDarwin();
     const exec = installedExecutablePath();
-    if (!fs.existsSync(exec)) {
+    if (!fs.existsSync(exec) || installedHelperIsStale()) {
         ensureKeychainHelperInstalled();
     }
     return exec;

package/dist/lib/secrets/linux.d.ts

@@ -43,6 +43,18 @@ export declare function hasSecretToolToken(item: string): boolean;
 export declare function getSecretToolToken(item: string): string;
 export declare function setSecretToolToken(item: string, value: string): void;
 export declare function deleteSecretToolToken(item: string): boolean;
+/**
+ * Parse the item names out of `secret-tool search --all` output, keeping only
+ * those starting with `prefix`. Exported for tests.
+ *
+ * `output` must be the combined stdout+stderr of the search: libsecret splits
+ * the dump across both streams — the value/label/schema lines go to stdout
+ * while the `attribute.*` lines (which carry `attribute.item`, the only place
+ * the item name is reliably machine-readable) go to stderr (observed on
+ * libsecret 0.21.4). Which stream each line lands on has varied across
+ * libsecret versions, so callers concatenate both rather than bet on one.
+ */
+export declare function parseSecretToolItems(output: string, prefix: string): string[];
 /**
  * List secrets by prefix. secret-tool doesn't have a list command,
  * so we use secret-tool search which outputs in a specific format.

package/dist/lib/secrets/linux.js

@@ -345,6 +345,34 @@ export function deleteSecretToolToken(item) {
     // surface that rather than silently swallowing.
     return false;
 }
+/**
+ * Parse the item names out of `secret-tool search --all` output, keeping only
+ * those starting with `prefix`. Exported for tests.
+ *
+ * `output` must be the combined stdout+stderr of the search: libsecret splits
+ * the dump across both streams — the value/label/schema lines go to stdout
+ * while the `attribute.*` lines (which carry `attribute.item`, the only place
+ * the item name is reliably machine-readable) go to stderr (observed on
+ * libsecret 0.21.4). Which stream each line lands on has varied across
+ * libsecret versions, so callers concatenate both rather than bet on one.
+ */
+export function parseSecretToolItems(output, prefix) {
+    const items = [];
+    // Parse output format:
+    // [/org/freedesktop/secrets/collection/login/1]
+    // label = agents-cli: myitem
+    // ...
+    // attribute.item = myitem
+    const itemRegex = /attribute\.item\s*=\s*(.+)/g;
+    let match;
+    while ((match = itemRegex.exec(output)) !== null) {
+        const itemName = match[1].trim();
+        if (itemName.startsWith(prefix)) {
+            items.push(itemName);
+        }
+    }
+    return [...new Set(items)]; // dedupe
+}
 /**
  * List secrets by prefix. secret-tool doesn't have a list command,
  * so we use secret-tool search which outputs in a specific format.
@@ -365,22 +393,8 @@ export function listSecretToolItems(prefix) {
         }
         return [];
     }
-    const output = result.stdout?.toString() || '';
-    const items = [];
-    // Parse output format:
-    // [/org/freedesktop/secrets/collection/login/1]
-    // label = agents-cli: myitem
-    // ...
-    // attribute.item = myitem
-    const itemRegex = /attribute\.item\s*=\s*(.+)/g;
-    let match;
-    while ((match = itemRegex.exec(output)) !== null) {
-        const itemName = match[1].trim();
-        if (itemName.startsWith(prefix)) {
-            items.push(itemName);
-        }
-    }
-    return [...new Set(items)]; // dedupe
+    const output = `${result.stdout?.toString() || ''}\n${result.stderr?.toString() || ''}`;
+    return parseSecretToolItems(output, prefix);
 }
 /** KeychainBackend implementation for Linux. Routes through secret-tool
  *  with a transparent encrypted-file fallback when the default Secret

package/dist/lib/shims.d.ts

@@ -68,8 +68,16 @@ export interface ConflictInfo {
  *         scoped plugin marketplaces (agents-cli/agents-system/extras-<alias>/
  *         agents-project). Version-home reconciliation stays out of the hot
  *         path — management commands still own that.
+ *   v17 — bash-side skip-fast sentinel under ~/.agents/.cache/launch-sync/.
+ *         When the sentinel mtime is newer than every source dir, exec the
+ *         agent binary directly without spawning node. Cuts steady-state
+ *         hot-path latency from ~680ms (node startup + module init) to ~11ms
+ *         (a few stat calls). Node writes the sentinel after each successful
+ *         sync. Documented limitation: POSIX dir mtime only updates on
+ *         top-level entry add/remove — deep edits to plugin contents won't
+ *         trigger auto-resync, run `agents sync` for that.
  */
-export declare const SHIM_SCHEMA_VERSION = 16;
+export declare const SHIM_SCHEMA_VERSION = 17;
 /**
  * Generate the full bash shim script for the given agent. The returned string
  * is written to ~/.agents/shims/{cliCommand} and made executable.

package/dist/lib/shims.js

@@ -192,8 +192,16 @@ async function promptConflictStrategy(conflictInfos) {
  *         scoped plugin marketplaces (agents-cli/agents-system/extras-<alias>/
  *         agents-project). Version-home reconciliation stays out of the hot
  *         path — management commands still own that.
+ *   v17 — bash-side skip-fast sentinel under ~/.agents/.cache/launch-sync/.
+ *         When the sentinel mtime is newer than every source dir, exec the
+ *         agent binary directly without spawning node. Cuts steady-state
+ *         hot-path latency from ~680ms (node startup + module init) to ~11ms
+ *         (a few stat calls). Node writes the sentinel after each successful
+ *         sync. Documented limitation: POSIX dir mtime only updates on
+ *         top-level entry add/remove — deep edits to plugin contents won't
+ *         trigger auto-resync, run `agents sync` for that.
  */
-export const SHIM_SCHEMA_VERSION = 16;
+export const SHIM_SCHEMA_VERSION = 17;
 /** Internal marker string used to embed the schema version in shim scripts. */
 const SHIM_VERSION_MARKER = 'agents-shim-version:';
 function shellQuote(value) {
@@ -473,8 +481,32 @@ fi
 ${managedEnv}
 
 # Project-scoped compile (rules, workspace resources, scoped plugin marketplaces).
-# Filesystem-only — sub-50ms steady state. Never blocks launch on failure.
-"$AGENTS_BIN" sync --agent "$AGENT" --agent-version "$VERSION" --launch --cwd "$PWD" --quiet 2>/dev/null || true
+# Skip-fast: if a sentinel from the last sync exists and is newer than all
+# source dirs (project .agents/, user plugins, system plugins), exec the
+# agent binary directly without spawning node. Cuts steady-state hot-path
+# latency from ~680ms (node startup + agents-cli module init) to ~11ms (a
+# handful of stat calls). Never blocks launch on failure of the sync itself.
+#
+# Known limitation: POSIX dir mtime updates only on entry add/remove at that
+# level. Deep edits to existing plugin contents (e.g. editing a SKILL.md
+# inside a plugin) won't bump the parent dir's mtime — the marketplace copy
+# stays stale until \`agents sync\` runs explicitly or a top-level entry
+# changes. Advanced users hot-iterating on plugins know to run sync.
+PROJECT_SLUG=\$(printf '%s' "\$PWD" | tr / _ | tr ' ' _)
+LAUNCH_SENTINEL="\$AGENTS_USER_DIR/.cache/launch-sync/\${AGENT}@\${VERSION}@\${PROJECT_SLUG}"
+LAUNCH_SKIP=0
+if [ -f "\$LAUNCH_SENTINEL" ]; then
+  LAUNCH_SKIP=1
+  for LAUNCH_SRC in "\$PWD/.agents" "\$AGENTS_USER_DIR/plugins" "\$AGENTS_USER_DIR/.system/plugins"; do
+    if [ -e "\$LAUNCH_SRC" ] && [ "\$LAUNCH_SRC" -nt "\$LAUNCH_SENTINEL" ]; then
+      LAUNCH_SKIP=0
+      break
+    fi
+  done
+fi
+if [ "\$LAUNCH_SKIP" = "0" ]; then
+  "\$AGENTS_BIN" sync --agent "\$AGENT" --agent-version "\$VERSION" --launch --cwd "\$PWD" --quiet 2>/dev/null || true
+fi
 
 exec "$BINARY"${launchArgs} "$@"
 `;

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

@@ -3,8 +3,8 @@
  * whose contents match the central source. Mirrors versions.ts:391-421.
  */
 import * as fs from 'fs';
-import * as path from 'path';
 import { agentConfigDirName } from '../../agents.js';
+import * as path from 'path';
 import { capableAgents } from '../../capabilities.js';
 import { resolveHookSource } from '../writers/sources.js';
 import { lazyAgentMap } from '../writers/lazy-map.js';

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

@@ -5,8 +5,8 @@
  * stays in the orchestrator since it depends on the broader available set.
  */
 import * as fs from 'fs';
-import * as path from 'path';
 import { agentConfigDirName } from '../../agents.js';
+import * as path from 'path';
 import { capableAgents } from '../../capabilities.js';
 import { safeJoin } from '../../paths.js';
 import { registerHooksToSettings } from '../../hooks.js';

package/dist/lib/teams/api.d.ts

@@ -64,6 +64,73 @@ export interface TaskStatusResult {
     };
     cursor: string;
 }
+/**
+ * Compact per-teammate snapshot for the default `teams status` view.
+ *
+ * The detail shape (`AgentStatusDetail`) carries the full prompt (often many
+ * KB), every absolute path the agent has touched, and uncapped message
+ * bodies. That's the right shape for programmatic consumers, but it makes
+ * `teams status` unreadable for orchestrators who only need: what state are
+ * you in, what did you just do, what files have you touched.
+ *
+ * Use {@link toAgentStatusSummary} to derive this from a detail record.
+ */
+export interface AgentStatusSummary {
+    agent_id: string;
+    name: string | null;
+    agent_type: string;
+    status: string;
+    duration: string | null;
+    tool_count: number;
+    has_errors: boolean;
+    pr_url: string | null;
+    files: {
+        /** Count of files modified since the cursor (delta), plus basenames. */
+        modified: {
+            count: number;
+            names: string[];
+        };
+        created: {
+            count: number;
+            names: string[];
+        };
+        deleted: {
+            count: number;
+            names: string[];
+        };
+        /** Read is noisy (per-Read events fire constantly); only emit a count. */
+        read: {
+            count: number;
+        };
+    };
+    /** Already capped at 15 × 120 chars by the detail builder. */
+    bash_commands: string[];
+    /** Last 3 messages, each body trimmed to ~400 chars. */
+    last_messages: string[];
+    /** ISO timestamp — feed back via --since for delta polling. */
+    cursor: string;
+}
+/** Compact aggregated result; mirrors {@link TaskStatusResult} but agents[] is the summary shape. */
+export interface TaskStatusSummaryResult {
+    task_name: string;
+    agents: AgentStatusSummary[];
+    summary: {
+        pending: number;
+        running: number;
+        completed: number;
+        failed: number;
+        stopped: number;
+    };
+    cursor: string;
+}
+/**
+ * Project a full AgentStatusDetail down to a compact AgentStatusSummary.
+ * Drops `prompt` entirely (caller knows what they queued), folds file lists
+ * to basenames + counts, caps `last_messages` to 3 × {@link SUMMARY_MESSAGE_MAX_CHARS}.
+ */
+export declare function toAgentStatusSummary(detail: AgentStatusDetail): AgentStatusSummary;
+/** Project a full TaskStatusResult down to the compact summary shape. */
+export declare function toTaskStatusSummary(result: TaskStatusResult): TaskStatusSummaryResult;
 /** Result of stopping one or more teammates. */
 export interface StopResult {
     task_name: string;

package/dist/lib/teams/api.js

@@ -55,6 +55,84 @@ function recentToolCalls(events, max = 10) {
         timestamp: typeof event.timestamp === 'string' ? event.timestamp : null,
     }));
 }
+/** Max files to name per category in the summary. Counts are always exact. */
+const SUMMARY_MAX_FILE_NAMES = 6;
+/** Max messages in the summary. */
+const SUMMARY_MAX_MESSAGES = 3;
+/** Max chars per message body in the summary. */
+const SUMMARY_MESSAGE_MAX_CHARS = 400;
+/**
+ * Reduce a file path to just its basename for compact rendering. Keeps the
+ * orchestrator oriented ("you touched types.ts") without dumping the full
+ * absolute path every time. The full paths are still in `AgentStatusDetail`
+ * for the verbose path.
+ */
+function basenameOf(p) {
+    const ix = p.lastIndexOf('/');
+    return ix < 0 ? p : p.slice(ix + 1);
+}
+/**
+ * Trim long assistant messages to a fixed budget. We collapse leading
+ * whitespace so the budget covers actual content, not indent.
+ */
+function trimMessage(msg, max = SUMMARY_MESSAGE_MAX_CHARS) {
+    const s = msg.replace(/^\s+/, '');
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 1) + '…';
+}
+/** Pull at most `max` basenames out of a path list, preserving order. */
+function compactFileList(paths, max = SUMMARY_MAX_FILE_NAMES) {
+    const seen = new Set();
+    const names = [];
+    for (const p of paths) {
+        const base = basenameOf(p);
+        if (seen.has(base))
+            continue;
+        seen.add(base);
+        names.push(base);
+        if (names.length >= max)
+            break;
+    }
+    return { count: paths.length, names };
+}
+/**
+ * Project a full AgentStatusDetail down to a compact AgentStatusSummary.
+ * Drops `prompt` entirely (caller knows what they queued), folds file lists
+ * to basenames + counts, caps `last_messages` to 3 × {@link SUMMARY_MESSAGE_MAX_CHARS}.
+ */
+export function toAgentStatusSummary(detail) {
+    return {
+        agent_id: detail.agent_id,
+        name: detail.name ?? null,
+        agent_type: detail.agent_type,
+        status: detail.status,
+        duration: detail.duration,
+        tool_count: detail.tool_count,
+        has_errors: detail.has_errors,
+        pr_url: detail.pr_url ?? null,
+        files: {
+            modified: compactFileList(detail.files_modified),
+            created: compactFileList(detail.files_created),
+            deleted: compactFileList(detail.files_deleted),
+            read: { count: detail.files_read.length },
+        },
+        bash_commands: detail.bash_commands,
+        last_messages: detail.last_messages
+            .slice(-SUMMARY_MAX_MESSAGES)
+            .map((m) => trimMessage(m)),
+        cursor: detail.cursor,
+    };
+}
+/** Project a full TaskStatusResult down to the compact summary shape. */
+export function toTaskStatusSummary(result) {
+    return {
+        task_name: result.task_name,
+        agents: result.agents.map(toAgentStatusSummary),
+        summary: result.summary,
+        cursor: result.cursor,
+    };
+}
 /** Spawn a new teammate in a task and return its initial metadata. */
 export async function handleSpawn(manager, taskName, agentType, prompt, cwd, mode, effort = 'medium', parentSessionId = null, workspaceDir = null, version = null, name = null, after = [], model = null, envOverrides = null, taskType = null, cloudProvider = null, cloudSessionId = null, cloudRepo = null, cloudBranch = null, worktreeName = null, worktreePath = null, profileName = null) {
     const defaultMode = manager.getDefaultMode();