@livx.cc/agentx 0.99.121 → 0.99.123

package/dist/{mcp-CUo-9LUe.d.ts → mcp-DZhcLur2.d.ts}

@@ -1,4 +1,4 @@
-import { A as AgentTool } from './tools-DZHZIyxh.js';
+import { A as AgentTool } from './tools-DwfeF8VQ.js';
 
 /**
  * MCP bridge — adapt a Model Context Protocol tool list into the agent's AgentTool[],

package/dist/mcp.client.d.ts

@@ -1,5 +1,5 @@
-import { e as McpToolSearchOptions, f as McpToolSpec } from './mcp-CUo-9LUe.js';
-import { A as AgentTool } from './tools-DZHZIyxh.js';
+import { e as McpToolSearchOptions, f as McpToolSpec } from './mcp-DZhcLur2.js';
+import { A as AgentTool } from './tools-DwfeF8VQ.js';
 import '@livx.cc/wcli/core';
 
 /** Hard cap for `tools/call`. NOT the 30s protocol timeout: a tool call is real work (an image render, a crawl)

package/dist/{secondChannel-D33Wvruo.d.ts → secondChannel-DES_VIeN.d.ts}

@@ -1,5 +1,5 @@
 import { IFilesystem } from '@livx.cc/wcli/core';
-import { M as Message, o as MessageContent, H as HostBridge, A as AgentTool, C as ChatLike, k as JobRegistry, U as UserQuestion } from './tools-DZHZIyxh.js';
+import { M as Message, o as MessageContent, H as HostBridge, A as AgentTool, C as ChatLike, k as JobRegistry, U as UserQuestion } from './tools-DwfeF8VQ.js';
 
 /**
  * `--model auto`: per-turn model routing. A classifier (Jev by default — injected, so a regex or
@@ -260,6 +260,106 @@ declare function planMode(opts?: {
 /** Run several Hooks as one: preToolUse stops at the first block; post/stop all fire. */
 declare function composeHooks(...list: (Hooks | undefined)[]): Hooks;
 
