@phnx-labs/agents-cli 1.20.71 → 1.20.73

package/dist/lib/star-nudge.d.ts

@@ -0,0 +1,45 @@
+/**
+ * One-time "star us on GitHub" nudge.
+ *
+ * Printed a single time, ever, after a user's first *successful* headline run
+ * (`agents run` / `agents teams`). Modelled on the existing warn-once sentinel
+ * pattern (see maybeWarnMultiInstall in src/index.ts): a marker under the
+ * regenerable runtime-state dir records that the hint was shown so it never
+ * repeats. It is a plain inline line — not a toast, not a nag — and stays out
+ * of the way of non-interactive, CI, quiet, and JSON output.
+ */
+/** Canonical GitHub repo the nudge points at. */
+export declare const REPO_URL = "https://github.com/phnx-labs/agents-cli";
+/** Has the star nudge already been shown on this machine? */
+export declare function hasShownStarNudge(): boolean;
+/** Inputs to the pure show/skip decision (kept side-effect free for testing). */
+export interface StarNudgeContext {
+    /** Caller asked for quiet / JSON output. */
+    quiet?: boolean;
+    /** stdout is attached to an interactive terminal. */
+    isTTY: boolean;
+    /** CI is set in the environment. */
+    ci: boolean;
+    /** User opted out via AGENTS_NO_NUDGE=1. */
+    optedOut: boolean;
+    /** The one-time sentinel already exists. */
+    alreadyShown: boolean;
+}
+/**
+ * Pure decision: should the one-time star nudge be shown? Skipped for
+ * quiet/JSON output, non-interactive terminals (pipes, redirects), CI, an
+ * explicit opt-out, or once it has already been shown.
+ */
+export declare function shouldShowStarNudge(ctx: StarNudgeContext): boolean;
+/**
+ * Show the one-time star nudge if it hasn't been shown yet and the context is
+ * appropriate. Best-effort by contract: never throws, never blocks the run it
+ * follows.
+ *
+ * Skipped when: the caller asked for quiet/JSON output, stdout is not an
+ * interactive terminal (pipes, redirects), CI is set, or the user opted out
+ * with AGENTS_NO_NUDGE=1.
+ */
+export declare function maybeShowStarNudge(opts?: {
+    quiet?: boolean;
+}): void;

package/dist/lib/star-nudge.js

