@livx.cc/agentx 0.99.122 → 0.99.124

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-BddfVzTp.d.ts → secondChannel-GFT69ax4.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
@@ -99,6 +99,26 @@ type JevOpts = {
 declare function jevAvailable(opts?: JevOpts): Promise<boolean>;
 declare function jevClassifier(opts?: JevOpts): Classifier;
 
+/**
+ * Walk the VFS directory tree from `/` down, collecting instruction files
+ * (AGENT.md, AGENTS.md, CLAUDE.md, .claude/<name>) at each level.
+ * Merges all found files general-first → specific-last (mirrors Claude Code's
+ * hierarchical CLAUDE.md discovery). First matching filename per directory wins
+ * (no duplicates from the same level). Edge-portable: works over any IFilesystem.
+ */
+declare function loadInstructions(fs: IFilesystem, names?: string[]): Promise<string>;
+/** An extra file injected into the prompt next to the instructions (e.g. a kb/user-space note). */
+interface ContextFileSpec {
+    path: string;
+    maxChars?: number;
+    label?: string;
+}
+/**
+ * Load explicit context files, same section format as instructions. Missing/empty → skipped;
+ * ≤ `maxChars` → full; over → head + a pointer to the full file (the agent can Read the rest).
+ */
+declare function loadContextFiles(fs: IFilesystem, specs?: ContextFileSpec[]): Promise<string>;
+
 /**
  * Hooks — deterministic interception points around tool execution, run by the
  * harness/host (mirrors Claude Code hooks). The seam stays edge-safe: hooks are
@@ -284,6 +304,12 @@ declare function composeHooks(...list: (Hooks | undefined)[]): Hooks;
 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. */
@@ -338,6 +364,21 @@ declare function meterWorkers<T extends ChatLike>(ai: T, main: string): {
     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.
@@ -542,6 +583,8 @@ declare class AgentOptions {
      *  Walks the VFS tree and merges all found files (general → specific, like Claude Code).
      *  `true` (default) = auto-discover standard names. `string[]` = custom names. `false` = skip. */
     instructionFiles: boolean | string[];
+    /** Extra files injected right after the instructions (missing → skipped; over `maxChars` → head + pointer to the full file). */
+    contextFiles?: ContextFileSpec[];
     /** Host interaction channel (human-in-the-loop). If set: adds the `AskUserQuestion` tool. */
     host?: HostBridge;
     /** Add the `AskUserQuestion` tool when a host is present (default true). Set false for an agent that
@@ -664,6 +707,8 @@ declare class Agent {
     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?;
@@ -1189,4 +1234,4 @@ declare class SecondChannel {
     private say;
 }
 
-export { ADVISE_LIMIT as A, advisorPrompt as B, type ChannelMode as C, DEFAULT_MUTATING as D, claudeCodeDisallowedTools as E, composeHooks as F, type Gender as G, type Hooks as H, delegatePrompt as I, delegateTools as J, delegateWorkerFor as K, type LineKind as L, ModelRouter as M, estimateTokens as N, jevAvailable as O, PLANNER_BLOCKED as P, jevClassifier as Q, type ReasoningEffort as R, SecondChannel as S, type Tier as T, makeAdvisor as U, meterWorkers as V, WRITE_TOOLS as W, pickTier as X, planMode as Y, reasoningToChatFragment as Z, type AdvisorSetup as a, Agent as b, AgentOptions as c, type ChatFragment as d, type ChatUsage as e, type Classification as f, type Classifier as g, type CompactResult as h, type Decider as i, type Decision as j, ModelRouterOptions as k, PLANNER_REFUSAL as l, PLAN_FIRST as m, PermissionOptions as n, PermissionPolicy as o, type PermissionRule as p, type PreToolUseDecision as q, RecordingHooks as r, RecordingLifecycle as s, type RouteDecision as t, type RouterState as u, type RunResult as v, SecondChannelOptions as w, type ToolUse as x, type ToolUseMeta as y, advisorFor as z };
+export { meterWorkers as $, ADVISE_LIMIT as A, type ToolUseMeta as B, CC_WRITE_TOOLS as C, DEFAULT_MUTATING as D, advisorFor as E, advisorPrompt as F, type Gender as G, type Hooks as H, ccModeOptions as I, claudeCodeDisallowedTools as J, composeHooks as K, type LineKind as L, ModelRouter as M, delegatePrompt as N, delegateTools as O, PLANNER_BLOCKED as P, delegateWorkerFor as Q, type ReasoningEffort as R, SecondChannel as S, type Tier as T, estimateTokens as U, jevAvailable as V, WRITE_TOOLS as W, jevClassifier as X, loadContextFiles as Y, loadInstructions as Z, makeAdvisor as _, type AdvisorSetup as a, pickTier as a0, planMode as a1, plannerBlocks as a2, reasoningToChatFragment as a3, 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 ContextFileSpec as j, type Decider as k, type Decision as l, ModelRouterOptions as m, PLANNER_REFUSAL as n, PLAN_FIRST as o, PermissionOptions as p, PermissionPolicy as q, type PermissionRule as r, type PreToolUseDecision as s, RecordingHooks as t, RecordingLifecycle as u, type RouteDecision as v, type RouterState as w, type RunResult as x, SecondChannelOptions as y, type ToolUse 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