@wrongstack/core 0.313.0 → 0.316.1

package/dist/registry/tool-registry.d.ts

@@ -1,4 +1,5 @@
-import type { ToolDescriptionMode, ToolDescriptionModeConfig } from '../types/config.js';
+import type { EventBus } from '../kernel/events.js';
+import type { DisabledToolMeta, ToolDescriptionMode, ToolDescriptionModeConfig } from '../types/config.js';
 import type { Tool } from '../types/tool.js';
 /**
  * A function that wraps (decorates) an existing tool. Receives the
@@ -26,11 +27,20 @@ export declare class ToolRegistry {
     private readonly tools;
     private readonly descriptionModes;
     /**
-     * Set of tool names that are disabled (hidden from list(), get() and all
-     * other public accessors). The underlying tool data stays in `_tools` so
-     * re-enable is a constant-time operation.
+     * Disabled tool names plus the audit-trail metadata explaining WHY each
+     * one was disabled. `user` is the historical default (manual
+     * `/tool disable`); `auto-thinned` is the new path the auto-thinning
+     * pipeline writes so `/tool autothin undo` can restore the right subset.
+     * The underlying tool data stays in `_tools` so re-enable is constant-time.
      */
     private readonly _disabled;
+    /**
+     * Optional EventBus used by `thinUnderused()` to emit `tool.thinned`.
+     * Set via `setEventBus()` at boot — optional so the registry stays
+     * usable in pure unit tests and in code paths that never run the
+     * auto-thinning pipeline.
+     */
+    private _events;
     /** Monotonic version bumped on every registry mutation. */
     private _version;
     /** Cached `list()` result, frozen after build. Invalidated on _version change. */
@@ -99,16 +109,26 @@ export declare class ToolRegistry {
     };
     get(name: string): Tool | undefined;
     ownerOf(name: string): string | undefined;
+    /** Attach the EventBus so `thinUnderused()` can emit `tool.thinned`.
+     *  Idempotent; safe to call multiple times at boot. */
+    setEventBus(events: EventBus | undefined): void;
     /**
      * Disable a tool by name. The tool is removed from all public accessors
      * (list(), get(), listByCategory(), listWithOwner()) so it does NOT
      * appear in the system prompt or provider request. The underlying
      * registration is preserved in memory — use `enable()` to restore it.
      *
+     * `reason` defaults to `'user'` for backward compatibility — every
+     * historical caller (CLI `/tool disable`, WebUI, subagent filter)
+     * writes a user-authored disable. The auto-thinning pipeline always
+     * passes `'auto-thinned'`.
+     *
      * @returns `true` if the tool was found and disabled; `false` if the
      *          tool is not registered or is already disabled.
      */
-    disable(name: string): boolean;
+    disable(name: string, reason?: 'user' | 'auto-thinned', meta?: {
+        caller?: string;
+    }): boolean;
     /**
      * Re-enable a previously disabled tool. The tool reappears in all
      * public accessors and will be included in the next system prompt /
@@ -123,24 +143,54 @@ export declare class ToolRegistry {
      * of tools that were re-enabled.
      */
     enableAll(): number;
+    /**
+     * Re-enable only the tools that were disabled by the auto-thinning
+     * pipeline (`reason === 'auto-thinned'` in `disabledToolMeta`). Manual
+     * user disables are preserved. Returns the names that were re-enabled.
+     */
+    enableAutoThinned(): string[];
     /**
      * Check whether a tool is currently disabled.
      */
     isDisabled(name: string): boolean;
+    /** Return the audit-trail metadata for a disabled tool, if any. */
+    disabledMeta(name: string): DisabledToolMeta | undefined;
     /**
      * Apply a list of tool names to disable. Tools not in the registry
      * are silently ignored so config can reference future tools without
-     * error. Returns the number of tools actually disabled.
+     * error. Returns the number of tools actually disabled. Always
+     * tagged `reason: 'user'` — the auto-thinning pipeline uses
+     * `thinUnderused()` instead.
      */
     applyDisabled(names: readonly string[]): number;
     /**
-     * Return the list of all disabled tool entries (tool + owner). Useful
-     * for the /tools slash command to show disabled tools alongside
-     * enabled ones.
+     * Apply the audit-trail metadata for a previously-disabled tool.
+     * Used at boot to restore `disabledToolMeta` (so the auto-thinned
+     * decision survives a restart). Does NOT mutate the disabled set
+     * itself — pair with `applyDisabled()` on the same names.
+     */
+    applyDisabledMeta(meta: Readonly<Record<string, DisabledToolMeta>>): number;
+    /**
+     * Disable every name in `candidates` that is currently registered and
+     * not already disabled, tagged with `reason: 'auto-thinned'`. Emits
+     * a `tool.thinned` event with the names that actually flipped.
+     *
+     * @returns `{ thinned, skipped }` so the caller can persist the
+     *  decision to `disabledToolMeta` and report what was changed.
+     */
+    thinUnderused(candidates: readonly string[], caller: string): {
+        thinned: string[];
+        skipped: string[];
+    };
+    /**
+     * Return the list of all disabled tool entries (tool + owner + reason).
+     * Useful for the /tools slash command to show disabled tools alongside
+     * enabled ones, and for `/tool autothin status` to count the auto-thinned subset.
      */
     listDisabled(): {
         tool: Tool;
         owner: string;
+        meta: DisabledToolMeta;
     }[];
     list(): Tool[];
     /** Replace the direct provider surface. Pass `undefined` to expose the catalog. */

