@phnx-labs/agents-cli 1.22.120 → 1.22.121

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

@@ -5,7 +5,6 @@ export interface ToolCallDetail {
     summary: string;
     timestamp: string | null;
 }
-/** Result returned after spawning a new teammate. */
 export interface SpawnResult {
     task_name: string;
     agent_id: string;
@@ -20,12 +19,9 @@ export interface SpawnResult {
     task_type?: TaskType | null;
     cloud_provider?: string | null;
     cloud_session_id?: string | null;
-    /** Device name the teammate runs on for a distributed (--on) teammate; null for local. */
     host?: string | null;
-    /** Sanitized evidence observed at the lifecycle boundary that failed. */
     failure?: TeammateFailure | null;
 }
-/** Detailed status of a single teammate, including file ops, commands, and a cursor for delta polling. */
 export interface AgentStatusDetail {
     agent_id: string;
     agent_type: string;
@@ -48,11 +44,6 @@ export interface AgentStatusDetail {
     cloud_session_id?: string | null;
     cloud_provider?: string | null;
     pr_url?: string | null;
-    /**
-     * Delivery postcondition (RUSH-2380), distinct from process `status`.
-     * `pr_open` when the process completed but left an unmerged PR — orchestrators
-     * must not treat that as "work landed on main".
-     */
     delivery?: string;
     version?: string | null;
     remote_session_id?: string | null;
@@ -60,14 +51,10 @@ export interface AgentStatusDetail {
     name?: string | null;
     after?: string[];
     task_type?: TaskType | null;
-    /** Device name the teammate runs on for a distributed (--on) teammate; null for local. */
     host?: string | null;
-    /** Absolute path to the teammate's worktree, when known. */
     workspace_dir?: string | null;
-    /** Sanitized evidence observed at the lifecycle boundary that failed. */
     failure?: TeammateFailure | null;
 }
-/** Aggregated status of all teammates in a task, with per-status counts and a global cursor. */
 export interface TaskStatusResult {
     task_name: string;
     agents: AgentStatusDetail[];
@@ -81,30 +68,17 @@ 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;
-    /** Delivery postcondition — see {@link AgentStatusDetail.delivery}. */
     delivery?: 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[];
@@ -117,24 +91,17 @@ export interface AgentStatusSummary {
             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[];
-    /** Device name for a distributed (--on) teammate; null for local. */
     host: string | null;
     failure: TeammateFailure | null;
-    /** Absolute path to the teammate's worktree, when known. */
     workspace_dir?: string | null;
-    /** 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[];
@@ -148,29 +115,20 @@ export interface TaskStatusSummaryResult {
     };
     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;
     stopped: string[];
     already_stopped: string[];
     not_found: string[];
 }
-/** Summary metadata for a single task (team), including agent counts by status and timestamps. */
 export interface TaskInfo {
     task_name: string;
     agent_count: number;
     pending: number;
     running: number;
     completed: number;
-    /** Completed teammates with uncommitted work and no PR (PHNX-2951). */
     stranded: number;
     failed: number;
     stopped: number;
@@ -178,20 +136,12 @@ export interface TaskInfo {
     created_at: string;
     modified_at: string;
 }
-/** Paginated list of tasks sorted by most recent activity. */
 export interface TasksResult {
     tasks: TaskInfo[];
 }
-/** Spawn a new teammate in a task and return its initial metadata. */
-export declare function handleSpawn(manager: AgentManager, taskName: string, agentType: AgentType, prompt: string, cwd: string | null, mode: string | null, effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'auto' | null, parentSessionId?: string | null, workspaceDir?: string | null, version?: string | null, name?: string | null, after?: string[], model?: string | null, envOverrides?: Record<string, string> | null, taskType?: TaskType | null, cloudProvider?: string | null, cloudSessionId?: string | null, cloudRepo?: string | null, cloudBranch?: string | null, worktreeName?: string | null, worktreePath?: string | null, profileName?: string | null, hostName?: string | null, hostTarget?: string | null, repoPath?: string | null, 
-/** The team's `--project`; grants resolve from it at launch. */
-project?: string | null): Promise<SpawnResult>;
-/** Retrieve the current status of all teammates in a task, with optional timestamp-based delta filtering. */
-export declare function handleStatus(manager: AgentManager, taskName: string | null | undefined, filter?: string, since?: string, // Optional ISO timestamp - return only events after this time
-parentSessionId?: string | null): Promise<TaskStatusResult>;
-/** List all known tasks grouped by task name, sorted by most recent activity. */
+export declare function handleSpawn(manager: AgentManager, taskName: string, agentType: AgentType, prompt: string, cwd: string | null, mode: string | null, effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'auto' | null, parentSessionId?: string | null, workspaceDir?: string | null, version?: string | null, name?: string | null, after?: string[], model?: string | null, envOverrides?: Record<string, string> | null, taskType?: TaskType | null, cloudProvider?: string | null, cloudSessionId?: string | null, cloudRepo?: string | null, cloudBranch?: string | null, worktreeName?: string | null, worktreePath?: string | null, profileName?: string | null, hostName?: string | null, hostTarget?: string | null, repoPath?: string | null, project?: string | null): Promise<SpawnResult>;
+export declare function handleStatus(manager: AgentManager, taskName: string | null | undefined, filter?: string, since?: string, parentSessionId?: string | null): Promise<TaskStatusResult>;
 export declare function handleTasks(manager: AgentManager, limit?: number): Promise<TasksResult>;
-/** Stop a specific teammate or all teammates in a task. */
 export declare function handleStop(manager: AgentManager, taskName: string, agentId?: string): Promise<StopResult | {
     error: string;
 }>;

package/dist/lib/teams/api.js

@@ -4,17 +4,11 @@ import { debug } from './debug.js';
 import { buildClaudeLabelMap } from '../session/discover.js';
 import { resolveTeammateDelivery } from './delivery.js';
 import { hasUncommittedChanges } from './worktree.js';
-/**
- * Truncate a bash command for status output.
- * Handles heredocs specially - shows the redirect target instead of contents.
- */
 function truncateBashCommand(cmd, maxLen = 120) {
-    // Detect heredoc patterns: cat <<'EOF' > path or cat << EOF > path
     const heredocMatch = cmd.match(/cat\s+<<['"]?(\w+)['"]?\s*>\s*([^\s]+)/);
     if (heredocMatch) {
         return `cat <<${heredocMatch[1]} > ${heredocMatch[2]}`;
     }
-    // For regular commands, just truncate
     if (cmd.length <= maxLen)
         return cmd;
     return cmd.substring(0, maxLen - 3) + '...';
@@ -57,33 +51,19 @@ 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 = [];
@@ -98,11 +78,6 @@ function compactFileList(paths, max = SUMMARY_MAX_FILE_NAMES) {
     }
     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,
@@ -131,7 +106,6 @@ export function toAgentStatusSummary(detail) {
         cursor: detail.cursor,
     };
 }
-/** Project a full TaskStatusResult down to the compact summary shape. */
 export function toTaskStatusSummary(result) {
     return {
         task_name: result.task_name,
@@ -140,19 +114,11 @@ export function toTaskStatusSummary(result) {
         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, hostName = null, hostTarget = null, repoPath = null, 
-/** The team's `--project`; grants resolve from it at launch. */
-project = null) {
+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, hostName = null, hostTarget = null, repoPath = null, project = null) {
     const defaultMode = manager.getDefaultMode();
     const resolvedMode = resolveMode(mode, defaultMode);
     const resolvedEffort = effort ?? 'medium';
     debug(`[spawn] Spawning ${agentType} agent for task "${taskName}" [${resolvedMode}] effort=${resolvedEffort}${profileName ? ` profile=${profileName}` : ''}...`);
-    // Budget pre-flight gate (issue #346). Teammates inherit the project's caps:
-    // before launching one, project its estimated cost onto current spend and
-    // refuse when on_exceed:block would be breached. Cross-vendor by construction
-    // — a Claude teammate and a Codex teammate draw down the same per_project /
-    // per_day pool. Dormant (no-op) when no caps are configured.
     {
         const gateCwd = cwd || workspaceDir || worktreePath || process.cwd();
         const { runPreflightGate } = await import('../budget/preflight.js');
@@ -187,10 +153,7 @@ project = null) {
         host: agent.hostName,
     };
 }
-/** Retrieve the current status of all teammates in a task, with optional timestamp-based delta filtering. */
-export async function handleStatus(manager, taskName, filter, since, // Optional ISO timestamp - return only events after this time
-parentSessionId) {
-    // Default to 'all' so callers see completed/failed agents unless they opt to filter
+export async function handleStatus(manager, taskName, filter, since, parentSessionId) {
     const effectiveFilter = filter || 'all';
     const normalizedTaskName = taskName?.trim() || '';
     const normalizedParentSessionId = parentSessionId?.trim() || '';
@@ -204,13 +167,11 @@ parentSessionId) {
     const allAgents = normalizedParentSessionId && !normalizedTaskName
         ? await manager.listByParentSession(normalizedParentSessionId)
         : await manager.listByTask(normalizedTaskName);
-    // Filter agents by status ('all' shows everything)
     const agents = effectiveFilter === 'all'
         ? allAgents
         : allAgents.filter((a) => a.status === effectiveFilter);
     const agentStatuses = [];
     const counts = { pending: 0, running: 0, completed: 0, stranded: 0, failed: 0, stopped: 0 };
-    // Count ALL agents for summary (not just filtered)
     for (const agent of allAgents) {
         if (agent.status === AgentStatus.PENDING)
             counts.pending++;
@@ -223,10 +184,6 @@ parentSessionId) {
         else if (agent.status === AgentStatus.STOPPED)
             counts.stopped++;
     }
-    // Stranded count is computed over ALL agents, not the filter-narrowed view,
-    // so a `--filter running` status still reports teammates that completed dirty.
-    // Cache the probe result so we can reuse it when building details for the
-    // filtered subset without probing the worktree twice.
     const uncommittedCache = new Map();
     for (const agent of allAgents) {
         if (agent.status !== AgentStatus.COMPLETED)
@@ -247,17 +204,14 @@ parentSessionId) {
             counts.stranded++;
         }
     }
-    // Build details only for filtered agents
-    let maxTimestamp = since || new Date(0).toISOString(); // Track max timestamp for cursor
+    let maxTimestamp = since || new Date(0).toISOString();
     const claudeLabels = allAgents.some((agent) => agent.agentType === 'claude')
         ? buildClaudeLabelMap()
         : new Map();
     for (const agent of agents) {
         await agent.readNewEvents();
         const events = agent.events;
-        // Use getDelta to filter events by timestamp (or get all if no since)
         const delta = getDelta(agent.agentId, agent.agentType, agent.status, events, since);
-        // Find latest timestamp from this agent's events
         const latestEvent = events[events.length - 1];
         const agentTimestamp = latestEvent?.timestamp || new Date().toISOString();
         if (agentTimestamp > maxTimestamp) {
@@ -311,14 +265,12 @@ parentSessionId) {
         task_name: normalizedTaskName,
         agents: agentStatuses,
         summary: counts,
-        cursor: maxTimestamp, // Max timestamp across all agents
+        cursor: maxTimestamp,
     };
 }
-/** List all known tasks grouped by task name, sorted by most recent activity. */
 export async function handleTasks(manager, limit = 10) {
     debug(`[tasks] Listing tasks (limit=${limit})...`);
     const allAgents = await manager.listAll();
-    // Group agents by taskName
     const taskMap = new Map();
     for (const agent of allAgents) {
         const existing = taskMap.get(agent.taskName) || [];
@@ -332,7 +284,6 @@ export async function handleTasks(manager, limit = 10) {
         let latestActivity = null;
         let workspaceDir = null;
         for (const agent of agents) {
-            // Count by status
             if (agent.status === AgentStatus.PENDING)
                 pending++;
             else if (agent.status === AgentStatus.RUNNING)
@@ -343,9 +294,6 @@ export async function handleTasks(manager, limit = 10) {
                 failed++;
             else if (agent.status === AgentStatus.STOPPED)
                 stopped++;
-            // Stranded = completed, no PR, local worktree still dirty. Probes the real
-            // worktree so `teams tasks` and `teams list --status` don't classify lost
-            // work as done (PHNX-2951).
             if (agent.status === AgentStatus.COMPLETED && !agent.prUrl?.trim() && !agent.hostName && agent.workspaceDir) {
                 const delivery = resolveTeammateDelivery({
                     status: agent.status,
@@ -356,19 +304,15 @@ export async function handleTasks(manager, limit = 10) {
                     stranded++;
                 }
             }
-            // Track earliest start (created_at)
             if (!earliestStart || agent.startedAt < earliestStart) {
                 earliestStart = agent.startedAt;
             }
-            // Track latest activity (modified_at)
-            // For running agents, use current time; for others use completedAt or startedAt
             const activityTime = agent.status === AgentStatus.RUNNING
                 ? new Date()
                 : (agent.completedAt || agent.startedAt);
             if (!latestActivity || activityTime > latestActivity) {
                 latestActivity = activityTime;
             }
-            // Use first non-null workspaceDir found
             if (!workspaceDir && agent.workspaceDir) {
                 workspaceDir = agent.workspaceDir;
             }
@@ -387,14 +331,11 @@ export async function handleTasks(manager, limit = 10) {
             modified_at: latestActivity?.toISOString() || new Date().toISOString(),
         });
     }
-    // Sort by modified_at descending (most recent first)
     tasks.sort((a, b) => new Date(b.modified_at).getTime() - new Date(a.modified_at).getTime());
-    // Apply limit
     const limitedTasks = tasks.slice(0, limit);
     debug(`[tasks] Returning ${limitedTasks.length}/${tasks.length} tasks`);
     return { tasks: limitedTasks };
 }
-/** Stop a specific teammate or all teammates in a task. */
 export async function handleStop(manager, taskName, agentId) {
     if (agentId) {
         debug(`[stop] Stopping agent ${agentId} in task "${taskName}"...`);

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

@@ -1,7 +1 @@
-/**
- * Debug logging for the teams module.
- *
- * Outputs to stderr when AGENTS_DEBUG or DEBUG environment variables are set.
- */
-/** Log debug messages to stderr when debug mode is enabled. */
 export declare function debug(...args: unknown[]): void;

package/dist/lib/teams/debug.js

@@ -1,10 +1,4 @@
-/**
- * Debug logging for the teams module.
- *
- * Outputs to stderr when AGENTS_DEBUG or DEBUG environment variables are set.
- */
 const ENABLED = Boolean(process.env.AGENTS_DEBUG || process.env.DEBUG);
-/** Log debug messages to stderr when debug mode is enabled. */
 export function debug(...args) {
     if (ENABLED)
         console.error(...args);

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

@@ -1,51 +1,10 @@
-/**
- * Teammate *delivery* vs process *lifecycle* (RUSH-2380).
- *
- * `AgentStatus.COMPLETED` means the process exited 0 — not that the PR merged.
- * Orchestrators that treat COMPLETED as "work landed on main" compose on top of
- * unmerged PRs. This module derives a delivery signal from process status +
- * whether a PR URL is still open, so `teams status` can surface `PR OPEN`
- * instead of bare COMPLETED.
- *
- * Process status still drives the DAG (`--after` deps): a finished process
- * unblocks dependents. Delivery is the postcondition for "done end-to-end".
- */
 import { AgentStatus } from './agents.js';
-/** Postcondition-facing delivery of a teammate's work. */
 export type TeammateDelivery = 'pending' | 'in_progress' | 'pr_open' | 'pr_merged' | 'no_pr' | 'stranded' | 'failed' | 'stopped';
-/**
- * Derive delivery from process status and PR state.
- *
- * When the process completed with a `prUrl` and merge is unknown or false,
- * delivery is `pr_open` — pessimistic: assume open until proven merged so an
- * orchestrator never mistakes "agent stopped" for "work on main".
- *
- * When the process completed with no PR and uncommitted changes remain in the
- * worktree, delivery is `stranded` — the work exists only locally and will be
- * lost if the worktree is cleaned up (PHNX-2951).
- */
 export declare function resolveTeammateDelivery(opts: {
     status: AgentStatus | string;
     prUrl?: string | null;
-    /**
-     * When known from a probe or meta: true = merged, false = still open.
-     * `null`/`undefined` = unknown; with a `prUrl` that means `pr_open`.
-     */
     prMerged?: boolean | null;
-    /**
-     * Whether the teammate's worktree has uncommitted changes. Only consulted
-     * when the process completed without a PR URL.
-     */
     hasUncommittedChanges?: boolean | null;
 }): TeammateDelivery;
-/**
- * Human label for `teams status` rows. Replaces bare COMPLETED with PR OPEN
- * when delivery is still pending merge, and with STRANDED when uncommitted
- * work is stranded in the worktree.
- */
 export declare function deliveryDisplayLabel(delivery: TeammateDelivery, processStatus: AgentStatus | string): string;
-/**
- * Color key for statusColor-style switches. `pr_open` and `stranded` get their
- * own keys so the rows are visually distinct from green COMPLETED.
- */
 export declare function deliveryColorKey(delivery: TeammateDelivery, processStatus: string): string;

package/dist/lib/teams/delivery.js

@@ -1,27 +1,4 @@
-/**
- * Teammate *delivery* vs process *lifecycle* (RUSH-2380).
- *
- * `AgentStatus.COMPLETED` means the process exited 0 — not that the PR merged.
- * Orchestrators that treat COMPLETED as "work landed on main" compose on top of
- * unmerged PRs. This module derives a delivery signal from process status +
- * whether a PR URL is still open, so `teams status` can surface `PR OPEN`
- * instead of bare COMPLETED.
- *
- * Process status still drives the DAG (`--after` deps): a finished process
- * unblocks dependents. Delivery is the postcondition for "done end-to-end".
- */
 import { AgentStatus } from './agents.js';
-/**
- * Derive delivery from process status and PR state.
- *
- * When the process completed with a `prUrl` and merge is unknown or false,
- * delivery is `pr_open` — pessimistic: assume open until proven merged so an
- * orchestrator never mistakes "agent stopped" for "work on main".
- *
- * When the process completed with no PR and uncommitted changes remain in the
- * worktree, delivery is `stranded` — the work exists only locally and will be
- * lost if the worktree is cleaned up (PHNX-2951).
- */
 export function resolveTeammateDelivery(opts) {
     const status = String(opts.status);
     if (status === AgentStatus.PENDING || status === 'pending')
@@ -43,11 +20,6 @@ export function resolveTeammateDelivery(opts) {
     }
     return 'in_progress';
 }
-/**
- * Human label for `teams status` rows. Replaces bare COMPLETED with PR OPEN
- * when delivery is still pending merge, and with STRANDED when uncommitted
- * work is stranded in the worktree.
- */
 export function deliveryDisplayLabel(delivery, processStatus) {
     if (delivery === 'pr_open')
         return 'PR OPEN';
@@ -57,10 +29,6 @@ export function deliveryDisplayLabel(delivery, processStatus) {
         return 'STRANDED';
     return String(processStatus).toUpperCase();
 }
-/**
- * Color key for statusColor-style switches. `pr_open` and `stranded` get their
- * own keys so the rows are visually distinct from green COMPLETED.
- */
 export function deliveryColorKey(delivery, processStatus) {
     if (delivery === 'pr_open')
         return 'pr_open';

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

@@ -1,12 +1 @@
-/**
- * Bash command file-operation inference.
- *
- * Heuristically extracts file read, write, and delete operations from
- * shell command strings using regex patterns. Used by the event parsers
- * and summarizer to attribute file-level side effects to bash tool calls.
- */
-/**
- * Try to infer file operations (read/write/delete) from a bash command string.
- * Returns three arrays: files read, written, and deleted.
- */
 export declare function extractFileOpsFromBash(command: string): [string[], string[], string[]];

package/dist/lib/teams/file_ops.js

@@ -1,14 +1,3 @@
-/**
- * Bash command file-operation inference.
- *
- * Heuristically extracts file read, write, and delete operations from
- * shell command strings using regex patterns. Used by the event parsers
- * and summarizer to attribute file-level side effects to bash tool calls.
- */
-/**
- * Try to infer file operations (read/write/delete) from a bash command string.
- * Returns three arrays: files read, written, and deleted.
- */
 export function extractFileOpsFromBash(command) {
     const filesRead = [];
     const filesWritten = [];

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

@@ -1,111 +1,35 @@
 import type { AgentManager, AgentProcess, EffortLevel } from './agents.js';
 import { type ForEachSpec, type ForEachTeammate } from '../workflows.js';
-/**
- * Parse a producer's stdout into the item list `expandForEach` fans out over.
- *
- * Two shapes are accepted (issue #343), tried in order:
- *   1. A JSON array — `["a","b","c"]` (each element coerced to a trimmed string).
- *   2. Newline-delimited — one item per line.
- *
- * Empty lines / entries are dropped so a trailing newline or a `[]` never
- * fabricates a phantom teammate. Pure and deterministic — no I/O.
- */
 export declare function parseProducedItems(stdout: string): string[];
 interface ProduceItemsOptions {
-    /** Working directory for the producer command. */
     cwd?: string | null;
-    /** Environment for the producer command (defaults to the current process env). */
     env?: NodeJS.ProcessEnv;
-    /** Kill the producer after this many ms (default 120_000). */
     timeoutMs?: number;
-    /**
-     * Resolve an `itemsRef` (`${step}`-style reference) to a prior step's produced
-     * list. When a spec carries `itemsRef` and this resolver returns a list, the
-     * producer command is skipped entirely.
-     */
     resolveItemsRef?: (ref: string) => string[] | undefined;
 }
-/**
- * Resolve a `for_each` spec's item list at runtime (issue #343): either by
- * running its `produce:` shell command and parsing stdout, or by resolving an
- * `itemsRef` to a prior step's list. The resulting items feed `expandForEach` /
- * `runForEach`.
- *
- * `itemsRef` wins when a resolver is supplied and returns a list; otherwise the
- * `produce` command runs. A spec with neither a resolvable ref nor a produce
- * command is a hard error — there is nothing to fan out over.
- */
 export declare function produceItems(spec: ForEachSpec, opts?: ProduceItemsOptions): Promise<string[]>;
-/**
- * Evaluate a verify panel's `keep_if` gate against its boolean votes (issue
- * #343). A `true` vote is a skeptic confirming the finding should be kept.
- *
- *   - `all`      — every skeptic must vote keep.
- *   - `any`      — at least one skeptic votes keep.
- *   - `majority` — strictly more than half vote keep (a tie does NOT pass).
- *
- * An empty panel returns false: with no votes there is nothing affirming the
- * item, so the conservative gate drops it.
- */
 export declare function evaluateKeepIf(votes: boolean[], keepIf: 'majority' | 'all' | 'any'): boolean;
-/** Per-item verdict after tallying its verify panel. */
 interface ForEachItemVerdict {
-    /** The produced item this verdict is for. */
     item: string;
-    /** Zero-based index in the (capped) produced list. */
     itemIndex: number;
-    /** The stage teammate that handled this item. */
     stageName: string;
-    /** Whether the item survives its `keep_if` gate (true when it has no panel). */
     kept: boolean;
-    /** The votes that were tallied (empty when the item has no verify panel). */
     votes: boolean[];
-    /** The gate applied (undefined when the item has no verify panel). */
     keepIf?: 'majority' | 'all' | 'any';
 }
-/**
- * Tally the verify panels of an expanded `for_each` and gate each item (issue
- * #343). Groups verify teammates by the stage teammate they depend on, reads a
- * boolean vote per verify teammate via `readVote`, and applies `keep_if`.
- *
- * An item with no verify panel is kept unconditionally (there is no gate).
- * Pure and deterministic: `readVote` is the only place runtime state enters, so
- * this is unit-testable with a synthetic vote reader.
- */
 export declare function tallyForEach(teammates: ForEachTeammate[], readVote: (verify: ForEachTeammate) => boolean): ForEachItemVerdict[];
 export interface RunForEachOptions {
-    /** Working directory for the spawned teammates. */
     cwd?: string | null;
-    /**
-     * Name of the producer teammate the stage teammates should depend on. When
-     * set, each stage runs `--after` the producer so it can't start before the
-     * list is available.
-     */
     producerName?: string;
-    /** Default effort for spawned teammates (per-item overrides live in the spec). */
     effort?: EffortLevel;
-    /** Concurrency cap for the wave; falls back to the spec's `concurrency`. */
     concurrency?: number;
 }
 export interface RunForEachResult {
-    /** The expanded descriptors (stage + verify), in spawn order. */
     teammates: ForEachTeammate[];
-    /** The AgentProcess handles returned by `spawn`, aligned to `teammates`. */
     spawned: AgentProcess[];
-    /** Items the producer emitted (pre-cap). */
     producedCount: number;
-    /** Items actually fanned out (post-cap). */
     usedCount: number;
-    /** How many items the runaway guard dropped. */
     truncated: number;
 }
-/**
- * Expand a `for_each` spec against a producer's output and stage every
- * resulting teammate into the given team via the dynamic-add path.
- *
- * Returns the descriptors and the spawned handles so a caller can drive the
- * supervisor and later gather results (e.g. to evaluate a `verify` panel's
- * `keep_if` gate — that vote-counting lives downstream, not here).
- */
 export declare function runForEach(mgr: AgentManager, teamName: string, spec: ForEachSpec, items: string[], opts?: RunForEachOptions): Promise<RunForEachResult>;
 export {};