@wrongstack/core 0.310.1 → 0.313.1

package/dist/kernel/index.js

@@ -1,995 +1,17 @@
-// src/utils/error.ts
-function toErrorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-
-// src/types/errors.ts
-var ERROR_CODES = {
-  // Provider
-  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
-  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
-  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
-  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
-  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
-  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
-  PROVIDER_CONTEXT_OVERFLOW: "PROVIDER_CONTEXT_OVERFLOW",
-  // Tool
-  TOOL_NOT_FOUND: "TOOL_NOT_FOUND",
-  TOOL_PERMISSION_DENIED: "TOOL_PERMISSION_DENIED",
-  TOOL_EXECUTION_FAILED: "TOOL_EXECUTION_FAILED",
-  TOOL_TIMEOUT: "TOOL_TIMEOUT",
-  TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
-  // Config
-  CONFIG_INVALID: "CONFIG_INVALID",
-  CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
-  CONFIG_PARSE_FAILED: "CONFIG_PARSE_FAILED",
-  CONFIG_MIGRATION_NEEDED: "CONFIG_MIGRATION_NEEDED",
-  // Plugin
-  PLUGIN_LOAD_FAILED: "PLUGIN_LOAD_FAILED",
-  PLUGIN_API_MISMATCH: "PLUGIN_API_MISMATCH",
-  PLUGIN_MISSING_DEPENDENCY: "PLUGIN_MISSING_DEPENDENCY",
-  // Agent
-  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
-  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
-  AGENT_ABORTED: "AGENT_ABORTED",
-  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
-  // Session
-  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
-  SESSION_CORRUPTED: "SESSION_CORRUPTED",
-  SESSION_WRITE_FAILED: "SESSION_WRITE_FAILED",
-  // Container / Registry
-  CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
-  CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
-  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
-  REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
-  REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
-  REGISTRY_INVALID: "REGISTRY_INVALID",
-  // File system
-  FS_READ_FAILED: "FS_READ_FAILED",
-  FS_WRITE_FAILED: "FS_WRITE_FAILED",
-  FS_MKDIR_FAILED: "FS_MKDIR_FAILED",
-  FS_DELETE_FAILED: "FS_DELETE_FAILED",
-  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED",
-  // SDD (Spec-Driven Development)
-  SDD_VALIDATION_FAILED: "SDD_VALIDATION_FAILED",
-  SDD_PARSE_FAILED: "SDD_PARSE_FAILED",
-  SDD_INVALID_STATE: "SDD_INVALID_STATE",
-  SDD_NOT_READY: "SDD_NOT_READY",
-  // General
-  VALIDATION_ERROR: "VALIDATION_ERROR",
-  PARSE_FAILED: "PARSE_FAILED",
-  UNKNOWN: "UNKNOWN"
-};
-var WrongStackError = class extends Error {
-  code;
-  subsystem;
-  severity;
-  recoverable;
-  context;
-  constructor(opts) {
-    super(opts.message, { cause: opts.cause });
-    this.name = "WrongStackError";
-    this.code = opts.code;
-    this.subsystem = opts.subsystem;
-    this.severity = opts.severity ?? "error";
-    this.recoverable = opts.recoverable ?? false;
-    this.context = opts.context;
-  }
-  /**
-   * Render a one-line user-facing description.
-   * Subclasses should override for domain-specific formatting.
-   */
-  describe() {
-    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
-    return `${this.code}: ${this.message}${ctx}`;
-  }
-};
-function formatContext(ctx) {
-  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
-  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
-}
-
-// src/kernel/container.ts
-var Container = class {
-  entries = /* @__PURE__ */ new Map();
-  /**
-   * Tokens currently mid-resolve. Tracked so we can detect circular
-   * dependencies (A → B → A) and throw a structured error instead of
-   * overflowing the call stack with "Maximum call stack size exceeded".
-   *
-   * Not a memoization cache — the per-entry `cache` field is the source
-   * of truth for "have I built this before?". This set only lives for
-   * the duration of a single resolve call.
-   */
-  resolving = /* @__PURE__ */ new Set();
-  bind(token, factory, opts = {}) {
-    if (this.entries.has(token)) {
-      throw new WrongStackError({
-        message: `Container: token "${token.description ?? "unknown"}" already bound`,
-        code: ERROR_CODES.CONTAINER_TOKEN_ALREADY_BOUND,
-        subsystem: "container",
-        context: { token: token.description }
-      });
-    }
-    this.entries.set(token, {
-      factory,
-      singleton: opts.singleton ?? true,
-      decorators: [],
-      hasCache: false,
-      owner: opts.owner ?? "core"
-    });
-  }
-  override(token, factory, opts = {}) {
-    const existing = this.entries.get(token);
-    if (!existing) {
-      throw new WrongStackError({
-        message: `Container: cannot override "${token.description ?? "unknown"}" \u2014 not bound`,
-        code: ERROR_CODES.CONTAINER_TOKEN_NOT_BOUND,
-        subsystem: "container",
-        context: { token: token.description }
-      });
-    }
-    this.entries.set(token, {
-      factory,
-      singleton: opts.singleton ?? existing.singleton,
-      decorators: existing.decorators,
-      hasCache: false,
-      owner: opts.owner ?? existing.owner
-    });
-  }
-  decorate(token, decorator, owner = "core") {
-    const existing = this.entries.get(token);
-    if (!existing) {
-      throw new WrongStackError({
-        message: `Container: cannot decorate "${token.description ?? "unknown"}" \u2014 not bound`,
-        code: ERROR_CODES.CONTAINER_TOKEN_NOT_BOUND,
-        subsystem: "container",
-        context: { token: token.description }
-      });
-    }
-    existing.decorators.push(decorator);
-    existing.cache = void 0;
-    existing.hasCache = false;
-    existing.owner = `${existing.owner}+${owner}`;
-  }
-  resolve(token) {
-    const entry = this.entries.get(token);
-    if (!entry) {
-      throw new WrongStackError({
-        message: `Container: token "${token.description ?? "unknown"}" not bound`,
-        code: ERROR_CODES.CONTAINER_TOKEN_NOT_BOUND,
-        subsystem: "container",
-        context: { token: token.description }
-      });
-    }
-    if (entry.singleton && entry.hasCache) {
-      return entry.cache;
-    }
-    if (this.resolving.has(token)) {
-      const cycle = this.describeCycle(token);
-      throw new WrongStackError({
-        message: `Container: circular dependency detected \u2014 ${cycle}`,
-        code: ERROR_CODES.CONTAINER_CIRCULAR_DEPENDENCY,
-        subsystem: "container",
-        context: { token: token.description, cycle }
-      });
-    }
-    this.resolving.add(token);
-    try {
-      let value = entry.factory(this);
-      for (const d of entry.decorators) {
-        value = d(value, this);
-      }
-      if (entry.singleton) {
-        entry.cache = value;
-        entry.hasCache = true;
-      }
-      return value;
-    } finally {
-      this.resolving.delete(token);
-    }
-  }
-  /**
-   * Build a human-readable description of the dependency cycle that
-   * caused the resolution to re-enter. Lists the tokens in the order
-   * they were entered, then appends the re-entered token to close the
-   * loop. Falls back to a generic message if the resolving set is
-   * somehow empty (shouldn't happen, but defensive).
-   */
-  describeCycle(reentry) {
-    const descs = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const t2 of this.resolving) {
-      if (seen.has(t2)) continue;
-      seen.add(t2);
-      descs.push(t2.description ?? "unknown");
-    }
-    descs.push(reentry.description ?? "unknown");
-    return descs.join(" \u2192 ");
-  }
-  has(token) {
-    return this.entries.has(token);
-  }
-  /**
-   * Resolve a token if it is bound, otherwise return undefined.
-   * Unlike `resolve()`, this does not throw if the token is unbound.
-   *
-   * Single map lookup — `has()` + `resolve()` would walk the entries
-   * map twice. The bound check is folded into the resolve path so a
-   * non-existent token can never enter the `resolving` cycle-detection
-   * set.
-   */
-  safeResolve(token) {
-    if (!this.entries.has(token)) return void 0;
-    return this.resolve(token);
-  }
-  ownerOf(token) {
-    return this.entries.get(token)?.owner;
-  }
-  /**
-   * Remove a token's binding (along with any decorators stacked on it).
-   * Returns true if the token existed. Use this to withdraw temporary
-   * bindings installed by a short-lived run or plugin — without it, the
-   * entry persists in the map forever.
-   */
-  unbind(token) {
-    return this.entries.delete(token);
-  }
-  /**
-   * Drop every binding. Intended for tests and short-lived CLI invocations
-   * that rebuild the container from scratch. Production code should prefer
-   * `unbind` on the specific tokens it owns.
-   */
-  clear() {
-    this.entries.clear();
-  }
-  list() {
-    return Array.from(this.entries.entries()).map(([token, entry]) => ({
-      token,
-      owner: entry.owner
-    }));
-  }
-  /**
-   * Inspect a binding's full shape, including decorator count and whether
-   * a singleton value is cached. Returns null if the token is unbound.
-   * Decorator and factory function references are not exposed — only counts
-   * and metadata, to keep internal state hidden.
-   */
-  inspect(token) {
-    const entry = this.entries.get(token);
-    if (!entry) return null;
-    return {
-      owner: entry.owner,
-      singleton: entry.singleton,
-      decoratorCount: entry.decorators.length,
-      cached: entry.hasCache
-    };
-  }
-};
-
-// src/kernel/pipeline.ts
-var Pipeline = class {
-  chain = [];
-  errorHandler;
-  /**
-   * Optional operational logger. When set, the `swallow` error-boundary path
-   * emits a structured warning so a swallowed middleware crash is never
-   * completely silent (P2 #7, before-release.md). Without a logger, the
-   * swallow path still works but the crash is invisible — host code should
-   * always wire one.
-   */
-  logger;
-  /**
-   * Install an error boundary. When a middleware throws or rejects, the
-   * handler is called and decides whether to swallow (continue with the
-   * pre-handler value) or rethrow. Without a handler, errors propagate.
-   *
-   * Wire one per pipeline at boot — the host CLI typically installs a
-   * single boundary that logs to the operational log and emits a
-   * `pipeline.error` event for /diag.
-   */
-  setErrorHandler(handler) {
-    this.errorHandler = handler;
-    return this;
-  }
-  /**
-   * Set the operational logger used by the swallow error-boundary path.
-   * Without this, a swallowed middleware crash is completely silent.
-   */
-  setLogger(logger) {
-    this.logger = logger;
-    return this;
-  }
-  use(mw) {
-    this.ensureUnique(mw.name);
-    this.chain.push(mw);
-    return this;
-  }
-  prepend(mw) {
-    this.ensureUnique(mw.name);
-    this.chain.unshift(mw);
-    return this;
-  }
-  /**
-   * Insert middleware at an explicit index. Out-of-range indices are clamped.
-   * Use this when insertBefore/insertAfter are insufficient (e.g. to place
-   * a middleware at a known position regardless of named targets).
-   */
-  insertAt(index, mw) {
-    this.ensureUnique(mw.name);
-    const idx = Math.max(0, Math.min(index, this.chain.length));
-    this.chain.splice(idx, 0, mw);
-    return this;
-  }
-  /**
-   * Insert mw immediately before the first occurrence of target.
-   * If called multiple times with the same target, each call inserts
-   * before the target's current position — so after insertBefore('B', X)
-   * then insertBefore('B', Y), the order is Y → X → B.
-   */
-  insertBefore(target, mw, opts) {
-    this.ensureUnique(mw.name);
-    const idx = this.indexOf(target, opts?.optional);
-    if (idx === -1) return this;
-    this.chain.splice(idx, 0, mw);
-    return this;
-  }
-  /**
-   * Insert mw immediately after the first occurrence of target.
-   * If called multiple times with the same target, each call inserts
-   * after the target's current position — so after insertAfter('B', X)
-   * then insertAfter('B', Y), the order is B → X → Y.
-   */
-  insertAfter(target, mw, opts) {
-    this.ensureUnique(mw.name);
-    const idx = this.indexOf(target, opts?.optional);
-    if (idx === -1) return this;
-    this.chain.splice(idx + 1, 0, mw);
-    return this;
-  }
-  replace(target, mw, opts) {
-    if (mw.name !== target) this.ensureUnique(mw.name);
-    const idx = this.indexOf(target, opts?.optional);
-    if (idx === -1) return this;
-    this.chain[idx] = mw;
-    return this;
-  }
-  remove(name, opts) {
-    const idx = this.indexOf(name, opts?.optional);
-    if (idx === -1) return this;
-    this.chain.splice(idx, 1);
-    return this;
-  }
-  list() {
-    return this.chain.map((m) => m.name);
-  }
-  size() {
-    return this.chain.length;
-  }
-  /** Return a read-only view suitable for passing to plugins. */
-  asReadonly() {
-    const self = this;
-    const view = Object.freeze({
-      get size() {
-        return self.chain.length;
-      },
-      list() {
-        return Object.freeze(self.chain.map((m) => m.name));
-      },
-      run(input) {
-        return self.run(input);
-      }
-    });
-    return view;
-  }
-  async run(input) {
-    let index = -1;
-    const chain = this.chain;
-    const errorHandler = this.errorHandler;
-    const dispatch = async (i, value) => {
-      if (i <= index) {
-        const offender = chain[index]?.name;
-        throw new WrongStackError({
-          message: `Pipeline: next() called multiple times in "${offender}"`,
-          code: ERROR_CODES.VALIDATION_ERROR,
-          subsystem: "container",
-          context: { middleware: offender }
-        });
-      }
-      index = i;
-      const mw = chain[i];
-      if (!mw) return value;
-      try {
-        return await mw.handler(value, (v) => dispatch(i + 1, v));
-      } catch (err) {
-        if (!errorHandler) throw err;
-        const policy = await errorHandler({ middleware: mw.name, owner: mw.owner, err });
-        if (policy === "rethrow") throw err;
-        this.logger?.warn("pipeline.error", {
-          middleware: mw.name,
-          owner: mw.owner,
-          error: err instanceof Error ? err.message : String(err)
-        });
-        return value;
-      }
-    };
-    return dispatch(0, input);
-  }
-  indexOf(name, optional = false) {
-    const idx = this.chain.findIndex((m) => m.name === name);
-    if (idx === -1 && !optional) {
-      throw new WrongStackError({
-        message: `Pipeline: middleware "${name}" not found`,
-        code: ERROR_CODES.REGISTRY_NOT_FOUND,
-        subsystem: "container",
-        context: { middleware: name }
-      });
-    }
-    return idx;
-  }
-  ensureUnique(name) {
-    if (this.chain.some((m) => m.name === name)) {
-      throw new WrongStackError({
-        message: `Pipeline: middleware "${name}" already registered`,
-        code: ERROR_CODES.REGISTRY_DUPLICATE,
-        subsystem: "container",
-        context: { middleware: name }
-      });
-    }
-  }
-};
-
-// src/kernel/events.ts
-var MAX_WILDCARDS = 500;
-var MAX_NAMED_LISTENERS = 2e3;
-var EventBus = class {
-  listeners = /* @__PURE__ */ new Map();
-  wildcards = [];
-  logger;
-  /**
-   * Dispatch arrays cached per event name, rebuilt lazily after a
-   * subscription change. See {@link namedSnapshot}. Every mutation of
-   * `listeners` must invalidate the matching entry, and every mutation of
-   * `wildcards` must null `wildcardSnapshotCache` — a missed invalidation
-   * means an emit dispatches to a stale listener set.
-   */
-  listenerSnapshots = /* @__PURE__ */ new Map();
-  wildcardSnapshotCache = null;
-  setLogger(logger) {
-    this.logger = logger;
-  }
-  on(event, fn) {
-    if (this.listenerCount() >= MAX_NAMED_LISTENERS) {
-      this.logger?.error(
-        `EventBus named listener limit (~${MAX_NAMED_LISTENERS}) reached \u2014 rejecting on("${event}"). Callers must dispose their named listeners to prevent unbounded memory growth.`
-      );
-      return () => {
-      };
-    }
-    let set = this.listeners.get(event);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.listeners.set(event, set);
-    }
-    set.add(fn);
-    this.listenerSnapshots.delete(event);
-    return () => this.off(event, fn);
-  }
-  off(event, fn) {
-    const set = this.listeners.get(event);
-    if (!set) return;
-    set.delete(fn);
-    this.listenerSnapshots.delete(event);
-    if (set.size === 0) this.listeners.delete(event);
-  }
-  once(event, fn) {
-    const wrapper = (payload) => {
-      this.off(event, wrapper);
-      fn(payload);
-    };
-    this.on(event, wrapper);
-    return () => {
-      this.off(event, wrapper);
-    };
-  }
-  /**
-   * Subscribe to all events, regardless of name. Short-hand for
-   * `onPattern('*')`. Use for logging, debugging, or forwarding every
-   * event to another bus (as FleetBus does).
-   *
-   * Returns an unsubscribe function.
-   */
-  onAny(fn) {
-    return this.onPattern("*", fn);
-  }
-  /**
-   * Subscribe to all events whose name matches a glob-style prefix.
-   * `'tool.*'` matches `tool.started`, `tool.executed`, `tool.progress`, etc.
-   * `'*'` matches every event.
-   *
-   * The handler receives `(eventName, payload)` with the event name as a
-   * string and the payload as `unknown`. Use for logging, debugging, or
-   * metrics collection across a family of events.
-   *
-   * Returns an unsubscribe function.
-   */
-  onPattern(pattern, fn) {
-    if (this.wildcards.length >= MAX_WILDCARDS) {
-      this.logger?.error(
-        `EventBus wildcard limit (${MAX_WILDCARDS}) reached \u2014 rejecting onPattern("${pattern}"). Callers must dispose their wildcard listeners to prevent unbounded growth.`
-      );
-      return () => {
-      };
-    }
-    const match = makePatternMatcher(pattern);
-    const entry = { match, fn };
-    this.wildcards.push(entry);
-    this.wildcardSnapshotCache = null;
-    return () => {
-      const idx = this.wildcards.indexOf(entry);
-      if (idx >= 0) {
-        this.wildcards.splice(idx, 1);
-        this.wildcardSnapshotCache = null;
-      }
-    };
-  }
-  /**
-   * Subscribe to all events whose name matches a RegExp.
-   * More flexible than `onPattern` — use when you need regex features
-   * (alternation, character classes, capture groups).
-   *
-   * Returns an unsubscribe function.
-   */
-  onRegex(regex, fn) {
-    if (this.wildcards.length >= MAX_WILDCARDS) {
-      this.logger?.error(
-        `EventBus wildcard limit (${MAX_WILDCARDS}) reached \u2014 rejecting onRegex(${regex}). Callers must dispose their wildcard listeners to prevent unbounded growth.`
-      );
-      return () => {
-      };
-    }
-    const entry = { match: (e) => regex.test(e), fn };
-    this.wildcards.push(entry);
-    this.wildcardSnapshotCache = null;
-    return () => {
-      const idx = this.wildcards.indexOf(entry);
-      if (idx >= 0) {
-        this.wildcards.splice(idx, 1);
-        this.wildcardSnapshotCache = null;
-      }
-    };
-  }
-  emit(event, payload) {
-    const snapshot = this.namedSnapshot(event);
-    if (snapshot !== void 0) {
-      for (const fn of snapshot) {
-        try {
-          fn(payload);
-        } catch (err) {
-          this.logger?.error(`EventBus listener for "${event}" threw`, err);
-        }
-      }
-    }
-    if (this.wildcards.length > 0) {
-      const name = event;
-      for (const { match, fn } of this.wildcardSnapshot()) {
-        if (!match(name)) continue;
-        try {
-          fn(name, payload);
-        } catch (err) {
-          this.logger?.error(`EventBus wildcard listener for "${name}" threw`, err);
-        }
-      }
-    }
-  }
-  /**
-   * Dispatch array for one event name, or `undefined` when nothing is
-   * subscribed.
-   *
-   * Dispatch iterates a stable array rather than the live Set so a listener
-   * that subscribes or unsubscribes mid-emit cannot change what this round
-   * delivers: an addition fires from the next emit, a removal may still fire
-   * this round. That is the contract callers rely on, and it is unchanged.
-   *
-   * What changed is who pays for it. Building the array per emit did O(number
-   * of listeners) copying on every event, including `tool.progress` and
-   * streaming deltas — the highest-frequency paths in the process. The array
-   * is now cached and rebuilt only when the subscription set actually changes,
-   * which is wiring time and essentially never during a run. Measured at 2M
-   * emits with 12 named + 6 wildcard listeners: 207 ms → 141 ms.
-   *
-   * This is a throughput win, not a footprint one: the per-emit arrays died in
-   * the nursery and never showed up as retained heap (measured heap growth was
-   * the same either way). Do not cite this as a memory fix.
-   *
-   * A mutation during dispatch invalidates the cache for the *next* emit while
-   * the in-flight loop keeps walking the array it started with — which is
-   * exactly the snapshot semantics described above.
-   */
-  namedSnapshot(event) {
-    const cached = this.listenerSnapshots.get(event);
-    if (cached !== void 0) return cached;
-    const set = this.listeners.get(event);
-    if (!set || set.size === 0) return void 0;
-    const snapshot = [...set];
-    this.listenerSnapshots.set(event, snapshot);
-    return snapshot;
-  }
-  /** Wildcard counterpart to {@link namedSnapshot}; same caching rationale. */
-  wildcardSnapshot() {
-    this.wildcardSnapshotCache ??= this.wildcards.slice();
-    return this.wildcardSnapshotCache;
-  }
-  /**
-   * Emit a plugin-defined event that is intentionally outside EventMap.
-   * Custom events are delivered to wildcard/pattern listeners only; typed
-   * listeners remain reserved for core EventMap keys.
-   */
-  emitCustom(event, payload) {
-    if (this.wildcards.length === 0) return;
-    for (const { match, fn } of this.wildcardSnapshot()) {
-      if (!match(event)) continue;
-      try {
-        fn(event, payload);
-      } catch (err) {
-        this.logger?.error(`EventBus wildcard listener for "${event}" threw`, err);
-      }
-    }
-  }
-  clear() {
-    this.listeners.clear();
-    this.wildcards.length = 0;
-    this.listenerSnapshots.clear();
-    this.wildcardSnapshotCache = null;
-  }
-  /**
-   * V2-D: introspection helper. Pass an `event` to count handlers for a
-   * single key, or omit to get the total across every event. Used by the
-   * leak-detection smoke test to flag handler accumulation across runs.
-   * Does NOT include wildcard listeners.
-   */
-  listenerCount(event) {
-    if (event !== void 0) return this.listeners.get(event)?.size ?? 0;
-    let total = 0;
-    for (const set of this.listeners.values()) total += set.size;
-    return total;
-  }
-  /**
-   * Number of wildcard listeners currently registered.
-   */
-  wildcardCount() {
-    return this.wildcards.length;
-  }
-  /**
-   * True if anything would receive an emit for `event` — a named listener
-   * OR a wildcard/regex pattern that matches the event name. Unlike
-   * `listenerCount`, this DOES account for wildcards, so callers that gate
-   * behavior on "is anyone listening?" (e.g. SubagentBudget deciding whether
-   * to negotiate a soft limit vs hard-stop) don't misfire when the only
-   * subscriber is a pattern listener like the FleetBus's `onPattern('*')`.
-   */
-  hasListenerFor(event) {
-    if ((this.listeners.get(event)?.size ?? 0) > 0) return true;
-    return this.wildcards.some((w) => w.match(event));
-  }
-};
-var ScopedEventBus = class extends EventBus {
-  // Track registrations by a unique counter key so that EventBus.once()'s
-  // internal listener-removal doesn't affect our tracking (once removes the
-  // fn from EventBus but we still need to call our unsub during teardown).
-  registrations = /* @__PURE__ */ new Map();
-  nextKey = 0;
-  /**
-   * Identical to `EventBus.on` but the listener is tracked so that
-   * `teardown()` will remove it automatically.
-   */
-  on(event, fn) {
-    const key = this.nextKey++;
-    const unsub = super.on(event, fn);
-    this.registrations.set(key, unsub);
-    return () => {
-      this.registrations.delete(key);
-      unsub();
-    };
-  }
-  /**
-   * Identical to `EventBus.once` but the listener is tracked so that
-   * `teardown()` will remove it automatically.
-   *
-   * Uses EventBus's public API directly to avoid triggering our own `on()`
-   * override (which would consume a key slot for the wrapper, then orphan
-   * our registration entry under a different key).
-   *
-   * When the wrapper fires, it cleans up BOTH the underlying EventBus
-   * listener AND the tracking entry — so `scopedListenerCount` returns to
-   * its pre-`once()` value without requiring the caller to invoke the
-   * returned unsubscribe. The returned `unsub` is still safe to call
-   * after auto-removal (its delete is a no-op and its off() finds
-   * nothing to remove).
-   */
-  once(event, fn) {
-    const key = this.nextKey++;
-    const wrapper = (payload) => {
-      EventBus.prototype.off.call(this, event, wrapper);
-      this.registrations.delete(key);
-      fn(payload);
-    };
-    EventBus.prototype.on.call(this, event, wrapper);
-    const unsub = () => {
-      this.registrations.delete(key);
-      EventBus.prototype.off.call(this, event, wrapper);
-    };
-    this.registrations.set(key, unsub);
-    return unsub;
-  }
-  /**
-   * Subscribe to all events. Alias for `onPattern('*')` — the listener is
-   * tracked so that `teardown()` will remove it automatically.
-   */
-  onAny(fn) {
-    if (this.wildcards.length >= MAX_WILDCARDS) {
-      this.logger?.error(
-        `EventBus wildcard limit (${MAX_WILDCARDS}) reached \u2014 rejecting onAny(). Callers must dispose their wildcard listeners to prevent unbounded growth.`
-      );
-      return () => {
-      };
-    }
-    const key = this.nextKey++;
-    const unsub = EventBus.prototype.onPattern.call(this, "*", fn);
-    this.registrations.set(key, unsub);
-    return () => {
-      this.registrations.delete(key);
-      unsub();
-    };
-  }
-  /**
-   * Identical to `EventBus.onPattern` but the listener is tracked so that
-   * `teardown()` will remove it automatically.
-   */
-  onPattern(pattern, fn) {
-    if (this.wildcards.length >= MAX_WILDCARDS) {
-      this.logger?.error(
-        `EventBus wildcard limit (${MAX_WILDCARDS}) reached \u2014 rejecting onPattern("${pattern}"). Callers must dispose their wildcard listeners to prevent unbounded growth.`
-      );
-      return () => {
-      };
-    }
-    const key = this.nextKey++;
-    const unsub = super.onPattern(pattern, fn);
-    this.registrations.set(key, unsub);
-    return () => {
-      this.registrations.delete(key);
-      unsub();
-    };
-  }
-  /**
-   * Identical to `EventBus.onRegex` but the listener is tracked so that
-   * `teardown()` will remove it automatically.
-   */
-  onRegex(regex, fn) {
-    if (this.wildcards.length >= MAX_WILDCARDS) {
-      this.logger?.error(
-        `EventBus wildcard limit (${MAX_WILDCARDS}) reached \u2014 rejecting onRegex(${regex}). Callers must dispose their wildcard listeners to prevent unbounded growth.`
-      );
-      return () => {
-      };
-    }
-    const key = this.nextKey++;
-    const unsub = super.onRegex(regex, fn);
-    this.registrations.set(key, unsub);
-    return () => {
-      this.registrations.delete(key);
-      unsub();
-    };
-  }
-  /**
-   * Remove every listener that was registered through this scoped bus.
-   * Idempotent — calling it multiple times is safe.
-   *
-   * Also available as `[Symbol.dispose]` for explicit resource management:
-   * ```ts
-   * using scope = new ScopedEventBus();
-   * scope.on('tool.executed', handler);
-   * // automatically teardown()'d when scope exits
-   * ```
-   */
-  teardown() {
-    for (const unsub of this.registrations.values()) {
-      try {
-        unsub();
-      } catch {
-      }
-    }
-    this.registrations.clear();
-    this.clear();
-  }
-  /** Alias for `teardown()` — enables `using new ScopedEventBus()` in Node ≥ 22. */
-  [Symbol.dispose]() {
-    this.teardown();
-  }
-  /** Number of tracked registrations. */
-  get scopedListenerCount() {
-    return this.registrations.size;
-  }
-};
-var MATCH_ALL = () => true;
-function makePatternMatcher(pattern) {
-  if (pattern === "*") return MATCH_ALL;
-  if (pattern.endsWith(".*")) {
-    const prefix = pattern.slice(0, -2);
-    return (e) => e.startsWith(`${prefix}.`);
-  }
-  return (e) => e === pattern;
-}
-
-// src/kernel/tokens.ts
-var t = (name) => /* @__PURE__ */ Symbol.for(`@wrongstack/core/kernel#${name}`);
-var TOKENS = {
-  Logger: t("Logger"),
-  TokenCounter: t("TokenCounter"),
-  SessionStore: t("SessionStore"),
-  /**
-   * @deprecated Token name retained for compatibility.
-   * The resolved value IS a `MemoryPort`, NOT the legacy `MemoryStore` interface.
-   * Callers that cast or destructure as `MemoryStore` will lose `getCapability`,
-   * `health`, `dispose`, and the narrowed `withTraceId(): MemoryPort` return type.
-   * Port implementations are opaque — query optional features via `getCapability`.
-   * Use `TOKENS.MemoryPort` instead.
-   */
-  MemoryStore: t("MemoryStore"),
-  /** Production memory backend. Use instead of the deprecated `MemoryStore` token. */
-  MemoryPort: t("MemoryPort"),
-  PermissionPolicy: t("PermissionPolicy"),
-  Compactor: t("Compactor"),
-  PathResolver: t("PathResolver"),
-  ConfigLoader: t("ConfigLoader"),
-  ConfigStore: t("ConfigStore"),
-  FallbackProfileManager: t("FallbackProfileManager"),
-  /** Shared (provider, model) health tracker; fallback extensions read/write it. */
-  ProviderModelStatusTracker: t("ProviderModelStatusTracker"),
-  Renderer: t("Renderer"),
-  InputReader: t("InputReader"),
-  ErrorHandler: t("ErrorHandler"),
-  RetryPolicy: t("RetryPolicy"),
-  SkillLoader: t("SkillLoader"),
-  PromptLoader: t("PromptLoader"),
-  SystemPromptBuilder: t("SystemPromptBuilder"),
-  SecretScrubber: t("SecretScrubber"),
-  ModelsRegistry: t("ModelsRegistry"),
-  ModeStore: t("ModeStore"),
-  /** Replaces the entire provider call layer — retry, streaming, tracing. */
-  ProviderRunner: t("ProviderRunner"),
-  /** Optional git-worktree lifecycle manager (per-phase isolation in Goal). */
-  WorktreeManager: t("WorktreeManager"),
-  /** Optional global Brain arbiter for policy/decision escalation. */
-  BrainArbiter: t("BrainArbiter"),
-  /** Lifecycle hook registry (shell + in-process hooks). */
-  HookRegistry: t("HookRegistry")
-};
-
-// src/kernel/run-controller.ts
-var RunController = class {
-  ctrl = new AbortController();
-  hooks = [];
-  disposed = false;
-  hooksDrained = false;
-  errorSink;
-  /**
-   * Shared promise for the in-flight `runHooks()` call. Set by the abort
-   * signal handler or by `dispose()`, whichever fires first. Both callers
-   * await the same promise so abort-triggered async cleanup (session flush,
-   * socket close) completes before `dispose()` resolves.
-   */
-  _hooksPromise = null;
-  constructor(opts = {}) {
-    this.errorSink = opts.errorSink ?? ((err, where) => {
-      console.warn(JSON.stringify({
-        level: "warn",
-        event: "run.cleanup_hook_failed",
-        where,
-        message: toErrorMessage(err),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
-    });
-    if (opts.parentSignal) {
-      const parent = opts.parentSignal;
-      if (parent.aborted) {
-        this.ctrl.abort(parent.reason);
-        queueMicrotask(() => {
-          void this.runHooks();
-        });
-      } else {
-        const onParentAbort = () => this.ctrl.abort(parent.reason);
-        parent.addEventListener("abort", onParentAbort, { once: true });
-        this.onAbort(() => parent.removeEventListener("abort", onParentAbort));
-      }
-    }
-    this.ctrl.signal.addEventListener(
-      "abort",
-      () => {
-        this.ensureHooksRun();
-      },
-      { once: true }
-    );
-  }
-  get signal() {
-    return this.ctrl.signal;
-  }
-  get aborted() {
-    return this.ctrl.signal.aborted;
-  }
-  abort(reason) {
-    if (this.ctrl.signal.aborted) return;
-    this.ctrl.abort(reason);
-  }
-  /**
-   * Register a teardown hook. Returns an unsubscribe function so callers
-   * can opt out before the hook fires (e.g. when a tool finishes cleanly
-   * before abort happens).
-   *
-   * If the controller has already drained its hooks (a prior abort() or
-   * dispose() ran), the new hook is fired immediately on a best-effort
-   * basis — otherwise a hook registered after teardown would be silently
-   * dropped and the resource it cleans up would leak. The returned
-   * unsubscribe is a no-op in that case (the hook has already run). Errors
-   * from the immediate run are routed through `errorSink` like any other
-   * cleanup failure.
-   */
-  onAbort(fn) {
-    if (this.hooksDrained) {
-      void (async () => {
-        try {
-          await fn();
-        } catch (err) {
-          this.errorSink(err, "RunController.onAbort(post-drain)");
-        }
-      })();
-      return () => {
-      };
-    }
-    this.hooks.push(fn);
-    return () => {
-      const idx = this.hooks.indexOf(fn);
-      if (idx !== -1) this.hooks.splice(idx, 1);
-    };
-  }
-  /**
-   * Fire cleanup hooks and tear down listeners — called when the run
-   * ends *normally* so cleanup happens regardless of outcome. Subsequent
-   * aborts become no-ops.
-   */
-  async dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    await this.ensureHooksRun();
-  }
-  /**
-   * Start running hooks (or wait for an already-in-flight run) and return
-   * a promise that settles when all hooks complete. Both the abort signal
-   * handler and `dispose()` call this so they share the same underlying
-   * promise — abort-triggered async cleanup (session flush, socket close)
-   * is guaranteed to finish before `dispose()` resolves.
-   */
-  ensureHooksRun() {
-    if (!this._hooksPromise) {
-      this._hooksPromise = this.runHooks();
-    }
-    return this._hooksPromise;
-  }
-  async runHooks() {
-    if (this.hooksDrained) return;
-    this.hooksDrained = true;
-    const snapshot = this.hooks.splice(0, this.hooks.length).reverse();
-    if (snapshot.length === 0) return;
-    await Promise.allSettled(
-      snapshot.map(
-        (hook) => Promise.resolve().then(() => hook()).catch((err) => {
-          this.errorSink(err, "RunController.dispose");
-        })
-      )
-    );
-  }
-};
+import {
+  Container
+} from "../chunk-O74MJHXU.js";
+import {
+  EventBus,
+  ScopedEventBus
+} from "../chunk-4LJJYBAU.js";
+import {
+  Pipeline,
+  RunController,
+  TOKENS
+} from "../chunk-Y2GE5TSI.js";
+import "../chunk-WOEZV3Q4.js";
+import "../chunk-TBRL2RCC.js";
 export {
   Container,
   EventBus,