+/**
+ * Two-model modes (ported from Blank #258/#272) — generic, host-agnostic.
+ *
+ * DELEGATE `[planner->worker]` — the (premium) agent model PLANS, a cheaper worker model WRITES.
+ * The planner keeps every read tool plus `Task`/`TaskBatch`, but may not write: a nudge in the prompt
+ * was not enough (Opus, told to delegate, wrote the whole app itself 8 runs of 8). So the rule is
+ * enforced at EXECUTION. Workers inherit this exact toolbelt (children get the parent's tools), so the
+ * one thing that tells a planner call from a worker call is the calling agent's own model, which the
+ * Agent puts on `ToolContext.model`. That is why delegate mode refuses to start when the models are equal.
+ *
+ * ADVISOR `[worker<-advisor]` — the inverse. The cheap model drives with every tool; `Advise` makes a
+ * few short calls to the premium model that see only the request, an optional host snapshot and the
+ * question — never the system prompt or the conversation (Anthropic's advisor tool / Aider's architect).
+ * A prompt rule was not enough here either (Haiku, told to consult, wrote everything with 0 calls), so
+ * the first write waits for one consult.
+ *
+ * Both modes run the second model through the agent's shared `ai`; `meterWorkers` sums every call on
+ * a model other than the agent's own, which the Agent reports as `RunResult.workerUsage`.
+ */
+
+/** Tools that change files — refused for the planner, gated for an advised worker. */
+declare const WRITE_TOOLS: Set<string>;
+/** The planner also loses the shells: either one can write files. */
+declare const PLANNER_BLOCKED: Set<string>;
+/** Does the planner lose this tool? By the tool's own `writes` flag first — it survives a host rename (shraga-ee's
+ *  `Shell` → `Bash`) — then by name, case-insensitively (`Bash`, a host's own `write`). */
+declare const plannerBlocks: (t: {
+    name: string;
+    writes?: boolean;
+}) => boolean;
+declare const PLANNER_REFUSAL = "Refused: you are the planner and do not write files. Delegate the change with Task/TaskBatch (model set to the worker) and give the worker a full spec.";
+declare const PLAN_FIRST = "Refused: check your plan with `Advise` before the first write (files, data shape, the hard parts). Then write.";
+/** A build may consult at most this many times by default: plan + review + one spare. */
+declare const ADVISE_LIMIT = 3;
+type ModeTool = {
+    name: string;
+    run: (...a: any[]) => any;
+};
+/** The worker model when delegate mode can run for this planner, else undefined (why: in the log). */
+declare function delegateWorkerFor(planner: string, worker?: string | false | null): string | undefined;
+/** The advisor model when advisor mode can run for this worker, else undefined. */
+declare function advisorFor(worker: string, advisor?: string | false | null): string | undefined;
+/** Refuse the planner's file-changing tools; a worker (any other `ctx.model`) runs them as usual. */
+declare function delegateTools<T extends ModeTool>(tools: T[], planner: string): T[];
+/** Appended to the PLANNER's system prompt only (workers inherit the host's base prompt). */
+declare function delegatePrompt(worker: string): string;
+/** Appended to the advised worker's system prompt. */
+declare function advisorPrompt(advisor: string): string;
+interface AdvisorSetup {
+    ai: ChatLike;
+    advisor: string;
+    /** The user's request as the advisor should read it (the current turn's text). */
+    request: () => string;
+    /** Host-supplied state the advisor reads NOW (mid-run): files, a diff, a summary. Capped. Default: none. */
+    snapshot?: () => string | Promise<string>;
+    limit?: number;
+}
+/** The `Advise` tool, plus `gate` for the file tools: the first write waits for one consult
+ *  (a failed consult counts — it never blocks the work). */
+type Advisor = {
+    tool: ModeTool & {
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+    gate: <T extends ModeTool>(tools: T[]) => T[];
+    used: () => number;
+};
+declare function makeAdvisor(o: AdvisorSetup): Advisor;
+type ChatUsage = {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+};
+/** Meter the second model's calls: every call on the shared `ai` that names a model other than `main`
+ *  (workers, the advisor). Streams count their LAST usage chunk, as the agent loop does. `model()` is
+ *  the provider's resolved id of the last such call (captured right after it, before `main` overwrites it). */
+declare function meterWorkers<T extends ChatLike>(ai: T, main: string): {
+    ai: T;
+    usage: () => ChatUsage | undefined;
+    model: () => string | undefined;
+    reset: () => void;
+};
+/** Claude Code's NATIVE file-changing tools (its own loop runs them; agentx's tool wrappers never see the call). */
+declare const CC_WRITE_TOOLS: string[];
+/**
+ * The same two modes for a claude-code/* agent. Claude Code runs its OWN tool loop, so `delegateTools`/`gate`
+ * (which wrap agentx tools) never fire there — Opus wrote with its native Write and had no worker tool.
+ * - planner: native writes, Bash and native Task/Agent are `disallowedTools` (the SDK strips them); agentx's
+ *   Task/TaskBatch reach it over the in-process bridge (ccBridge.ts), so it delegates to workers on the worker model.
+ * - advised worker: `Advise` goes over the bridge; a PreToolUse hook denies a native write until one consult
+ *   (`used()` > 0). The host's own `hooks` are kept.
+ */
+declare function ccModeOptions(kind: 'delegate' | 'advisor' | undefined, hostHooks: Record<string, unknown[]> | undefined, used: () => number): {
+    bridge: Set<string>;
+    disallow: string[];
+    hooks?: Record<string, unknown[]>;
+};
+
 /**
  * Normalized reasoning/thinking control → provider-specific request fragment.
  *
@@ -337,6 +437,10 @@ interface RunResult {
      *  ran it"), and on the guard's own success path that sentence is false. Whether a turn needed rescuing
      *  is a telemetry question, and the `log.warn` at the nudge already answers it. */
     fabricatedToolClaims?: string[];
+    /** Delegate/advisor mode: the second model (provider-resolved id when known) and the summed usage of its
+     *  calls this run — NOT included in `usage`, which is the agent's own model. */
+    workerModel?: string;
+    workerUsage?: ChatUsage;
     error?: unknown;
 }
 /** What a manual `/compact` actually freed (token estimates, ~4 chars/token). */
