@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-Y2GE5TSI.js

@@ -0,0 +1,355 @@
+import {
+  ERROR_CODES,
+  WrongStackError
+} from "./chunk-WOEZV3Q4.js";
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// 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");
+        })
+      )
+    );
+  }
+};
+
+// 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/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 }
+      });
+    }
+  }
+};
+
+export {
+  RunController,
+  TOKENS,
+  Pipeline
+};
+//# sourceMappingURL=chunk-Y2GE5TSI.js.map

package/dist/chunk-YBUJCZ57.js

@@ -0,0 +1,351 @@
+import {
+  SessionCatalogProjectClient
+} from "./chunk-52RTVH4M.js";
+import {
+  sessionCatalogProjectServerMetadataPath
+} from "./chunk-E6I5RXVK.js";
+
+// src/session-catalog/registry.ts
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var AGENT_WRITE_THROTTLE_MS = 300;
+var MAX_PROJECT_CLIENTS = 128;
+var MAX_GLOBAL_ROOTS = 16;
+var ProjectSessionRegistry = class {
+  constructor(globalRoot) {
+    this.globalRoot = globalRoot;
+  }
+  globalRoot;
+  instanceId = randomUUID();
+  clients = /* @__PURE__ */ new Map();
+  current;
+  heartbeatTimer;
+  agentRevision = 0;
+  pendingAgents;
+  agentTimer;
+  lastAgentWriteAt = 0;
+  bindingKey(projectDir) {
+    const resolved = path.resolve(projectDir);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+  }
+  async closeBinding(binding) {
+    if (this.current?.binding === binding) return;
+    const key = this.bindingKey(binding.projectDir);
+    if (this.clients.get(key) === binding) this.clients.delete(key);
+    await binding.client.close();
+  }
+  binding(projectSlug, projectRoot) {
+    const projectDir = path.join(this.globalRoot, "projects", projectSlug);
+    const key = this.bindingKey(projectDir);
+    let binding = this.clients.get(key);
+    if (!binding) {
+      if (this.clients.size >= MAX_PROJECT_CLIENTS) {
+        const oldest = [...this.clients.entries()].find(
+          ([, candidate]) => candidate !== this.current?.binding
+        );
+        if (oldest) {
+          this.clients.delete(oldest[0]);
+          void oldest[1].client.close();
+        }
+      }
+      binding = {
+        projectDir,
+        projectRoot: path.resolve(projectRoot),
+        client: new SessionCatalogProjectClient({ projectDir, projectRoot })
+      };
+      this.clients.set(key, binding);
+    } else {
+      this.clients.delete(key);
+      this.clients.set(key, binding);
+    }
+    return binding;
+  }
+  fullEntry(entry) {
+    const agents = entry.agents ?? [];
+    return {
+      ...entry,
+      status: agents.some((agent) => agent.status !== "idle") ? "active" : "idle",
+      lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+      agentCount: agents.length,
+      agents
+    };
+  }
+  async register(entry) {
+    const full = this.fullEntry(entry);
+    if (this.current?.entry.sessionId === full.sessionId && this.current.entry.pid === full.pid) {
+      this.current.entry = full;
+      this.current.credential = await this.current.binding.client.call("heartbeat", {
+        credential: this.current.credential,
+        status: full.status
+      });
+      return;
+    }
+    const nextBinding = this.binding(full.projectSlug, full.projectRoot);
+    let nextCredential;
+    try {
+      nextCredential = await nextBinding.client.call("claim_new", {
+        entry: full,
+        ownerInstanceId: this.instanceId
+      });
+    } catch (error) {
+      await this.closeBinding(nextBinding).catch(() => void 0);
+      throw error;
+    }
+    const previous = this.current;
+    this.current = { binding: nextBinding, credential: nextCredential, entry: full };
+    this.agentRevision = 0;
+    this.cancelAgentTimer();
+    this.startHeartbeat();
+    if (previous) {
+      await previous.binding.client.call("release", { credential: previous.credential }).catch(() => void 0);
+      if (previous.binding !== nextBinding) await this.closeBinding(previous.binding);
+    }
+  }
+  /** Reserve before transcript hydration; activation swaps ownership only after the writer opened. */
+  async reserveResume(target) {
+    const binding = this.binding(target.projectSlug, target.projectRoot);
+    let reservation;
+    try {
+      reservation = await binding.client.call("reserve_resume", {
+        targetSessionId: target.sessionId,
+        requesterInstanceId: this.instanceId,
+        ...this.current ? { currentSessionId: this.current.entry.sessionId } : {}
+      });
+    } catch (error) {
+      await this.closeBinding(binding).catch(() => void 0);
+      throw error;
+    }
+    let settled = false;
+    return {
+      reservation,
+      activate: async (registration) => {
+        if (settled) throw new Error("Resume reservation is already settled");
+        const entry = this.fullEntry(registration);
+        const credential = await binding.client.call("activate_reservation", {
+          reservation,
+          entry
+        });
+        const previous = this.current;
+        this.current = { binding, credential, entry };
+        settled = true;
+        this.agentRevision = 0;
+        this.cancelAgentTimer();
+        this.startHeartbeat();
+        if (previous) {
+          await previous.binding.client.call("release", { credential: previous.credential }).catch(() => void 0);
+          if (previous.binding !== binding) await this.closeBinding(previous.binding);
+        }
+      },
+      cancel: async () => {
+        if (settled) return;
+        settled = true;
+        try {
+          await binding.client.call("cancel_reservation", {
+            reservationId: reservation.reservationId,
+            requesterInstanceId: this.instanceId
+          }).catch(() => void 0);
+        } finally {
+          await this.closeBinding(binding).catch(() => void 0);
+        }
+      }
+    };
+  }
+  async updateAgents(agents) {
+    if (!this.current) return;
+    this.pendingAgents = agents;
+    this.current.entry = {
+      ...this.current.entry,
+      agents,
+      agentCount: agents.length,
+      status: agents.some((agent) => agent.status !== "idle") ? "active" : "idle",
+      lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const elapsed = Date.now() - this.lastAgentWriteAt;
+    if (!this.agentTimer && elapsed >= AGENT_WRITE_THROTTLE_MS) {
+      await this.flushAgents();
+      return;
+    }
+    if (!this.agentTimer) {
+      this.agentTimer = setTimeout(
+        () => {
+          this.agentTimer = void 0;
+          void this.flushAgents();
+        },
+        Math.max(0, AGENT_WRITE_THROTTLE_MS - elapsed)
+      );
+      this.agentTimer.unref?.();
+    }
+  }
+  async flushAgents() {
+    const agents = this.pendingAgents;
+    const current = this.current;
+    if (!agents || !current) return;
+    this.pendingAgents = void 0;
+    this.lastAgentWriteAt = Date.now();
+    const revision = ++this.agentRevision;
+    await current.binding.client.call("publish_agents", {
+      credential: current.credential,
+      revision,
+      agents
+    });
+  }
+  async markClosing() {
+    this.stopHeartbeat();
+    this.cancelAgentTimer();
+    if (this.current)
+      await this.current.binding.client.call("mark_closing", {
+        credential: this.current.credential
+      });
+  }
+  async unregister() {
+    this.stopHeartbeat();
+    this.cancelAgentTimer();
+    const current = this.current;
+    this.current = void 0;
+    if (current) {
+      try {
+        await current.binding.client.call("release", { credential: current.credential });
+      } finally {
+        await this.closeBinding(current.binding);
+      }
+    }
+  }
+  async list() {
+    const projectsDir = path.join(this.globalRoot, "projects");
+    let directories = [];
+    try {
+      directories = (await fs.readdir(projectsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).slice(0, 1e3).map((entry) => entry.name);
+    } catch {
+      return [];
+    }
+    const snapshots = await Promise.all(
+      directories.map(async (slug) => {
+        const projectDir = path.join(projectsDir, slug);
+        let client;
+        try {
+          const metadata = JSON.parse(
+            await fs.readFile(sessionCatalogProjectServerMetadataPath(projectDir), "utf8")
+          );
+          if (typeof metadata.projectRoot !== "string" || !metadata.projectRoot) return [];
+          client = new SessionCatalogProjectClient({
+            projectDir,
+            projectRoot: metadata.projectRoot
+          });
+          return await client.callExisting("list_live", {});
+        } catch {
+          return [];
+        } finally {
+          await client?.close().catch(() => void 0);
+        }
+      })
+    );
+    return snapshots.flat();
+  }
+  async listByProject(projectSlug) {
+    const current = this.current;
+    if (current && path.basename(current.binding.projectDir) === projectSlug) {
+      return current.binding.client.call("list_live", {}).catch(() => []);
+    }
+    const projectDir = path.join(this.globalRoot, "projects", projectSlug);
+    let client;
+    try {
+      const metadata = JSON.parse(
+        await fs.readFile(sessionCatalogProjectServerMetadataPath(projectDir), "utf8")
+      );
+      if (typeof metadata.projectRoot !== "string") return [];
+      client = new SessionCatalogProjectClient({ projectDir, projectRoot: metadata.projectRoot });
+      return await client.callExisting("list_live", {}).catch(() => []);
+    } catch {
+      return [];
+    } finally {
+      await client?.close().catch(() => void 0);
+    }
+  }
+  async get(sessionId) {
+    return (await this.list()).find((entry) => entry.sessionId === sessionId);
+  }
+  subscribeProject(projectSlug, projectRoot, listener) {
+    const binding = this.binding(projectSlug, projectRoot);
+    return binding.client.subscribe(listener).then((unsubscribe) => async () => {
+      await unsubscribe();
+      await this.closeBinding(binding);
+    });
+  }
+  get registryPath() {
+    return path.join(this.globalRoot, "projects");
+  }
+  async dispose() {
+    await this.unregister().catch(() => void 0);
+    await Promise.all([...this.clients.values()].map((binding) => binding.client.close()));
+    this.clients.clear();
+  }
+  /** Whether this facade currently owns a live session lease. */
+  ownsSession() {
+    return this.current !== void 0;
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      void this.heartbeat();
+    }, HEARTBEAT_INTERVAL_MS);
+    this.heartbeatTimer.unref?.();
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = void 0;
+  }
+  cancelAgentTimer() {
+    if (this.agentTimer) clearTimeout(this.agentTimer);
+    this.agentTimer = void 0;
+    this.pendingAgents = void 0;
+  }
+  async heartbeat() {
+    const current = this.current;
+    if (!current) return;
+    try {
+      const credential = await current.binding.client.call("heartbeat", {
+        credential: current.credential,
+        status: current.entry.status
+      });
+      if (this.current === current) current.credential = credential;
+    } catch {
+    }
+  }
+};
+var registries = /* @__PURE__ */ new Map();
+var lastRegistryKey;
+function getProjectSessionRegistry(globalRoot) {
+  const key = globalRoot !== void 0 ? path.resolve(globalRoot) : lastRegistryKey;
+  if (!key)
+    throw new Error("SessionRegistry not initialized. Call getSessionRegistry(globalRoot) first.");
+  let registry = registries.get(key);
+  if (!registry) {
+    if (registries.size >= MAX_GLOBAL_ROOTS) {
+      const idle = [...registries.entries()].find(([, candidate]) => !candidate.ownsSession());
+      if (!idle)
+        throw new Error(`Session Registry global-root limit reached (${MAX_GLOBAL_ROOTS})`);
+      registries.delete(idle[0]);
+      void idle[1].dispose();
+    }
+    registry = new ProjectSessionRegistry(key);
+    registries.set(key, registry);
+  } else {
+    registries.delete(key);
+    registries.set(key, registry);
+  }
+  lastRegistryKey = key;
+  return registry;
+}
+function hasProjectSessionRegistry(globalRoot) {
+  if (globalRoot === void 0) return registries.size > 0;
+  return registries.has(path.resolve(globalRoot));
+}
+
+export {
+  ProjectSessionRegistry,
+  getProjectSessionRegistry,
+  hasProjectSessionRegistry
+};
+//# sourceMappingURL=chunk-YBUJCZ57.js.map