@phnx-labs/agents-cli 1.20.35 → 1.20.36

package/dist/lib/watchdog/watchdogTail.js

@@ -0,0 +1,154 @@
+// Watchdog tail summarization: pull the most recent user / assistant message
+// out of the session JSONL window the watchdog read this tick. Pure functions —
+// the watchdog runtime hands us tailLines + agentType and we read no files.
+// Ported from Swarmify (extension/src/core/watchdogTail.ts) — behavior verbatim.
+const MAX_MESSAGE_CHARS = 600;
+export function summarizeWatchdogTail(tailLines, agentType) {
+    let lastUser;
+    let lastAssistant;
+    for (let i = tailLines.length - 1; i >= 0; i--) {
+        if (lastUser && lastAssistant)
+            break;
+        let raw;
+        try {
+            raw = JSON.parse(tailLines[i]);
+        }
+        catch {
+            continue;
+        }
+        if (!raw || typeof raw !== 'object')
+            continue;
+        if (agentType === 'claude') {
+            const claim = readClaude(raw);
+            if (claim?.role === 'user' && !lastUser)
+                lastUser = claim.text;
+            else if (claim?.role === 'assistant' && !lastAssistant)
+                lastAssistant = claim.text;
+        }
+        else if (agentType === 'codex') {
+            const claim = readCodex(raw);
+            if (claim?.role === 'user' && !lastUser)
+                lastUser = claim.text;
+            else if (claim?.role === 'assistant' && !lastAssistant)
+                lastAssistant = claim.text;
+        }
+        else if (agentType === 'gemini') {
+            const claim = readGemini(raw);
+            if (claim?.role === 'user' && !lastUser)
+                lastUser = claim.text;
+            else if (claim?.role === 'assistant' && !lastAssistant)
+                lastAssistant = claim.text;
+        }
+    }
+    return {
+        lastUserMessage: clip(lastUser),
+        lastAssistantMessage: clip(lastAssistant),
+    };
+}
+function readClaude(raw) {
+    const t = raw.type;
+    if (t !== 'user' && t !== 'assistant')
+        return null;
+    const msg = raw.message;
+    if (!msg)
+        return null;
+    const text = pickContentText(msg.content);
+    if (!text)
+        return null;
+    return { role: t, text };
+}
+function readCodex(raw) {
+    if (raw.type !== 'response_item')
+        return null;
+    const payload = raw.payload;
+    if (!payload || payload.type !== 'message')
+        return null;
+    const role = payload.role;
+    if (role !== 'user' && role !== 'assistant')
+        return null;
+    const text = pickContentText(payload.content);
+    if (!text)
+        return null;
+    return { role, text };
+}
+// Gemini stores chats as a single pretty-printed JSON document — readTailLines
+// returns partial fragments that JSON.parse rejects. So in practice this
+// branch only fires for the JSONL-style events that some Gemini wrappers emit
+// during a live session. Acceptable: the result is an empty summary, which
+// the UI handles gracefully.
+function readGemini(raw) {
+    const t = raw.type;
+    if (t === 'user_message') {
+        const text = typeof raw.text === 'string' ? raw.text : null;
+        return text ? { role: 'user', text } : null;
+    }
+    if (t === 'agent_message' || t === 'model_message') {
+        const text = typeof raw.text === 'string' ? raw.text : null;
+        return text ? { role: 'assistant', text } : null;
+    }
+    if (t === 'message') {
+        const role = raw.role === 'user' ? 'user' : raw.role === 'assistant' ? 'assistant' : null;
+        if (!role)
+            return null;
+        const text = typeof raw.text === 'string' ? raw.text : pickContentText(raw.content);
+        return text ? { role, text } : null;
+    }
+    return null;
+}
+function pickContentText(content) {
+    if (typeof content === 'string')
+        return isSyntheticTagged(content) ? null : content;
+    if (!Array.isArray(content))
+        return null;
+    const parts = [];
+    for (const part of content) {
+        if (!part || typeof part !== 'object')
+            continue;
+        const p = part;
+        if ((p.type === 'text' || p.type === 'input_text' || p.type === 'output_text') && typeof p.text === 'string') {
+            if (isSyntheticTagged(p.text))
+                continue;
+            parts.push(p.text);
+        }
+    }
+    return parts.length ? parts.join('\n') : null;
+}
+// Mirrors the synthetic-tag filter in the session readers so a "User: …"
+// surfaced in the watchdog UI never shows a <local-command-stdout>,
+// <system-reminder>, or similar harness chunk that Claude wraps tool output in.
+const SYNTHETIC_TAG_PREFIXES = [
+    '<local-command-caveat',
+    '<local-command-stdout',
+    '<local-command-stderr',
+    '<command-name',
+    '<command-message',
+    '<command-args',
+    '<bash-input',
+    '<bash-stdout',
+    '<bash-stderr',
+    '<system-reminder',
+    '<user-prompt-submit-hook',
+    '<task-notification',
+    '<persisted-output',
+];
+function isSyntheticTagged(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return true;
+    const lower = trimmed.toLowerCase();
+    for (const prefix of SYNTHETIC_TAG_PREFIXES) {
+        if (lower.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
+function clip(text) {
+    if (!text)
+        return undefined;
+    const cleaned = text.replace(/\s+/g, ' ').trim();
+    if (!cleaned)
+        return undefined;
+    return cleaned.length > MAX_MESSAGE_CHARS
+        ? cleaned.slice(0, MAX_MESSAGE_CHARS - 1) + '…'
+        : cleaned;
+}

package/dist/lib/workflows.d.ts

@@ -21,6 +21,70 @@ export interface LoopConfigRaw {
     /** Delay between iterations ("0" back-to-back, "30m" paces). */
     interval?: string;
 }
+/**
+ * The `verify:` sub-block of a `for_each:` construct (issue #343).
+ *
+ * Each produced item's stage teammate can be gated by a panel of independent
+ * skeptics: `votes` of them run (as teammates that depend on the stage), and
+ * `keep_if` records how their verdicts converge (`majority` / `all` / `any`).
+ * The vote-counting itself is a downstream concern — the declarative layer's
+ * job is to expand the panel; see `expandForEach`.
+ */
+export interface ForEachVerifySpec {
+    /** Subagent / agent id that plays skeptic for each item. */
+    agent: string;
+    /** Prompt template for each skeptic (`{{item}}`, `{{index}}` substituted). */
+    prompt?: string;
+    /** How many independent skeptics run per item (>= 1). */
+    votes: number;
+    /** Convergence rule for keeping a finding. */
+    keep_if: 'majority' | 'all' | 'any';
+}
+/**
+ * The `for_each:` block as it appears in WORKFLOW.md frontmatter (issue #343).
+ *
+ * Declarative dynamic fan-out: a producer emits a list at runtime, one stage
+ * teammate runs per produced item (runtime-computed N), optionally followed by
+ * a `verify` panel. This is a thin declarative layer over the existing teams
+ * substrate — each expanded teammate is staged into the supervisor's
+ * mid-flight-add path (`AgentManager.spawn`), NOT a new engine. See
+ * `expandForEach` and `src/lib/teams/forEach.ts`.
+ *
+ * Parsed defensively (mirrors `parseLoopBlock`): a malformed block drops to
+ * undefined rather than passing a bad shape downstream.
+ */
+export interface ForEachSpec {
+    /**
+     * The producer: a shell command or subagent whose stdout is a JSON array (or
+     * newline-delimited list) of items. Alternatively `itemsRef` names a prior
+     * step's output. At least one of the two is expected for a runnable spec.
+     */
+    produce?: string;
+    /** `${step}`-style reference to a prior step's produced list. */
+    itemsRef?: string;
+    /** Subagent / agent id for the per-item stage. */
+    agent: string;
+    /** Base name for the expanded teammates (default `item`). */
+    name?: string;
+    /** Per-item prompt template (`{{item}}`, `{{index}}` substituted). */
+    prompt: string;
+    /** In-flight cap — maps to the supervisor's wave size (>= 1). */
+    concurrency?: number;
+    /**
+     * Hard runaway guard: the producer can emit at most this many items before
+     * the fan-out is truncated. Defaults to `DEFAULT_FOR_EACH_CAP`.
+     */
+    max_items?: number;
+    /** Optional convergence gate run after each item's stage. */
+    verify?: ForEachVerifySpec;
+}
+/**
+ * Hard upper bound on items a single `for_each` expands, absent an explicit
+ * `max_items`. A guard against a runaway producer spawning unbounded teammates
+ * (acceptance criterion in issue #343). Anthropic's Dynamic Workflows cap at
+ * 1000; we default lower and let authors raise it deliberately.
+ */
+export declare const DEFAULT_FOR_EACH_CAP = 256;
 /** Parsed WORKFLOW.md frontmatter. */
 export interface WorkflowFrontmatter {
     name: string;
@@ -43,6 +107,12 @@ export interface WorkflowFrontmatter {
      * `--loop` flag. Validated/coerced in parseWorkflowFrontmatter.
      */
     loop?: LoopConfigRaw;
+    /**
+     * Optional declarative dynamic fan-out (issue #343): a producer emits a list
+     * and one stage teammate runs per item, with an optional verify panel.
+     * Validated/coerced in parseWorkflowFrontmatter via `parseForEachBlock`.
+     */
+    forEach?: ForEachSpec;
 }
 /** A workflow found during repo discovery. */
 export interface DiscoveredWorkflow {
@@ -76,6 +146,81 @@ export declare function parseWorkflowFrontmatter(workflowDir: string): WorkflowF
  *   - interval:       a string (e.g. "0", "30m"); non-strings dropped.
  */
 export declare function parseLoopBlock(v: unknown): LoopConfigRaw | undefined;
+/**
+ * Defensively coerce a frontmatter `verify:` sub-block into a ForEachVerifySpec.
+ *
+ * Requires an `agent`; drops the whole block otherwise (a verify panel with no
+ * skeptic is meaningless). `votes` defaults to 1 (a single confirmation) and
+ * `keep_if` to `majority`; both are validated against their allowed shapes.
+ */
+export declare function parseVerifyBlock(v: unknown): ForEachVerifySpec | undefined;
+/**
+ * Defensively coerce a frontmatter `for_each:` block into a ForEachSpec (issue
+ * #343). Mirrors `parseLoopBlock`'s discipline: a block missing the two
+ * load-bearing fields (`agent` + `prompt`) drops to undefined rather than
+ * passing a half-formed spec to the expander. Optional numeric/verify fields
+ * are individually validated and dropped when malformed.
+ */
+export declare function parseForEachBlock(v: unknown): ForEachSpec | undefined;
+/** One teammate produced by expanding a `for_each` spec against a produced list. */
+export interface ForEachTeammate {
+    /** `stage` runs the per-item work; `verify` is a skeptic in the panel. */
+    role: 'stage' | 'verify';
+    /** Unique teammate name within the team (used for `--after` linkage). */
+    name: string;
+    /** Subagent / agent id this teammate runs as. */
+    agentType: string;
+    /** Fully-resolved prompt (template variables already substituted). */
+    prompt: string;
+    /** Names of sibling teammates this one waits on (`--after` semantics). */
+    after: string[];
+    /** The produced item this teammate handles. */
+    item: string;
+    /** Zero-based index of the item in the (capped) produced list. */
+    itemIndex: number;
+    /** For `verify` teammates: 1-based vote index and the panel's gate config. */
+    vote?: number;
+    votes?: number;
+    keep_if?: 'majority' | 'all' | 'any';
+}
+/** Result of expanding a `for_each` spec: the teammates plus cap accounting. */
+export interface ForEachExpansion {
+    teammates: ForEachTeammate[];
+    /** How many items the producer emitted (pre-cap). */
+    producedCount: number;
+    /** How many items were actually expanded (post-cap). */
+    usedCount: number;
+    /** producedCount - usedCount; > 0 means the runaway guard truncated. */
+    truncated: number;
+    /** The effective per-`for_each` item cap that was applied. */
+    cap: number;
+}
+/**
+ * Substitute `{{item}}` / `{{index}}` (and 1-based `{{n}}`) in a prompt
+ * template. Unknown `{{...}}` tokens are left intact so a template can carry
+ * placeholders the caller resolves elsewhere.
+ */
+export declare function renderForEachTemplate(template: string, item: string, index: number): string;
+/**
+ * Expand a `for_each` spec against a producer's output into concrete teammate
+ * descriptors (issue #343) — the heart of the declarative fan-out.
+ *
+ * Pure and deterministic: no I/O, no spawning. `src/lib/teams/forEach.ts`
+ * feeds the result to `AgentManager.spawn`, staging each descriptor into the
+ * supervisor's existing mid-flight-add path — so this reuses the dynamic-DAG
+ * substrate rather than introducing a new engine.
+ *
+ * For N produced items (capped at `spec.max_items` / `DEFAULT_FOR_EACH_CAP`):
+ *   - one `stage` teammate per item, depending on `producerName` if given;
+ *   - when `verify` is set, `votes` `verify` teammates per item, each
+ *     depending on that item's stage teammate.
+ *
+ * Names are unique (`<base>-<n>` and `<base>-<n>-verify-<v>`) so `--after`
+ * linkage and the teams cycle check carry over unchanged.
+ */
+export declare function expandForEach(spec: ForEachSpec, items: string[], opts?: {
+    producerName?: string;
+}): ForEachExpansion;
 /**
  * Decide which subagent .md stems a workflow may use, given the discovered
  * subagent files and the parsed `allowedAgents` frontmatter. This is the
@@ -95,6 +240,27 @@ export declare function resolveAllowedSubagents(available: string[], allowedAgen
     allowedStems: string[];
     missing: string[];
 };
+/**
+ * Prune stale workflow-managed subagent files from the shared per-agent agents
+ * dir before a scoped run writes the permitted set (issue #401, follow-up to
+ * #324). A prior *unrestricted* run of a workflow copies every subagent
+ * definition into the shared `~/.claude/agents/` dir; a later run that declares
+ * `allowedAgents:` copies only the permitted ones but never removes the
+ * leftovers — so an unlisted subagent stays on disk and remains dispatchable,
+ * silently defeating the fail-closed scope.
+ *
+ * Fail-closed fix (mirrors how `cleanupWorkflowMcpConfig` only tears down what
+ * the workflow itself created): remove any file that (a) belongs to THIS
+ * workflow's subagents/ — matched by filename, i.e. the workflow-managed
+ * universe — and (b) is NOT in the permitted set. A user's own hand-placed
+ * subagent shares no name with a workflow subagent file, so it is never
+ * touched. Permitted files are left in place; the caller (re)copies them.
+ *
+ * `workflowSubagentFiles` are the .md filenames in the workflow's subagents/
+ * dir (e.g. `security.md`); `allowedStems` are the permitted stems from
+ * `resolveAllowedSubagents`. Returns the filenames actually removed.
+ */
+export declare function pruneStaleWorkflowSubagents(sharedAgentsDir: string, workflowSubagentFiles: string[], allowedStems: string[]): string[];
 /** Count subagent .md files in a workflow's subagents/ directory. */
 export declare function countWorkflowSubagents(workflowDir: string): number;
 /**

package/dist/lib/workflows.js

@@ -11,6 +11,13 @@ import * as yaml from 'yaml';
 import { capableAgents } from './capabilities.js';
 import { getProjectAgentsDir, getSystemWorkflowsDir, getUserWorkflowsDir, getTrashWorkflowsDir, getEnabledExtraRepos, } from './state.js';
 import { listInstalledVersions, getVersionHomePath } from './versions.js';
+/**
+ * Hard upper bound on items a single `for_each` expands, absent an explicit
+ * `max_items`. A guard against a runaway producer spawning unbounded teammates
+ * (acceptance criterion in issue #343). Anthropic's Dynamic Workflows cap at
+ * 1000; we default lower and let authors raise it deliberately.
+ */
+export const DEFAULT_FOR_EACH_CAP = 256;
 /** Parse WORKFLOW.md frontmatter from a workflow directory. Returns null if invalid. */
 export function parseWorkflowFrontmatter(workflowDir) {
     const workflowMdPath = path.join(workflowDir, 'WORKFLOW.md');
@@ -42,6 +49,7 @@ export function parseWorkflowFrontmatter(workflowDir) {
             allowedAgents: asStringArray(parsed.allowedAgents),
             secrets: asStringArray(parsed.secrets),
             loop: parseLoopBlock(parsed.loop),
+            forEach: parseForEachBlock(parsed.for_each),
         };
     }
     catch {
@@ -83,6 +91,152 @@ export function parseLoopBlock(v) {
         out.interval = raw.interval;
     return Object.keys(out).length > 0 ? out : undefined;
 }
+/** A finite positive integer, or undefined. Shared guard for count-like fields. */
+function asPosInt(v) {
+    return typeof v === 'number' && Number.isFinite(v) && Number.isInteger(v) && v > 0
+        ? v
+        : undefined;
+}
+/** A non-empty trimmed string, or undefined. */
+function asNonEmptyString(v) {
+    return typeof v === 'string' && v.trim().length > 0 ? v : undefined;
+}
+/**
+ * Defensively coerce a frontmatter `verify:` sub-block into a ForEachVerifySpec.
+ *
+ * Requires an `agent`; drops the whole block otherwise (a verify panel with no
+ * skeptic is meaningless). `votes` defaults to 1 (a single confirmation) and
+ * `keep_if` to `majority`; both are validated against their allowed shapes.
+ */
+export function parseVerifyBlock(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return undefined;
+    const raw = v;
+    const agent = asNonEmptyString(raw.agent);
+    if (!agent)
+        return undefined;
+    const keepIf = raw.keep_if;
+    const out = {
+        agent,
+        votes: asPosInt(raw.votes) ?? 1,
+        keep_if: keepIf === 'all' || keepIf === 'any' || keepIf === 'majority'
+            ? keepIf
+            : 'majority',
+    };
+    const prompt = asNonEmptyString(raw.prompt);
+    if (prompt)
+        out.prompt = prompt;
+    return out;
+}
+/**
+ * Defensively coerce a frontmatter `for_each:` block into a ForEachSpec (issue
+ * #343). Mirrors `parseLoopBlock`'s discipline: a block missing the two
+ * load-bearing fields (`agent` + `prompt`) drops to undefined rather than
+ * passing a half-formed spec to the expander. Optional numeric/verify fields
+ * are individually validated and dropped when malformed.
+ */
+export function parseForEachBlock(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return undefined;
+    const raw = v;
+    const agent = asNonEmptyString(raw.agent);
+    const prompt = asNonEmptyString(raw.prompt);
+    if (!agent || !prompt)
+        return undefined;
+    const out = { agent, prompt };
+    const produce = asNonEmptyString(raw.produce);
+    if (produce)
+        out.produce = produce;
+    // `for_each: ${step}` references a prior step's list. Accept either the
+    // snake-case `for_each` key or an explicit `items_ref`.
+    const itemsRef = asNonEmptyString(raw.for_each) ?? asNonEmptyString(raw.items_ref);
+    if (itemsRef)
+        out.itemsRef = itemsRef;
+    const name = asNonEmptyString(raw.name);
+    if (name)
+        out.name = name;
+    const concurrency = asPosInt(raw.concurrency);
+    if (concurrency)
+        out.concurrency = concurrency;
+    const maxItems = asPosInt(raw.max_items);
+    if (maxItems)
+        out.max_items = maxItems;
+    const verify = parseVerifyBlock(raw.verify);
+    if (verify)
+        out.verify = verify;
+    return out;
+}
+/**
+ * Substitute `{{item}}` / `{{index}}` (and 1-based `{{n}}`) in a prompt
+ * template. Unknown `{{...}}` tokens are left intact so a template can carry
+ * placeholders the caller resolves elsewhere.
+ */
+export function renderForEachTemplate(template, item, index) {
+    return template
+        .replace(/\{\{\s*item\s*\}\}/g, item)
+        .replace(/\{\{\s*index\s*\}\}/g, String(index))
+        .replace(/\{\{\s*n\s*\}\}/g, String(index + 1));
+}
+/**
+ * Expand a `for_each` spec against a producer's output into concrete teammate
+ * descriptors (issue #343) — the heart of the declarative fan-out.
+ *
+ * Pure and deterministic: no I/O, no spawning. `src/lib/teams/forEach.ts`
+ * feeds the result to `AgentManager.spawn`, staging each descriptor into the
+ * supervisor's existing mid-flight-add path — so this reuses the dynamic-DAG
+ * substrate rather than introducing a new engine.
+ *
+ * For N produced items (capped at `spec.max_items` / `DEFAULT_FOR_EACH_CAP`):
+ *   - one `stage` teammate per item, depending on `producerName` if given;
+ *   - when `verify` is set, `votes` `verify` teammates per item, each
+ *     depending on that item's stage teammate.
+ *
+ * Names are unique (`<base>-<n>` and `<base>-<n>-verify-<v>`) so `--after`
+ * linkage and the teams cycle check carry over unchanged.
+ */
+export function expandForEach(spec, items, opts = {}) {
+    const cap = spec.max_items ?? DEFAULT_FOR_EACH_CAP;
+    const producedCount = items.length;
+    const used = items.slice(0, cap);
+    const base = spec.name ?? 'item';
+    const teammates = [];
+    used.forEach((item, itemIndex) => {
+        const stageName = `${base}-${itemIndex + 1}`;
+        teammates.push({
+            role: 'stage',
+            name: stageName,
+            agentType: spec.agent,
+            prompt: renderForEachTemplate(spec.prompt, item, itemIndex),
+            after: opts.producerName ? [opts.producerName] : [],
+            item,
+            itemIndex,
+        });
+        if (spec.verify) {
+            const verifyPrompt = spec.verify.prompt ?? spec.prompt;
+            for (let vote = 1; vote <= spec.verify.votes; vote++) {
+                teammates.push({
+                    role: 'verify',
+                    name: `${stageName}-verify-${vote}`,
+                    agentType: spec.verify.agent,
+                    prompt: renderForEachTemplate(verifyPrompt, item, itemIndex),
+                    after: [stageName],
+                    item,
+                    itemIndex,
+                    vote,
+                    votes: spec.verify.votes,
+                    keep_if: spec.verify.keep_if,
+                });
+            }
+        }
+    });
+    return {
+        teammates,
+        producedCount,
+        usedCount: used.length,
+        truncated: producedCount - used.length,
+        cap,
+    };
+}
 /**
  * Decide which subagent .md stems a workflow may use, given the discovered
  * subagent files and the parsed `allowedAgents` frontmatter. This is the
@@ -110,6 +264,45 @@ export function resolveAllowedSubagents(available, allowedAgents) {
         missing: allowedAgents.filter(a => !present.has(a)),
     };
 }
+/**
+ * Prune stale workflow-managed subagent files from the shared per-agent agents
+ * dir before a scoped run writes the permitted set (issue #401, follow-up to
+ * #324). A prior *unrestricted* run of a workflow copies every subagent
+ * definition into the shared `~/.claude/agents/` dir; a later run that declares
+ * `allowedAgents:` copies only the permitted ones but never removes the
+ * leftovers — so an unlisted subagent stays on disk and remains dispatchable,
+ * silently defeating the fail-closed scope.
+ *
+ * Fail-closed fix (mirrors how `cleanupWorkflowMcpConfig` only tears down what
+ * the workflow itself created): remove any file that (a) belongs to THIS
+ * workflow's subagents/ — matched by filename, i.e. the workflow-managed
+ * universe — and (b) is NOT in the permitted set. A user's own hand-placed
+ * subagent shares no name with a workflow subagent file, so it is never
+ * touched. Permitted files are left in place; the caller (re)copies them.
+ *
+ * `workflowSubagentFiles` are the .md filenames in the workflow's subagents/
+ * dir (e.g. `security.md`); `allowedStems` are the permitted stems from
+ * `resolveAllowedSubagents`. Returns the filenames actually removed.
+ */
+export function pruneStaleWorkflowSubagents(sharedAgentsDir, workflowSubagentFiles, allowedStems) {
+    if (!fs.existsSync(sharedAgentsDir))
+        return [];
+    const allow = new Set(allowedStems);
+    const pruned = [];
+    for (const file of workflowSubagentFiles) {
+        if (!file.endsWith('.md'))
+            continue;
+        const stem = file.replace(/\.md$/, '');
+        if (allow.has(stem))
+            continue; // permitted → the copy step will (re)write it
+        const target = path.join(sharedAgentsDir, file);
+        if (fs.existsSync(target)) {
+            fs.rmSync(target, { force: true });
+            pruned.push(file);
+        }
+    }
+    return pruned;
+}
 /** Count subagent .md files in a workflow's subagents/ directory. */
 export function countWorkflowSubagents(workflowDir) {
     const subagentsDir = path.join(workflowDir, 'subagents');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.35",
+  "version": "1.20.36",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",
@@ -46,6 +46,7 @@
   "scripts": {
     "build": "tsc && rm -rf 'dist/lib/secrets/AgentsKeychain.app' 'dist/lib/secrets/Agents CLI.app' 'dist/lib/menubar/MenubarHelper.app' && ([ \"$(uname)\" = \"Darwin\" ] && cp -R 'bin/Agents CLI.app' 'dist/lib/secrets/Agents CLI.app' || true) && ([ \"$(uname)\" = \"Darwin\" ] && [ -d 'bin/MenubarHelper.app' ] && mkdir -p 'dist/lib/menubar' && cp -R 'bin/MenubarHelper.app' 'dist/lib/menubar/MenubarHelper.app' || true)",
     "build:bin": "scripts/build-bin.sh",
+    "prepare": "npm run build",
     "prepack": "scripts/verify-keychain-helper.sh && scripts/verify-menubar-helper.sh",
     "postinstall": "node scripts/postinstall.js",
     "dev": "tsx src/index.ts",
@@ -72,7 +73,7 @@
     "multi-agent"
   ],
   "author": "Phoenix Labs",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "engines": {
     "node": ">=22.5.0",
     "npm": ">=9"
@@ -102,8 +103,8 @@
   "devDependencies": {
     "@types/diff": "8.0.0",
     "@types/marked-terminal": "6.1.1",
-    "@types/node": "25.9.3",
-    "tsx": "4.22.4",
+    "@types/node": "26.1.0",
+    "tsx": "4.23.0",
     "typescript": "6.0.3",
     "vitest": "4.1.9"
   }