@wrongstack/core 0.313.1 → 0.316.2

package/dist/{chunk-KI4L2DUL.js → chunk-TCCHINEF.js}

@@ -4,11 +4,11 @@ import {
 } from "./chunk-WQTOVMGV.js";
 import {
   estimateToolDefTokens
-} from "./chunk-FSWCWSTS.js";
+} from "./chunk-HMLIGAU7.js";
 import {
   ERROR_CODES,
   WrongStackError
-} from "./chunk-WOEZV3Q4.js";
+} from "./chunk-25LSLC3G.js";
 import {
   toErrorMessage
 } from "./chunk-TBRL2RCC.js";
@@ -198,11 +198,20 @@ var ToolRegistry = class _ToolRegistry {
   tools = /* @__PURE__ */ new Map();
   descriptionModes = /* @__PURE__ */ new Map();
   /**
-   * 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.
    */
-  _disabled = /* @__PURE__ */ new Set();
+  _disabled = /* @__PURE__ */ new Map();
+  /**
+   * 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.
+   */
+  _events;
   /** Monotonic version bumped on every registry mutation. */
   _version = 0;
   /** Cached `list()` result, frozen after build. Invalidated on _version change. */
@@ -388,18 +397,32 @@ var ToolRegistry = class _ToolRegistry {
     return this.tools.get(name)?.owner;
   }
   // ── Disable / enable ────────────────────────────────────────────
+  /** Attach the EventBus so `thinUnderused()` can emit `tool.thinned`.
+   *  Idempotent; safe to call multiple times at boot. */
+  setEventBus(events) {
+    this._events = events;
+  }
   /**
    * 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) {
+  disable(name, reason = "user", meta) {
     if (!this.tools.has(name) || this._disabled.has(name)) return false;
-    this._disabled.add(name);
+    this._disabled.set(name, {
+      reason,
+      at: Date.now(),
+      ...meta?.caller ? { caller: meta.caller } : {}
+    });
     this._version++;
     return true;
   }
@@ -428,34 +451,106 @@ var ToolRegistry = class _ToolRegistry {
     this._version++;
     return count;
   }
+  /**
+   * 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() {
+    const restored = [];
+    for (const [name, meta] of this._disabled) {
+      if (meta.reason === "auto-thinned") {
+        this._disabled.delete(name);
+        restored.push(name);
+      }
+    }
+    if (restored.length > 0) this._version++;
+    return restored;
+  }
   /**
    * Check whether a tool is currently disabled.
    */
   isDisabled(name) {
     return this._disabled.has(name);
   }
+  /** Return the audit-trail metadata for a disabled tool, if any. */
+  disabledMeta(name) {
+    return this._disabled.get(name);
+  }
   /**
    * 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) {
     let count = 0;
     for (const name of names) {
-      if (this.disable(name)) count++;
+      if (this.disable(name, "user")) count++;
     }
     return count;
   }
   /**
-   * 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) {
+    let count = 0;
+    const at = Date.now();
+    for (const [name, entry] of Object.entries(meta)) {
+      if (!this._disabled.has(name)) continue;
+      this._disabled.set(name, { ...entry, at: entry.at ?? at });
+      count++;
+    }
+    if (count > 0) this._version++;
+    return count;
+  }
+  /**
+   * 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, caller) {
+    const thinned = [];
+    const skipped = [];
+    const at = Date.now();
+    for (const name of candidates) {
+      if (!this.tools.has(name)) {
+        skipped.push(name);
+        continue;
+      }
+      if (this._disabled.has(name)) {
+        skipped.push(name);
+        continue;
+      }
+      this._disabled.set(name, { reason: "auto-thinned", at, caller });
+      thinned.push(name);
+    }
+    if (thinned.length > 0) {
+      this._version++;
+      this._events?.emit("tool.thinned", { names: thinned, reason: caller, at });
+    }
+    return { thinned, skipped };
+  }
+  /**
+   * 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() {
-    return Array.from(this._disabled).map((name) => {
+    const out = [];
+    for (const [name, meta] of this._disabled) {
       const entry = this.tools.get(name);
-      return entry ? { tool: entry.tool, owner: entry.owner } : null;
-    }).filter((e) => e !== null);
+      if (!entry) continue;
+      out.push({ tool: entry.tool, owner: entry.owner, meta });
+    }
+    return out;
   }
   list() {
     if (this._listSnapshot && this._version === this._listSnapshotVersion) {
@@ -543,8 +638,8 @@ var ToolRegistry = class _ToolRegistry {
     for (const [name, { tool, owner }] of this.tools) {
       copy.tools.set(name, { tool, owner });
     }
-    for (const name of this._disabled) {
-      copy._disabled.add(name);
+    for (const [name, meta] of this._disabled) {
+      copy._disabled.set(name, { ...meta });
     }
     copy._providerToolNames = this._providerToolNames ? new Set(this._providerToolNames) : void 0;
     copy._version = this._version;
@@ -557,4 +652,4 @@ export {
   SlashCommandRegistry,
   ToolRegistry
 };
-//# sourceMappingURL=chunk-KI4L2DUL.js.map
+//# sourceMappingURL=chunk-TCCHINEF.js.map

package/dist/{chunk-AWNQ6ED6.js → chunk-THEGTRAG.js}

@@ -91,7 +91,12 @@ var RUNTIME_CAPABILITY_MANIFEST = [
     id: "coordination.mailbox",
     pack: "fleet",
     exposure: "direct",
-    tools: ["mailbox", "mail_send", "mail_inbox", "fleet_status"]
+    // `session_note` sits beside mailbox rather than in its own capability:
+    // both are "one agent speaks to another". The split that matters is
+    // durability — mailbox persists and crosses sessions, a note is
+    // in-process and dies with the session — and that is a property of the
+    // tool, not of who is allowed to talk.
+    tools: ["mailbox", "mail_send", "mail_inbox", "fleet_status", "session_note"]
   },
   {
     id: "fleet.delegate",
@@ -308,4 +313,4 @@ export {
   runtimeToolReferencesFromText,
   isDeprecatedRuntimeToolAlias
 };
-//# sourceMappingURL=chunk-AWNQ6ED6.js.map
+//# sourceMappingURL=chunk-THEGTRAG.js.map

package/dist/{chunk-2KKODIQU.js → chunk-TR4LQE7L.js}

@@ -1,33 +1,33 @@
+import {
+  sessionScopedPath
+} from "./chunk-5BMIE7QG.js";
 import {
   resolveHqRedactionPolicy,
   scrubAndTruncateHqPreview,
   summarizeHqToolArgs
-} from "./chunk-ZYU2YOJ6.js";
+} from "./chunk-NIOAGFPB.js";
 import {
   HQ_TRANSCRIPT_TEXT_CAP,
   isHqKanbanSnapshotPayload
 } from "./chunk-Z2IJUO45.js";
 import {
   SECRET_FILE_MODE
-} from "./chunk-H5E77KUJ.js";
-import {
-  effectiveInputTokens
-} from "./chunk-NFAYHPRH.js";
-import {
-  CHAT_MARKER_SOURCES,
-  sessionEventToMarker
-} from "./chunk-KSJ5UTP7.js";
-import {
-  sessionScopedPath
-} from "./chunk-AD7ZFZCS.js";
+} from "./chunk-6FHWXLPT.js";
 import {
   atomicReplaceWithWriter,
   atomicWrite,
   withFileLock
-} from "./chunk-7ZHZE5EO.js";
+} from "./chunk-OSGLYW5J.js";
 import {
   resolveWstackPaths
-} from "./chunk-YNCVSFGF.js";
+} from "./chunk-SAFHACFA.js";
+import {
+  effectiveInputTokens
+} from "./chunk-3ECENVHL.js";
+import {
+  CHAT_MARKER_SOURCES,
+  sessionEventToMarker
+} from "./chunk-ULMAQV3T.js";
 
 // src/hq/session-bridge.ts
 import * as fs from "node:fs";
@@ -2253,4 +2253,4 @@ export {
   isOpenMode,
   assessHqExposure
 };
-//# sourceMappingURL=chunk-2KKODIQU.js.map
+//# sourceMappingURL=chunk-TR4LQE7L.js.map

package/dist/{chunk-GPQ3NJPR.js → chunk-TWJMGXCI.js}

@@ -1,9 +1,9 @@
 import {
   assertNotPrivateHost
-} from "./chunk-GFJOMSHG.js";
+} from "./chunk-LA7CLDRW.js";
 import {
   buildChildEnv
-} from "./chunk-VB3H5WWB.js";
+} from "./chunk-6NWEVFEL.js";
 import {
   toErrorMessage
 } from "./chunk-TBRL2RCC.js";
@@ -897,4 +897,4 @@ export {
   shellHooksEqual,
   countShellHooks
 };
-//# sourceMappingURL=chunk-GPQ3NJPR.js.map
+//# sourceMappingURL=chunk-TWJMGXCI.js.map

package/dist/{chunk-H72H4XDU.js → chunk-U45AXT5D.js}

@@ -1,10 +1,10 @@
 import {
   deactivateProxyOnConnectionFailure,
   waitForProxyRoutingSettle
-} from "./chunk-4ZHTKJHM.js";
+} from "./chunk-4SJNS7OB.js";
 import {
   scrubErrorText
-} from "./chunk-PAAWLLZX.js";
+} from "./chunk-Y5YXDM7D.js";
 import {
   runWithNetworkTelemetry
 } from "./chunk-HA4ZYA6T.js";
@@ -16,22 +16,22 @@ import {
 import {
   createChroniclePromptManifest
 } from "./chunk-2YU4WVBW.js";
-import {
-  ProviderError,
-  isFallbackWorthy
-} from "./chunk-NFAYHPRH.js";
 import {
   bindRequestProvider,
   completePartialObject,
   resolveEventSessionId
-} from "./chunk-EFEHDQGY.js";
+} from "./chunk-ZHZ2Y2DH.js";
+import {
+  ProviderError,
+  isFallbackWorthy
+} from "./chunk-3ECENVHL.js";
 import {
   isTextBlock,
   isToolUseBlock
 } from "./chunk-O37BQ65S.js";
 import {
   toWrongStackError
-} from "./chunk-WOEZV3Q4.js";
+} from "./chunk-25LSLC3G.js";
 
 // src/core/streaming-response-builder.ts
 import { randomUUID } from "node:crypto";
@@ -1020,4 +1020,4 @@ export {
   runtimeFallbackChain,
   createFallbackModelExtension
 };
-//# sourceMappingURL=chunk-H72H4XDU.js.map
+//# sourceMappingURL=chunk-U45AXT5D.js.map

package/dist/{chunk-62V2AFVG.js → chunk-U4FWBSO3.js}

@@ -1,10 +1,13 @@
+import {
+  CHRONICLE_MAX_APPEND_BATCH
+} from "./chunk-4BMVPOHO.js";
 import {
   mapWithConcurrency
 } from "./chunk-SZ6AYUIZ.js";
 import {
   DEFAULT_WALK_IGNORE_DIRS,
   watchProjectTree
-} from "./chunk-TYW2GI5I.js";
+} from "./chunk-J2WRWR37.js";
 
 // src/chronicle/context.ts
 import { randomUUID } from "node:crypto";
@@ -40,6 +43,7 @@ var DEFAULT_EXCLUDED = [
 var SCAN_HASH_CONCURRENCY = 32;
 var DEFAULT_FULL_RESCAN_MIN_INTERVAL_MS = 3e4;
 var MAX_RECENT_TOOL_MUTATIONS = 500;
+var JOURNAL_FLUSH_CHUNK = CHRONICLE_MAX_APPEND_BATCH;
 async function startChronicleFileObserver(options) {
   const root = path.resolve(options.projectRoot);
   const excluded = new Set(options.excludedDirectories ?? DEFAULT_EXCLUDED);
@@ -81,6 +85,7 @@ async function startChronicleFileObserver(options) {
   let timer;
   let closed = false;
   let flushTail = null;
+  let drainFailure;
   const minFullRescanIntervalMs = options.minFullRescanIntervalMs ?? DEFAULT_FULL_RESCAN_MIN_INTERVAL_MS;
   let lastFullScanAt = Date.now();
   let fullRescanTimer;
@@ -137,86 +142,125 @@ async function startChronicleFileObserver(options) {
     const deleted = changes.filter((change) => change.before && !change.after);
     const created = changes.filter((change) => !change.before && change.after);
     const consumed = /* @__PURE__ */ new Set();
-    const journalWrites = [];
-    for (const from of deleted) {
-      const match = created.find(
-        (to) => !consumed.has(to.relative) && from.before?.hash !== void 0 && from.before.hash === to.after?.hash
+    const pendingEvents = [];
+    const pushPending = (eventType, relativePath, state, attributes, stateWrites) => {
+      const attribution = peekAttribution(relativePath, recentToolMutations);
+      const { input, emitActivity } = buildMutation(
+        options,
+        eventType,
+        relativePath,
+        state,
+        attributes,
+        attribution
       );
+      pendingEvents.push({
+        input,
+        state: stateWrites,
+        emitActivity,
+        attribution,
+        attributionKey: attribution ? relativePath : void 0
+      });
+    };
+    const createdByHash = /* @__PURE__ */ new Map();
+    for (const to of created) {
+      const hash = to.after?.hash;
+      if (hash === void 0) continue;
+      const bucket = createdByHash.get(hash);
+      if (bucket) bucket.entries.push(to);
+      else createdByHash.set(hash, { entries: [to], cursor: 0 });
+    }
+    const claimCreated = (hash) => {
+      const bucket = createdByHash.get(hash);
+      if (!bucket) return void 0;
+      return bucket.cursor < bucket.entries.length ? bucket.entries[bucket.cursor++] : void 0;
+    };
+    for (const from of deleted) {
+      const fromHash = from.before?.hash;
+      if (fromHash === void 0) continue;
+      const match = claimCreated(fromHash);
       if (!match) continue;
       consumed.add(from.relative);
       consumed.add(match.relative);
-      known.delete(from.relative);
-      known.set(match.relative, match.after);
-      journalWrites.push(
-        recordMutation(
-          options,
-          "file.external.renamed",
-          match.relative,
-          match.after,
-          {
-            operation: "rename",
-            previousPath: from.relative,
-            previousResourceId: resourceId(from.relative),
-            actor: "external"
-          },
-          mutationAttribution(match.relative, recentToolMutations)
-        )
+      pushPending(
+        "file.external.renamed",
+        match.relative,
+        match.after,
+        {
+          operation: "rename",
+          previousPath: from.relative,
+          previousResourceId: resourceId(from.relative),
+          actor: "external"
+        },
+        [
+          [from.relative, void 0],
+          [match.relative, match.after]
+        ]
       );
     }
     for (const change of changes) {
       if (consumed.has(change.relative)) continue;
       if (!change.after) {
-        known.delete(change.relative);
-        journalWrites.push(
-          recordMutation(
-            options,
-            "file.external.deleted",
-            change.relative,
-            change.before,
-            {
-              operation: "delete",
-              actor: "external",
-              previousHash: change.before?.hash,
-              previousSize: change.before?.size
-            },
-            mutationAttribution(change.relative, recentToolMutations)
-          )
+        pushPending(
+          "file.external.deleted",
+          change.relative,
+          change.before,
+          {
+            operation: "delete",
+            actor: "external",
+            previousHash: change.before?.hash,
+            previousSize: change.before?.size
+          },
+          [[change.relative, void 0]]
         );
       } else if (!change.before) {
-        known.set(change.relative, change.after);
-        journalWrites.push(
-          recordMutation(
-            options,
-            "file.external.created",
-            change.relative,
-            change.after,
-            {
-              operation: "write",
-              actor: "external"
-            },
-            mutationAttribution(change.relative, recentToolMutations)
-          )
+        pushPending(
+          "file.external.created",
+          change.relative,
+          change.after,
+          {
+            operation: "write",
+            actor: "external"
+          },
+          [[change.relative, change.after]]
         );
       } else {
-        known.set(change.relative, change.after);
-        journalWrites.push(
-          recordMutation(
-            options,
-            "file.external.modified",
-            change.relative,
-            change.after,
-            {
-              operation: "edit",
-              actor: "external",
-              previousHash: change.before.hash,
-              previousSize: change.before.size
-            },
-            mutationAttribution(change.relative, recentToolMutations)
-          )
+        pushPending(
+          "file.external.modified",
+          change.relative,
+          change.after,
+          {
+            operation: "edit",
+            actor: "external",
+            previousHash: change.before.hash,
+            previousSize: change.before.size
+          },
+          [[change.relative, change.after]]
         );
       }
     }
-    await Promise.all(journalWrites);
+    try {
+      await flushJournalInputs(options, pendingEvents, (committed) => {
+        for (const event of committed) {
+          for (const [relative2, after] of event.state) {
+            if (after) known.set(relative2, after);
+            else known.delete(relative2);
+          }
+          if (event.attributionKey && recentToolMutations.get(event.attributionKey) === event.attribution) {
+            recentToolMutations.delete(event.attributionKey);
+          }
+          event.emitActivity?.();
+        }
+      });
+    } catch (error) {
+      for (const event of pendingEvents) {
+        if (!event.attribution || !event.attributionKey) continue;
+        const held = recentToolMutations.get(event.attributionKey);
+        if (held !== event.attribution) continue;
+        recentToolMutations.set(event.attributionKey, { ...event.attribution, at: Date.now() });
+      }
+      requestFullRescan();
+      throw error;
+    }
   };
   const drainPending = () => {
     if (flushTail) return flushTail;
@@ -224,7 +268,12 @@ async function startChronicleFileObserver(options) {
       while (pending.size > 0) {
         const paths = [...pending];
         pending.clear();
-        await reconcile(paths).catch((error) => options.onError?.(error));
+        try {
+          await reconcile(paths);
+        } catch (error) {
+          drainFailure = error;
+          options.onError?.(error);
+        }
       }
     })().finally(() => {
       if (flushTail === drain) flushTail = null;
@@ -247,9 +296,22 @@ async function startChronicleFileObserver(options) {
       return known.size;
     },
     noteToolMutation,
+    /**
+     * Shut down the observer. If the final drain (an in-flight drain plus
+     * anything still pending at close time) fails, close() REJECTS with
+     * that error — a failed shutdown flush is surfaced, not silently
+     * dropped. The failure is still not retried after close returns:
+     * `requestFullRescan()` no-ops once `closed` is set, and `known` is
+     * in-memory state that dies here, so uncommitted changes are not
+     * re-derived by a future boot (the startup scan builds fresh
+     * fingerprints without diffing against this process's history). The
+     * journal remains authoritative for everything that did commit. A
+     * second close() call is a no-op and does not re-throw.
+     */
     async close() {
       if (closed) return;
       closed = true;
+      drainFailure = void 0;
       offToolProgress?.();
       watcher.close();
       if (timer) {
@@ -259,17 +321,20 @@ async function startChronicleFileObserver(options) {
       if (fullRescanTimer) {
         clearTimeout(fullRescanTimer);
         fullRescanTimer = void 0;
+        pending.add("*");
       }
       if (pending.size > 0) drainPending();
       await flushTail;
       recentToolMutations.clear();
+      if (drainFailure !== void 0) throw drainFailure;
     }
   };
 }
-async function recordMutation(options, eventType, relativePath, state, attributes, attribution) {
+function buildMutation(options, eventType, relativePath, state, attributes, attribution) {
   const context = typeof options.context === "function" ? options.context() : options.context;
   const operation = attributes["operation"];
-  options.events?.emit("file.activity", {
+  const bus = options.events;
+  const activity = {
     filePath: path.join(options.projectRoot, relativePath),
     operation,
     phase: "changed",
@@ -279,7 +344,10 @@ async function recordMutation(options, eventType, relativePath, state, attribute
     traceId: context.correlation.traceId,
     agentId: attribution?.agentId ?? context.scope.agentId,
     ...attribution ? { toolUseId: attribution.toolUseId, toolName: attribution.toolName } : {}
-  });
+  };
+  const emitActivity = bus ? () => {
+    bus.emit("file.activity", activity);
+  } : void 0;
   const input = {
     eventType: attribution ? eventType.replace(".external.", ".tool.") : eventType,
     scope: {
@@ -308,12 +376,31 @@ async function recordMutation(options, eventType, relativePath, state, attribute
       observedBy: "fs.watch"
     }
   };
-  await options.journal.append(input);
+  return { input, emitActivity };
+}
+async function flushJournalInputs(options, events, onCommitted) {
+  if (events.length === 0) return;
+  const batch = options.journal.appendBatch?.bind(options.journal);
+  if (!batch) {
+    const settled = await Promise.allSettled(
+      events.map(async (event) => {
+        await options.journal.append(event.input);
+        onCommitted([event]);
+      })
+    );
+    const failure = settled.find((result) => result.status === "rejected");
+    if (failure) throw failure.reason;
+    return;
+  }
+  for (let index = 0; index < events.length; index += JOURNAL_FLUSH_CHUNK) {
+    const chunk = events.slice(index, index + JOURNAL_FLUSH_CHUNK);
+    await batch(chunk.map((event) => event.input));
+    onCommitted(chunk);
+  }
 }
-function mutationAttribution(relativePath, recent) {
+function peekAttribution(relativePath, recent) {
   const value = recent.get(relativePath);
   if (!value) return void 0;
-  recent.delete(relativePath);
   return Date.now() - value.at <= 2e3 ? value : void 0;
 }
 async function scanProject(root, excluded, excludedPaths, maxHashBytes, onError, previous) {
@@ -419,4 +506,4 @@ export {
   childChronicleContext,
   startChronicleFileObserver
 };
-//# sourceMappingURL=chunk-62V2AFVG.js.map
+//# sourceMappingURL=chunk-U4FWBSO3.js.map