package/dist/registry-7N4O3E7W.js

@@ -0,0 +1,14 @@
+import {
+  ProjectSessionRegistry,
+  getProjectSessionRegistry,
+  hasProjectSessionRegistry
+} from "./chunk-4I7HGVVA.js";
+import "./chunk-F3JWNST7.js";
+import "./chunk-AYW5YINX.js";
+import "./chunk-POOOIWE5.js";
+export {
+  ProjectSessionRegistry,
+  getProjectSessionRegistry,
+  hasProjectSessionRegistry
+};
+//# sourceMappingURL=registry-7N4O3E7W.js.map

package/dist/replay/index.js

@@ -1,87 +1,9 @@
-// src/replay/hash.ts
-import { createHash } from "node:crypto";
-function stableStringify(value) {
-  return JSON.stringify(sortKeys(value));
-}
-function sortKeys(value) {
-  if (Array.isArray(value)) return value.map(sortKeys);
-  if (value && typeof value === "object") {
-    const obj = value;
-    const sorted = {};
-    for (const key of Object.keys(obj).sort()) {
-      sorted[key] = sortKeys(obj[key]);
-    }
-    return sorted;
-  }
-  return value;
-}
-function semanticMessage(message) {
-  const { ts: _ts, _estTokens: _estimate, origin: _origin, ...semantic } = message;
-  return semantic;
-}
-function hashRequest(request) {
-  const payload = {
-    model: request.model,
-    system: request.system,
-    messages: request.messages.map(semanticMessage),
-    tools: request.tools,
-    maxTokens: request.maxTokens,
-    temperature: request.temperature,
-    topP: request.topP,
-    stopSequences: request.stopSequences,
-    toolChoice: request.toolChoice
-  };
-  const json = stableStringify(payload);
-  const digest = createHash("sha256").update(json, "utf8").digest("hex");
-  return `sha256:${digest}`;
-}
-
-// src/replay/replay-provider-runner.ts
-var ReplayProviderRunner = class {
-  constructor(inner, opts) {
-    this.inner = inner;
-    this.opts = opts;
-  }
-  inner;
-  opts;
-  /** Resolve the target session for this call. See {@link ReplayProviderRunnerOptions.sessionId}. */
-  resolveSessionId() {
-    const { sessionId } = this.opts;
-    return typeof sessionId === "function" ? sessionId() : sessionId;
-  }
-  async run(runOpts) {
-    const hash = hashRequest(runOpts.request);
-    const sessionId = this.resolveSessionId();
-    const cached = await this.opts.log.lookup(sessionId, hash);
-    if (this.opts.mode === "replay") {
-      if (!cached) {
-        this.opts.logger?.warn?.(
-          `replay: no recorded response for hash ${hash} (model ${runOpts.request.model})`
-        );
-        throw new Error(
-          `ReplayProviderRunner: no recorded response for hash ${hash} in session ${sessionId}. Either the request changed since recording, or this session has no replay log.`
-        );
-      }
-      this.opts.logger?.debug?.(
-        `replay: served cached response for hash ${hash} (recorded ${cached.ts})`
-      );
-      return cached.response;
-    }
-    if (this.opts.mode === "auto" && cached) {
-      this.opts.logger?.debug?.(
-        `replay: auto-hit hash ${hash}, served cached response`
-      );
-      return cached.response;
-    }
-    const response = await this.inner.run(runOpts);
-    await this.opts.log.record({
-      sessionId,
-      request: runOpts.request,
-      response
-    });
-    return response;
-  }
-};
+import {
+  ReplayProviderRunner
+} from "../chunk-BJHVULHO.js";
+import {
+  hashRequest
+} from "../chunk-SWUFN7XM.js";
 export {
   ReplayProviderRunner,
   hashRequest

package/dist/security/capabilities.d.ts

@@ -45,6 +45,12 @@ export declare const ToolCapabilities: {
     readonly NET_OUTBOUND: 'net.outbound';
     /** Can mutate in-memory session todos only. */
     readonly SESSION_TODO: 'session.todo';
+    /**
+     * Can post an ephemeral same-session note to the leader or a peer
+     * (`session_note` / `session.note`). In-process only — not the durable
+     * cross-session mailbox (`coordination.mail`).
+     */
+    readonly SESSION_NOTE: 'session.note';
     /** Can park after-task `<nextsteps>` suggestions for the current turn. */
     readonly SESSION_NEXTSTEPS: 'session.nextsteps';
     /** Can mutate in-memory session mode only. */

package/dist/security/file-permissions.d.ts

@@ -14,5 +14,5 @@
  *
  * @module security/file-permissions
  */
-export { restrictDirPermissions, restrictFilePermissions, SECRET_DIR_MODE, SECRET_FILE_MODE, type RestrictPermissionsOptions, } from '@wrongstack/persistence';
+export { restrictDirPermissions, restrictFilePermissions, SECRET_DIR_MODE, SECRET_FILE_MODE } from '@wrongstack/persistence';
 //# sourceMappingURL=file-permissions.d.ts.map