@@ -0,0 +1,91 @@
+/**
+ * One-time "star us on GitHub" nudge.
+ *
+ * Printed a single time, ever, after a user's first *successful* headline run
+ * (`agents run` / `agents teams`). Modelled on the existing warn-once sentinel
+ * pattern (see maybeWarnMultiInstall in src/index.ts): a marker under the
+ * regenerable runtime-state dir records that the hint was shown so it never
+ * repeats. It is a plain inline line — not a toast, not a nag — and stays out
+ * of the way of non-interactive, CI, quiet, and JSON output.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { getRuntimeStateDir } from './state.js';
+/** Canonical GitHub repo the nudge points at. */
+export const REPO_URL = 'https://github.com/phnx-labs/agents-cli';
+/** Sentinel written the first (and only) time the nudge is shown. */
+function nudgeSentinelPath() {
+    return path.join(getRuntimeStateDir(), 'star-nudge-shown');
+}
+/** Has the star nudge already been shown on this machine? */
+export function hasShownStarNudge() {
+    try {
+        return fs.existsSync(nudgeSentinelPath());
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Pure decision: should the one-time star nudge be shown? Skipped for
+ * quiet/JSON output, non-interactive terminals (pipes, redirects), CI, an
+ * explicit opt-out, or once it has already been shown.
+ */
+export function shouldShowStarNudge(ctx) {
+    if (ctx.quiet)
+        return false;
+    if (!ctx.isTTY)
+        return false;
+    if (ctx.ci)
+        return false;
+    if (ctx.optedOut)
+        return false;
+    if (ctx.alreadyShown)
+        return false;
+    return true;
+}
+/**
+ * Show the one-time star nudge if it hasn't been shown yet and the context is
+ * appropriate. Best-effort by contract: never throws, never blocks the run it
+ * follows.
+ *
+ * Skipped when: the caller asked for quiet/JSON output, stdout is not an
+ * interactive terminal (pipes, redirects), CI is set, or the user opted out
+ * with AGENTS_NO_NUDGE=1.
+ */
+export function maybeShowStarNudge(opts = {}) {
+    try {
+        const show = shouldShowStarNudge({
+            quiet: opts.quiet,
+            isTTY: Boolean(process.stdout.isTTY),
+            ci: Boolean(process.env.CI),
+            optedOut: process.env.AGENTS_NO_NUDGE === '1',
+            alreadyShown: hasShownStarNudge(),
+        });
+        if (!show)
+            return;
+        // Claim the one-time slot with an ATOMIC exclusive create (O_EXCL). The
+        // hasShownStarNudge() check above is only a cheap fast-path; the existsSync
+        // + write pair is a TOCTOU race across processes, and `agents teams` spawns
+        // many at once. The `wx` flag makes the create itself the arbiter: exactly
+        // one process succeeds, every other gets EEXIST and stays silent — so the
+        // hint prints at most once even under concurrent completions.
+        const sentinel = nudgeSentinelPath();
+        fs.mkdirSync(path.dirname(sentinel), { recursive: true });
+        try {
+            fs.writeFileSync(sentinel, new Date().toISOString(), { flag: 'wx' });
+        }
+        catch (e) {
+            if (e.code === 'EEXIST')
+                return; // another process won the race
+            throw e; // real write failure -> caught by the outer best-effort guard
+        }
+        console.log('\n' +
+            chalk.gray('Enjoying agents-cli? Give it a star to help others find it: ') +
+            chalk.cyan(REPO_URL));
+    }
+    catch {
+        /* best-effort: a nudge must never break a successful run */
+    }
+}

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

@@ -25,6 +25,7 @@ export type Registrar = (program: Command) => void;
 export type ModuleLoader = () => Promise<Registrar>;
 export declare const loadView: ModuleLoader;
 export declare const loadInspect: ModuleLoader;
+export declare const loadResources: ModuleLoader;
 export declare const loadFeedback: ModuleLoader;
 export declare const loadCommands: ModuleLoader;
 export declare const loadHooks: ModuleLoader;
@@ -41,7 +42,6 @@ export declare const loadWorktree: ModuleLoader;
 export declare const loadVersions: ModuleLoader;
 export declare const loadImport: ModuleLoader;
 export declare const loadPackages: ModuleLoader;
-export declare const loadDaemon: ModuleLoader;
 export declare const loadRoutines: ModuleLoader;
 export declare const loadMonitors: ModuleLoader;
 export declare const loadRun: ModuleLoader;
@@ -57,6 +57,7 @@ export declare const loadCheck: ModuleLoader;
 export declare const loadStatus: ModuleLoader;
 export declare const loadProfiles: ModuleLoader;
 export declare const loadSecrets: ModuleLoader;
+export declare const loadLogin: ModuleLoader;
 export declare const loadWallet: ModuleLoader;
 export declare const loadHelper: ModuleLoader;
 export declare const loadMenubar: ModuleLoader;
@@ -71,6 +72,7 @@ export declare const loadCost: ModuleLoader;
 export declare const loadOutput: ModuleLoader;
 export declare const loadBudget: ModuleLoader;
 export declare const loadAlias: ModuleLoader;
+export declare const loadMine: ModuleLoader;
 export declare const loadPty: ModuleLoader;
 export declare const loadTmux: ModuleLoader;
 export declare const loadWatchdog: ModuleLoader;
@@ -85,11 +87,15 @@ export declare const loadPull: ModuleLoader;
 export declare const loadPush: ModuleLoader;
 export declare const loadRepo: ModuleLoader;
 export declare const loadSetup: ModuleLoader;
+export declare const loadUninstall: ModuleLoader;
 export declare const loadSessions: ModuleLoader;
 export declare const loadTeams: ModuleLoader;
 export declare const loadCloud: ModuleLoader;
 export declare const loadMessage: ModuleLoader;
+export declare const loadSend: ModuleLoader;
+export declare const loadHq: ModuleLoader;
 export declare const loadFeed: ModuleLoader;
+export declare const loadActivity: ModuleLoader;
 export declare const loadMailboxes: ModuleLoader;
 export declare const loadServe: ModuleLoader;
 export declare const loadShare: ModuleLoader;

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

@@ -3,6 +3,7 @@
 // them into the exact main-branch registration order for the slow path.
 export const loadView = async () => (await import('../../commands/view.js')).registerViewCommand;
 export const loadInspect = async () => (await import('../../commands/inspect.js')).registerInspectCommand;
+export const loadResources = async () => (await import('../../commands/resources.js')).registerResourcesCommand;
 export const loadFeedback = async () => (await import('../../commands/feedback.js')).registerFeedbackCommand;
 export const loadCommands = async () => (await import('../../commands/commands.js')).registerCommandsCommands;
 export const loadHooks = async () => (await import('../../commands/hooks.js')).registerHooksCommands;
@@ -19,7 +20,6 @@ export const loadWorktree = async () => (await import('../../commands/worktree.j
 export const loadVersions = async () => (await import('../../commands/versions.js')).registerVersionsCommands;
 export const loadImport = async () => (await import('../../commands/import.js')).registerImportCommand;
 export const loadPackages = async () => (await import('../../commands/packages.js')).registerPackagesCommands;
-export const loadDaemon = async () => (await import('../../commands/daemon.js')).registerDaemonCommands;
 export const loadRoutines = async () => (await import('../../commands/routines.js')).registerRoutinesCommands;
 export const loadMonitors = async () => (await import('../../commands/monitors.js')).registerMonitorsCommands;
 export const loadRun = async () => (await import('../../commands/exec.js')).registerRunCommand;
@@ -35,6 +35,7 @@ export const loadCheck = async () => (await import('../../commands/check.js')).r
 export const loadStatus = async () => (await import('../../commands/status.js')).registerStatusCommand;
 export const loadProfiles = async () => (await import('../../commands/profiles.js')).registerProfilesCommands;
 export const loadSecrets = async () => (await import('../../commands/secrets.js')).registerSecretsCommands;
+export const loadLogin = async () => (await import('../../commands/login.js')).registerLoginCommands;
 export const loadWallet = async () => (await import('../../commands/wallet.js')).registerWalletCommands;
 export const loadHelper = async () => (await import('../../commands/helper.js')).registerHelperCommand;
 export const loadMenubar = async () => (await import('../../commands/menubar.js')).registerMenubarCommands;
@@ -49,6 +50,7 @@ export const loadCost = async () => (await import('../../commands/cost.js')).reg
 export const loadOutput = async () => (await import('../../commands/output.js')).registerOutputCommand;
 export const loadBudget = async () => (await import('../../commands/budget.js')).registerBudgetCommand;
 export const loadAlias = async () => (await import('../../commands/alias.js')).registerAliasCommand;
+export const loadMine = async () => (await import('../../commands/mine.js')).registerMineCommand;
 export const loadPty = async () => (await import('../../commands/pty.js')).registerPtyCommands;
 export const loadTmux = async () => (await import('../../commands/tmux.js')).registerTmuxCommands;
 export const loadWatchdog = async () => (await import('../../commands/watchdog.js')).registerWatchdogCommand;
@@ -63,11 +65,15 @@ export const loadPull = async () => (await import('../../commands/pull.js')).reg
 export const loadPush = async () => (await import('../../commands/push.js')).registerPushCommand;
 export const loadRepo = async () => (await import('../../commands/repo.js')).registerRepoCommands;
 export const loadSetup = async () => (await import('../../commands/setup.js')).registerSetupCommand;
+export const loadUninstall = async () => (await import('../../commands/uninstall.js')).registerUninstallCommands;
 export const loadSessions = async () => (await import('../../commands/sessions.js')).registerSessionsCommands;
 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 loadSend = async () => (await import('../../commands/send.js')).registerSendCommand;
+export const loadHq = async () => (await import('../../commands/hq.js')).registerHqCommand;
 export const loadFeed = async () => (await import('../../commands/feed.js')).registerFeedCommand;
+export const loadActivity = async () => (await import('../../commands/activity.js')).registerActivityCommand;
 export const loadMailboxes = async () => (await import('../../commands/mailboxes.js')).registerMailboxesCommand;
 export const loadServe = async () => (await import('../../commands/serve.js')).registerServeCommand;
 export const loadShare = async () => (await import('../../commands/share.js')).registerShareCommands;
@@ -81,7 +87,7 @@ export const loadFunnel = async () => (await import('../../commands/funnel.js'))
  * inherit the root's custom help formatter rather than getting the per-command
  * recursive pass. Keeping that ordering preserves their `--help` output exactly.
  */
-export const LAZY_COMMAND_NAMES = new Set(['sessions', 'teams', 'cloud', 'message', 'serve']);
+export const LAZY_COMMAND_NAMES = new Set(['sessions', 'teams', 'cloud', 'message', 'hq', 'serve']);
 /**
  * User-typed top-level command name -> ordered list of module loaders to run.
  *
@@ -99,6 +105,7 @@ export const LAZY_COMMAND_NAMES = new Set(['sessions', 'teams', 'cloud', 'messag
 export const COMMAND_LOADERS = {
     view: [loadView],
     inspect: [loadInspect],
+    resources: [loadResources],
     feedback: [loadFeedback],
     commands: [loadCommands],
     hooks: [loadHooks],
@@ -123,7 +130,6 @@ export const COMMAND_LOADERS = {
     registry: [loadPackages],
     search: [loadPackages],
     install: [loadPackages],
-    daemon: [loadDaemon],
     routines: [loadRoutines],
     monitors: [loadMonitors],
     run: [loadRun],
@@ -136,8 +142,12 @@ export const COMMAND_LOADERS = {
     apply: [loadApply],
     check: [loadCheck],
     status: [loadStatus],
+    profile: [loadProfiles],
     profiles: [loadProfiles],
     secrets: [loadSecrets],
+    login: [loadLogin],
+    logout: [loadLogin],
+    whoami: [loadLogin],
     wallet: [loadWallet],
     helper: [loadHelper],
     menubar: [loadMenubar],
@@ -152,6 +162,7 @@ export const COMMAND_LOADERS = {
     output: [loadOutput],
     budget: [loadBudget],
     alias: [loadAlias],
+    mine: [loadMine],
     pty: [loadPty],
     tmux: [loadTmux],
     watchdog: [loadWatchdog],
@@ -174,11 +185,16 @@ export const COMMAND_LOADERS = {
     repos: [loadRepo],
     repo: [loadRepo],
     setup: [loadSetup],
+    uninstall: [loadUninstall],
     sessions: [loadSessions],
     teams: [loadTeams],
     cloud: [loadCloud],
     message: [loadMessage],
+    send: [loadSend],
+    notify: [loadSend],
+    hq: [loadHq],
     feed: [loadFeed],
+    activity: [loadActivity],
     mailboxes: [loadMailboxes],
     mailbox: [loadMailboxes],
     serve: [loadServe],

package/dist/lib/state.d.ts

@@ -137,6 +137,8 @@ export declare function getMonitorsHistoryDir(): string;
 export declare function getMailboxRootDir(): string;
 /** Root for open-block feed records (~/.agents/.history/feed/). */
 export declare function getFeedDir(): string;
+/** Append-only per-session agent-activity event logs (~/.agents/.history/activity/). */
+export declare function getActivityDir(): string;
 /** Path to installed agent CLI binaries (~/.agents/.history/versions/). */
 export declare function getVersionsDir(): string;
 /** Path to version-switching shim scripts (~/.agents/.cache/shims/). */

package/dist/lib/state.js

@@ -101,6 +101,7 @@ const BACKUPS_DIR = path.join(HISTORY_DIR, 'backups');
 const TRASH_DIR = path.join(HISTORY_DIR, 'trash');
 const MAILBOX_DIR = path.join(HISTORY_DIR, 'mailbox');
 const FEED_DIR = path.join(HISTORY_DIR, 'feed');
+const ACTIVITY_DIR = path.join(HISTORY_DIR, 'activity');
 // Cache bucket (regenerable).
 const SHIMS_DIR = path.join(CACHE_DIR, 'shims');
 const HOOK_SHIMS_DIR = path.join(SHIMS_DIR, 'hooks');
@@ -340,6 +341,8 @@ export function getMonitorsHistoryDir() { return MONITORS_HISTORY_DIR; }
 export function getMailboxRootDir() { return MAILBOX_DIR; }
 /** Root for open-block feed records (~/.agents/.history/feed/). */
 export function getFeedDir() { return FEED_DIR; }
+/** Append-only per-session agent-activity event logs (~/.agents/.history/activity/). */
+export function getActivityDir() { return ACTIVITY_DIR; }
 /** Path to installed agent CLI binaries (~/.agents/.history/versions/). */
 export function getVersionsDir() { return VERSIONS_DIR; }
 /** Path to version-switching shim scripts (~/.agents/.cache/shims/). */

package/dist/lib/subagents-registry.d.ts

@@ -27,6 +27,8 @@ export interface SubagentTarget {
     names(dir: string): string[];
     /** On-disk paths subagent `name` occupies (for removal / soft-delete). */
     occupied(dir: string, name: string): OccupiedEntry[];
+    /** Cross-item files this target owns outside any one subagent's occupied paths. */
+    finalizeOccupied?(dir: string): OccupiedEntry[];
     /** Rich metadata for `name`; `null` skips it from the listing. */
     read(dir: string, name: string): SubagentMeta | null;
     /** Optional post-sync pass over the just-synced subagents (Kimi's parent index). */

package/dist/lib/subagents-registry.js

@@ -213,6 +213,9 @@ const kimiTarget = {
             { path: safeJoin(dir, `${name}.system.md`), kind: 'file' },
         ];
     },
+    finalizeOccupied(dir) {
+        return [{ path: safeJoin(dir, KIMI_SUBAGENTS_PARENT_FILE), kind: 'file' }];
+    },
     read(dir, name) {
         const yamlPath = path.join(dir, `${name}.yaml`);
         if (!fs.existsSync(yamlPath) || !fs.statSync(yamlPath).isFile())

package/dist/lib/teams/parsers.js

@@ -8,6 +8,7 @@
  */
 import { extractFileOpsFromBash } from './file_ops.js';
 const claudeToolUseMap = new Map();
+const droidToolUseMap = new Map();
 /** Normalize a raw JSON event from any agent type into an array of unified event objects. */
 export function normalizeEvents(agentType, raw) {
     if (agentType === 'codex') {
@@ -34,12 +35,9 @@ export function normalizeEvents(agentType, raw) {
     else if (agentType === 'kimi') {
         return normalizeKimi(raw);
     }
-    // droid (Factory AI) intentionally falls through to the generic normalizer
-    // below: its `-o stream-json` JSONL event schema is not yet verified against
-    // a live run (the documented `debug` format differs from stream-json). Events
-    // still stream and render; structured tool/file categorization will be added
-    // once a real `droid exec -o stream-json` sample is captured. Do NOT guess the
-    // schema here — a wrong discriminator silently mislabels every event.
+    else if (agentType === 'droid') {
+        return normalizeDroid(raw);
+    }
     const timestamp = new Date().toISOString();
     return [{
             type: raw.type || 'unknown',
@@ -1078,6 +1076,216 @@ function normalizeKimi(raw) {
             timestamp: timestamp,
         }];
 }
+// --- Droid parsing ---
+// Droid's `droid exec -o stream-json` stream mirrors the Factory session JSONL
+// envelope: session_start records plus Anthropic-shaped message content blocks.
+// Tool blocks carry the actionable file path / command in `input`; result blocks
+// only carry `tool_use_id`, so keep a small id map just like normalizeClaude.
+function normalizeDroid(raw) {
+    const timestamp = typeof raw?.timestamp === 'string' ? raw.timestamp : new Date().toISOString();
+    if (!raw || typeof raw !== 'object') {
+        return [{
+                type: 'unknown',
+                agent: 'droid',
+                raw: raw,
+                timestamp: timestamp,
+            }];
+    }
+    const eventType = typeof raw.type === 'string' ? raw.type : 'unknown';
+    if (eventType === 'session_start') {
+        return [{
+                type: 'init',
+                agent: 'droid',
+                session_id: typeof raw.id === 'string' ? raw.id : null,
+                timestamp: timestamp,
+            }];
+    }
+    if (eventType === 'result') {
+        return [{
+                type: 'result',
+                agent: 'droid',
+                status: raw.is_error === true ? 'error' : 'success',
+                message: typeof raw.result === 'string' ? raw.result : undefined,
+                timestamp: timestamp,
+            }];
+    }
+    if (eventType !== 'message') {
+        return [{
+                type: eventType,
+                agent: 'droid',
+                raw: raw,
+                timestamp: timestamp,
+            }];
+    }
+    const message = raw.message || {};
+    const role = message.role === 'user' ? 'user' : 'assistant';
+    const blocks = message.content;
+    if (typeof blocks === 'string') {
+        const content = blocks.trim();
+        if (!content)
+            return [];
+        return role === 'assistant'
+            ? [{ type: 'message', agent: 'droid', content, complete: true, timestamp }]
+            : [{ type: 'user_message', agent: 'droid', content, timestamp }];
+    }
+    if (!Array.isArray(blocks))
+        return [];
+    const events = [];
+    for (const block of blocks) {
+        if (!block || typeof block !== 'object')
+            continue;
+        if (block.type === 'text') {
+            const text = typeof block.text === 'string' ? block.text.trim() : '';
+            if (!text)
+                continue;
+            if (role === 'assistant') {
+                events.push({
+                    type: 'message',
+                    agent: 'droid',
+                    content: text,
+                    complete: true,
+                    timestamp: timestamp,
+                });
+            }
+            else if (!text.startsWith('<system-reminder>') && !text.startsWith('Hook execution:')) {
+                events.push({
+                    type: 'user_message',
+                    agent: 'droid',
+                    content: text,
+                    timestamp: timestamp,
+                });
+            }
+            continue;
+        }
+        if (block.type === 'thinking') {
+            const thinking = typeof block.thinking === 'string' ? block.thinking.trim() : '';
+            if (thinking) {
+                events.push({
+                    type: 'thinking',
+                    agent: 'droid',
+                    content: thinking,
+                    timestamp: timestamp,
+                });
+            }
+            continue;
+        }
+        if (block.type === 'tool_use') {
+            events.push(...normalizeDroidToolUse(block, timestamp));
+            continue;
+        }
+        if (block.type === 'tool_result') {
+            const toolUseId = typeof block.tool_use_id === 'string' ? block.tool_use_id : null;
+            const toolInfo = toolUseId ? droidToolUseMap.get(toolUseId) : undefined;
+            if (toolUseId)
+                droidToolUseMap.delete(toolUseId);
+            const content = extractDroidToolResultContent(block.content);
+            if (block.is_error === true) {
+                events.push({
+                    type: 'error',
+                    agent: 'droid',
+                    tool: toolInfo?.tool,
+                    content: content || 'Tool execution failed',
+                    timestamp: timestamp,
+                });
+            }
+            else {
+                events.push({
+                    type: 'tool_result',
+                    agent: 'droid',
+                    tool: toolInfo?.tool,
+                    tool_call_id: toolUseId,
+                    success: true,
+                    content: content.length > 500 ? content.slice(0, 497) + '...' : content,
+                    timestamp: timestamp,
+                });
+            }
+        }
+    }
+    return events;
+}
+function normalizeDroidToolUse(block, timestamp) {
+    const toolName = typeof block.name === 'string' ? block.name : 'unknown';
+    const toolInput = block.input && typeof block.input === 'object' ? block.input : {};
+    if (typeof block.id === 'string') {
+        droidToolUseMap.set(block.id, { tool: toolName, args: toolInput });
+    }
+    const filePath = toolInput.file_path || toolInput.path || '';
+    const command = toolInput.command || '';
+    if ((toolName === 'Execute' || toolName === 'Bash') && command) {
+        const events = [{
+                type: 'bash',
+                agent: 'droid',
+                tool: toolName,
+                command: command,
+                timestamp: timestamp,
+            }];
+        const [filesRead, filesWritten, filesDeleted] = extractFileOpsFromBash(command);
+        for (const path of filesRead) {
+            events.push({ type: 'file_read', agent: 'droid', tool: 'bash', path, command, timestamp });
+        }
+        for (const path of filesWritten) {
+            events.push({ type: 'file_write', agent: 'droid', tool: 'bash', path, command, timestamp });
+        }
+        for (const path of filesDeleted) {
+            events.push({ type: 'file_delete', agent: 'droid', tool: 'bash', path, command, timestamp });
+        }
+        return events;
+    }
+    if (toolName === 'Read' && filePath) {
+        return [{
+                type: 'file_read',
+                agent: 'droid',
+                tool: toolName,
+                path: filePath,
+                timestamp: timestamp,
+            }];
+    }
+    if ((toolName === 'Create' || toolName === 'Write') && filePath) {
+        return [{
+                type: 'file_create',
+                agent: 'droid',
+                tool: toolName,
+                path: filePath,
+                timestamp: timestamp,
+            }];
+    }
+    if ((toolName === 'Edit' || toolName === 'MultiEdit') && filePath) {
+        return [{
+                type: 'file_write',
+                agent: 'droid',
+                tool: toolName,
+                path: filePath,
+                timestamp: timestamp,
+            }];
+    }
+    if ((toolName === 'Delete' || toolName === 'Remove') && filePath) {
+        return [{
+                type: 'file_delete',
+                agent: 'droid',
+                tool: toolName,
+                path: filePath,
+                timestamp: timestamp,
+            }];
+    }
+    return [{
+            type: 'tool_use',
+            agent: 'droid',
+            tool: toolName,
+            args: toolInput,
+            timestamp: timestamp,
+        }];
+}
+function extractDroidToolResultContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((part) => part && typeof part === 'object' && part.type === 'text')
+            .map((part) => typeof part.text === 'string' ? part.text : '')
+            .join('\n');
+    }
+    return '';
+}
 // --- Antigravity parsing ---
 // Intentionally conservative. Antigravity's `agy` binary advertises an
 // `--output-format json` flag in its docs, but the released binary errors with

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

@@ -51,6 +51,13 @@ export interface SupervisorResult {
     waves: number;
     stoppedBy: 'drained' | 'max-waves' | 'signal' | 'callback' | 'budget';
     elapsed_ms: number;
+    /**
+     * Number of teammates in the `failed` state when the team drained. Only set
+     * for `stoppedBy === 'drained'`. A drained DAG means nothing is pending or
+     * running — NOT that everything succeeded — so callers that treat "drained"
+     * as success (e.g. a completion nudge) must check `failed === 0` first.
+     */
+    failed?: number;
     /** Set when `stoppedBy === 'budget'` — the breach that terminated the team. */
     budgetBreach?: BreachInfo;
 }

package/dist/lib/teams/supervisor.js

@@ -80,7 +80,8 @@ export async function runSupervisor(mgr, opts) {
             const afterCallback = await mgr.listByTask(team);
             const stillLive = afterCallback.some((a) => a.status === 'pending' || a.status === 'running');
             if (!stillLive) {
-                return { waves: wave, stoppedBy: 'drained', elapsed_ms: Date.now() - startedAt };
+                const failed = afterCallback.filter((a) => a.status === 'failed').length;
+                return { waves: wave, stoppedBy: 'drained', failed, elapsed_ms: Date.now() - startedAt };
             }
             if (stopSignal) {
                 return { waves: wave, stoppedBy: 'signal', elapsed_ms: Date.now() - startedAt };

package/dist/lib/template.d.ts

@@ -1,6 +1,6 @@
 /**
  * Template resolution utilities.
- * Ported from agents/halo/cli/pkg/template.
+ * Ported from the legacy agent CLI template helpers.
  *
  * Supports {{artifact.*}} and {{preflight.*}} placeholder patterns used in
  * artifact action input mappings.

package/dist/lib/template.js

@@ -1,6 +1,6 @@
 /**
  * Template resolution utilities.
- * Ported from agents/halo/cli/pkg/template.
+ * Ported from the legacy agent CLI template helpers.
  *
  * Supports {{artifact.*}} and {{preflight.*}} placeholder patterns used in
  * artifact action input mappings.