@wrongstack/core 0.300.0 → 0.301.0

package/dist/core/index.js

@@ -305,9 +305,15 @@ var ExtensionRegistry = class {
    * Build a composed provider runner. Extensions with `wrapProviderRunner`
    * form a middleware-style chain: the innermost extension wraps the
    * default runner, each subsequent wrapper wraps the previous.
+   *
+   * Utility calls may exclude agent-loop-only middleware (notably
+   * `fallback-model`) while retaining request-safety wrappers such as the
+   * prompt firewall. One-shot orchestration owns its provider and fallback
+   * route, so an agent-loop fallback wrapper cannot safely run against it.
    */
-  wrapProviderRunner(inner) {
-    const wrappers = this.extensions.filter((e) => e.wrapProviderRunner).map((e) => ({ name: e.name, wrap: expectDefined(e.wrapProviderRunner) }));
+  wrapProviderRunner(inner, options) {
+    const excluded = new Set(options?.exclude);
+    const wrappers = this.extensions.filter((e) => e.wrapProviderRunner && !excluded.has(e.name)).map((e) => ({ name: e.name, wrap: expectDefined(e.wrapProviderRunner) }));
     if (wrappers.length === 0) return inner;
     let composed = inner;
     for (let i = wrappers.length - 1; i >= 0; i--) {
@@ -540,6 +546,9 @@ function canonicalProjectRoot(absRoot) {
     const commonDirFile = path.join(gitDir, "commondir");
     if (!fs.statSync(commonDirFile).isFile()) return checkoutRoot;
     const commonDir = path.resolve(gitDir, fs.readFileSync(commonDirFile, "utf8").trim());
+    const worktreesDir = path.dirname(gitDir);
+    if (path.basename(worktreesDir).toLowerCase() !== "worktrees") return checkoutRoot;
+    if (path.resolve(worktreesDir, "..") !== commonDir) return checkoutRoot;
     if (path.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
     return path.dirname(commonDir);
   } catch {
@@ -1647,6 +1656,20 @@ import * as path7 from "node:path";
 // src/security/file-permissions.ts
 var SECRET_FILE_MODE = 384;
 
+// src/utils/pid.ts
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  if (pid === process.pid) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "EPERM") return true;
+    return false;
+  }
+}
+
 // src/hq/auth-store.ts
 function defaultHqDataDir() {
   return path7.join(wstackGlobalRoot(), "hq");
@@ -1662,22 +1685,13 @@ function hqAuthFilePath(dataDir) {
 function hqRuntimeFilePath(dataDir) {
   return path7.join(dataDir, "runtime.json");
 }
-function isProcessAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
 function readHqRuntimeFileSync(dataDir) {
   try {
     const parsed = JSON.parse(
       syncFs.readFileSync(hqRuntimeFilePath(dataDir), "utf8")
     );
     if (typeof parsed.url !== "string" || parsed.url.trim().length === 0) return void 0;
-    if (typeof parsed.pid === "number" && !isProcessAlive(parsed.pid)) return void 0;
+    if (typeof parsed.pid === "number" && !isPidAlive(parsed.pid)) return void 0;
     return {
       url: parsed.url,
       updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : "",
@@ -2303,6 +2317,7 @@ function createMailboxEventPayload(input) {
 var TRANSCRIPT_EVENT_TYPES = /* @__PURE__ */ new Set(["session.transcript", "agent.message"]);
 var OPEN_STATE = 1;
 var CONNECT_WARN_AFTER_FAILURES = 5;
+var DEFAULT_CONNECT_WARN_COOLDOWN_MS = 5 * 6e4;
 var DEFAULT_RECONNECT_BASE_MS = 1e3;
 var DEFAULT_RECONNECT_MAX_MS = 3e4;
 var DEFAULT_DISCOVERY_POLL_MS = 5e3;
@@ -2314,6 +2329,7 @@ var DEFAULT_MAX_QUEUED_BYTES = Math.min(
 var DEFAULT_COMMAND_POLL_INTERVAL_MS = 500;
 var DEFAULT_COMMAND_POLL_LIMIT = 25;
 var DEFAULT_HEARTBEAT_INTERVAL_MS2 = 25e3;
+var lastConnectWarningAtMs = 0;
 function queuedFrameCoalesceKey(frame) {
   if (frame.type !== "client.event" || !frame.event.type.endsWith(".snapshot")) {
     return void 0;
@@ -2365,6 +2381,8 @@ var HqPublisher = class {
     this.reconnect = options.reconnect ?? true;
     this.reconnectBaseMs = options.reconnectBaseMs ?? DEFAULT_RECONNECT_BASE_MS;
     this.reconnectMaxMs = options.reconnectMaxMs ?? DEFAULT_RECONNECT_MAX_MS;
+    this.connectWarnAfterFailures = options.connectWarnAfterFailures ?? CONNECT_WARN_AFTER_FAILURES;
+    this.connectWarnCooldownMs = options.connectWarnCooldownMs ?? DEFAULT_CONNECT_WARN_COOLDOWN_MS;
     this.maxQueuedMessages = options.maxQueuedMessages ?? DEFAULT_MAX_QUEUED_MESSAGES;
     this.maxQueuedBytes = options.maxQueuedBytes ?? DEFAULT_MAX_QUEUED_BYTES;
     this.resolvedRedactionPolicy = resolveHqRedactionPolicy(options.redactionPolicy);
@@ -2378,6 +2396,8 @@ var HqPublisher = class {
   reconnect;
   reconnectBaseMs;
   reconnectMaxMs;
+  connectWarnAfterFailures;
+  connectWarnCooldownMs;
   maxQueuedMessages;
   maxQueuedBytes;
   resolvedRedactionPolicy;
@@ -2789,9 +2809,8 @@ var HqPublisher = class {
     if (this.stopped || !this.reconnect || this.reconnectTimer !== null) return;
     const delay2 = Math.min(this.reconnectMaxMs, this.reconnectBaseMs * 2 ** this.reconnectAttempt);
     this.reconnectAttempt += 1;
-    if (!this.connectWarningEmitted && this.reconnectAttempt >= CONNECT_WARN_AFTER_FAILURES) {
-      this.connectWarningEmitted = true;
-      this.emitConnectWarning();
+    if (!this.connectWarningEmitted && this.reconnectAttempt >= this.connectWarnAfterFailures) {
+      if (this.emitConnectWarning()) this.connectWarningEmitted = true;
     }
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
@@ -2800,11 +2819,16 @@ var HqPublisher = class {
     this.reconnectTimer.unref?.();
   }
   emitConnectWarning() {
+    const nowMs = Date.now();
+    if (nowMs - lastConnectWarningAtMs < this.connectWarnCooldownMs) {
+      return false;
+    }
+    lastConnectWarningAtMs = nowMs;
     const attempt = this.lastAttempt;
     const message = `WrongStack HQ publisher: ${this.reconnectAttempt} consecutive connection failures${attempt !== null ? ` to ${attempt.url} (client token ${attempt.hadToken ? "present" : "absent"})` : ""}. Either the HQ server is unreachable or it rejected the token (401). If HQ runs in client-token mode, verify WRONGSTACK_HQ_TOKEN / auth.json. Retries continue with backoff.`;
     if (this.logger) {
       this.logger.warn(message, { event: "hq.publisher.connect_failed" });
-      return;
+      return true;
     }
     const warn = this.options.warn ?? ((msg) => console.warn(
       JSON.stringify({
@@ -2818,6 +2842,7 @@ var HqPublisher = class {
       warn(message);
     } catch {
     }
+    return true;
   }
   /**
    * Dormant re-check while no HQ endpoint is discoverable. Uses a FIXED
@@ -4826,6 +4851,8 @@ var Context = class _Context {
   allowOutsideProjectRoot;
   model;
   tools = [];
+  /** Complete enabled catalog; provider token accounting continues to use `tools`. */
+  catalogTools = [];
   meta = {};
   /** Agent id performing this run (e.g. 'leader', 'executor'). */
   agentId;
@@ -4906,6 +4933,32 @@ var Context = class _Context {
    * Cleared after being consumed by agent-tools.
    */
   pendingPostToolContext = void 0;
+  /**
+   * Bounded, provider-bound memory evidence kept outside conversation and
+   * tool-result history. Owners replace their own slot instead of appending a
+   * fresh message on every retrieval, so long sessions do not accumulate the
+   * same SAGE hints. Request construction emits these as ephemeral system
+   * suffixes, preserving the stable prompt-cache prefix.
+   */
+  memoryEvidence = [];
+  setMemoryEvidence(source, text, maxChars = 6e3) {
+    const key = source.trim();
+    if (!key) return;
+    const clean = text?.trim();
+    const retained = this.memoryEvidence.filter((entry) => entry.source !== key);
+    if (clean) {
+      const boundedMax = Number.isFinite(maxChars) ? Math.max(0, Math.floor(maxChars)) : 0;
+      if (boundedMax > 0) retained.push({ source: key, text: clean.slice(0, boundedMax) });
+    }
+    this.memoryEvidence = retained.slice(-8);
+  }
+  clearMemoryEvidence(source) {
+    if (source === void 0) {
+      this.memoryEvidence = [];
+      return;
+    }
+    this.memoryEvidence = this.memoryEvidence.filter((entry) => entry.source !== source);
+  }
   /**
    * H1: pre-computed total-request token estimate from the most recent
    * `estimateRequestTokens()` call in the agent loop's pre-flight step.
@@ -4941,6 +4994,7 @@ var Context = class _Context {
     this.allowOutsideProjectRoot = init.allowOutsideProjectRoot ?? false;
     this.model = init.model;
     this.tools = init.tools ?? [];
+    this.catalogTools = init.catalogTools ?? this.tools;
     this.agentId = init.agentId ?? "unknown";
     this.agentName = init.agentName ?? "Unknown Agent";
     this.traceId = init.traceId;
@@ -5446,6 +5500,87 @@ function requestLimitExtension(opts) {
   });
 }
 
+// src/utils/todos-format.ts
+function hasOpenTodos(todos) {
+  if (!Array.isArray(todos) || todos.length === 0) return false;
+  return todos.some((t2) => t2.status === "pending" || t2.status === "in_progress");
+}
+
+// src/core/next-steps-slot.ts
+var SLOT_KEY = "nextsteps.pending";
+var MAX_PENDING_NEXT_STEPS = 4;
+var NEXT_STEPS_TAG_RE = /<nextsteps\b[^>]*>/i;
+function writePendingNextSteps(ctx, steps) {
+  const cleaned = [];
+  for (const step of steps) {
+    const text = typeof step?.text === "string" ? step.text.replace(/\s+/g, " ").trim() : "";
+    if (!text) continue;
+    cleaned.push(step.auto === true && cleaned.length === 0 ? { text, auto: true } : { text });
+    if (cleaned.length >= MAX_PENDING_NEXT_STEPS) break;
+  }
+  if (cleaned.length === 0) {
+    clearPendingNextSteps(ctx);
+    return;
+  }
+  ctx.meta[SLOT_KEY] = cleaned;
+}
+function readPendingNextSteps(ctx) {
+  const raw = ctx.meta[SLOT_KEY];
+  if (!Array.isArray(raw) || raw.length === 0) return void 0;
+  const steps = raw.filter(
+    (s) => typeof s?.text === "string" && s.text.length > 0
+  );
+  return steps.length > 0 ? steps : void 0;
+}
+function clearPendingNextSteps(ctx) {
+  delete ctx.meta[SLOT_KEY];
+}
+function hasNextStepsTag(text) {
+  return NEXT_STEPS_TAG_RE.test(text);
+}
+function renderNextStepsBlock(steps) {
+  const lines = steps.map((step, i) => {
+    const auto = i === 0 && step.auto === true ? ' auto="true"' : "";
+    return `${i + 1}. ${step.text}${auto}`;
+  });
+  return `<nextsteps>
+${lines.join("\n")}
+</nextsteps>`;
+}
+function endsTurn(stopReason) {
+  return stopReason !== "tool_use" && stopReason !== "tool_call";
+}
+function maybeAppendPendingNextSteps(ctx, res) {
+  if (ctx.agentId !== "leader") return res;
+  if (!endsTurn(res.stopReason)) return res;
+  if (ctx.signal.aborted) return res;
+  const steps = readPendingNextSteps(ctx);
+  if (!steps) return res;
+  if (hasOpenTodos(ctx.todos)) {
+    clearPendingNextSteps(ctx);
+    return res;
+  }
+  const lastTextIndex = res.content.findLastIndex(isTextBlock);
+  if (lastTextIndex >= 0) {
+    const block = res.content[lastTextIndex];
+    if (block && isTextBlock(block) && hasNextStepsTag(block.text)) {
+      clearPendingNextSteps(ctx);
+      return res;
+    }
+  }
+  const rendered = renderNextStepsBlock(steps);
+  const content = [...res.content];
+  const target = lastTextIndex >= 0 ? content[lastTextIndex] : void 0;
+  if (target && isTextBlock(target)) {
+    const separator = target.text.trim() ? "\n\n" : "";
+    content[lastTextIndex] = { ...target, text: `${target.text}${separator}${rendered}` };
+  } else {
+    content.push({ type: "text", text: rendered });
+  }
+  clearPendingNextSteps(ctx);
+  return { ...res, content };
+}
+
 // src/core/streaming-response-builder.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 
@@ -6279,6 +6414,91 @@ function createAgentLoopHandler(a, handlers) {
   const getFleetPulse = attachFleetPulse(a, fleetPulseCfg);
   const pulseEveryN = Math.max(1, fleetPulseCfg?.everyNIterations ?? 5);
   const backgroundCoordination = () => a.ctx.meta["coordinationContextMode"] === "background";
+  async function refreshProviderContextLimit(provider, model, opts = {}) {
+    a.ctx.meta ??= {};
+    const routeKey = `${provider.id}/${model}`;
+    const previousRouteKey = a.ctx.meta["contextLimitRouteKey"];
+    const routeChanged = previousRouteKey !== void 0 && previousRouteKey !== routeKey;
+    const previousMaxContext = currentMaxContext();
+    if (routeChanged) {
+      delete a.ctx.meta["providerOverflowMaxContext"];
+      delete a.ctx.meta["contextLimitBaseline"];
+      delete a.ctx.meta["providerLimitEffectiveMaxContext"];
+      delete a.ctx.meta["effectiveMaxContext"];
+      delete a.ctx.meta["effectiveMaxContextSource"];
+      delete a.ctx.meta["contextLimitLastEmittedMaxContext"];
+      delete a.ctx.meta["contextLimitLastEmittedSource"];
+    }
+    a.ctx.meta["contextLimitRouteKey"] = routeKey;
+    const routeMeta = a.ctx.meta["effectiveMaxContext"];
+    const routeProviderCap = provider.capabilities.maxContext;
+    const currentEffective = typeof routeMeta === "number" && routeMeta > 0 ? routeMeta : typeof routeProviderCap === "number" && routeProviderCap > 0 ? routeProviderCap : 2e5;
+    const emitEffectiveLimit = (effective2, source) => {
+      const lastEmitted = a.ctx.meta["contextLimitLastEmittedMaxContext"];
+      const lastEmittedSource = a.ctx.meta["contextLimitLastEmittedSource"];
+      if (lastEmitted === effective2 && lastEmittedSource === source) return;
+      const eventPrevious = typeof lastEmitted === "number" && Number.isFinite(lastEmitted) && lastEmitted > 0 ? Math.floor(lastEmitted) : previousMaxContext;
+      a.ctx.meta["contextLimitLastEmittedMaxContext"] = effective2;
+      a.ctx.meta["contextLimitLastEmittedSource"] = source;
+      a.events.emit("ctx.max_context", {
+        sessionId: resolveEventSessionId(a.ctx),
+        providerId: provider.id,
+        modelId: model,
+        maxContext: effective2,
+        ...eventPrevious > 0 ? { previousMaxContext: eventPrevious } : {},
+        source,
+        decreased: eventPrevious > 0 && effective2 < eventPrevious
+      });
+    };
+    const emitNativeAfterRouteChange = () => {
+      if (routeChanged && currentEffective > 0) {
+        a.ctx.meta["effectiveMaxContext"] = currentEffective;
+        a.ctx.meta["effectiveMaxContextSource"] = "configured";
+        emitEffectiveLimit(currentEffective, "configured");
+      }
+    };
+    const refresh = provider.refreshContextLimit;
+    if (opts.probe === false || !refresh) {
+      emitNativeAfterRouteChange();
+      return;
+    }
+    let discovered;
+    try {
+      discovered = await refresh.call(provider, model, { signal: a.ctx.signal });
+    } catch {
+      emitNativeAfterRouteChange();
+      return;
+    }
+    const providerLimit = discovered?.maxContext;
+    if (typeof providerLimit !== "number" || !Number.isFinite(providerLimit) || providerLimit <= 0) {
+      emitNativeAfterRouteChange();
+      return;
+    }
+    const providerLimitFloored = Math.floor(providerLimit);
+    const existingBaseline = a.ctx.meta["contextLimitBaseline"];
+    const lastApplied = a.ctx.meta["providerLimitEffectiveMaxContext"];
+    const existingOverflow = a.ctx.meta["providerOverflowMaxContext"];
+    const effectiveChangedOutsideProbe = typeof lastApplied === "number" && Number.isFinite(lastApplied) && currentEffective !== Math.floor(lastApplied) && currentEffective !== existingOverflow;
+    const baseline = effectiveChangedOutsideProbe || typeof existingBaseline !== "number" || !Number.isFinite(existingBaseline) || existingBaseline <= 0 ? currentEffective : Math.floor(existingBaseline);
+    a.ctx.meta["contextLimitBaseline"] = baseline;
+    const overflowLimit = a.ctx.meta["providerOverflowMaxContext"];
+    const overflowFloored = typeof overflowLimit === "number" && Number.isFinite(overflowLimit) && overflowLimit > 0 ? Math.floor(overflowLimit) : void 0;
+    const ceilings = [baseline, providerLimitFloored];
+    if (overflowFloored !== void 0) ceilings.push(overflowFloored);
+    const effective = Math.min(...ceilings.filter((limit) => limit > 0));
+    let effectiveSource;
+    if (overflowFloored !== void 0 && effective === overflowFloored) {
+      effectiveSource = "provider_overflow";
+    } else if (effective === providerLimitFloored) {
+      effectiveSource = "provider";
+    } else {
+      effectiveSource = "configured";
+    }
+    a.ctx.meta["effectiveMaxContext"] = effective;
+    a.ctx.meta["providerLimitEffectiveMaxContext"] = effective;
+    a.ctx.meta["effectiveMaxContextSource"] = effectiveSource;
+    emitEffectiveLimit(effective, effectiveSource);
+  }
   async function compactContextIfNeeded() {
     const msgCount = a.ctx.messages.length;
     const maxContext = currentMaxContext();
@@ -6291,13 +6511,14 @@ function createAgentLoopHandler(a, handlers) {
     }
     const beforeMessages = a.ctx.messages;
     const beforeMsgCount = a.ctx.messages.length;
+    const beforeRevision = a.ctx.state.revision;
     await a.pipelines.contextWindow.run(a.ctx);
     _lastCompactionMsgCount = a.ctx.messages.length;
     _lastCompactionRevision = a.ctx.state.revision;
     _lastCompactionToolsRef = a.ctx.tools;
     _lastCompactionSystemRef = a.ctx.systemPrompt;
     _lastCompactionMaxContext = maxContext;
-    const changed = a.ctx.messages !== beforeMessages || a.ctx.messages.length !== beforeMsgCount;
+    const changed = a.ctx.state.revision !== beforeRevision || a.ctx.messages !== beforeMessages || a.ctx.messages.length !== beforeMsgCount;
     const tokens = refreshContextRequestTokenStash({ force: changed });
     _lastCompactionRequestTokens = tokens;
     const load = maxContext > 0 ? tokens / maxContext : 0;
@@ -6334,40 +6555,58 @@ function createAgentLoopHandler(a, handlers) {
     );
     a.ctx.lastRequestTokens = preFlight.total;
     _lastPreFlightMsgCount = req.messages.length;
+    _lastPreFlightToolCount = (req.tools ?? []).length;
+    _lastPreFlightRevision = a.ctx.state.revision;
     _cachedSysRef = req.system;
     _cachedToolsRef = req.tools ?? [];
     _cachedOverheadTokens = preFlight.systemPrompt + preFlight.tools;
     a.ctx.meta["lastRequestTokensAt"] = {
       msgCount: req.messages.length,
-      toolCount: (req.tools ?? []).length
+      toolCount: (req.tools ?? []).length,
+      revision: a.ctx.state.revision
     };
     return preFlight;
   }
   function refreshContextRequestTokenStash(opts = {}) {
     const msgCount = a.ctx.messages.length;
     const toolCount = (a.ctx.tools ?? []).length;
+    const revision = a.ctx.state.revision;
     const stashed = a.ctx.lastRequestTokens;
     const stashedAt = a.ctx.meta?.["lastRequestTokensAt"];
     if (!opts.force && typeof stashed === "number" && stashed > 0 && typeof stashedAt === "object" && stashedAt !== null) {
       const meta = stashedAt;
-      if (meta.msgCount === msgCount && (typeof meta.toolCount !== "number" || meta.toolCount === toolCount)) {
+      if (meta.msgCount === msgCount && meta.toolCount === toolCount && meta.revision === revision && _lastPreFlightRevision === revision) {
         return stashed;
       }
     }
     const refreshed = estimateMessageTokens(a.ctx.messages) + systemAndToolsOverhead();
     a.ctx.lastRequestTokens = refreshed;
     _lastPreFlightMsgCount = msgCount;
-    a.ctx.meta["lastRequestTokensAt"] = { msgCount, toolCount };
+    _lastPreFlightToolCount = toolCount;
+    _lastPreFlightRevision = revision;
+    a.ctx.meta["lastRequestTokensAt"] = { msgCount, toolCount, revision };
     return refreshed;
   }
   async function buildRequestWithPreflightCompaction(opts) {
     let prepared = await handlers.response.buildAndRunRequestPipeline(opts);
     let req = prepared.request;
     let preFlight = stashRequestTokens(req);
+    let probedRouteKey = `${prepared.provider.id}/${req.model}`;
+    await refreshProviderContextLimit(prepared.provider, req.model);
     if (await compactContextIfNeeded()) {
       prepared = await handlers.response.buildAndRunRequestPipeline(opts);
       req = prepared.request;
       preFlight = stashRequestTokens(req);
+      const rebuiltRouteKey = `${prepared.provider.id}/${req.model}`;
+      if (rebuiltRouteKey !== probedRouteKey) {
+        probedRouteKey = rebuiltRouteKey;
+        await refreshProviderContextLimit(prepared.provider, req.model);
+        if (await compactContextIfNeeded()) {
+          prepared = await handlers.response.buildAndRunRequestPipeline(opts);
+          req = prepared.request;
+          preFlight = stashRequestTokens(req);
+        }
+      }
     }
     return { req, provider: prepared.provider, preFlight };
   }
@@ -6383,16 +6622,8 @@ function createAgentLoopHandler(a, handlers) {
     _lastEmittedToolCount = toolCount;
     _lastEmittedRevision = revision;
     _lastEmittedMaxContext = maxContext;
-    if (msgCount !== _lastPreFlightMsgCount) {
-      const stashed2 = a.ctx.lastRequestTokens;
-      if (typeof stashed2 === "number" && stashed2 > 0 && _lastPreFlightMsgCount >= 0 && _lastPreFlightMsgCount < msgCount) {
-        const delta = estimateMessageTokens(a.ctx.messages.slice(_lastPreFlightMsgCount));
-        a.ctx.lastRequestTokens = stashed2 + delta;
-      } else {
-        a.ctx.lastRequestTokens = estimateMessageTokens(a.ctx.messages) + systemAndToolsOverhead();
-      }
-      _lastPreFlightMsgCount = msgCount;
-      a.ctx.meta["lastRequestTokensAt"] = { msgCount, toolCount };
+    if (msgCount !== _lastPreFlightMsgCount || toolCount !== _lastPreFlightToolCount || revision !== _lastPreFlightRevision) {
+      refreshContextRequestTokenStash({ force: true });
     }
     let total;
     const anchored = realAnchoredInputTokens(
@@ -6407,9 +6638,7 @@ function createAgentLoopHandler(a, handlers) {
       const cal = getCalibrationState(calibrationKey());
       total = cal.calibrated ? Math.round(stashed * Math.min(1.5, Math.max(0.5, cal.ratio))) : stashed;
     } else {
-      const raw = estimateMessageTokens(a.ctx.messages) + systemAndToolsOverhead();
-      a.ctx.lastRequestTokens = raw;
-      _lastPreFlightMsgCount = msgCount;
+      const raw = refreshContextRequestTokenStash({ force: true });
       const cal = getCalibrationState(calibrationKey());
       total = cal.calibrated ? Math.round(raw * Math.min(1.5, Math.max(0.5, cal.ratio))) : raw;
     }
@@ -6433,6 +6662,8 @@ function createAgentLoopHandler(a, handlers) {
   let _lastEmittedRevision = -1;
   let _lastEmittedMaxContext = -1;
   let _lastPreFlightMsgCount = -1;
+  let _lastPreFlightToolCount = -1;
+  let _lastPreFlightRevision = -1;
   let _lastCompactionMsgCount = -1;
   let _lastCompactionRevision = -1;
   let _lastCompactionToolsRef = null;
@@ -6538,6 +6769,7 @@ function createAgentLoopHandler(a, handlers) {
     } catch (err) {
       (a.logger.debug ?? a.logger.warn)?.(`session boundary flush failed: ${toErrorMessage(err)}`);
     }
+    clearPendingNextSteps(a.ctx);
     let finalText = "";
     let iterations = 0;
     const delegateSummaries = [];
@@ -6625,7 +6857,11 @@ ${text}` : text;
           return { ...limitCheck.exit, finalText };
         }
         await a.extensions.runBeforeIteration(a.ctx, i);
-        a.events.emit("iteration.started", { sessionId: resolveEventSessionId(a.ctx), ctx: a.ctx, index: i });
+        a.events.emit("iteration.started", {
+          sessionId: resolveEventSessionId(a.ctx),
+          ctx: a.ctx,
+          index: i
+        });
         injectPendingBtwNotes((block) => pendingMailboxBlocks.push(block));
         injectQueueAwareness();
         if (pendingLoopSteer) {
@@ -6775,11 +7011,9 @@ ${text}` : text;
           res = recovered.response;
         }
         clearEvaluatedMailboxBlocks();
-        const responseResult = await handlers.response.processResponse(
-          res,
-          req,
-          providerBoundToRequest(req) ?? requestProvider
-        );
+        const responseProvider = providerBoundToRequest(req) ?? requestProvider;
+        const responseResult = await handlers.response.processResponse(res, req, responseProvider);
+        await refreshProviderContextLimit(responseProvider, req.model, { probe: false });
         if (responseResult.aborted) {
           return {
             status: "aborted",
@@ -6937,7 +7171,11 @@ ${text}` : text;
         }
         await compactContextIfNeeded();
         emitContextPct();
-        a.events.emit("iteration.completed", { sessionId: resolveEventSessionId(a.ctx), ctx: a.ctx, index: i });
+        a.events.emit("iteration.completed", {
+          sessionId: resolveEventSessionId(a.ctx),
+          ctx: a.ctx,
+          index: i
+        });
         await a.extensions.runAfterIteration(a.ctx, i);
         if (autonomousContinue && responseResult.directive === "continue") {
           continue;
@@ -7091,6 +7329,9 @@ function buildLiveNextStepsGateBlock(ctx) {
     (todo) => todo.status === "pending" || todo.status === "in_progress"
   );
   if (openTodos.length === 0) {
+    const toolRoute = ctx.tools?.some((t2) => t2.name === "nextsteps") ? [
+      "Calling the `nextsteps` tool with the same items satisfies branch 1 as well; if you both call it and write the block, the block wins."
+    ] : [];
     return {
       type: "text",
       text: [
@@ -7099,6 +7340,7 @@ function buildLiveNextStepsGateBlock(ctx) {
         "On the final response, you MUST take exactly one branch:",
         "1. If at least one genuinely useful follow-on action exists, include a balanced <nextsteps> block containing 1-4 exact prompt messages that can be submitted back to you through the current TUI or WebUI input.",
         "Every item must ask the agent to perform work. Never put a human-only chore or an instruction addressed to the user inside <nextsteps>; natural-language agent-directed imperatives are valid and need not be shell commands.",
+        ...toolRoute,
         "2. If no useful follow-on action truly exists, omit <nextsteps> and explicitly tell the user in normal prose that no further steps are needed for this task.",
         "Silently omitting both is invalid. Do not decide by chance, tone, or response length, and do not invent filler suggestions.",
         "[/nextsteps_gate]"
@@ -7126,6 +7368,27 @@ function buildLiveNextStepsGateBlock(ctx) {
     cache_control: { type: "ephemeral" }
   };
 }
+var MAX_MEMORY_EVIDENCE_CHARS = 12e3;
+function buildMemoryEvidenceBlocks(ctx) {
+  const blocks = [];
+  let remaining = MAX_MEMORY_EVIDENCE_CHARS;
+  for (const entry of ctx.memoryEvidence) {
+    if (remaining <= 0) break;
+    const text = entry.text.trim();
+    if (!text) continue;
+    const source = entry.source.replace(/[^a-z0-9_.-]+/gi, "-").slice(0, 80) || "memory";
+    const bounded = text.slice(0, remaining);
+    remaining -= bounded.length;
+    blocks.push({
+      type: "text",
+      text: `[memory_evidence source="${source}"]
+${bounded}
+[/memory_evidence]`,
+      cache_control: { type: "ephemeral" }
+    });
+  }
+  return blocks;
+}
 function createAgentResponseHandler(a) {
   const stabilizedPromptEpochs = /* @__PURE__ */ new WeakSet();
   function stabilizePromptEpoch() {
@@ -7157,7 +7420,8 @@ function createAgentResponseHandler(a) {
     stabilizePromptEpoch();
     const volatileLedger = buildCompletedWorkLedgerBlock(a.ctx);
     const liveNextStepsGate = buildLiveNextStepsGateBlock(a.ctx);
-    const volatileBlocks = [volatileLedger, liveNextStepsGate].filter(
+    const memoryEvidence = buildMemoryEvidenceBlocks(a.ctx);
+    const volatileBlocks = [volatileLedger, liveNextStepsGate, ...memoryEvidence].filter(
       (block) => block !== void 0
     );
     const system = volatileBlocks.length > 0 ? [...a.ctx.systemPrompt, ...volatileBlocks] : a.ctx.systemPrompt;
@@ -7167,7 +7431,7 @@ function createAgentResponseHandler(a) {
       model: opts.model ?? a.ctx.model,
       system,
       messages: a.ctx.messages,
-      tools: a.tools.list(),
+      tools: a.tools.listForProvider(),
       // `maxTokens` is deliberately NOT set here. The provider adapter
       // resolves the ceiling from the catalog entry for the model in
       // `req.model`, which is the only source that stays correct across a
@@ -7190,6 +7454,7 @@ function createAgentResponseHandler(a) {
   async function processResponse(raw, req, requestProvider = a.ctx.provider) {
     let res = raw;
     res = await a.pipelines.response.run(res);
+    res = maybeAppendPendingNextSteps(a.ctx, res);
     a.events.emit("provider.response", {
       sessionId: resolveEventSessionId(a.ctx),
       ctx: a.ctx,
@@ -7330,7 +7595,7 @@ var DIFF_TOOL_NAMES = /* @__PURE__ */ new Set(["edit", "write", "replace", "patc
 var DIFF_TOOL_EVENT_PREVIEW_MAX = 16e3;
 var SAGE_EVENT_MAX = 2e3;
 function createAgentToolHandler(a) {
-  async function executeSingleWithDecision(tool, use) {
+  async function executeSingleWithDecision(tool, use, preToolContext) {
     const start = Date.now();
     try {
       const result = await a.toolExecutor.executeTool(
@@ -7342,7 +7607,8 @@ function createAgentToolHandler(a) {
           input: use.input
         },
         a.ctx,
-        a.perIterationOutputCapBytes
+        a.perIterationOutputCapBytes,
+        preToolContext
       );
       return { result: result.block, durationMs: Date.now() - start };
     } catch (err) {
@@ -7486,11 +7752,15 @@ function createAgentToolHandler(a) {
           const p = a.permission;
           p.denyOnce?.({ tool: tool.name, pattern: result.suggestedPattern });
         }
-        const reRunResult = decision === "yes" || decision === "always" ? await executeSingleWithDecision(tool, {
-          id: result.toolUseId,
-          name: tool.name,
-          input: result.input
-        }) : {
+        const reRunResult = decision === "yes" || decision === "always" ? await executeSingleWithDecision(
+          tool,
+          {
+            id: result.toolUseId,
+            name: tool.name,
+            input: result.input
+          },
+          result.preToolContext
+        ) : {
           result: {
             type: "tool_result",
             tool_use_id: result.toolUseId,
@@ -7924,7 +8194,8 @@ var Agent = class {
       await sessionWriter.flush().catch(() => {
       });
     });
-    this.ctx.tools = this.tools.list();
+    this.ctx.tools = this.tools.listForProvider();
+    this.ctx.catalogTools = this.tools.list();
     const span = this.tracer?.startSpan("agent.run", {
       "agent.model": opts.model ?? this.ctx.model,
       "agent.executionStrategy": opts.executionStrategy ?? this.executionStrategy
@@ -8011,165 +8282,6 @@ var Agent = class {
   // ── Tool + response execution handled by AgentToolHandler / AgentResponseHandler ──
 };
 
-// src/core/input-builder.ts
-var InputBuilder = class {
-  store;
-  pasteLineThreshold;
-  pasteCharThreshold;
-  display = "";
-  refs = [];
-  constructor(opts) {
-    this.store = opts.store;
-    this.pasteLineThreshold = opts.pasteLineThreshold ?? 8;
-    this.pasteCharThreshold = opts.pasteCharThreshold ?? 2e3;
-  }
-  get text() {
-    return this.display;
-  }
-  get attachments() {
-    return [...this.refs];
-  }
-  get isEmpty() {
-    return this.display.trim().length === 0;
-  }
-  appendText(text) {
-    this.display += text;
-  }
-  /**
-   * Decide whether a chunk of pasted text is "big" enough to collapse.
-   * If yes, store it and append a placeholder. If no, inline it.
-   * Returns the placeholder string actually appended (or `null` if inlined).
-   */
-  async appendPaste(text) {
-    if (this.shouldCollapse(text)) {
-      const ref = await this.store.add({
-        kind: "text",
-        data: text,
-        meta: { label: paragraphLabel(text) }
-      });
-      const placeholder = `[pasted #${ref.seq}]`;
-      this.display += placeholder;
-      this.refs.push(ref);
-      return placeholder;
-    }
-    this.display += text;
-    return null;
-  }
-  /**
-   * Always collapses to `[image #N]` — images are never inlined.
-   * `dataBase64` is the raw base64 payload (no data: prefix).
-   */
-  async appendImage(dataBase64, mediaType) {
-    const ref = await this.store.add({
-      kind: "image",
-      data: dataBase64,
-      meta: { mediaType, label: `${mediaType.split("/")[1]?.toUpperCase() ?? "IMG"}` }
-    });
-    const placeholder = `[image #${ref.seq}]`;
-    this.display += placeholder;
-    this.refs.push(ref);
-    return placeholder;
-  }
-  async appendFile(input) {
-    const ref = await this.store.add({ ...input, kind: "file" });
-    const placeholder = `[file #${ref.seq}]`;
-    this.display += placeholder;
-    this.refs.push(ref);
-    return placeholder;
-  }
-  /**
-   * Register-only variant of `appendPaste`. Always stores the paste and
-   * returns the inline `[pasted #N, L lines]` token WITHOUT mutating
-   * `display` — the caller (TUI) owns its own editable buffer as the single
-   * source of truth, inserts the token there, and expands the buffer at
-   * submit. The collapse decision is the caller's (it gates this call); use
-   * `wouldCollapse()` for that.
-   */
-  async registerPaste(text) {
-    const ref = await this.store.add({
-      kind: "text",
-      data: text,
-      meta: { label: paragraphLabel(text) }
-    });
-    this.refs.push(ref);
-    const lines = text.split(/\r?\n|\r/).length;
-    return `[pasted #${ref.seq}, ${lines} lines]`;
-  }
-  /**
-   * Register-only variant of `appendImage` — see `registerPaste`. Returns a
-   * seq-keyed `[image #N, LABEL]` token; does not touch `display`.
-   */
-  async registerImage(dataBase64, mediaType) {
-    const label = `${mediaType.split("/")[1]?.toUpperCase() ?? "IMG"}`;
-    const ref = await this.store.add({
-      kind: "image",
-      data: dataBase64,
-      meta: { mediaType, label }
-    });
-    this.refs.push(ref);
-    return `[image #${ref.seq}, ${label}]`;
-  }
-  /**
-   * Register-only variant of `appendFile` — see `registerPaste`. Returns a
-   * path-keyed `[file:<path>]` token (resolved by path at expand time); does
-   * not touch `display`. The path is read from `meta.filename` (falling back
-   * to `meta.label`).
-   */
-  async registerFile(input) {
-    const ref = await this.store.add({ ...input, kind: "file" });
-    this.refs.push(ref);
-    const path15 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
-    return `[file:${path15}]`;
-  }
-  /**
-   * Whether `appendPaste(text)` would collapse the text to a placeholder
-   * (rather than inlining it). Lets a frontend decide where to route a paste
-   * — e.g. collapsed pastes become a pill, while inlined ones can be shown
-   * in the editable input row — without calling `appendPaste` first (which
-   * mutates the display buffer).
-   */
-  wouldCollapse(text) {
-    return this.shouldCollapse(text);
-  }
-  /** Reset display and ref list. Does NOT clear the store itself. */
-  reset() {
-    this.display = "";
-    this.refs.length = 0;
-  }
-  /**
-   * Resolve the current display string into ContentBlock[]. Empty
-   * input returns an empty array — caller decides what to do.
-   */
-  async submit() {
-    const text = this.display;
-    this.reset();
-    return text ? this.store.expand(text) : [];
-  }
-  shouldCollapse(text) {
-    if (text.length >= this.pasteCharThreshold) return true;
-    let lines = 1;
-    for (let i = 0; i < text.length; i++) {
-      const c = text.charCodeAt(i);
-      if (c === 10) lines++;
-      else if (c === 13 && text.charCodeAt(i + 1) !== 10) lines++;
-      if (lines >= this.pasteLineThreshold) return true;
-    }
-    return false;
-  }
-};
-function paragraphLabel(text) {
-  const lines = text.split(/\r?\n|\r/).length;
-  const bytes = Buffer.byteLength(text, "utf8");
-  if (bytes < 1024) return `${lines} lines, ${bytes} B`;
-  return `${lines} lines, ${(bytes / 1024).toFixed(1)} KB`;
-}
-
-// src/utils/todos-format.ts
-function hasOpenTodos(todos) {
-  if (!Array.isArray(todos) || todos.length === 0) return false;
-  return todos.some((t2) => t2.status === "pending" || t2.status === "in_progress");
-}
-
 // src/core/continue-intent.ts
 var CONTINUE_PHRASES = /* @__PURE__ */ new Set([
   // ── English ──
@@ -9101,34 +9213,157 @@ function createFallbackModelExtension(deps) {
   };
 }
 
-// src/types/config/runtime.ts
-function normalizeTokenSavingTier(val) {
-  if (val === void 0) return "off";
-  if (typeof val === "boolean") return val ? "medium" : "off";
-  const validTiers = /* @__PURE__ */ new Set([
-    "off",
-    "minimal",
-    "light",
-    "medium",
-    "aggressive"
-  ]);
-  return validTiers.has(val) ? val : "off";
-}
-function resolveTokenSavingTier(val, maxContext) {
-  if (val === "auto") {
-    if (typeof maxContext !== "number" || !Number.isFinite(maxContext) || maxContext <= 0) {
-      return "off";
+// src/core/input-builder.ts
+var InputBuilder = class {
+  store;
+  pasteLineThreshold;
+  pasteCharThreshold;
+  display = "";
+  refs = [];
+  constructor(opts) {
+    this.store = opts.store;
+    this.pasteLineThreshold = opts.pasteLineThreshold ?? 8;
+    this.pasteCharThreshold = opts.pasteCharThreshold ?? 2e3;
+  }
+  get text() {
+    return this.display;
+  }
+  get attachments() {
+    return [...this.refs];
+  }
+  get isEmpty() {
+    return this.display.trim().length === 0;
+  }
+  appendText(text) {
+    this.display += text;
+  }
+  /**
+   * Decide whether a chunk of pasted text is "big" enough to collapse.
+   * If yes, store it and append a placeholder. If no, inline it.
+   * Returns the placeholder string actually appended (or `null` if inlined).
+   */
+  async appendPaste(text) {
+    if (this.shouldCollapse(text)) {
+      const ref = await this.store.add({
+        kind: "text",
+        data: text,
+        meta: { label: paragraphLabel(text) }
+      });
+      const placeholder = `[pasted #${ref.seq}]`;
+      this.display += placeholder;
+      this.refs.push(ref);
+      return placeholder;
     }
-    if (maxContext < 32e3) return "medium";
-    if (maxContext < 128e3) return "light";
-    return "minimal";
+    this.display += text;
+    return null;
   }
-  return normalizeTokenSavingTier(val);
-}
-
-// src/types/system-prompt.ts
-function flattenSystemPromptRegions(regions) {
-  return [...regions.core, ...regions.session, ...regions.volatile];
+  /**
+   * Always collapses to `[image #N]` — images are never inlined.
+   * `dataBase64` is the raw base64 payload (no data: prefix).
+   */
+  async appendImage(dataBase64, mediaType) {
+    const ref = await this.store.add({
+      kind: "image",
+      data: dataBase64,
+      meta: { mediaType, label: `${mediaType.split("/")[1]?.toUpperCase() ?? "IMG"}` }
+    });
+    const placeholder = `[image #${ref.seq}]`;
+    this.display += placeholder;
+    this.refs.push(ref);
+    return placeholder;
+  }
+  async appendFile(input) {
+    const ref = await this.store.add({ ...input, kind: "file" });
+    const placeholder = `[file #${ref.seq}]`;
+    this.display += placeholder;
+    this.refs.push(ref);
+    return placeholder;
+  }
+  /**
+   * Register-only variant of `appendPaste`. Always stores the paste and
+   * returns the inline `[pasted #N, L lines]` token WITHOUT mutating
+   * `display` — the caller (TUI) owns its own editable buffer as the single
+   * source of truth, inserts the token there, and expands the buffer at
+   * submit. The collapse decision is the caller's (it gates this call); use
+   * `wouldCollapse()` for that.
+   */
+  async registerPaste(text) {
+    const ref = await this.store.add({
+      kind: "text",
+      data: text,
+      meta: { label: paragraphLabel(text) }
+    });
+    this.refs.push(ref);
+    const lines = text.split(/\r?\n|\r/).length;
+    return `[pasted #${ref.seq}, ${lines} lines]`;
+  }
+  /**
+   * Register-only variant of `appendImage` — see `registerPaste`. Returns a
+   * seq-keyed `[image #N, LABEL]` token; does not touch `display`.
+   */
+  async registerImage(dataBase64, mediaType) {
+    const label = `${mediaType.split("/")[1]?.toUpperCase() ?? "IMG"}`;
+    const ref = await this.store.add({
+      kind: "image",
+      data: dataBase64,
+      meta: { mediaType, label }
+    });
+    this.refs.push(ref);
+    return `[image #${ref.seq}, ${label}]`;
+  }
+  /**
+   * Register-only variant of `appendFile` — see `registerPaste`. Returns a
+   * path-keyed `[file:<path>]` token (resolved by path at expand time); does
+   * not touch `display`. The path is read from `meta.filename` (falling back
+   * to `meta.label`).
+   */
+  async registerFile(input) {
+    const ref = await this.store.add({ ...input, kind: "file" });
+    this.refs.push(ref);
+    const path15 = ref.meta.filename ?? ref.meta.label ?? String(ref.seq);
+    return `[file:${path15}]`;
+  }
+  /**
+   * Whether `appendPaste(text)` would collapse the text to a placeholder
+   * (rather than inlining it). Lets a frontend decide where to route a paste
+   * — e.g. collapsed pastes become a pill, while inlined ones can be shown
+   * in the editable input row — without calling `appendPaste` first (which
+   * mutates the display buffer).
+   */
+  wouldCollapse(text) {
+    return this.shouldCollapse(text);
+  }
+  /** Reset display and ref list. Does NOT clear the store itself. */
+  reset() {
+    this.display = "";
+    this.refs.length = 0;
+  }
+  /**
+   * Resolve the current display string into ContentBlock[]. Empty
+   * input returns an empty array — caller decides what to do.
+   */
+  async submit() {
+    const text = this.display;
+    this.reset();
+    return text ? this.store.expand(text) : [];
+  }
+  shouldCollapse(text) {
+    if (text.length >= this.pasteCharThreshold) return true;
+    let lines = 1;
+    for (let i = 0; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      if (c === 10) lines++;
+      else if (c === 13 && text.charCodeAt(i + 1) !== 10) lines++;
+      if (lines >= this.pasteLineThreshold) return true;
+    }
+    return false;
+  }
+};
+function paragraphLabel(text) {
+  const lines = text.split(/\r?\n|\r/).length;
+  const bytes = Buffer.byteLength(text, "utf8");
+  if (bytes < 1024) return `${lines} lines, ${bytes} B`;
+  return `${lines} lines, ${(bytes / 1024).toFixed(1)} KB`;
 }
 
 // src/core/instruction-bundle.ts
@@ -9306,7 +9541,281 @@ function firstExistingDirSync(candidates) {
   return candidates[0] ?? "";
 }
 
+// src/types/runtime-capability-manifest.ts
+var PLAYWRIGHT_ALIASES = {
+  playwright_navigate: "browser_navigate",
+  playwright_screenshot: "browser_screenshot",
+  playwright_click: "browser_click",
+  playwright_type: "browser_type",
+  playwright_evaluate: "browser_evaluate",
+  playwright_select_option: "browser_select",
+  playwright_hover: "browser_hover",
+  playwright_fill_form: "browser_type",
+  playwright_wait_for: "browser_wait",
+  playwright_press_key: "browser_press",
+  playwright_drag: "browser_drag"
+};
+var RUNTIME_CAPABILITY_MANIFEST = [
+  {
+    id: "filesystem.read",
+    pack: "core",
+    exposure: "direct",
+    tools: ["read", "grep", "glob", "tree"]
+  },
+  {
+    id: "code.inspect",
+    pack: "core",
+    exposure: "direct",
+    tools: [
+      "codebase-stats",
+      "codebase-search",
+      "codebase-incoming-calls",
+      "codebase-outgoing-calls",
+      "codebase-index",
+      "dead-code-scan",
+      "diff",
+      "json",
+      "logs"
+    ]
+  },
+  {
+    id: "filesystem.write",
+    pack: "development",
+    exposure: "direct",
+    tools: ["write", "edit", "replace", "patch"]
+  },
+  {
+    id: "execution.shell",
+    pack: "development",
+    exposure: "direct",
+    tools: ["bash", "exec", "language", "language_info", "language_package"]
+  },
+  {
+    id: "verification.run",
+    pack: "development",
+    exposure: "direct",
+    tools: ["lint", "format", "typecheck", "test", "e2e_plan"]
+  },
+  {
+    id: "version-control.manage",
+    pack: "development",
+    exposure: "direct",
+    tools: ["git"]
+  },
+  {
+    id: "dependencies.manage",
+    pack: "development",
+    exposure: "on-demand",
+    tools: ["install", "outdated", "audit"]
+  },
+  {
+    id: "documentation.author",
+    pack: "development",
+    exposure: "on-demand",
+    tools: ["document", "design", "scaffold"]
+  },
+  {
+    id: "web.research",
+    pack: "core",
+    exposure: "direct",
+    tools: ["search", "fetch"]
+  },
+  {
+    id: "work.plan",
+    pack: "core",
+    exposure: "direct",
+    tools: ["todo", "plan", "task", "kanban", "nextsteps"]
+  },
+  {
+    id: "coordination.mailbox",
+    pack: "fleet",
+    exposure: "direct",
+    tools: ["mailbox", "mail_send", "mail_inbox", "fleet_status"]
+  },
+  {
+    id: "fleet.delegate",
+    pack: "fleet",
+    exposure: "on-demand",
+    tools: [
+      "delegate",
+      "spawn_subagent",
+      "assign_task",
+      "kanban_queue",
+      "await_tasks",
+      "ask_subagent",
+      "ask_result",
+      "roll_up",
+      "quality_gate",
+      "terminate_subagent",
+      "terminate_all",
+      "work_complete",
+      "collab_debug",
+      "fleet_emit",
+      "fleet"
+    ]
+  },
+  {
+    id: "reasoning.oneshot",
+    pack: "core",
+    exposure: "on-demand",
+    tools: ["llm", "council"]
+  },
+  {
+    id: "memory.manage",
+    pack: "memory",
+    exposure: "on-demand",
+    tools: ["remember", "search_memory", "find_related_memories", "forget"]
+  },
+  {
+    id: "memory.curate",
+    pack: "memory",
+    exposure: "on-demand",
+    tools: [
+      "memory_candidates",
+      "memory_update",
+      "memory_delete",
+      "memory_recover",
+      "memory_backfill_recoverable",
+      "memory_for_file",
+      "memory_for_path",
+      "memory_search",
+      "memory_graph",
+      "memory_gather_batch",
+      "memory_verify",
+      "memory_hygiene"
+    ]
+  },
+  {
+    id: "browser.interact",
+    pack: "browser",
+    exposure: "on-demand",
+    tools: [
+      "browser_open",
+      "browser_status",
+      "browser_list",
+      "browser_navigate",
+      "browser_snapshot",
+      "browser_screenshot",
+      "browser_click",
+      "browser_type",
+      "browser_select",
+      "browser_press",
+      "browser_hover",
+      "browser_drag",
+      "browser_wait",
+      "browser_evaluate",
+      "browser_upload",
+      "browser_close"
+    ],
+    aliases: PLAYWRIGHT_ALIASES
+  },
+  {
+    id: "mcp.dynamic",
+    pack: "mcp",
+    exposure: "on-demand",
+    tools: ["mcp_use"]
+  },
+  {
+    id: "automation.manage",
+    pack: "admin",
+    exposure: "on-demand",
+    tools: ["cron_schedule", "cron_list", "cron_cancel", "watch_start", "watch_list", "watch_stop"]
+  },
+  {
+    id: "context.pin",
+    pack: "admin",
+    exposure: "on-demand",
+    tools: ["pin_add", "pin_list", "pin_remove"]
+  },
+  {
+    id: "quality.analyze",
+    pack: "development",
+    exposure: "on-demand",
+    tools: ["dead_code_scan", "detect_duplicate_code", "secret_scanner_test", "error_lens_history"]
+  },
+  {
+    id: "release.manage",
+    pack: "development",
+    exposure: "on-demand",
+    tools: ["git_autocommit", "semver_current", "semver_bump", "semver_changelog"]
+  },
+  {
+    id: "messaging.telegram",
+    pack: "fleet",
+    exposure: "on-demand",
+    tools: ["telegram_send", "telegram_read", "telegram_approve"]
+  },
+  {
+    id: "tools.discover",
+    pack: "admin",
+    exposure: "direct",
+    tools: ["tool_search", "tool_use", "tool_help", "batch_tool_use"]
+  },
+  {
+    id: "runtime.admin",
+    pack: "admin",
+    exposure: "internal",
+    tools: ["set_working_dir", "context_manager", "mode", "skill", "mcp_control"]
+  }
+];
+var CAPABILITY_BY_ID = new Map(
+  RUNTIME_CAPABILITY_MANIFEST.map((definition) => [definition.id, definition])
+);
+var CAPABILITY_BY_TOOL = /* @__PURE__ */ new Map();
+var TOOL_ALIASES = /* @__PURE__ */ new Map();
+for (const definition of RUNTIME_CAPABILITY_MANIFEST) {
+  for (const tool of definition.tools) {
+    CAPABILITY_BY_TOOL.set(tool, definition.id);
+  }
+  for (const [alias, tool] of Object.entries(definition.aliases ?? {})) {
+    TOOL_ALIASES.set(alias, tool);
+  }
+}
+function normalizeRuntimeToolName(name) {
+  return TOOL_ALIASES.get(name) ?? name;
+}
+function runtimeCapabilityForTool(name) {
+  return CAPABILITY_BY_TOOL.get(normalizeRuntimeToolName(name));
+}
+function inferRuntimeCapabilities(toolNames) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const rawName of toolNames) {
+    const id = runtimeCapabilityForTool(rawName);
+    if (id) ids.add(id);
+  }
+  return [...ids];
+}
+function missingRuntimeCapabilities(required, toolNames) {
+  if (!required || required.length === 0) return [];
+  const available = new Set(inferRuntimeCapabilities(toolNames));
+  return required.filter((id) => !CAPABILITY_BY_ID.has(id) || !available.has(id));
+}
+function missingRequiredRuntimeTools(required, toolNames) {
+  if (!required || required.length === 0) return [];
+  const available = new Set(toolNames.map(normalizeRuntimeToolName));
+  return required.map(normalizeRuntimeToolName).filter((name) => !CAPABILITY_BY_TOOL.has(name) || !available.has(name));
+}
+function runtimeToolReferencesFromText(text) {
+  const references = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(/`([a-z][a-z0-9_-]+)`/gi)) {
+    const name = normalizeRuntimeToolName(match[1] ?? "");
+    if (CAPABILITY_BY_TOOL.has(name)) references.add(name);
+  }
+  for (const pattern of [
+    /\b(?:call|use|invoke|run)\s+`([a-z][a-z0-9_-]+)`/gi,
+    /`([a-z][a-z0-9_-]+)`\s+tool\b/gi
+  ]) {
+    for (const match of text.matchAll(pattern)) {
+      references.add(normalizeRuntimeToolName(match[1] ?? ""));
+    }
+  }
+  return [...references];
+}
+
 // src/core/instruction-template.ts
+var CANONICAL_TOOL_NAMES = new Set(
+  RUNTIME_CAPABILITY_MANIFEST.flatMap((entry) => [...entry.tools])
+);
 var DIRECTIVE_RE = /[ \t]*<!--\s*ws:(if|else|end)\b([^>]*?)-->[ \t]*(?:\r?\n)?/g;
 var PLACEHOLDER_RE = /\{\{\s*(tools:)?\s*([a-zA-Z0-9_.,\s-]+?)\s*\}\}/g;
 function renderInstructionLayer(text, ctx) {
@@ -9316,7 +9825,41 @@ function renderInstructionLayer(text, ctx) {
   if (!hasDirectives && !hasPlaceholders) return text;
   const rendered = hasDirectives ? emit(parse(text), ctx) : text;
   const substituted = hasPlaceholders ? substitute(rendered, ctx) : rendered;
-  return tidy(substituted);
+  const guarded = ctx?.strictToolReferences ? dropLinesWithUnavailableToolReferences(
+    substituted,
+    ctx,
+    /* @__PURE__ */ new Set([...CANONICAL_TOOL_NAMES, ...declaredToolNames(text)])
+  ) : substituted;
+  return tidy(guarded);
+}
+function declaredToolNames(text) {
+  const names = /* @__PURE__ */ new Set();
+  for (const marker of text.matchAll(/<!--\s*ws:if\b([^>]*?)-->/g)) {
+    for (const attr of (marker[1] ?? "").matchAll(/!?tool=([A-Za-z0-9_.,-]+)/g)) {
+      for (const name of (attr[1] ?? "").split(",")) if (name.trim()) names.add(name.trim());
+    }
+  }
+  for (const placeholder of text.matchAll(/\{\{\s*tools:\s*([^}]+)}}/g)) {
+    for (const name of (placeholder[1] ?? "").split(",")) if (name.trim()) names.add(name.trim());
+  }
+  return names;
+}
+function dropLinesWithUnavailableToolReferences(text, ctx, declared) {
+  const unavailable = [...declared].filter((name) => !ctx.toolNames.has(name));
+  if (unavailable.length === 0) return text;
+  return text.split(/(?<=\n)/).filter((line) => !unavailable.some((name) => formattedToolMention(line, name))).join("");
+}
+function formattedToolMention(line, name) {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const token = new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`);
+  if (line.split("`").some((segment, index) => {
+    if (index % 2 !== 1) return false;
+    if (segment.includes(`<${name}`) || segment.includes(`</${name}`)) return false;
+    return token.test(segment);
+  })) {
+    return true;
+  }
+  return line.split("**").some((segment, index) => index % 2 === 1 && segment.trim() === name);
 }
 function parse(text) {
   const root = [];
@@ -9401,6 +9944,37 @@ function tidy(text) {
   return text.replace(/(\r?\n){3,}/g, "$1$1");
 }
 
+// src/types/config/runtime.ts
+function normalizeTokenSavingTier(val) {
+  if (val === void 0) return "off";
+  if (typeof val === "boolean") return val ? "medium" : "off";
+  if (val === "auto") return "medium";
+  const validTiers = /* @__PURE__ */ new Set([
+    "off",
+    "minimal",
+    "light",
+    "medium",
+    "aggressive"
+  ]);
+  return validTiers.has(val) ? val : "off";
+}
+function resolveTokenSavingTier(val, maxContext) {
+  if (val === "auto") {
+    if (typeof maxContext !== "number" || !Number.isFinite(maxContext) || maxContext <= 0) {
+      return "off";
+    }
+    if (maxContext < 32e3) return "medium";
+    if (maxContext < 128e3) return "light";
+    return "minimal";
+  }
+  return normalizeTokenSavingTier(val);
+}
+
+// src/types/system-prompt.ts
+function flattenSystemPromptRegions(regions) {
+  return [...regions.core, ...regions.session, ...regions.volatile];
+}
+
 // src/core/modes/default.ts
 import { readFileSync as readFileSync6, statSync as statSync3 } from "node:fs";
 import * as path12 from "node:path";
@@ -9795,7 +10369,8 @@ async function buildEnvironment(ctx, env) {
     modelCapabilities?.maxContextTokens ?? 0,
     modelCapabilities?.supportsTools ? 1 : 0,
     modelCapabilities?.supportsVision ? 1 : 0,
-    modelCapabilities?.supportsReasoning ? 1 : 0
+    modelCapabilities?.supportsReasoning ? 1 : 0,
+    env.skillCache ?? ""
   ].join("\0");
   const cached = env.envCacheByRoot.get(cacheKey);
   if (cached) {
@@ -9854,7 +10429,7 @@ async function buildEnvironment(ctx, env) {
       lines.push(`- Mode: ${env.modeId}`);
     }
   }
-  if (effShell !== "posix" && tier !== "minimal") {
+  if (ctx.tools.some((tool) => tool.name === "bash") && effShell !== "posix" && tier !== "minimal") {
     const guide = shellGuidanceBlock(effShell, tier === "light" ? "short" : "full");
     if (guide) lines.push("", guide);
   }
@@ -10028,7 +10603,7 @@ function foreignProvenanceTag(source, originTool) {
   const origin = source === "foreign" && originTool ? originTool : source;
   return ` [foreign skill: ${origin}]`;
 }
-async function buildProgressiveSkillManifestText(loader) {
+async function buildProgressiveSkillManifestText(loader, availableToolNames = []) {
   try {
     const entries = await loader.listEntries();
     if (entries.length === 0) return "";
@@ -10038,7 +10613,12 @@ async function buildProgressiveSkillManifestText(loader) {
       "| Skill | Use when |",
       "|---|---|"
     ];
+    const manifests = new Map((await loader.list()).map((manifest) => [manifest.name, manifest]));
     for (const e of entries) {
+      const manifest = manifests.get(e.name);
+      if (manifest && (missingRuntimeCapabilities(manifest.requiredCapabilities, availableToolNames).length > 0 || missingRequiredRuntimeTools(manifest.requiredTools, availableToolNames).length > 0)) {
+        continue;
+      }
       const trigger = (e.trigger ?? "").replace(/\|/g, "\\|").replace(/\n+/g, " ").trim();
       lines.push(`| \`${e.name}\`${foreignProvenanceTag(e.source, e.originTool)} | ${trigger} |`);
     }
@@ -10047,7 +10627,7 @@ async function buildProgressiveSkillManifestText(loader) {
     return "";
   }
 }
-async function buildFullSkillBodiesText(loader, budget = SKILL_LIMITS.EAGER_DEFAULT_MAX_CHARS) {
+async function buildFullSkillBodiesText(loader, budget = SKILL_LIMITS.EAGER_DEFAULT_MAX_CHARS, availableToolNames = []) {
   try {
     const skills = await loader.list();
     if (skills.length === 0) return "";
@@ -10055,10 +10635,16 @@ async function buildFullSkillBodiesText(loader, budget = SKILL_LIMITS.EAGER_DEFA
     const overflow = [];
     let used = 0;
     for (const s of skills) {
+      if (missingRuntimeCapabilities(s.requiredCapabilities, availableToolNames).length > 0 || missingRequiredRuntimeTools(s.requiredTools, availableToolNames).length > 0) {
+        continue;
+      }
       try {
         const raw = await loader.readBody(s.name);
         const trimmed = stripFrontmatter(raw).trim();
         if (!trimmed) continue;
+        if (missingRequiredRuntimeTools(runtimeToolReferencesFromText(trimmed), availableToolNames).length > 0) {
+          continue;
+        }
         const entry = `## Skill: ${s.name}${foreignProvenanceTag(s.source, s.originTool)}
 
 ${capSkillBody(trimmed)}`;
@@ -10082,7 +10668,7 @@ ${overflow.join("\n")}`;
     return "";
   }
 }
-async function buildCompactSkillBodiesText(loader, budget = SKILL_LIMITS.COMPACT_DEFAULT_MAX_CHARS) {
+async function buildCompactSkillBodiesText(loader, budget = SKILL_LIMITS.COMPACT_DEFAULT_MAX_CHARS, availableToolNames = []) {
   try {
     const skills = await loader.list();
     if (skills.length === 0) return "";
@@ -10090,10 +10676,16 @@ async function buildCompactSkillBodiesText(loader, budget = SKILL_LIMITS.COMPACT
     const overflow = [];
     let used = 0;
     for (const s of skills) {
+      if (missingRuntimeCapabilities(s.requiredCapabilities, availableToolNames).length > 0 || missingRequiredRuntimeTools(s.requiredTools, availableToolNames).length > 0) {
+        continue;
+      }
       try {
         const saveBody = await loader.readSaveBody(s.name);
         const clean = stripFrontmatter(saveBody).trim();
         if (!clean) continue;
+        if (missingRequiredRuntimeTools(runtimeToolReferencesFromText(clean), availableToolNames).length > 0) {
+          continue;
+        }
         const entry = `## Skill: ${s.name}${foreignProvenanceTag(s.source, s.originTool)}
 
 ${clean}`;
@@ -10191,11 +10783,22 @@ ${memText}`);
   }
   if (mem.skillLoader) {
     if (mem.skillMode === "progressive") {
-      skillBodyCache = await buildProgressiveSkillManifestText(mem.skillLoader);
+      skillBodyCache = await buildProgressiveSkillManifestText(
+        mem.skillLoader,
+        mem.catalogTools?.map((tool) => tool.name) ?? []
+      );
     } else if (mem.isCompact) {
-      skillBodyCache = await buildCompactSkillBodiesText(mem.skillLoader);
+      skillBodyCache = await buildCompactSkillBodiesText(
+        mem.skillLoader,
+        void 0,
+        mem.catalogTools?.map((tool) => tool.name) ?? []
+      );
     } else {
-      skillBodyCache = await buildFullSkillBodiesText(mem.skillLoader, mem.skillEagerMaxChars);
+      skillBodyCache = await buildFullSkillBodiesText(
+        mem.skillLoader,
+        mem.skillEagerMaxChars,
+        mem.catalogTools?.map((tool) => tool.name) ?? []
+      );
     }
   }
   if (skillBodyCache) {
@@ -10282,6 +10885,8 @@ var DefaultSystemPromptBuilder = class {
   skillBodyCache;
   /** Tools from last build — used for memory relevance scoring. */
   _lastBuildTools;
+  /** Full executable catalog used to capability-gate progressive skills. */
+  _lastCatalogTools;
   /** Cached rendered online agents string, keyed by content fingerprint. */
   _lastOnlineAgents;
   /** Cached full buildToolUsage output — keyed by tools array ref + agents fingerprint + tier. */
@@ -10341,12 +10946,26 @@ var DefaultSystemPromptBuilder = class {
   }
   async buildRegions(ctx) {
     this._lastBuildTools = ctx.tools;
+    this._lastCatalogTools = ctx.catalogTools ?? ctx.tools;
     if (this.opts.skillLoader) {
       try {
         const entries = await this.opts.skillLoader.listEntries();
+        const manifests = new Map(
+          (await this.opts.skillLoader.list()).map((manifest) => [manifest.name, manifest])
+        );
         if (entries.length > 0) {
           const lines = [];
           for (const e of entries) {
+            const manifest = manifests.get(e.name);
+            if (manifest && (missingRuntimeCapabilities(
+              manifest.requiredCapabilities,
+              this._lastCatalogTools?.map((tool) => tool.name) ?? []
+            ).length > 0 || missingRequiredRuntimeTools(
+              manifest.requiredTools,
+              this._lastCatalogTools?.map((tool) => tool.name) ?? []
+            ).length > 0)) {
+              continue;
+            }
             const shortTrigger = compactTrigger(e.trigger);
             lines.push(`- **${e.name}**  (${shortTrigger})`);
           }
@@ -10371,14 +10990,8 @@ var DefaultSystemPromptBuilder = class {
     const layer5 = await this.buildMode();
     const layer6 = ctx.subagent ? "" : await this.buildActivePlan();
     const core = [
-      tagBlock(
-        { type: "text", text: layer1, cache_control: { type: "ephemeral" } },
-        "identity"
-      ),
-      tagBlock(
-        { type: "text", text: layer2, cache_control: { type: "ephemeral" } },
-        "tool-usage"
-      )
+      tagBlock({ type: "text", text: layer1, cache_control: { type: "ephemeral" } }, "identity"),
+      tagBlock({ type: "text", text: layer2, cache_control: { type: "ephemeral" } }, "tool-usage")
     ];
     const session = [
       tagBlock(
@@ -10389,18 +11002,12 @@ var DefaultSystemPromptBuilder = class {
     const volatile = [];
     if (layer4.trim()) {
       session.push(
-        tagBlock(
-          { type: "text", text: layer4, cache_control: { type: "ephemeral" } },
-          "skills"
-        )
+        tagBlock({ type: "text", text: layer4, cache_control: { type: "ephemeral" } }, "skills")
       );
     }
     if (layer5.trim()) {
       session.push(
-        tagBlock(
-          { type: "text", text: layer5, cache_control: { type: "ephemeral" } },
-          "mode"
-        )
+        tagBlock({ type: "text", text: layer5, cache_control: { type: "ephemeral" } }, "mode")
       );
     }
     if (this.opts.modeStore && this.opts.skillLoader) {
@@ -10428,10 +11035,7 @@ var DefaultSystemPromptBuilder = class {
     }
     if (layer6.trim()) {
       volatile.push(
-        tagBlock(
-          { type: "text", text: layer6, cache_control: { type: "ephemeral" } },
-          "plan"
-        )
+        tagBlock({ type: "text", text: layer6, cache_control: { type: "ephemeral" } }, "plan")
       );
     }
     if (this.opts.contributors && this.opts.contributors.length > 0) {
@@ -10469,7 +11073,8 @@ var DefaultSystemPromptBuilder = class {
     return {
       toolNames: new Set(ctx.tools.map((t2) => t2.name)),
       tier: this.tier,
-      subagent: ctx.subagent === true
+      subagent: ctx.subagent === true,
+      strictToolReferences: true
     };
   }
   /**
@@ -10582,7 +11187,15 @@ ${hint.trim()}`);
     }
     if (this.tier !== "minimal" && this.tier !== "aggressive") {
       const commonPatterns = section("tool.common.patterns");
-      if (commonPatterns) lines.push(commonPatterns);
+      if (commonPatterns) {
+        lines.push(
+          renderInstructionLayer(commonPatterns, {
+            toolNames: new Set(tools.map((tool) => tool.name)),
+            tier: this.tier,
+            subagent: ctx.subagent === true
+          })
+        );
+      }
     }
     const hasDelegate = tools.some((t2) => t2.name === "delegate");
     if (hasDelegate) {
@@ -10621,10 +11234,7 @@ ${hint.trim()}`);
         mailSendCommand
       };
       if (this.tier !== "off") {
-        const mailbox = section(
-          "tool.mailbox.compact",
-          mailboxVars
-        );
+        const mailbox = section("tool.mailbox.compact", mailboxVars);
         if (mailbox) lines.push(mailbox);
       } else {
         const mailbox = section("tool.mailbox.full", mailboxVars);
@@ -10640,14 +11250,10 @@ ${hint.trim()}`);
     const hasMcpUse = tools.some((t2) => t2.name === "mcp_use");
     if (hasMcpControl) {
       if (this.tier === "minimal" || this.tier === "light" || this.tier === "aggressive") {
-        const mcp = section(
-          hasMcpUse ? "tool.mcp.compact.use" : "tool.mcp.compact.control"
-        );
+        const mcp = section(hasMcpUse ? "tool.mcp.compact.use" : "tool.mcp.compact.control");
         if (mcp) lines.push(mcp);
       } else {
-        const mcp = section(
-          hasMcpUse ? "tool.mcp.full.use" : "tool.mcp.full.control"
-        );
+        const mcp = section(hasMcpUse ? "tool.mcp.full.use" : "tool.mcp.full.control");
         if (mcp) lines.push(mcp);
       }
     }
@@ -10655,17 +11261,12 @@ ${hint.trim()}`);
     if (hasContextManager) {
       if (this.tier === "minimal" || this.tier === "light") {
       } else if (this.tier === "medium") {
-        const contextManagement = section(
-          "tool.context.management.compact"
-        );
+        const contextManagement = section("tool.context.management.compact");
         if (contextManagement) lines.push(contextManagement);
       } else {
         const maxCtx = this.modelCapabilities()?.maxContextTokens ?? 0;
         const threshold = maxCtx <= 32e3 ? "50" : "70";
-        const contextManagement = section(
-          "tool.context.management.full",
-          { threshold }
-        );
+        const contextManagement = section("tool.context.management.full", { threshold });
         if (contextManagement) lines.push(contextManagement);
       }
     }
@@ -10704,6 +11305,7 @@ ${hint.trim()}`);
       skillMode: this.opts.skillMode,
       skillEagerMaxChars: this.opts.skillEagerMaxChars,
       lastBuildTools: this._lastBuildTools,
+      catalogTools: this._lastCatalogTools,
       skillBodyCache: this.skillBodyCache
     });
     this.skillBodyCache = result.skillBodyCache;
@@ -10724,7 +11326,9 @@ export {
   DefaultSystemPromptBuilder,
   FallbackProfileManager,
   InputBuilder,
+  MAX_PENDING_NEXT_STEPS,
   buildBtwBlock,
+  clearPendingNextSteps,
   consumeBtwNotes,
   createDefaultPipelines,
   createFallbackModelExtension,
@@ -10732,16 +11336,21 @@ export {
   effectiveFallbackChain,
   fallbackProfileChain,
   formatModelRef,
+  hasNextStepsTag,
   loadInstructionBundle,
+  maybeAppendPendingNextSteps,
   normalizeModelRef,
   parseModelRef,
   pendingBtwCount,
+  readPendingNextSteps,
   renderInstructionLayer,
+  renderNextStepsBlock,
   resolveContinuation,
   runProviderWithRetry,
   setBtwNote,
   setQueuedMessagesSnapshot,
   smartDefaultFallbackChain,
-  wrapAsState
+  wrapAsState,
+  writePendingNextSteps
 };
 //# sourceMappingURL=index.js.map