@@ -468,6 +572,19 @@ declare class AgentOptions {
     hooks?: Hooks;
     /** If true: add the `Task` tool so the agent can spawn depth-limited child agents over the VFS. */
     subagents: boolean;
+    /** DELEGATE MODE: `model` plans, `worker` writes. The planner's Write/Edit/MultiEdit/ApplyEdits/bash/Shell are
+     *  refused at execution; Task/TaskBatch are on (maxDepth 1, children default to `worker`) and children get the
+     *  parent's `postToolUse` too. Off when the models are equal or either is cursor/*. Wins over `advisor`. */
+    delegate?: {
+        worker: string;
+    };
+    /** ADVISOR MODE: `model` does the work; an `Advise` tool asks `advisor.model` (≤`limit`, default 3) with only
+     *  the request + `snapshot()` (host state, optional) + the question. The first write waits for one consult. */
+    advisor?: {
+        model: string;
+        limit?: number;
+        snapshot?: () => string | Promise<string>;
+    };
     /** VFS dir of typed-subagent defs (`<dir>/<name>.md`). If set with `subagents`: inject a catalog + enable the `Task` `agentType` param. */
     agentsDir?: string;
     /** Current recursion depth (0 = top-level); spawned children run at depth+1. */
@@ -566,6 +683,11 @@ declare class Agent {
     private ctx;
     private lastTrimNotified;
     private activeTools;
+    private meter?;
+    private modeModel?;
+    private modeKind?;
+    private adv?;
+    private lastTask;
     /** claude-code bridge for agentx-only tools (ccBridge.ts) + the current step's executor it calls. */
     private ccServer?;
     private ccExec?;
@@ -687,6 +809,7 @@ declare class Agent {
     /** Drop inline base64 images from older messages so Bun/JSC can reclaim the heap (see contentBytes). */
     releaseStaleImages(keepRecent?: number): void;
     private runLoop;
+    private loop;
     /**
      * Drain a streamed chat() response: emit each text delta to the host
      * (`{kind:'text_delta'}`) and fold all chunks back into the single
@@ -1089,4 +1212,4 @@ declare class SecondChannel {
     private say;
 }
 
-export { Agent as A, reasoningToChatFragment as B, type ChannelMode as C, DEFAULT_MUTATING as D, type Gender as G, type Hooks as H, type LineKind as L, ModelRouter as M, PermissionOptions as P, type ReasoningEffort as R, SecondChannel as S, type Tier as T, AgentOptions as a, type ChatFragment as b, type Classification as c, type Classifier as d, type CompactResult as e, type Decider as f, type Decision as g, ModelRouterOptions as h, PermissionPolicy as i, type PermissionRule as j, type PreToolUseDecision as k, RecordingHooks as l, RecordingLifecycle as m, type RouteDecision as n, type RouterState as o, type RunResult as p, SecondChannelOptions as q, type ToolUse as r, type ToolUseMeta as s, claudeCodeDisallowedTools as t, composeHooks as u, estimateTokens as v, jevAvailable as w, jevClassifier as x, pickTier as y, planMode as z };
+export { plannerBlocks as $, ADVISE_LIMIT as A, advisorFor as B, CC_WRITE_TOOLS as C, DEFAULT_MUTATING as D, advisorPrompt as E, ccModeOptions as F, type Gender as G, type Hooks as H, claudeCodeDisallowedTools as I, composeHooks as J, delegatePrompt as K, type LineKind as L, ModelRouter as M, delegateTools as N, delegateWorkerFor as O, PLANNER_BLOCKED as P, estimateTokens as Q, type ReasoningEffort as R, SecondChannel as S, type Tier as T, jevAvailable as U, jevClassifier as V, WRITE_TOOLS as W, makeAdvisor as X, meterWorkers as Y, pickTier as Z, planMode as _, type AdvisorSetup as a, reasoningToChatFragment as a0, Agent as b, AgentOptions as c, type ChannelMode as d, type ChatFragment as e, type ChatUsage as f, type Classification as g, type Classifier as h, type CompactResult as i, type Decider as j, type Decision as k, ModelRouterOptions as l, PLANNER_REFUSAL as m, PLAN_FIRST as n, PermissionOptions as o, PermissionPolicy as p, type PermissionRule as q, type PreToolUseDecision as r, RecordingHooks as s, RecordingLifecycle as t, type RouteDecision as u, type RouterState as v, type RunResult as w, SecondChannelOptions as x, type ToolUse as y, type ToolUseMeta as z };

package/dist/{tools-DZHZIyxh.d.ts → tools-DwfeF8VQ.d.ts}

@@ -552,6 +552,9 @@ interface AgentTool {
      * result. Omit for tools that return promptly.
      */
     maxDurationMs?: number;
+    /** This tool can change files (a file editor or a shell). Survives a host rename (`Shell` → `Bash`), so policy that
+     *  must hold whatever the tool is called — delegate mode's planner refusal — keys on it, not on the name. */
+    writes?: boolean;
     /**
      * Is `maxDurationMs` SELF-ENFORCED — does this tool abort itself at that bound and return?
      * An enforced bound cannot be overrun, so a transport above it needs only modest slack; an ADVISORY

package/dist/tools.shell.d.ts

@@ -1,4 +1,4 @@
-import { k as JobRegistry, A as AgentTool } from './tools-DZHZIyxh.js';
+import { k as JobRegistry, A as AgentTool } from './tools-DwfeF8VQ.js';
 import '@livx.cc/wcli/core';
 
 /**

package/dist/tools.shell.js

@@ -1221,6 +1221,7 @@ function makeRealShellTool(options) {
   };
   return {
     name: "Shell",
+    writes: true,
     // Rebind for an isolated child agent (git worktree): same policy/env/timeouts, new cwd. The
     // `registry` is deliberately dropped — it is bound to the PARENT's cwd (and, in hosts like
     // shraga-ee, to the parent's session), so a background job started from the child would run