@saasontools/strauss-kb 0.1.4 → 0.1.5

package/dist/index.d.cts

@@ -318,8 +318,9 @@ type KbLoadResult = {
     /** Named only. Their bodies are reachable through `trace`. */
     superseded: KbSupersededStub[];
     recordCount: number;
-    approxTokens: number;
-    budgetTokens: number;
+    tokensLoaded: number;
+    /** `null` when loaded via `all`: no ceiling was applied. */
+    budgetTokens: number | null;
 } | {
     loaded: false;
     recordCount: number;
@@ -430,10 +431,15 @@ declare class KbStore {
      * Refuses rather than truncates when the base is too large. A truncated base
      * is indistinguishable from a complete one, so a caller would answer "that
      * was never decided" from a slice it did not know was a slice.
+     *
+     * That refusal is the default guardrail. `all` bypasses it outright and
+     * always hands back the whole bundle: an explicit, never-accidental escape
+     * hatch for an operator who has the budget to spend, not a wider default.
      */
     load(bundlePath: string, options?: {
         budgetTokens?: number;
         type?: string;
+        all?: boolean;
     }): Promise<KbLoadResult>;
     /** How a position was arrived at, as a timeline. See `trace.ts`. */
     trace(bundlePath: string, seedId: string, options?: KbTraceOptions): Promise<KbTraceStep[]>;

package/dist/index.d.ts

@@ -318,8 +318,9 @@ type KbLoadResult = {
     /** Named only. Their bodies are reachable through `trace`. */
     superseded: KbSupersededStub[];
     recordCount: number;
-    approxTokens: number;
-    budgetTokens: number;
+    tokensLoaded: number;
+    /** `null` when loaded via `all`: no ceiling was applied. */
+    budgetTokens: number | null;
 } | {
     loaded: false;
     recordCount: number;
@@ -430,10 +431,15 @@ declare class KbStore {
      * Refuses rather than truncates when the base is too large. A truncated base
      * is indistinguishable from a complete one, so a caller would answer "that
      * was never decided" from a slice it did not know was a slice.
+     *
+     * That refusal is the default guardrail. `all` bypasses it outright and
+     * always hands back the whole bundle: an explicit, never-accidental escape
+     * hatch for an operator who has the budget to spend, not a wider default.
      */
     load(bundlePath: string, options?: {
         budgetTokens?: number;
         type?: string;
+        all?: boolean;
     }): Promise<KbLoadResult>;
     /** How a position was arrived at, as a timeline. See `trace.ts`. */
     trace(bundlePath: string, seedId: string, options?: KbTraceOptions): Promise<KbTraceStep[]>;

package/dist/index.js

@@ -1,10 +1,10 @@
 import {
   runKbCli
-} from "./chunk-Y5C7Z2HG.js";
+} from "./chunk-KQMGKSPZ.js";
 import {
   createKbMcpServer,
   runKbMcpServer
-} from "./chunk-TS26G7TL.js";
+} from "./chunk-VOJ6D6OX.js";
 import {
   BaseError,
   CONTEXT_BEGIN,
@@ -80,7 +80,7 @@ import {
   trace,
   unpinBase,
   validateBundle
-} from "./chunk-EDH43Z7J.js";
+} from "./chunk-FZIMFPGR.js";
 
 // src/match-diff.ts
 function matchToDiff(files, records, options = {}) {

package/dist/mcp-main.cjs

@@ -1074,25 +1074,32 @@ var import_zod9 = require("zod");
 var loadCommand = define({
   name: "load",
   tool: "kb_load",
-  usage: "load [type] [--budget N]",
-  description: "Load the whole knowledge base at once, each record with its standing. Prefer this over searching: these bases run to a few thousand tokens, and a reader holding all of it has perfect recall and knows why it is asking, which no ranker does. Superseded records arrive under `superseded` as name, replacement and date only \u2014 their bodies no longer hold, and reading one later in a long session is the mistake this prevents; pass the id to kb_trace when you need the history. Rejected and unresolved records arrive whole: what was turned down, and what is still open, is the part a diff cannot show you. Refuses with a count rather than truncating when the base is too large \u2014 a truncated base is indistinguishable from a complete one, and would have you conclude something was never decided from a slice you did not know was a slice. Call at the point of use, not once per session: a base loaded early is summarised away by compaction, so if the visible context holds no records from this base and the question at hand is one it might govern, load before answering \u2014 never conclude nothing was decided from a context with no KB content in it. This tool (with kb_query and kb_trace) is the only supported way to read a base; a raw file read bypasses supersession resolution and returns replaced records as if current.",
+  usage: "load [type] [--budget N | --all]",
+  description: "Load the whole knowledge base at once, each record with its standing. Prefer this over searching: these bases run to a few thousand tokens, and a reader holding all of it has perfect recall and knows why it is asking, which no ranker does. Superseded records arrive under `superseded` as name, replacement and date only \u2014 their bodies no longer hold, and reading one later in a long session is the mistake this prevents; pass the id to kb_trace when you need the history. Rejected and unresolved records arrive whole: what was turned down, and what is still open, is the part a diff cannot show you. Refuses with a count rather than truncating when the base is too large \u2014 a truncated base is indistinguishable from a complete one, and would have you conclude something was never decided from a slice you did not know was a slice. Call at the point of use, not once per session: a base loaded early is summarised away by compaction, so if the visible context holds no records from this base and the question at hand is one it might govern, load before answering \u2014 never conclude nothing was decided from a context with no KB content in it. This tool (with kb_query and kb_trace) is the only supported way to read a base; a raw file read bypasses supersession resolution and returns replaced records as if current.\n\nThat refusal is the default guardrail, meant for an agent that would otherwise burn its whole context on one call. `all` bypasses it and loads everything regardless of size: a deliberate operator with the budget to spend, not something to reach for automatically. It is mutually exclusive with `budgetTokens`. When the reader does not need everything, kb_query or a narrower `type` filter is the better fit than either.",
   input: import_zod9.z.object({
     bundlePath,
     type: import_zod9.z.enum(KB_RECORD_TYPES).optional(),
-    budgetTokens: import_zod9.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000.")
+    budgetTokens: import_zod9.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000."),
+    all: import_zod9.z.boolean().optional().describe(
+      "Load the entire base regardless of size. The deliberate-operator escape hatch; mutually exclusive with budgetTokens."
+    )
+  }).refine((value) => !(value.all && value.budgetTokens !== void 0), {
+    message: "all and budgetTokens are mutually exclusive: pass a ceiling or none, not both."
   }),
   fromArgv: (argv, path) => {
     const budget = argvFlag(argv, "--budget");
     return {
       bundlePath: path,
-      ...argv[1] && argv[1] !== "--budget" ? { type: argv[1] } : {},
-      ...budget ? { budgetTokens: Number(budget) } : {}
+      ...argv[1] && !argv[1].startsWith("--") ? { type: argv[1] } : {},
+      ...budget ? { budgetTokens: Number(budget) } : {},
+      ...argv.includes("--all") ? { all: true } : {}
     };
   },
-  run: async ({ store }, { bundlePath: path, type, budgetTokens }) => {
+  run: async ({ store }, { bundlePath: path, type, budgetTokens, all }) => {
     const result = await store.load(path, {
       ...type ? { type } : {},
-      ...budgetTokens ? { budgetTokens } : {}
+      ...budgetTokens ? { budgetTokens } : {},
+      ...all ? { all } : {}
     });
     if (!result.loaded) return result;
     return {
@@ -2088,6 +2095,10 @@ ${answer}
    * Refuses rather than truncates when the base is too large. A truncated base
    * is indistinguishable from a complete one, so a caller would answer "that
    * was never decided" from a slice it did not know was a slice.
+   *
+   * That refusal is the default guardrail. `all` bypasses it outright and
+   * always hands back the whole bundle: an explicit, never-accidental escape
+   * hatch for an operator who has the budget to spend, not a wider default.
    */
   async load(bundlePath2, options = {}) {
     const budgetTokens = options.budgetTokens ?? DEFAULT_LOAD_BUDGET;
@@ -2097,7 +2108,7 @@ ${answer}
     const records = adjudicated.filter((hit) => hit.standing !== "superseded");
     const superseded = adjudicated.filter((hit) => hit.standing === "superseded").map(stub);
     const approxTokens2 = records.reduce((total, hit) => total + estimateTokens(hit.record), 0) + superseded.reduce((total, entry) => total + estimateStubTokens(entry), 0);
-    if (approxTokens2 > budgetTokens) {
+    if (!options.all && approxTokens2 > budgetTokens) {
       return {
         loaded: false,
         recordCount: wanted.length,
@@ -2108,8 +2119,8 @@ ${answer}
     return {
       loaded: true,
       recordCount: wanted.length,
-      approxTokens: approxTokens2,
-      budgetTokens,
+      tokensLoaded: approxTokens2,
+      budgetTokens: options.all ? null : budgetTokens,
       records,
       superseded
     };