@wrongstack/core 0.250.0 → 0.256.0

package/dist/index.js

@@ -190,6 +190,10 @@ var init_session_registry = __esm({
        * Starts the heartbeat timer.
        */
       async register(entry) {
+        if (this.heartbeatTimer) {
+          clearInterval(this.heartbeatTimer);
+          this.heartbeatTimer = null;
+        }
         this.currentSessionId = entry.sessionId;
         const full = {
           ...entry,
@@ -201,7 +205,10 @@ var init_session_registry = __esm({
         await this.atomicUpdate((registry) => {
           const now = Date.now();
           for (const [id, existing] of Object.entries(registry)) {
-            if (existing.pid === entry.pid) continue;
+            if (existing.pid === entry.pid) {
+              if (id !== entry.sessionId) delete registry[id];
+              continue;
+            }
             const heartbeatAge = now - new Date(existing.lastHeartbeatAt).getTime();
             if (heartbeatAge > STALE_TIMEOUT_MS && !pidAlive(existing.pid)) {
               delete registry[id];
@@ -2045,6 +2052,10 @@ var DefaultTokenCounter = class {
     const price = model ? this.priceCache.get(model) : void 0;
     if (price) {
       this.applyPrice(usage, price);
+      this.events?.emit("token.accounted", {
+        usage: this.total(),
+        cost: { input: this.costInput, output: this.costOutput, total: this.costInput + this.costOutput }
+      });
     } else if (this.registry && this.providerId && model) {
       if (this.priceCache.size >= PRICE_CACHE_MAX_SIZE) {
         const keys = [...this.priceCache.keys()];
@@ -2055,6 +2066,10 @@ var DefaultTokenCounter = class {
           const p = priceFromModel(m);
           this.priceCache.set(model, p);
           this.applyPrice(usage, p);
+          this.events?.emit("token.accounted", {
+            usage: this.total(),
+            cost: { input: this.costInput, output: this.costOutput, total: this.costInput + this.costOutput }
+          });
         }
       }).catch(() => {
         this.events?.emit("token.cost_estimate_unavailable", { model: model ?? "<unknown>" });
@@ -2077,6 +2092,10 @@ var DefaultTokenCounter = class {
     }
     this.priceCache.set(resolved.modelId, price);
     this.applyPrice(usage, price);
+    this.events?.emit("token.accounted", {
+      usage: this.total(),
+      cost: { input: this.costInput, output: this.costOutput, total: this.costInput + this.costOutput }
+    });
   }
   total() {
     return {
@@ -3042,9 +3061,28 @@ var PATTERNS = [
   }
 ];
 var SCRUB_CHUNK_BYTES = 64 * 1024;
+function hasCredentialAnchors(text) {
+  return text.includes("-----BEGIN") || // Private keys (most unique → cheap reject)
+  text.includes("sk-") || // Anthropic + OpenAI keys
+  text.includes("sk_") || // Stripe live/test keys
+  text.includes("ghp_") || // GitHub PAT v1
+  text.includes("github_pat_") || // GitHub PAT v2
+  text.includes("eyJ") || // JWT
+  text.includes("AKIA") || // AWS access key
+  text.includes("AIza") || // GCP service key
+  text.includes("xox") || // Slack token (xoxa/xoxb/xoxp/xoxo/xoxs)
+  text.includes("Bearer ") || // Bearer token (space suffix reduces false positives)
+  text.includes("/bot") || // Telegram bot token (URL path pattern)
+  text.includes("_KEY=") || // High-entropy env vars: API_KEY=, SECRET_KEY=, ...
+  text.includes("_TOKEN=") || // ACCESS_TOKEN=, AUTH_TOKEN=, ...
+  text.includes("_SECRET=") || // API_SECRET=, CLIENT_SECRET=, ...
+  text.includes("_PASSWORD=") || // DB_PASSWORD=, ROOT_PASSWORD=, ...
+  text.includes("mongodb://") || text.includes("mongodb+srv://") || text.includes("postgres://") || text.includes("postgresql://") || text.includes("mysql://") || text.includes("redis://");
+}
 var DefaultSecretScrubber = class {
   scrub(text) {
     if (!text) return text;
+    if (!hasCredentialAnchors(text)) return text;
     if (text.length <= SCRUB_CHUNK_BYTES) {
       return this.scrubOne(text);
     }
@@ -3062,6 +3100,7 @@ var DefaultSecretScrubber = class {
     return out.join("");
   }
   scrubOne(text) {
+    if (!hasCredentialAnchors(text)) return text;
     let out = text;
     for (const p of PATTERNS) {
       out = out.replace(p.regex, (_match, group1, group2) => {
@@ -4099,10 +4138,14 @@ var ToolCapabilities = {
   SHELL_ARBITRARY: "shell.arbitrary",
   /** Can execute a restricted set of commands (the `exec` tool). */
   SHELL_RESTRICTED: "shell.restricted",
+  /** Can read files inside the project (and possibly outside via symlinks if not guarded). */
+  FS_READ: "fs.read",
   /** Can write / modify / delete files inside the project. */
   FS_WRITE: "fs.write",
   /** Can write files outside the current project root (very high risk). */
   FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
+  /** Can perform outbound network requests. */
+  NET_OUTBOUND: "net.outbound",
   /** Proxies tools from external MCP servers (unknown capability). */
   MCP_PROXY: "mcp.proxy",
   /** Can spawn or manage subagents / multi-agent tasks. */
@@ -4339,7 +4382,7 @@ var ToolExecutor = class _ToolExecutor {
       const tool = this.registry.get(use.name);
       if (!tool) {
         const result = this.unknownToolResult(use, () => this.registry.list().map((t2) => t2.name));
-        budget = this.decrementBudget(result, budget);
+        budget = this.budgetForString(result.content, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
       const validation = validateAgainstSchema(use.input, tool.inputSchema);
@@ -4356,20 +4399,20 @@ ${errorDetails}
 Please call the tool again with arguments that match its inputSchema. You can use the "tool-help" tool with name="${tool.name}" to see the exact expected schema.`,
           is_error: true
         };
-        budget = this.decrementBudget(result, budget);
+        budget = this.budgetForString(result.content, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
       const toolDangerousCaps = getDangerousCapabilities(tool);
       if (hasMalformedArguments(use.input)) {
         const result = this.malformedInputResult(use, extractMalformedRaw(use.input));
-        budget = this.decrementBudget(result, budget);
+        budget = this.budgetForString(result.content, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
       if (this.opts.hookRunner?.has("PreToolUse")) {
         const pre = await this.opts.hookRunner.preToolUse(tool.name, use.input, ctx);
         if (pre.block) {
           const result = this.blockedByHookResult(use, pre.reason);
-          budget = this.decrementBudget(result, budget);
+          budget = this.budgetForString(result.content, budget);
           return { result, tool, durationMs: Date.now() - start };
         }
         if (pre.input) {
@@ -4385,7 +4428,7 @@ Validation errors:
 ${errorDetails}`,
               is_error: true
             };
-            budget = this.decrementBudget(result, budget);
+            budget = this.budgetForString(result.content, budget);
             return { result, tool, durationMs: Date.now() - start };
           }
           use = { ...use, input: pre.input };
@@ -4400,7 +4443,7 @@ ${errorDetails}`,
       }
       if (effectivePermission === "deny") {
         const result = this.deniedResult(use, decision.reason);
-        budget = this.decrementBudget(result, budget);
+        budget = this.budgetForString(result.content, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
       if (effectivePermission === "confirm") {
@@ -4413,7 +4456,7 @@ ${errorDetails}`,
               content: `Tool "${tool.name}" denied by user.`,
               is_error: true
             };
-            budget = this.decrementBudget(result, budget);
+            budget = this.budgetForString(result.content, budget);
             return { result, tool, durationMs: Date.now() - start };
           }
         } else {
@@ -4437,7 +4480,8 @@ ${errorDetails}`,
         "tool.has_dangerous_capabilities": toolCapsForAudit.length > 0
       });
       try {
-        let result = await this.executeTool(tool, use, ctx, budget);
+        let { block: result, bytes } = await this.executeTool(tool, use, ctx, budget);
+        budget -= bytes;
         if (this.opts.hookRunner?.has("PostToolUse")) {
           const post = await this.opts.hookRunner.postToolUse(
             tool.name,
@@ -4446,12 +4490,13 @@ ${errorDetails}`,
             ctx
           );
           if (post.additionalContext) {
-            result = { ...result, content: `${result.content}
+            const appended = `
 
-${post.additionalContext}` };
+${post.additionalContext}`;
+            result = { ...result, content: `${result.content}${appended}` };
+            budget = Math.max(0, budget - Buffer.byteLength(appended, "utf8"));
           }
         }
-        budget = this.decrementBudget(result, budget);
         span?.setAttribute("tool.is_error", !!result.is_error);
         span?.setAttribute(
           "tool.output_bytes",
@@ -4468,7 +4513,7 @@ ${post.additionalContext}` };
           content: `Tool "${tool.name}" threw: ${scrubbed}`,
           is_error: true
         };
-        budget = this.decrementBudget(result, budget);
+        budget = this.budgetForString(result.content, budget);
         if (err instanceof Error) span?.recordError(err);
         span?.setAttribute("tool.is_error", true);
         return { result, tool, durationMs: Date.now() - start };
@@ -4488,7 +4533,7 @@ ${post.additionalContext}` };
           content: `Tool "${use.name}" execution failed: ${scrubbed}`,
           is_error: true
         };
-        budget = this.decrementBudget(result, budget);
+        budget = this.budgetForString(result.content, budget);
         return { result, tool: this.registry.get(use.name), durationMs: 0 };
       }
     };
@@ -4537,14 +4582,20 @@ ${post.additionalContext}` };
     const output = await this.runWithTimeout(tool, use.input, ctx.signal, ctx, use.id);
     const text = this.serializer.serialize(output);
     const scrubbed = this.opts.secretScrubber.scrub(text);
-    const { text: capped } = this.serializer.enforceCap(scrubbed, budget);
+    const { text: capped, newBudget } = this.serializer.enforceCap(scrubbed, budget);
     this.opts.renderer?.writeToolResult(tool.name, capped, false);
     return {
-      type: "tool_result",
-      tool_use_id: use.id,
-      name: tool.name,
-      content: capped,
-      is_error: false
+      block: {
+        type: "tool_result",
+        tool_use_id: use.id,
+        name: tool.name,
+        content: capped,
+        is_error: false
+      },
+      // `budget - newBudget` is the exact byte count enforceCap spent
+      // (capped at `budget` so a truncated output shows as `budget`
+      // consumed, matching the pre-fix `decrementBudget` semantics).
+      bytes: budget - newBudget
     };
   }
   async runWithTimeout(tool, input, parentSignal, ctx, toolUseId) {
@@ -4684,9 +4735,19 @@ ${excerpt}`;
       is_error: true
     };
   }
-  decrementBudget(result, budget) {
-    const contentBytes = typeof result.content === "string" ? Buffer.byteLength(result.content, "utf8") : Buffer.byteLength(JSON.stringify(result.content), "utf8");
-    return Math.max(0, budget - contentBytes);
+  /**
+   * Subtract a string-content result's UTF-8 byte length from the
+   * iteration output budget. Used for synthesized results (unknown tool,
+   * validation error, blocked, threw) where the content is a small
+   * string built in the executor. The success path no longer goes
+   * through here — `executeTool` carries the exact byte count it spent
+   * in its return value, derived from `enforceCap`'s `newBudget`.
+   *
+   * Floors the result at 0 to match the pre-fix `decrementBudget`
+   * semantics (over-budget spends don't underflow the running total).
+   */
+  budgetForString(content, budget) {
+    return Math.max(0, budget - Buffer.byteLength(content, "utf8"));
   }
   /**
    * Compute the suggestedPattern string for a tool+input pair.
@@ -4792,10 +4853,19 @@ var ConversationState = class {
     this.emit({ kind: "message_appended", message });
   }
   replaceMessages(messages) {
+    let hasToolBlock = false;
     for (const m of messages) {
       if (m._estTokens === void 0) {
         m._estTokens = computeMessageTokens(m);
       }
+      if (!hasToolBlock && Array.isArray(m.content)) {
+        for (const b of m.content) {
+          if (b.type === "tool_use" || b.type === "tool_result") {
+            hasToolBlock = true;
+            break;
+          }
+        }
+      }
     }
     const arr = this.ctx.messages;
     if (messages.length < arr.length) {
@@ -4804,9 +4874,7 @@ var ConversationState = class {
     for (let i = 0; i < messages.length; i++) {
       arr[i] = messages[i];
     }
-    if (messages.some(
-      (m) => Array.isArray(m.content) && m.content.some((b) => b.type === "tool_use" || b.type === "tool_result")
-    )) {
+    if (hasToolBlock) {
       this.ctx.toolAdjacencyDirty = true;
     }
     this.emit({ kind: "messages_replaced", messages: [...messages] });
@@ -4885,6 +4953,19 @@ var Context = class {
    * on iterations where no tool content was added (pure text responses).
    */
   toolAdjacencyDirty = false;
+  /**
+   * H1: pre-computed total-request token estimate from the most recent
+   * `estimateRequestTokens()` call in the agent loop's pre-flight step.
+   * The middleware that decides when to compact, the `emitContextPct`
+   * helper that drives the live context-fill bar, and the pre-flight
+   * itself all need this number; previously each one walked the same
+   * messages/system/tools arrays independently. Stashing it here lets
+   * the three call sites share a single compute per iteration.
+   *
+   * The value is the **uncalibrated** total. Callers that want the
+   * calibrated number apply the per-(provider,model) ratio themselves.
+   */
+  lastRequestTokens = void 0;
   constructor(init) {
     this.systemPrompt = init.systemPrompt;
     this.provider = init.provider;
@@ -5921,8 +6002,10 @@ function buildChildEnv(optsOrSessionId) {
     );
   }
   const out = {};
+  const nodeEnvDefaulted = process.env["WRONGSTACK_NODE_ENV_DEFAULTED"] === "1";
   for (const [k, v] of Object.entries(process.env)) {
     if (v === void 0) continue;
+    if (nodeEnvDefaulted && (k === "NODE_ENV" || k === "WRONGSTACK_NODE_ENV_DEFAULTED")) continue;
     if (passthrough) {
       out[k] = v;
       continue;
@@ -6081,6 +6164,9 @@ async function expandGlob(pattern) {
 function completePartialObject(s) {
   if (!s.trim().startsWith("{")) return s;
   if (tryParse(s).ok) return s;
+  return repairTruncated(s);
+}
+function repairTruncated(s) {
   const stack = [];
   let inString = false;
   let escaped = false;
@@ -9314,6 +9400,21 @@ var DefaultPermissionPolicy = class {
   promptDelegate;
   /** Pre-compiled wildcard patterns — rebuilt on reload for O(1) lookup. */
   wildcardEntries = [];
+  /**
+   * Evaluate-result cache. Keyed by `tool.name::subject` so repeated calls
+   * with the same tool+input skip namespace matching, subject computation,
+   * pattern matching (matchAny), and YOLO destructive gating.
+   *
+   * Cleared on any state change (reload, trust, deny, yolo toggle) because
+   * the result depends on the full policy state. The write-tool smart-bypass
+   * (step 7 in `evaluate()`) is not cached since `ctx.hasRead()` changes
+   * dynamically within a session.
+   *
+   * LRU eviction is not needed — the cache is cleared on state changes
+   * that are rare (trust file ops, user confirm) and the number of unique
+   * tool+subject pairs per iteration is small (<50).
+   */
+  _evalCache = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.trustFile = opts.trustFile;
     this.yolo = opts.yolo ?? false;
@@ -9332,6 +9433,7 @@ var DefaultPermissionPolicy = class {
   }
   /** Toggle YOLO (auto-approve) mode at runtime. */
   setYolo(enabled) {
+    if (this.yolo !== enabled) this._evalCache.clear();
     this.yolo = enabled;
   }
   /** Check whether YOLO mode is currently active. */
@@ -9340,6 +9442,7 @@ var DefaultPermissionPolicy = class {
   }
   /** Toggle the destructive YOLO override at runtime. */
   setYoloDestructive(enabled) {
+    if (this.yoloDestructive !== enabled) this._evalCache.clear();
     this.yoloDestructive = enabled;
   }
   /** Check whether the destructive YOLO override is active. */
@@ -9348,6 +9451,7 @@ var DefaultPermissionPolicy = class {
   }
   /** Toggle destructive confirmation gate (only meaningful when yolo is active). */
   setConfirmDestructive(enabled) {
+    if (this.confirmDestructive !== enabled) this._evalCache.clear();
     this.confirmDestructive = enabled;
   }
   /** Check whether destructive confirmation gate is active. */
@@ -9368,6 +9472,7 @@ var DefaultPermissionPolicy = class {
     }
     this.sessionDenied.clear();
     this.sessionAllowed.clear();
+    this._evalCache.clear();
     this.loaded = true;
   }
   async evaluate(tool, input, ctx) {
@@ -9375,44 +9480,60 @@ var DefaultPermissionPolicy = class {
     const namespaceEntry = this.findNamespaceEntry(tool.name);
     const entry = this.policy[tool.name] ?? namespaceEntry;
     const subject = this.subjectFor(tool.name, input, tool.subjectKey);
-    const subjectKey = `${tool.name}::${subject ?? tool.name}`;
-    if (this.sessionDenied.has(subjectKey)) {
-      return { permission: "deny", source: "deny", reason: "session soft deny (user pressed no)" };
+    const cacheKey = `${tool.name}::${subject ?? tool.name}`;
+    if (tool.name !== "write") {
+      const cached = this._evalCache.get(cacheKey);
+      if (cached !== void 0) return cached;
+    }
+    if (this.sessionDenied.has(cacheKey)) {
+      const decision = { permission: "deny", source: "deny", reason: "session soft deny (user pressed no)" };
+      this._evalCache.set(cacheKey, decision);
+      return decision;
     }
-    if (this.sessionAllowed.has(subjectKey)) {
-      return {
+    if (this.sessionAllowed.has(cacheKey)) {
+      const decision = {
         permission: "auto",
         source: "trust",
         reason: "session soft allow (user pressed yes)"
       };
+      this._evalCache.set(cacheKey, decision);
+      return decision;
     }
     if (entry?.deny && subject && matchAny(entry.deny, subject)) {
-      return { permission: "deny", source: "deny", reason: "matched deny pattern" };
+      const decision = { permission: "deny", source: "deny", reason: "matched deny pattern" };
+      this._evalCache.set(cacheKey, decision);
+      return decision;
     }
     if (tool.permission === "deny") {
-      return { permission: "deny", source: "default", reason: "tool default deny" };
+      const decision = { permission: "deny", source: "default", reason: "tool default deny" };
+      this._evalCache.set(cacheKey, decision);
+      return decision;
     }
     if (entry?.allow && subject && matchAny(entry.allow, subject)) {
-      return { permission: "auto", source: "trust", reason: "matched allow pattern" };
+      const decision = { permission: "auto", source: "trust", reason: "matched allow pattern" };
+      this._evalCache.set(cacheKey, decision);
+      return decision;
     }
     if (entry?.auto) {
-      return { permission: "auto", source: "trust" };
+      const decision = { permission: "auto", source: "trust" };
+      this._evalCache.set(cacheKey, decision);
+      return decision;
     }
     if (this.yolo) {
       if (this.confirmDestructive) {
         const destructive = this.isDestructiveYoloCall(tool, input, ctx);
         if (destructive) {
           if (this.promptDelegate) {
-            const decision = await this.promptDelegate(tool, input, subject ?? tool.name);
-            if (decision === "always") {
+            const decision2 = await this.promptDelegate(tool, input, subject ?? tool.name);
+            if (decision2 === "always") {
               await this.trust({ tool: tool.name, pattern: subject ?? tool.name });
               return { permission: "auto", source: "user", reason: "destructive yolo always-allowed" };
             }
-            if (decision === "deny") {
+            if (decision2 === "deny") {
               await this.deny({ tool: tool.name, pattern: subject ?? tool.name });
               return { permission: "deny", source: "user", reason: "user denied destructive yolo" };
             }
-            return { permission: decision === "yes" ? "auto" : "deny", source: "user" };
+            return { permission: decision2 === "yes" ? "auto" : "deny", source: "user" };
           }
           return {
             permission: "confirm",
@@ -9422,7 +9543,9 @@ var DefaultPermissionPolicy = class {
           };
         }
       }
-      return { permission: "auto", source: "yolo" };
+      const decision = { permission: "auto", source: "yolo" };
+      this._evalCache.set(cacheKey, decision);
+      return decision;
     }
     if (tool.name === "write" && subject) {
       if (ctx.hasRead(subject)) {
@@ -9434,7 +9557,9 @@ var DefaultPermissionPolicy = class {
       }
     }
     if (tool.permission === "auto" && !tool.mutating) {
-      return { permission: "auto", source: "default" };
+      const decision = { permission: "auto", source: "default" };
+      this._evalCache.set(cacheKey, decision);
+      return decision;
     }
     if (this.promptDelegate) {
       const decision = await this.promptDelegate(tool, input, subject ?? tool.name);
@@ -9467,6 +9592,7 @@ var DefaultPermissionPolicy = class {
     const entry = this.policy[rule.tool] ?? {};
     entry.allow = Array.from(/* @__PURE__ */ new Set([...entry.allow ?? [], rule.pattern]));
     this.policy[rule.tool] = entry;
+    this._evalCache.clear();
     try {
       await atomicWrite(this.trustFile, JSON.stringify(this.policy, null, 2));
     } catch (err) {
@@ -9484,6 +9610,7 @@ var DefaultPermissionPolicy = class {
     const entry = this.policy[rule.tool] ?? {};
     entry.deny = Array.from(/* @__PURE__ */ new Set([...entry.deny ?? [], rule.pattern]));
     this.policy[rule.tool] = entry;
+    this._evalCache.clear();
     try {
       await atomicWrite(this.trustFile, JSON.stringify(this.policy, null, 2));
     } catch (err) {
@@ -9498,10 +9625,12 @@ var DefaultPermissionPolicy = class {
   /** Block this tool+pattern for the rest of this session (no trust file). */
   denyOnce(rule) {
     this.sessionDenied.set(`${rule.tool}::${rule.pattern}`, true);
+    this._evalCache.clear();
   }
   /** Auto-approve this tool+pattern for the rest of this session (no trust file). */
   allowOnce(rule) {
     this.sessionAllowed.set(`${rule.tool}::${rule.pattern}`, true);
+    this._evalCache.clear();
   }
   subjectFor(toolName, input, subjectKey) {
     if (!input || typeof input !== "object") return void 0;
@@ -9537,15 +9666,23 @@ var DefaultPermissionPolicy = class {
   }
 };
 var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
+  allowedCapabilities;
+  constructor(allowedCapabilities) {
+    this.allowedCapabilities = allowedCapabilities ?? [
+      ToolCapabilities.FS_READ,
+      ToolCapabilities.NET_OUTBOUND
+    ];
+  }
   static isMcpTool(name) {
     return name.startsWith("mcp__");
   }
   async evaluate(tool) {
-    const hasDangerousCap = hasDangerousCapabilityForSubagents(tool);
+    const caps = tool.capabilities ?? [];
+    const hasAllowedCap = caps.some((c) => this.allowedCapabilities.includes(c));
     const isMcp = _AutoApprovePermissionPolicy.isMcpTool(tool.name);
-    const blocked = tool.permission === "deny" || hasDangerousCap || isMcp;
+    const blocked = tool.permission === "deny" || isMcp || !hasAllowedCap;
     if (blocked) {
-      const reason = hasDangerousCap ? `tool declares dangerous capability (${tool.capabilities?.join(", ")}) \u2014 not auto-approved for subagents` : isMcp ? `MCP tool ${tool.name} is not auto-approved for subagents \u2014 ask the leader to allow it explicitly` : "tool default deny";
+      const reason = isMcp ? `MCP tool ${tool.name} is not auto-approved for subagents \u2014 ask the leader to allow it explicitly` : tool.permission === "deny" ? "tool default deny" : `tool lacks allowed capability (has: ${caps.join(", ") || "none"}, allowed: ${this.allowedCapabilities.join(", ")})`;
       return {
         permission: "deny",
         source: "subagent_guard",
@@ -9565,6 +9702,35 @@ var AutoApprovePermissionPolicy = class _AutoApprovePermissionPolicy {
   async reload() {
   }
 };
+function stripFrontmatter(raw) {
+  if (!raw.startsWith("---")) return raw;
+  const end = raw.indexOf("\n---", 4);
+  if (end === -1) return raw;
+  let body = raw.slice(end + 4);
+  if (body.startsWith("\n")) body = body.slice(1);
+  return body;
+}
+function compactSkillBody(body) {
+  const sections = [];
+  const overviewMatch = body.match(/##\s*Overview\s*\n([\s\S]*?)(?=\n##|\n$|$)/i);
+  const overview = overviewMatch?.[1];
+  if (overview?.trim()) {
+    sections.push(overview.trim().slice(0, 200));
+  }
+  const rulesMatch = body.match(/##\s*Rules\s*\n([\s\S]*?)(?=\n##|\n$|$)/i);
+  const rules = rulesMatch?.[1];
+  if (rules?.trim()) {
+    const trimmed = rules.trim().slice(0, 350);
+    const ruleLines = trimmed.split("\n").filter((l) => /^\s*[-*]\s/.test(l) || /^\s*\d+[.)]\s/.test(l)).slice(0, 6).join("\n");
+    if (ruleLines) sections.push(ruleLines);
+  }
+  if (sections.length === 0) {
+    const first = body.trim().slice(0, 200);
+    if (first) sections.push(first);
+  }
+  const result = sections.join("\n\n");
+  return result.length > 450 ? result.slice(0, 447) + "\u2026" : result;
+}
 var DefaultSkillLoader = class {
   dirs;
   cache;
@@ -9646,6 +9812,24 @@ var DefaultSkillLoader = class {
     if (!m) throw new Error(`Skill "${name}" not found`);
     return fsp3.readFile(m.path, "utf8");
   }
+  async readSaveBody(name) {
+    const m = await this.find(name);
+    if (!m) throw new Error(`Skill "${name}" not found`);
+    const savePath = path7.join(path7.dirname(m.path), "SKILL.save.md");
+    try {
+      return await fsp3.readFile(savePath, "utf8");
+    } catch {
+      const full = await fsp3.readFile(m.path, "utf8");
+      const body = stripFrontmatter(full);
+      const compact = compactSkillBody(body);
+      if (compact) {
+        return `## Overview
+
+${compact}`;
+      }
+      return body.trim().slice(0, 300);
+    }
+  }
 };
 function parseFrontmatter(raw) {
   if (!raw.startsWith("---")) return {};
@@ -10726,6 +10910,13 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         tokens = this._estimator(ctx);
       } else if (msgCount === this._cachedMsgCount && toolCount === this._cachedToolCount && this._cachedTokens >= 0) {
         tokens = this._cachedTokens;
+      } else if (this.tryStashedTokens(ctx, msgCount, toolCount) !== null) {
+        const stashed = this.tryStashedTokens(ctx, msgCount, toolCount);
+        const cal = getCalibrationState(`${ctx.provider?.id ?? "unknown"}/${ctx.model}`);
+        tokens = cal.calibrated ? Math.round(stashed * Math.min(1.5, Math.max(0.5, cal.ratio))) : stashed;
+        this._cachedTokens = tokens;
+        this._cachedMsgCount = msgCount;
+        this._cachedToolCount = toolCount;
       } else {
         tokens = estimateRequestTokensCalibrated(
           ctx.messages,
@@ -10758,6 +10949,25 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
       return next(ctx);
     };
   }
+  /**
+   * H1: try to read a pre-computed token total from `ctx.lastRequestTokens`
+   * (set by the agent loop's pre-flight or its restash in emitContextPct).
+   * Returns the uncalibrated total when the stash is valid for the current
+   * context shape (positive number, and the message count it was computed
+   * at matches the current one — otherwise tool results have been appended
+   * since and the value is stale). Returns null when missing or stale so
+   * the caller falls back to a fresh walk.
+   */
+  tryStashedTokens(ctx, msgCount, toolCount) {
+    const stashed = ctx.lastRequestTokens;
+    if (typeof stashed !== "number" || stashed <= 0) return null;
+    const stashedAt = ctx.meta?.["lastRequestTokensAt"];
+    if (typeof stashedAt !== "object" || stashedAt === null) return null;
+    const meta = stashedAt;
+    if (meta.msgCount !== msgCount) return null;
+    if (typeof meta.toolCount === "number" && meta.toolCount !== toolCount) return null;
+    return stashed;
+  }
   /**
    * Returns true when the previous compaction at the same or higher pressure
    * level reduced nothing and context has not grown materially since. Prevents
@@ -18665,6 +18875,17 @@ var Director = class _Director {
    * default cap.
    */
   taskCompletedListener = null;
+  /**
+   * Unsub handles for the two `FleetBus.filter()` calls installed in the
+   * constructor for timeout-heartbeat tracking. Without capturing these
+   * and calling them in `shutdown()`, repeated Director construction
+   * (tests, hot reloads, `--director` restarts) accumulates 2 dangling
+   * listeners per Director on the FleetBus, slowly drifting the
+   * EventEmitter past its default cap. Mirrors the rationale on
+   * `taskCompletedListener` above.
+   */
+  toolExecFilter = null;
+  budgetFilter = null;
   /** Optional LLM classifier for smart dispatch. Passed from options. */
   dispatchClassifier;
   /** Leader agent's current context pressure (full request tokens). */
@@ -18802,10 +19023,10 @@ var Director = class _Director {
     const extendCounts = /* @__PURE__ */ new Map();
     const progressBySubagent = /* @__PURE__ */ new Map();
     const lastTimeoutProgress = /* @__PURE__ */ new Map();
-    this.fleet.filter("tool.executed", (e) => {
+    this.toolExecFilter = this.fleet.filter("tool.executed", (e) => {
       progressBySubagent.set(e.subagentId, (progressBySubagent.get(e.subagentId) ?? 0) + 1);
     });
-    this.fleet.filter("budget.threshold_reached", (e) => {
+    this.budgetFilter = this.fleet.filter("budget.threshold_reached", (e) => {
       const payload = e.payload;
       if (e.subagentId.startsWith("bug-hunter-") || e.subagentId.startsWith("refactor-planner-") || e.subagentId.startsWith("critic-")) {
         return;
@@ -19336,6 +19557,14 @@ var Director = class _Director {
       this.coordinator.off("task.completed", this.taskCompletedListener);
       this.taskCompletedListener = null;
     }
+    if (this.toolExecFilter) {
+      this.toolExecFilter();
+      this.toolExecFilter = null;
+    }
+    if (this.budgetFilter) {
+      this.budgetFilter();
+      this.budgetFilter = null;
+    }
     await this.coordinator.stopAll();
     for (const b of this.subagentBridges.values()) {
       await b.stop().catch((err) => this.logShutdownError("subagent_bridge_stop", err));
@@ -28714,15 +28943,15 @@ function createMcpControlTool(opts) {
     properties: {
       action: {
         type: "string",
-        enum: ["list", "search", "enable", "disable", "restart"],
-        description: "The management action to perform."
+        enum: ["list", "search", "enable", "disable", "restart", "activate", "deactivate"],
+        description: "The management action to perform. activate/deactivate toggle tool registration ephemerally without disconnecting."
       },
       /** Filter for `search`. Matches server name or description case-insensitively. */
       query: {
         type: "string",
         description: "Search term for `search` action. Matches server name or description."
       },
-      /** Target server name for `enable`, `disable`, `restart`. */
+      /** Target server name for `enable`, `disable`, `restart`, `activate`, `deactivate`. */
       server: {
         type: "string",
         description: 'Server name (e.g. "github", "filesystem", "brave-search").'
@@ -28732,7 +28961,7 @@ function createMcpControlTool(opts) {
   };
   return {
     name: "mcp_control",
-    description: "Manage MCP server lifecycle: list available servers, search by name or capability, enable or disable servers at runtime, restart running servers.",
+    description: "Manage MCP server lifecycle: list available servers, search by name or capability, enable or disable servers at runtime, restart running servers. Use activate/deactivate to ephemerally toggle tool registration without disconnecting \u2014 ideal for token-saving mode where MCP tools are lazy-loaded on demand.",
     category: "mcp",
     permission: "auto",
     mutating: true,
@@ -28757,8 +28986,12 @@ async function mcpControlDispatch(input, deps) {
       return server ? runDisable(server, deps) : "`server` is required for disable.";
     case "restart":
       return server ? runRestart(server, deps) : "`server` is required for restart.";
+    case "activate":
+      return server ? runActivate(server, deps) : "`server` is required for activate.";
+    case "deactivate":
+      return server ? runDeactivate(server, deps) : "`server` is required for deactivate.";
     default:
-      return `Unknown action "${action}". Use one of: list, search, enable, disable, restart.`;
+      return `Unknown action "${action}". Use one of: list, search, enable, disable, restart, activate, deactivate.`;
   }
 }
 function renderList(deps) {
@@ -28883,6 +29116,36 @@ async function runRestart(name, deps) {
     return `${red("\u2717 Restart failed")} for "${name}": ${err instanceof Error ? err.message : String(err)}`;
   }
 }
+async function runActivate(name, deps) {
+  if (!name) return "`server` is required for activate.";
+  if (!deps.registry.activateServer) {
+    return `Registry does not support ephemeral activation. Use \`enable\` to start "${name}" instead.`;
+  }
+  const live = deps.registry.describe().find((s) => s.name === name);
+  if (!live) {
+    return `Server "${name}" is not registered. Use \`mcp_control({ action: "enable", server: "${name}" })\` first.`;
+  }
+  if (live.state !== "connected") {
+    return `Server "${name}" is not connected (state: ${live.state}). Use \`enable\` to start it first.`;
+  }
+  if (deps.registry.isActivated?.(name)) {
+    return `${green("\u25CF")} Server "${name}" tools are already active. Use \`deactivate\` to hide them.`;
+  }
+  deps.registry.activateServer(name);
+  const updated = deps.registry.describe().find((s) => s.name === name);
+  return `${green("\u2713 Activated")} "${name}" \u2014 ${updated?.toolCount ?? 0} tool(s) now registered. Use \`mcp_control({ action: "deactivate", server: "${name}" })\` to hide them when done.`;
+}
+async function runDeactivate(name, deps) {
+  if (!name) return "`server` is required for deactivate.";
+  if (!deps.registry.deactivateServer) {
+    return `Registry does not support ephemeral deactivation. Use \`disable\` to stop "${name}" instead.`;
+  }
+  if (!deps.registry.isActivated?.(name)) {
+    return `Server "${name}" tools are not currently active.`;
+  }
+  const count = deps.registry.deactivateServer(name);
+  return `${yellow("\u25CB Deactivated")} "${name}" \u2014 ${count} tool(s) unregistered. Server stays connected.`;
+}
 async function readConfig(p) {
   try {
     return JSON.parse(await fsp3.readFile(p, "utf8"));
@@ -28928,6 +29191,70 @@ function badge(state) {
   }
 }
 
+// src/tools/mcp-use.ts
+function createMcpUseTool(opts) {
+  const { registry, toolRegistry } = opts;
+  const inputSchema = {
+    type: "object",
+    properties: {
+      server: {
+        type: "string",
+        description: 'MCP server name (e.g. "github", "filesystem", "brave-search"). Use mcp_control list or search first to discover available servers.'
+      },
+      tool: {
+        type: "string",
+        description: "Tool name on the MCP server to call (without the mcp__server__ prefix \u2014 just the bare tool name)."
+      },
+      input: {
+        type: "object",
+        description: "JSON input to pass to the tool. Use the tool's own input schema \u2014 check with mcp_control describe or the server's documentation.",
+        properties: {},
+        additionalProperties: true
+      }
+    },
+    required: ["server", "tool", "input"]
+  };
+  return {
+    name: "mcp_use",
+    description: "Call an MCP tool on a lazy-loaded server. Activates the server temporarily, calls the tool, returns the result, and deactivates. Use this instead of the manual activate\u2192use\u2192deactivate cycle. First call mcp_control list/search to find the right server and tool name.",
+    category: "mcp",
+    permission: "auto",
+    mutating: true,
+    riskTier: "standard",
+    inputSchema,
+    async execute(raw) {
+      const input = raw;
+      const { server: serverName, tool: toolName, input: toolInput } = input;
+      const servers = registry.describe();
+      const serverInfo = servers.find((s) => s.name === serverName);
+      if (!serverInfo) {
+        return `Server "${serverName}" not found. Available: ${servers.map((s) => s.name).join(", ") || "none"}.`;
+      }
+      if (serverInfo.state !== "connected") {
+        return `Server "${serverName}" is not connected (state: ${serverInfo.state}). Use \`mcp_control({ action: "enable", server: "${serverName}" })\` first.`;
+      }
+      if (registry.activateServer) {
+        registry.activateServer(serverName);
+      }
+      try {
+        const qualifiedName = `mcp__${serverName}__${toolName}`;
+        const mcpTool = toolRegistry.get(qualifiedName);
+        if (!mcpTool) {
+          const allTools = toolRegistry.list().filter((t2) => t2.name.startsWith(`mcp__${serverName}__`)).map((t2) => t2.name.replace(`mcp__${serverName}__`, ""));
+          const hint = allTools.length > 0 ? `Available tools on "${serverName}": ${allTools.join(", ")}.` : `No tools found on "${serverName}". The server may not have published any tools.`;
+          return `Tool "${toolName}" not found on server "${serverName}". ${hint}`;
+        }
+        const result = await mcpTool.execute(toolInput ?? {}, {}, {});
+        return result;
+      } finally {
+        if (registry.deactivateServer) {
+          registry.deactivateServer(serverName);
+        }
+      }
+    }
+  };
+}
+
 // src/extension/registry.ts
 var ExtensionRegistry = class {
   extensions = [];
@@ -29154,7 +29481,7 @@ function createAgentToolHandler(a) {
         a.ctx,
         a.perIterationOutputCapBytes
       );
-      return { result, durationMs: Date.now() - start };
+      return { result: result.block, durationMs: Date.now() - start };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       return {
@@ -29296,9 +29623,10 @@ function createAgentToolHandler(a) {
 // src/core/continue-to-next-iteration.ts
 function parseContinueDirective(text) {
   const LINE_MARKERS = /^\s*\[(continue|next step|proceed|done)\]\s*$/gim;
+  const tail = text.length <= DIRECTIVE_SCAN_WINDOW ? text : text.slice(text.length - DIRECTIVE_SCAN_WINDOW);
   let match;
   let lastDirective = "none";
-  while ((match = LINE_MARKERS.exec(text)) !== null) {
+  while ((match = LINE_MARKERS.exec(tail)) !== null) {
     const value = (match[1] ?? "").toLowerCase();
     if (value === "continue" || value === "next step" || value === "proceed") {
       lastDirective = "continue";
@@ -29308,6 +29636,7 @@ function parseContinueDirective(text) {
   }
   return lastDirective;
 }
+var DIRECTIVE_SCAN_WINDOW = 2048;
 var META_KEY = "_autonomousContinue";
 function setAutonomousContinue(ctx) {
   ctx.meta[META_KEY] = true;
@@ -29390,21 +29719,22 @@ function createAgentResponseHandler(a) {
     });
     await a.ctx.session.flush();
     if (a.ctx.signal.aborted) {
-      let finalText2 = "";
+      const parts2 = [];
       for (const block of res.content) {
-        if (isTextBlock(block)) finalText2 += block.text;
+        if (isTextBlock(block)) parts2.push(block.text);
       }
-      return { finalText: finalText2, aborted: true, done: false };
+      return { finalText: parts2.join(""), aborted: true, done: false };
     }
-    let finalText = "";
+    const parts = [];
     const streamed = a.ctx.provider.capabilities.streaming;
     for (const block of res.content) {
       if (isTextBlock(block)) {
         const rendered = await a.pipelines.assistantOutput.run(block);
-        finalText += rendered.text;
+        parts.push(rendered.text);
         if (!streamed) a.renderer?.write(rendered);
       }
     }
+    const finalText = parts.join("");
     let directive = "none";
     if (finalText) {
       directive = parseContinueDirective(finalText);
@@ -29514,7 +29844,9 @@ function normalizeRecipient(to) {
 
 // src/coordination/global-mailbox.ts
 var MAILBOX_FILE = "_mailbox.jsonl";
+var CLIENT_REGISTRY_FILE = "_mailbox.clients.json";
 var AGENT_STALE_MS = 6e4;
+var CLIENT_STALE_MS = 6e4;
 var HEARTBEAT_THROTTLE_MS = 5e3;
 var REGISTRY_CACHE_TTL_MS = 2e3;
 var LINE_SEPARATOR = "\n";
@@ -29526,6 +29858,8 @@ var GlobalMailbox = class {
   messagePath;
   /** Path to the JSON agent registry file. */
   registryPath;
+  /** Path to the JSON client registry file. */
+  clientRegistryPath;
   /** Optional event bus for emitting agent registration/heartbeat events. */
   _events;
   /**
@@ -29537,8 +29871,17 @@ var GlobalMailbox = class {
   _registryCache = null;
   /** When the registry cache was last refreshed from disk (epoch ms). */
   _registryCacheAt = 0;
+  /**
+   * Local cache of the client registry to avoid re-reading on every call.
+   * Same reasoning as agent registry cache.
+   */
+  _clientRegistryCache = null;
+  /** When the client registry cache was last refreshed from disk (epoch ms). */
+  _clientRegistryCacheAt = 0;
   /** Last time each local agent sent a heartbeat (throttle). */
   _lastHeartbeat = /* @__PURE__ */ new Map();
+  /** Last time each local client sent a heartbeat (throttle). */
+  _lastClientHeartbeat = /* @__PURE__ */ new Map();
   /**
    * @param projectDir — `~/.wrongstack/projects/<slug>/`
    * @param events — optional EventBus for real-time TUI/WebUI notifications
@@ -29546,6 +29889,7 @@ var GlobalMailbox = class {
   constructor(projectDir, events) {
     this.messagePath = path7.join(projectDir, MAILBOX_FILE);
     this.registryPath = path7.join(projectDir, "_mailbox.registry.json");
+    this.clientRegistryPath = path7.join(projectDir, CLIENT_REGISTRY_FILE);
     this._events = events;
   }
   // ── Messages ────────────────────────────────────────────────────────────
@@ -29727,9 +30071,74 @@ var GlobalMailbox = class {
     const all = await this.getAgentStatuses();
     return all.filter((a) => a.online);
   }
+  // ── Client registry ─────────────────────────────────────────────────────
+  async registerClient(input) {
+    await this._ensureClientRegistry();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const client = {
+      clientId: input.clientId,
+      sessionId: input.sessionId,
+      name: input.name,
+      source: input.source,
+      registeredAt: now,
+      lastSeenAt: now,
+      pid: input.pid
+    };
+    await withFileLock(this.clientRegistryPath, async () => {
+      const registry = await this._readClientRegistry({ fresh: true });
+      this._pruneStaleClientsInPlace(registry);
+      registry.set(input.clientId, client);
+      this._clientRegistryCache = registry;
+      this._clientRegistryCacheAt = Date.now();
+      await this._writeClientRegistry(registry);
+    });
+    this._events?.emitCustom("mailbox.client_registered", {
+      clientId: input.clientId,
+      sessionId: input.sessionId,
+      name: input.name,
+      source: input.source
+    });
+  }
+  async clientHeartbeat(input) {
+    const last = this._lastClientHeartbeat.get(input.clientId) ?? 0;
+    const now = Date.now();
+    if (now - last < HEARTBEAT_THROTTLE_MS) return;
+    this._lastClientHeartbeat.set(input.clientId, now);
+    await this._ensureClientRegistry();
+    await withFileLock(this.clientRegistryPath, async () => {
+      const registry = await this._readClientRegistry({ fresh: true });
+      this._pruneStaleClientsInPlace(registry);
+      const client = registry.get(input.clientId);
+      if (client) {
+        client.lastSeenAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      this._clientRegistryCache = registry;
+      this._clientRegistryCacheAt = Date.now();
+      await this._writeClientRegistry(registry);
+    });
+    this._events?.emitCustom("mailbox.client_heartbeat", {
+      clientId: input.clientId
+    });
+  }
+  async getClientStatuses() {
+    await this._ensureClientRegistry();
+    const registry = await this._readClientRegistry();
+    this._pruneStaleClientsInPlace(registry);
+    const now = Date.now();
+    return Array.from(registry.values()).map((c) => ({
+      clientId: c.clientId,
+      name: c.name,
+      source: c.source,
+      sessionId: c.sessionId,
+      lastSeenAt: c.lastSeenAt,
+      online: now - new Date(c.lastSeenAt).getTime() < CLIENT_STALE_MS,
+      pid: c.pid
+    })).sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt));
+  }
   // ── Lifecycle ───────────────────────────────────────────────────────────
   async close() {
     this._registryCache = null;
+    this._clientRegistryCache = null;
   }
   async clearAll() {
     await withFileLock(this.messagePath, async () => {
@@ -29808,6 +30217,51 @@ var GlobalMailbox = class {
     await fsp3.writeFile(tmp, JSON.stringify(obj, null, 2), "utf8");
     await fsp3.rename(tmp, this.registryPath);
   }
+  // ── Client registry internals ───────────────────────────────────────────
+  async _ensureClientRegistry() {
+    await fsp3.mkdir(path7.dirname(this.clientRegistryPath), { recursive: true });
+  }
+  async _readClientRegistry(opts) {
+    if (!opts?.fresh && this._clientRegistryCache && Date.now() - this._clientRegistryCacheAt < REGISTRY_CACHE_TTL_MS) {
+      return new Map(this._clientRegistryCache);
+    }
+    try {
+      const raw = await fsp3.readFile(this.clientRegistryPath, "utf8");
+      const data = JSON.parse(raw);
+      const map = /* @__PURE__ */ new Map();
+      for (const [id, client] of Object.entries(data)) {
+        map.set(id, client);
+      }
+      this._clientRegistryCache = map;
+      this._clientRegistryCacheAt = Date.now();
+      return new Map(map);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        const empty = /* @__PURE__ */ new Map();
+        this._clientRegistryCache = empty;
+        this._clientRegistryCacheAt = Date.now();
+        return empty;
+      }
+      throw err;
+    }
+  }
+  _pruneStaleClientsInPlace(registry) {
+    const cutoff = Date.now() - CLIENT_STALE_MS;
+    for (const client of registry.values()) {
+      if (new Date(client.lastSeenAt).getTime() < cutoff) {
+        client.lastSeenAt = new Date(cutoff).toISOString();
+      }
+    }
+  }
+  async _writeClientRegistry(registry) {
+    const obj = {};
+    for (const [id, client] of registry) {
+      obj[id] = client;
+    }
+    const tmp = `${this.clientRegistryPath}.${randomUUID().slice(0, 8)}.tmp`;
+    await fsp3.writeFile(tmp, JSON.stringify(obj, null, 2), "utf8");
+    await fsp3.rename(tmp, this.clientRegistryPath);
+  }
 };
 function defaultResolveProjectDir(ctx) {
   return resolveProjectDir(ctx.projectRoot, wstackGlobalRoot());
@@ -30298,7 +30752,16 @@ function signalAbortReason(signal) {
 function createAgentLoopHandler(a, handlers) {
   const checkMailbox = attachMailboxChecker(a);
   async function compactContextIfNeeded() {
+    const msgCount = a.ctx.messages.length;
+    if (_lastCompactionMsgCount === msgCount && _lastCompactionWasNoop && _maxContext > 0) {
+      return;
+    }
     await a.pipelines.contextWindow.run(a.ctx);
+    _lastCompactionMsgCount = msgCount;
+    const stashed = a.ctx.lastRequestTokens;
+    const tokens = typeof stashed === "number" && stashed > 0 ? stashed : 0;
+    const load = _maxContext > 0 ? tokens / _maxContext : 0;
+    _lastCompactionWasNoop = tokens > 0 && load < 0.5;
   }
   const calibrationKey = (model = a.ctx.model) => `${a.ctx.provider?.id ?? "unknown"}/${model}`;
   function emitContextPct() {
@@ -30309,22 +30772,42 @@ function createAgentLoopHandler(a, handlers) {
     }
     _lastEmittedMsgCount = msgCount;
     _lastEmittedToolCount = toolCount;
+    if (msgCount !== _lastPreFlightMsgCount) {
+      a.ctx.lastRequestTokens = estimateRequestTokens(
+        a.ctx.messages,
+        a.ctx.systemPrompt,
+        a.ctx.tools ?? []
+      ).total;
+      _lastPreFlightMsgCount = msgCount;
+      a.ctx.meta["lastRequestTokensAt"] = { msgCount, toolCount };
+    }
     if (!_maxContext) {
       const metaLimit = a.ctx.meta?.["effectiveMaxContext"];
       const providerMax = a.ctx.provider.capabilities.maxContext;
       _maxContext = typeof metaLimit === "number" && metaLimit > 0 ? metaLimit : typeof providerMax === "number" && providerMax > 0 ? providerMax : 2e5;
     }
-    const { total } = estimateRequestTokensCalibrated(
-      a.ctx.messages,
-      a.ctx.systemPrompt,
-      a.ctx.tools ?? [],
-      calibrationKey()
-    );
+    let total;
+    const stashed = a.ctx.lastRequestTokens;
+    if (typeof stashed === "number" && stashed > 0) {
+      const cal = getCalibrationState(calibrationKey());
+      total = cal.calibrated ? Math.round(stashed * Math.min(1.5, Math.max(0.5, cal.ratio))) : stashed;
+    } else {
+      const est = estimateRequestTokensCalibrated(
+        a.ctx.messages,
+        a.ctx.systemPrompt,
+        a.ctx.tools ?? [],
+        calibrationKey()
+      );
+      total = est.total;
+    }
     a.events.emit("ctx.pct", { load: total / _maxContext, tokens: total, maxContext: _maxContext });
   }
   let _maxContext = 0;
   let _lastEmittedMsgCount = -1;
   let _lastEmittedToolCount = -1;
+  let _lastPreFlightMsgCount = -1;
+  let _lastCompactionMsgCount = -1;
+  let _lastCompactionWasNoop = false;
   function foldBlockIntoConversation(block) {
     const messages = a.ctx.messages;
     const last = messages[messages.length - 1];
@@ -30442,6 +30925,12 @@ function createAgentLoopHandler(a, handlers) {
         });
         const req = await handlers.response.buildAndRunRequestPipeline(opts);
         const preFlight = estimateRequestTokens(req.messages, req.system, req.tools ?? []);
+        a.ctx.lastRequestTokens = preFlight.total;
+        _lastPreFlightMsgCount = req.messages.length;
+        a.ctx.meta["lastRequestTokensAt"] = {
+          msgCount: req.messages.length,
+          toolCount: (req.tools ?? []).length
+        };
         await a.ctx.session.append({
           type: "llm_request",
           ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -31137,6 +31626,10 @@ function flagsToConfigPatch(flags) {
       skills: false
     };
   }
+  if (flags["token-saving-mode"]) {
+    patch.features ??= {};
+    patch.features.tokenSavingMode = true;
+  }
   return patch;
 }
 async function writeProjectMeta(paths, projectRoot) {
@@ -31438,14 +31931,15 @@ Never silently skip a failure \u2014 always report it, even when you choose not
 ## After-task suggestions
 
 After completing a significant task, end your response with 2\u20134 suggested next
-actions under a \`\u{1F4A1} Next steps\` heading. Use this format so the user can
+actions in a \`<next_steps>\` block. Use this exact format so the user can
 select them with \`/next 1\`, \`/next 2\`, or \`/next 1 2 3\`:
 
 \`\`\`
-\u{1F4A1} Next steps
+<next_steps>
 1. First suggestion \u2014 imperative, specific, actionable
 2. Second suggestion
 3. Third suggestion
+</next_steps>
 \`\`\`
 
 Rules:
@@ -31483,6 +31977,10 @@ var DefaultSystemPromptBuilder = class {
   skillBodyCache;
   /** Tools from last build — used for memory relevance scoring. */
   _lastBuildTools;
+  /** Cached rendered online agents string, keyed by array reference. */
+  _lastOnlineAgents;
+  /** Cached full buildToolUsage output — keyed by tools array + online agents refs. */
+  _toolsUsageCache;
   async build(ctx) {
     this._lastBuildTools = ctx.tools;
     if (this.opts.skillLoader && !this.skillCache) {
@@ -31618,6 +32116,9 @@ var DefaultSystemPromptBuilder = class {
   }
   buildToolUsage(tools, ctx) {
     if (tools.length === 0) return "## Tool usage\n\nNo tools registered.";
+    if (this._toolsUsageCache?.toolsRef === tools && this._toolsUsageCache?.agentsRef === ctx.onlineAgents) {
+      return this._toolsUsageCache.text;
+    }
     const byCat = /* @__PURE__ */ new Map();
     const uncategorized = [];
     for (const t2 of tools) {
@@ -31638,7 +32139,7 @@ var DefaultSystemPromptBuilder = class {
 ### ${cat}`);
       for (const t2 of catTools) {
         const hint = t2.usageHint ?? t2.description;
-        const desc = hint.length > 80 ? `${hint.slice(0, 77)}...` : hint.trim();
+        const desc = this.opts.tokenSavingMode ? hint.length > 60 ? hint.slice(0, hint.indexOf(".", 20) + 1 || 60) + (hint.length > 60 ? "\u2026" : "") : hint.trim() : hint.length > 80 ? `${hint.slice(0, 77)}...` : hint.trim();
         lines.push(`- **${t2.name}** \u2014 ${desc}`);
       }
     }
@@ -31651,7 +32152,8 @@ var DefaultSystemPromptBuilder = class {
 ${hint.trim()}`);
       }
     }
-    lines.push(`
+    if (!this.opts.tokenSavingMode) {
+      lines.push(`
 ## Common patterns
 
 - **Inspect before edit:** \`read\`/\`glob\`/\`grep\` \u2192 locate target \u2192 \`edit\`
@@ -31661,6 +32163,7 @@ ${hint.trim()}`);
 - **Batch ops:** Use \`replace\` with glob patterns for multi-file surgical changes
 
 When unsure about a file's current state, read it first rather than assuming.`);
+    }
     const hasDelegate = tools.some((t2) => t2.name === "delegate");
     if (hasDelegate) {
       const delegateTool = tools.find((t2) => t2.name === "delegate");
@@ -31669,7 +32172,12 @@ When unsure about a file's current state, read it first rather than assuming.`);
         return Array.isArray(role) ? role.filter((r) => typeof r === "string") : [];
       })();
       const roleList = enumValues.length > 0 ? enumValues.join(", ") : "(no roster configured)";
-      lines.push(`
+      if (this.opts.tokenSavingMode) {
+        lines.push(`## Delegation
+
+Use \`delegate\` to hand work to a subagent (roles: ${roleList}).`);
+      } else {
+        lines.push(`
 ## Delegation
 
 You have a \`delegate\` tool that hands a discrete piece of work to a
@@ -31732,21 +32240,20 @@ it's called \u2014 you do not need to call any setup tool. For fine-grained
 control over a long-running fleet (spawn N workers, hand them tasks
 one by one, roll up results), use \`spawn_subagent\` + \`assign_task\` +
 \`await_tasks\` directly; \`delegate\` is the one-call shortcut.`);
+      }
     }
     const hasMailbox = tools.some(
       (t2) => t2.name === "mailbox" || t2.name === "mail_send" || t2.name === "mail_inbox"
     );
     if (hasMailbox) {
-      let onlineAgentsInfo = "";
-      if (ctx.onlineAgents && ctx.onlineAgents.length > 0) {
-        const totalCount = ctx.onlineAgents.length;
-        const agentList = ctx.onlineAgents.map((a) => `- **${a.name}** (${a.source ?? "unknown"}${a.sessionId ? `, session: ${a.sessionId.slice(0, 8)}` : ""})`).join("\n");
-        onlineAgentsInfo = `
+      const onlineAgentsInfo = this.renderOnlineAgents(ctx.onlineAgents);
+      if (this.opts.tokenSavingMode) {
+        lines.push(`
+## Inter-agent mailbox${onlineAgentsInfo}
 
-**Currently online (${totalCount} agent${totalCount !== 1 ? "s" : ""}):**
-${agentList}`;
-      }
-      lines.push(`
+Use \`mail_inbox\` for new messages, \`mail_send\` to communicate with other agents.`);
+      } else {
+        lines.push(`
 ## Inter-agent mailbox${onlineAgentsInfo}
 
 You share a persistent project mailbox with every other agent working on
@@ -31805,9 +32312,52 @@ inline, the rest as a summary. To catch up explicitly:
 
 - \`mailbox action=ack messageId=<id> completed=true outcome="What you did"\`
 - Messages you \`check\` are auto-marked as read; use \`ack\` to mark complete.`);
+      }
+    }
+    const hasMcpControl = tools.some((t2) => t2.name === "mcp_control");
+    const hasMcpUse = tools.some((t2) => t2.name === "mcp_use");
+    if (hasMcpControl && this.opts.tokenSavingMode) {
+      if (hasMcpUse) {
+        lines.push(`
+## MCP tools (lazy-loaded)
+
+MCP server tools are NOT registered by default in token-saving mode to keep
+the prompt compact. Each server's process is running in the background; only
+tool registration is deferred.
+
+**Preferred approach** \u2014 one-shot meta-tool:
+\`mcp_use({ server: "<name>", tool: "<bare-tool>", input: { ... } })\`
+This activates the server, calls the tool, returns the result, and
+deactivates \u2014 all in one call. No need to track activate/deactivate state.
+
+**Manual approach** (for exploration):
+1. \`mcp_control({ action: "list" })\` \u2014 see which servers are connected
+2. \`mcp_control({ action: "activate", server: "<name>" })\` \u2014 register tools
+3. Use the tools normally
+4. \`mcp_control({ action: "deactivate", server: "<name>" })\` \u2014 clean up
+
+Activation/deactivation is ephemeral (no config writes) and does NOT affect
+the server connection \u2014 only tool visibility changes.`);
+      } else {
+        lines.push(`
+## MCP tools (lazy-loaded)
+
+MCP server tools are NOT registered by default in token-saving mode to keep
+the prompt compact. Each server's process is running in the background; only
+tool registration is deferred.
+
+When you need a specific MCP server's tools:
+1. \`mcp_control({ action: "list" })\` \u2014 see which servers are connected
+2. \`mcp_control({ action: "activate", server: "<name>" })\` \u2014 register its tools
+3. Use the tools as needed
+4. \`mcp_control({ action: "deactivate", server: "<name>" })\` \u2014 unregister when done
+
+Activation/deactivation is ephemeral (no config writes) and does NOT affect
+the server connection \u2014 only tool visibility changes.`);
+      }
     }
     const hasContextManager = tools.some((t2) => t2.name === "context_manager");
-    if (hasContextManager) {
+    if (hasContextManager && !this.opts.tokenSavingMode) {
       const maxCtx = this.opts.modelCapabilities?.maxContextTokens ?? 128e3;
       const threshold = maxCtx <= 32e3 ? "50" : "70";
       lines.push(`
@@ -31824,7 +32374,32 @@ use the context_manager tool proactively \u2014 do NOT wait to be told:
 **Never** stuff redundant information into a tool result. If you summarize a file, do not paste its full content \u2014
 summarize it, and let the tool result hold only the summary.`);
     }
-    return lines.join("\n");
+    const text = lines.join("\n");
+    this._toolsUsageCache = { toolsRef: tools, agentsRef: ctx.onlineAgents, text };
+    return text;
+  }
+  /**
+   * Render the online agents list, cached by array reference. The agents
+   * list changes at join/leave pace (seconds to minutes), not every prompt
+   * build turn (hundreds of ms). Reference equality avoids re-stringifying
+   * the same array on every iteration while still being correct when the
+   * caller passes a fresh array.
+   */
+  renderOnlineAgents(agents) {
+    if (!agents || agents.length === 0) return "";
+    if (this._lastOnlineAgents?.ref === agents) {
+      return this._lastOnlineAgents.text;
+    }
+    const totalCount = agents.length;
+    const agentList = agents.map(
+      (a) => `- **${a.name}** (${a.source ?? "unknown"}${a.sessionId ? `, session: ${a.sessionId.slice(0, 8)}` : ""})`
+    ).join("\n");
+    const text = `
+
+**Currently online (${totalCount} agent${totalCount !== 1 ? "s" : ""}):**
+${agentList}`;
+    this._lastOnlineAgents = { ref: agents, text };
+    return text;
   }
   async buildEnvironment(ctx) {
     const cached = this.envCacheByRoot.get(ctx.projectRoot);
@@ -31867,7 +32442,7 @@ summarize it, and let the tool result hold only the summary.`);
         "## Skills in scope for this session",
         this.skillCache,
         "",
-        "Full skill instructions are injected in the Active Skills block below."
+        this.opts.tokenSavingMode ? "Compact skill instructions are injected in the Active Skills block below (Overview + Rules only)." : "Full skill instructions are injected in the Active Skills block below."
       );
     }
     const text = lines.join("\n");
@@ -31906,41 +32481,83 @@ ${mem}`);
       } catch {
       }
     }
-    if (this.opts.skillLoader && this.skillBodyCache === void 0) {
-      try {
-        const skills = await this.opts.skillLoader.list();
-        if (skills.length > 0) {
-          const bodies = [];
-          for (const s of skills) {
-            try {
-              const raw = await this.opts.skillLoader.readBody(s.name);
-              const body = stripFrontmatter(raw);
-              if (body.trim()) {
-                bodies.push(`## Skill: ${s.name}
+    if (this.opts.skillLoader) {
+      if (this.opts.tokenSavingMode) {
+        if (this.skillBodyCache === void 0) {
+          await this.buildCompactSkillBodies();
+        }
+      } else {
+        if (this.skillBodyCache === void 0) {
+          await this.buildFullSkillBodies();
+        }
+      }
+    }
+    if (this.skillBodyCache) {
+      parts.push(`# Active Skills
+
+${this.skillBodyCache}`);
+    }
+    return parts.join("\n\n");
+  }
+  /** Build full skill bodies (token-saving OFF). */
+  async buildFullSkillBodies() {
+    try {
+      const skills = await this.opts.skillLoader.list();
+      if (skills.length > 0) {
+        const bodies = [];
+        for (const s of skills) {
+          try {
+            const raw = await this.opts.skillLoader.readBody(s.name);
+            const body = stripFrontmatter2(raw);
+            if (body.trim()) {
+              bodies.push(`## Skill: ${s.name}
 
 ${body.trim()}`);
-              }
-            } catch {
             }
+          } catch {
           }
-          if (bodies.length > 0) {
-            this.skillBodyCache = bodies.join("\n\n---\n\n");
-          } else {
-            this.skillBodyCache = "";
-          }
-        } else {
-          this.skillBodyCache = "";
         }
-      } catch {
+        this.skillBodyCache = bodies.length > 0 ? bodies.join("\n\n---\n\n") : "";
+      } else {
         this.skillBodyCache = "";
       }
+    } catch {
+      this.skillBodyCache = "";
     }
-    if (this.skillBodyCache) {
-      parts.push(`# Active Skills
+  }
+  /**
+   * Build compact skill bodies for token-saving mode.
+   * Uses `readSaveBody` from the skill loader which tries `SKILL.save.md`
+   * first, then falls back to auto-compaction.
+   */
+  async buildCompactSkillBodies() {
+    if (!this.opts.skillLoader) {
+      this.skillBodyCache = "";
+      return;
+    }
+    try {
+      const skills = await this.opts.skillLoader.list();
+      if (skills.length > 0) {
+        const bodies = [];
+        for (const s of skills) {
+          try {
+            const saveBody = await this.opts.skillLoader.readSaveBody(s.name);
+            const clean = stripFrontmatter2(saveBody);
+            if (clean.trim()) {
+              bodies.push(`## Skill: ${s.name}
 
-${this.skillBodyCache}`);
+${clean.trim()}`);
+            }
+          } catch {
+          }
+        }
+        this.skillBodyCache = bodies.length > 0 ? bodies.join("\n\n---\n\n") : "";
+      } else {
+        this.skillBodyCache = "";
+      }
+    } catch {
+      this.skillBodyCache = "";
     }
-    return parts.join("\n\n");
   }
   async buildMode() {
     if (this.opts.modePrompt) return this.opts.modePrompt;
@@ -32030,7 +32647,7 @@ ${this.skillBodyCache}`);
     return langs.size === 0 ? "unknown" : Array.from(langs).join(", ");
   }
 };
-function stripFrontmatter(raw) {
+function stripFrontmatter2(raw) {
   if (!raw.startsWith("---")) return raw;
   const end = raw.indexOf("\n---", 4);
   if (end === -1) return raw;
@@ -32050,6 +32667,11 @@ function compactTrigger(trigger) {
 // src/registry/tool-registry.ts
 var ToolRegistry = class _ToolRegistry {
   tools = /* @__PURE__ */ new Map();
+  /** Monotonic version bumped on every registry mutation. */
+  _version = 0;
+  /** Cached `list()` result, frozen after build. Invalidated on _version change. */
+  _listSnapshot;
+  _listSnapshotVersion = -1;
   /** Pre-compute tool definition token estimate once at registration time. */
   _stampDefTokens(tool) {
     if (tool._estDefTokens === void 0) {
@@ -32075,6 +32697,7 @@ var ToolRegistry = class _ToolRegistry {
     }
     this._stampDefTokens(tool);
     this.tools.set(tool.name, { tool, owner });
+    this._version++;
   }
   /**
    * Attempt to register a tool. Returns true if successful, false if a tool
@@ -32088,6 +32711,7 @@ var ToolRegistry = class _ToolRegistry {
     }
     this._stampDefTokens(tool);
     this.tools.set(tool.name, { tool, owner });
+    this._version++;
     return true;
   }
   /**
@@ -32159,6 +32783,7 @@ var ToolRegistry = class _ToolRegistry {
     wrapped._estDefTokens = void 0;
     this._stampDefTokens(wrapped);
     this.tools.set(name, { tool: wrapped, owner: `${entry.owner}+${owner}` });
+    this._version++;
   }
   get(name) {
     return this.tools.get(name)?.tool;
@@ -32167,7 +32792,13 @@ var ToolRegistry = class _ToolRegistry {
     return this.tools.get(name)?.owner;
   }
   list() {
-    return Array.from(this.tools.values()).map((e) => e.tool);
+    if (this._listSnapshot && this._version === this._listSnapshotVersion) {
+      return this._listSnapshot;
+    }
+    const arr = Array.from(this.tools.values()).map((e) => e.tool);
+    this._listSnapshot = arr;
+    this._listSnapshotVersion = this._version;
+    return arr;
   }
   /**
    * Group tools by their `category` field. Tools without a category
@@ -32415,14 +33046,19 @@ var DefaultPluginAPI = class {
     this.pipelines = readonlyPipelines;
     const tr = init.toolRegistry;
     const isOfficial = init.official === true;
+    const capabilities = init.capabilities;
     const assertCanMutateTool = (name, op) => {
       if (isOfficial) return;
       const currentOwner = tr.ownerOf(name);
       if (currentOwner === void 0) return;
       const ownedSolelyByMe = currentOwner.split("+").every((seg) => seg === owner);
-      if (!ownedSolelyByMe) {
+      if (ownedSolelyByMe) return;
+      const toolCaps = tr.get(name)?.capabilities ?? [];
+      const pluginMutateCaps = capabilities?.toolMutateCapabilities ?? [];
+      const hasRequiredCap = toolCaps.some((c) => pluginMutateCaps.includes(c));
+      if (!hasRequiredCap) {
         throw new Error(
-          `Plugin "${owner}" may not ${op} tool "${name}" \u2014 it is owned by "${currentOwner}". Only official (first-party) plugins may modify tools they do not own.`
+          `Plugin "${owner}" may not ${op} tool "${name}" \u2014 it is owned by "${currentOwner}". Tool capabilities: [${toolCaps.join(", ") || "none"}]. Plugin toolMutateCapabilities: [${pluginMutateCaps.join(", ") || "none"}]. Missing required capability to mutate this tool.`
         );
       }
     };
@@ -34714,6 +35350,7 @@ ${check.stderr}`);
     return new Promise((res) => {
       let stdout = "";
       let stderr = "";
+      const MAX_GIT_OUTPUT = 1e6;
       const child = spawn(this.gitBin, args, {
         cwd,
         env: buildChildEnv(),
@@ -34722,10 +35359,10 @@ ${check.stderr}`);
         windowsHide: true
       });
       child.stdout?.on("data", (c) => {
-        stdout += c.toString();
+        if (stdout.length < MAX_GIT_OUTPUT) stdout += c.toString();
       });
       child.stderr?.on("data", (c) => {
-        stderr += c.toString();
+        if (stderr.length < MAX_GIT_OUTPUT) stderr += c.toString();
       });
       child.on("error", (err) => res({ code: 1, stdout, stderr: err.message }));
       child.on("close", (code) => res({ code: code ?? 1, stdout, stderr }));
@@ -35093,7 +35730,7 @@ var CollaborationBus = class {
     const timeoutPromise = new Promise((resolve14) => {
       timer = setTimeout(() => resolve14("timeout"), timeoutMs);
     });
-    const resumedPromise = this.pausePromise.then(() => "resumed");
+    const resumedPromise = this.pausePromise.then(() => "resumed").catch(() => "resumed");
     const winner = await Promise.race([resumedPromise, timeoutPromise]);
     if (timer) clearTimeout(timer);
     if (winner === "timeout") {
@@ -35285,6 +35922,14 @@ var DefaultMailbox = class {
       await fsp3.writeFile(this.filePath, "", "utf8");
     });
   }
+  // ── Client registry stubs (not applicable per-session) ─────────────────
+  async registerClient(_input) {
+  }
+  async clientHeartbeat(_input) {
+  }
+  async getClientStatuses() {
+    return [];
+  }
   // ── Internal ──────────────────────────────────────────────────────────
   async _readAll() {
     try {
@@ -37600,6 +38245,6 @@ function createChimeraPlugin() {
   };
 }
 
-export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AgentStatusTracker, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BrainDecisionQueue, BrainMonitor, BudgetExceededError, CHIMERA_REVIEW_PROMPT, CONTEXT_WINDOW_MODES, CORE_RECONSTRUCT_EVENTS, CheckpointManager, CloudSync, CollaborationBus, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SESSION_PRUNE_DAYS, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DEPENDENCY_FILE_PATTERNS, DefaultAttachmentStore, DefaultBrainArbiter, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMailbox, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ENHANCER_SYSTEM_PROMPT, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FORBIDDEN_PROTO_KEYS, FileMemoryBackend, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, GlobalMailbox, GraphMemoryBackend, HookRegistry, HookRunner, HumanEscalatingBrainArbiter, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MATRIX_PHASE_KEYS, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, MEMORY_TYPE_LABELS, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, ObservableBrainArbiter, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, STANDARD_AUDIT_EVENTS, ScopedEventBus, SddError, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, StreamHangError, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertNever, assertSafePath, atomicWrite, attachAutoExtend, attachDepWatcherBridge, attachMailboxChecker, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, bootConfig, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildLosslessDigest, buildMailboxBlock, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildQueuedMessagesBlock, buildRecoveryStrategies, buildSmartDigest, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compactLog, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeMessageTokens, computeTaskItemProgress, computeTaskProgress, consumeBtwNotes, consumeQueuedMessagesUpdate, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createAutonomyBrain, createChimeraPlugin, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMailboxChecker, createMcpControlTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createStrategyCompactor, createSyncPlugin, createTieredBrainArbiter, createToolOutputSerializer, decryptConfigSecrets, deepMerge, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, detectEcosystem as detectPackageEcosystem, dispatchAgent, downloadGitHubTarball, eliseOldToolResults, emptyGoal, emptyPlan, emptyTaskFile, encryptConfigSecrets, enhanceUserPrompt, ensureDir, estimateMessageTokens, estimateMessages, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, expandGlob, expectDefined, extractRunEnv, extractText, filesystemServer, findCriticalPath, findPreserveStart, flagsToConfigPatch, formatContextWindowModeList, formatDecisionSummary, formatGoal, formatHumanPrompt, formatPlan, formatPlanTemplates, formatTaskList, formatTaskProgress, formatTodosList, getAgentDefinition, getCalibrationState, getContextWindowMode, getFileHistory, getFilesByAgent, getFullLog, getFullPackageLog, getLastAuthor, getManifestPackages, getPackageAuthor, getPackagesByAgent, getPlanTemplate, getSessionRegistry, getTemplate, getTermSize, githubServer, goalFilePath, googleMapsServer, hasSessionRegistry, hasTextContent, hashRequest, hookMatcherMatches, injectPendingMailboxMessages, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isInteractive, isPluginError, isPrimitiveArray, isSddError, isSecretField, isSessionError, isStdinTTY, isStdoutTTY, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isValidMatrixKey, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTasks, loadTodosCheckpoint, loadUserModes, mailboxSessionTag, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, matchAny, matchGlob, matrixKeyKind, mergeCustomModelDefs, mergeModelsPayload, migratePlaintextSecrets, miniMaxVisionServer, mutatePlan, mutateTasks, noOpLogger, noOpVault, normalizeRecipient, normalizeToLf, normalizedEqual, onResize, parseContinueDirective, parseEntries, parseProgressFromText, parseSkillRef, peekQueuedMessages, pendingBtwCount, phaseForRole, projectHash, projectSlug, recentTextTurns, recordActualUsage, recordFileAction, recordPackageAction, recordProgress, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resetCalibration, resolveAuditLevel, resolveChimeraConfig, resolveContextWindowPolicy, resolveMailboxIdentity, resolveModelMatrix, resolveProjectDir, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, scoreAgents, scoreMessage, securitySlashCommand, sentinelServer, setBtwNote, setOutputLineGuard, setPlanItemStatus, setProgress, setQueuedMessagesSnapshot, setRawMode, shouldEnhance, slackServer, sleep, stableStringify, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, startPackageOutdatedWatcher, startTechStackConsumer, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, truncate, unifiedDiff, unloadPlugins, updatePackageOutdatedStatus, validateAgainstSchema, wireMetricsToEvents, withFileLock, wrapAsState, writeErr, writeOut, wstackGlobalRoot, zaiVisionServer };
+export { ACP_AGENTS, AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AgentStatusTracker, AnnotationsStore, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BrainDecisionQueue, BrainMonitor, BudgetExceededError, CHIMERA_REVIEW_PROMPT, CONTEXT_WINDOW_MODES, CORE_RECONSTRUCT_EVENTS, CheckpointManager, CloudSync, CollaborationBus, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SESSION_PRUNE_DAYS, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DEPENDENCY_FILE_PATTERNS, DefaultAttachmentStore, DefaultBrainArbiter, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMailbox, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ENHANCER_SYSTEM_PROMPT, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FLEET_ROSTER_WITHACP, FORBIDDEN_PROTO_KEYS, FileMemoryBackend, FleetBus, FleetCostCapError, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, GlobalMailbox, GraphMemoryBackend, HookRegistry, HookRunner, HumanEscalatingBrainArbiter, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MATRIX_PHASE_KEYS, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, MEMORY_TYPE_LABELS, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, ObservableBrainArbiter, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReplayLogStore, ReplayProviderRunner, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, STANDARD_AUDIT_EVENTS, ScopedEventBus, SddError, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SessionMemoryConsolidator, SessionRecovery, SessionRegistry, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, StreamHangError, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolAuditLog, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertNever, assertSafePath, atomicWrite, attachAutoExtend, attachDepWatcherBridge, attachMailboxChecker, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, bootConfig, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildLosslessDigest, buildMailboxBlock, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildQueuedMessagesBlock, buildRecoveryStrategies, buildSmartDigest, classifyFamily, clearPlan, collabInjectMiddleware, collabPauseMiddleware, color, compactLog, compileGlob, compileUserRegex, completePartialObject, composeDirectorPrompt, composeSubagentPrompt, computeMessageTokens, computeTaskItemProgress, computeTaskProgress, consumeBtwNotes, consumeQueuedMessagesUpdate, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createAutonomyBrain, createChimeraPlugin, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMailboxChecker, createMcpControlTool, createMcpUseTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSessionEventBridge, createSkillsPlugin, createStrategyCompactor, createSyncPlugin, createTieredBrainArbiter, createToolOutputSerializer, decryptConfigSecrets, deepMerge, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, detectEcosystem as detectPackageEcosystem, dispatchAgent, downloadGitHubTarball, eliseOldToolResults, emptyGoal, emptyPlan, emptyTaskFile, encryptConfigSecrets, enhanceUserPrompt, ensureDir, estimateMessageTokens, estimateMessages, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, expandGlob, expectDefined, extractRunEnv, extractText, filesystemServer, findCriticalPath, findPreserveStart, flagsToConfigPatch, formatContextWindowModeList, formatDecisionSummary, formatGoal, formatHumanPrompt, formatPlan, formatPlanTemplates, formatTaskList, formatTaskProgress, formatTodosList, getAgentDefinition, getCalibrationState, getContextWindowMode, getFileHistory, getFilesByAgent, getFullLog, getFullPackageLog, getLastAuthor, getManifestPackages, getPackageAuthor, getPackagesByAgent, getPlanTemplate, getSessionRegistry, getTemplate, getTermSize, githubServer, goalFilePath, googleMapsServer, hasSessionRegistry, hasTextContent, hashRequest, hookMatcherMatches, injectPendingMailboxMessages, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isInteractive, isPluginError, isPrimitiveArray, isSddError, isSecretField, isSessionError, isStdinTTY, isStdoutTTY, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isValidMatrixKey, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTasks, loadTodosCheckpoint, loadUserModes, mailboxSessionTag, makeAgentSubagentRunner, makeAskTool, makeAssignTool, makeAutonomyPromptContributor, makeAwaitTasksTool, makeCollabDebugTool, makeContinueToNextIterationTool, makeDependencyWatcherConfig, makeDirectorSessionFactory, makeFleetEmitTool, makeFleetHealthTool, makeFleetSessionTool, makeFleetStatusTool, makeFleetUsageTool, makeLLMClassifier, makeMailInboxTool, makeMailSendTool, makeMailboxTool, makeRollUpTool, makeSpawnTool, makeTerminateTool, matchAny, matchGlob, matrixKeyKind, mergeCustomModelDefs, mergeModelsPayload, migratePlaintextSecrets, miniMaxVisionServer, mutatePlan, mutateTasks, noOpLogger, noOpVault, normalizeRecipient, normalizeToLf, normalizedEqual, onResize, parseContinueDirective, parseEntries, parseProgressFromText, parseSkillRef, peekQueuedMessages, pendingBtwCount, phaseForRole, projectHash, projectSlug, recentTextTurns, recordActualUsage, recordFileAction, recordPackageAction, recordProgress, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resetCalibration, resolveAuditLevel, resolveChimeraConfig, resolveContextWindowPolicy, resolveMailboxIdentity, resolveModelMatrix, resolveProjectDir, resolveSessionLoggingConfig, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, runProviderWithRetry, runShellHook, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTasks, saveTodosCheckpoint, scoreAgents, scoreMessage, securitySlashCommand, sentinelServer, setBtwNote, setOutputLineGuard, setPlanItemStatus, setProgress, setQueuedMessagesSnapshot, setRawMode, shouldEnhance, slackServer, sleep, stableStringify, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, startPackageOutdatedWatcher, startTechStackConsumer, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, truncate, unifiedDiff, unloadPlugins, updatePackageOutdatedStatus, validateAgainstSchema, wireMetricsToEvents, withFileLock, wrapAsState, writeErr, writeOut, wstackGlobalRoot, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map