@vpxa/kb 0.1.1 → 0.1.2

package/packages/server/dist/tools/forge.tools.js

@@ -1,501 +1,13 @@
-import { digest, evidenceMap, forgeClassify, forgeGround, stratumCard } from "@kb/tools";
-import { z } from "zod";
-function registerEvidenceMapTool(server) {
-  server.registerTool(
-    "evidence_map",
-    {
-      description: "FORGE Evidence Map \u2014 track critical-path claims as Verified/Assumed/Unresolved with receipts. Supports CRUD operations and deterministic Gate evaluation (YIELD/HOLD/HARD_BLOCK/FORCED_DELIVERY). Persists across tool calls.",
-      inputSchema: {
-        action: z.enum(["create", "add", "update", "get", "gate", "list", "delete"]).describe("Operation to perform"),
-        task_id: z.string().optional().describe("Task identifier (required for all except list)"),
-        tier: z.enum(["floor", "standard", "critical"]).optional().describe("FORGE tier (required for create)"),
-        claim: z.string().optional().describe("Critical-path claim text (for add)"),
-        status: z.enum(["V", "A", "U"]).optional().describe("Evidence status: V=Verified, A=Assumed, U=Unresolved"),
-        receipt: z.string().optional().describe("Evidence receipt: tool\u2192ref for V, reasoning for A, attempts for U"),
-        id: z.number().optional().describe("Entry ID (for update)"),
-        critical_path: z.boolean().default(true).describe("Whether this claim is on the critical path"),
-        unknown_type: z.enum(["contract", "convention", "freshness", "runtime", "data-flow", "impact"]).optional().describe("Typed unknown classification"),
-        retry_count: z.number().default(0).describe("Retry count for gate evaluation (0 = first attempt)"),
-        cwd: z.string().optional().describe(
-          "Working directory for evidence map storage (default: server cwd). Use root_path from forge_ground to match."
-        )
-      }
-    },
-    async ({
-      action,
-      task_id,
-      tier,
-      claim,
-      status,
-      receipt,
-      id,
-      critical_path,
-      unknown_type,
-      retry_count,
-      cwd
-    }) => {
-      try {
-        switch (action) {
-          case "create": {
-            if (!task_id) throw new Error("task_id required for create");
-            if (!tier) throw new Error("tier required for create");
-            evidenceMap({ action: "create", taskId: task_id, tier }, cwd);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Created evidence map "${task_id}" (tier: ${tier}).
+import{digest as y,evidenceMap as g,forgeClassify as x,forgeGround as b,stratumCard as v}from"@kb/tools";import{z as t}from"zod";function T(m){m.registerTool("evidence_map",{description:"FORGE Evidence Map \u2014 track critical-path claims as Verified/Assumed/Unresolved with receipts. Supports CRUD operations and deterministic Gate evaluation (YIELD/HOLD/HARD_BLOCK/FORCED_DELIVERY). Persists across tool calls.",inputSchema:{action:t.enum(["create","add","update","get","gate","list","delete"]).describe("Operation to perform"),task_id:t.string().optional().describe("Task identifier (required for all except list)"),tier:t.enum(["floor","standard","critical"]).optional().describe("FORGE tier (required for create)"),claim:t.string().optional().describe("Critical-path claim text (for add)"),status:t.enum(["V","A","U"]).optional().describe("Evidence status: V=Verified, A=Assumed, U=Unresolved"),receipt:t.string().optional().describe("Evidence receipt: tool\u2192ref for V, reasoning for A, attempts for U"),id:t.number().optional().describe("Entry ID (for update)"),critical_path:t.boolean().default(!0).describe("Whether this claim is on the critical path"),unknown_type:t.enum(["contract","convention","freshness","runtime","data-flow","impact"]).optional().describe("Typed unknown classification"),retry_count:t.number().default(0).describe("Retry count for gate evaluation (0 = first attempt)"),cwd:t.string().optional().describe("Working directory for evidence map storage (default: server cwd). Use root_path from forge_ground to match.")}},async({action:h,task_id:s,tier:l,claim:c,status:i,receipt:d,id:o,critical_path:p,unknown_type:n,retry_count:r,cwd:u})=>{try{switch(h){case"create":{if(!s)throw new Error("task_id required for create");if(!l)throw new Error("tier required for create");return g({action:"create",taskId:s,tier:l},u),{content:[{type:"text",text:`Created evidence map "${s}" (tier: ${l}).
 
 ---
-_Next: Use \`evidence_map\` with action "add" to record critical-path claims._`
-                }
-              ]
-            };
-          }
-          case "add": {
-            if (!task_id) throw new Error("task_id required for add");
-            if (!claim) throw new Error("claim required for add");
-            if (!status) throw new Error("status required for add");
-            const result = evidenceMap(
-              {
-                action: "add",
-                taskId: task_id,
-                claim,
-                status,
-                receipt: receipt ?? "",
-                criticalPath: critical_path,
-                unknownType: unknown_type
-              },
-              cwd
-            );
-            const lines = [
-              `Added entry #${result.entry?.id} to "${task_id}": [${status}] ${claim}`
-            ];
-            if (result.formattedMap) {
-              lines.push("", result.formattedMap);
-            }
-            return { content: [{ type: "text", text: lines.join("\n") }] };
-          }
-          case "update": {
-            if (!task_id) throw new Error("task_id required for update");
-            if (id === void 0) throw new Error("id required for update");
-            if (!status) throw new Error("status required for update");
-            const result = evidenceMap(
-              {
-                action: "update",
-                taskId: task_id,
-                id,
-                status,
-                receipt: receipt ?? ""
-              },
-              cwd
-            );
-            const lines = [`Updated entry #${id} in "${task_id}" \u2192 ${status}`];
-            if (result.formattedMap) {
-              lines.push("", result.formattedMap);
-            }
-            return { content: [{ type: "text", text: lines.join("\n") }] };
-          }
-          case "get": {
-            if (!task_id) throw new Error("task_id required for get");
-            const result = evidenceMap({ action: "get", taskId: task_id }, cwd);
-            if (!result.state) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Evidence map "${task_id}" not found.`
-                  }
-                ]
-              };
-            }
-            const lines = [
-              `## Evidence Map: ${task_id} (${result.state.tier})`,
-              "",
-              result.formattedMap ?? "No entries.",
-              "",
-              `_${result.state.entries.length} entries \u2014 created ${result.state.createdAt}_`
-            ];
-            return { content: [{ type: "text", text: lines.join("\n") }] };
-          }
-          case "gate": {
-            if (!task_id) throw new Error("task_id required for gate");
-            const result = evidenceMap(
-              {
-                action: "gate",
-                taskId: task_id,
-                retryCount: retry_count
-              },
-              cwd
-            );
-            if (!result.gate) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Evidence map "${task_id}" not found.`
-                  }
-                ]
-              };
-            }
-            const g = result.gate;
-            const lines = [
-              `## FORGE Gate: **${g.decision}**`,
-              "",
-              `**Reason:** ${g.reason}`,
-              "",
-              `**Stats:** ${g.stats.verified}V / ${g.stats.assumed}A / ${g.stats.unresolved}U (${g.stats.total} total)`
-            ];
-            if (g.warnings.length > 0) {
-              lines.push("", "**Warnings:**", ...g.warnings.map((w) => `- \u26A0\uFE0F ${w}`));
-            }
-            if (g.unresolvedCritical.length > 0) {
-              lines.push(
-                "",
-                "**Blocking entries:**",
-                ...g.unresolvedCritical.map(
-                  (e) => `- #${e.id}: ${e.claim} [${e.unknownType ?? "untyped"}]`
-                )
-              );
-            }
-            if (g.annotation) {
-              lines.push("", "**Annotation:**", g.annotation);
-            }
-            if (result.formattedMap) {
-              lines.push("", "---", "", result.formattedMap);
-            }
-            lines.push(
-              "",
-              "---",
-              `_Next: ${g.decision === "YIELD" ? "Proceed to implementation." : g.decision === "HOLD" ? "Resolve blocking entries, then re-run gate." : g.decision === "HARD_BLOCK" ? "Contract unknowns MUST be resolved. Use search or schema_validate." : "Proceed with annotation \u2014 document unresolved items in delivery."}_`
-            );
-            return { content: [{ type: "text", text: lines.join("\n") }] };
-          }
-          case "list": {
-            const result = evidenceMap({ action: "list" }, cwd);
-            if (!result.states || result.states.length === 0) {
-              return {
-                content: [{ type: "text", text: "No evidence maps found." }]
-              };
-            }
-            const lines = result.states.map(
-              (s) => `- **${s.taskId}** (${s.tier}) \u2014 ${s.entries.length} entries \u2014 ${s.updatedAt}`
-            );
-            return {
-              content: [{ type: "text", text: lines.join("\n") }]
-            };
-          }
-          case "delete": {
-            if (!task_id) throw new Error("task_id required for delete");
-            const result = evidenceMap({ action: "delete", taskId: task_id }, cwd);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: result.deleted ? `Deleted evidence map "${task_id}".` : `Evidence map "${task_id}" not found.`
-                }
-              ]
-            };
-          }
-        }
-      } catch (err) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Evidence map error: ${err.message}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerDigestTool(server, embedder) {
-  server.registerTool(
-    "digest",
-    {
-      description: "Compress multiple text sources (handoffs, debates, phase summaries) into a token-budgeted digest. Jointly ranks across all sources, pins structured fields (status, files, decisions, blockers), and allocates budget by priority weight.",
-      inputSchema: {
-        sources: z.array(
-          z.object({
-            id: z.string().describe('Source identifier (e.g., "phase-2-handoff")'),
-            text: z.string().describe("Source text to compress"),
-            weight: z.number().min(0).default(1).describe("Priority weight (higher = more budget)")
-          })
-        ).min(1).describe("Text sources to compress"),
-        query: z.string().describe("Focus query \u2014 what matters for the next step?"),
-        max_chars: z.number().min(100).max(5e4).default(4e3).describe("Target budget in characters"),
-        pin_fields: z.array(z.string()).optional().describe(
-          "Key fields to always extract (default: status, files, decisions, blockers, next)"
-        ),
-        segmentation: z.enum(["paragraph", "sentence", "line"]).default("paragraph").describe("How to split text for scoring")
-      }
-    },
-    async ({ sources, query, max_chars, pin_fields, segmentation }) => {
-      try {
-        const result = await digest(embedder, {
-          sources,
-          query,
-          maxChars: max_chars,
-          pinFields: pin_fields,
-          segmentation
-        });
-        const lines = [
-          `## Digest (${result.totalOriginalChars} \u2192 ${result.totalCompressedChars} chars, ${(result.ratio * 100).toFixed(0)}%)`,
-          ""
-        ];
-        const fieldKeys = Object.keys(result.fields);
-        if (fieldKeys.length > 0) {
-          lines.push("### Extracted Fields");
-          for (const key of fieldKeys) {
-            const entries = result.fields[key];
-            lines.push(`**${key}:**`);
-            for (const e of entries) {
-              lines.push(`  - [${e.sourceId}] ${e.value}`);
-            }
-          }
-          lines.push("");
-        }
-        lines.push("### Compressed Content", "", result.text);
-        lines.push("", "### Source Stats");
-        for (const s of result.sourceStats) {
-          lines.push(
-            `- **${s.id}**: ${s.originalChars} \u2192 ${s.keptChars} chars (${s.segmentsKept}/${s.segmentsTotal} segments)`
-          );
-        }
-        lines.push(
-          "",
-          "---",
-          "_Next: Use the digest as compressed context for the next phase. Use `stash` to persist it if needed._"
-        );
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Digest failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerForgeClassifyTool(server) {
-  server.registerTool(
-    "forge_classify",
-    {
-      description: "Classify FORGE tier (Floor/Standard/Critical) from target files and task description. Checks blast radius, cross-package boundaries, schema/contract patterns, and security signals. Returns tier, triggers, typed unknown seeds, and ceremony guidance.",
-      inputSchema: {
-        files: z.array(z.string()).min(1).describe("Files being modified (paths)"),
-        task: z.string().describe("Task description"),
-        root_path: z.string().describe("Root path of the codebase")
-      }
-    },
-    async ({ files, task, root_path }) => {
-      try {
-        const result = await forgeClassify({ files, task, rootPath: root_path });
-        const lines = [`## FORGE Classification: **${result.tier.toUpperCase()}**`, ""];
-        if (result.triggers.length > 0) {
-          lines.push("### Triggers");
-          for (const t of result.triggers) {
-            lines.push(`- **${t.rule}** (${t.source}): ${t.detail}`);
-          }
-          lines.push("");
-        }
-        if (result.packagesCrossed.length > 0) {
-          lines.push(`**Packages crossed:** ${result.packagesCrossed.join(", ")}`);
-        }
-        if (result.typedUnknownSeeds.length > 0) {
-          lines.push("", "### Typed Unknown Seeds");
-          for (const u of result.typedUnknownSeeds) {
-            lines.push(`- [${u.type}] ${u.description} \u2192 use \`${u.suggestedTool}\``);
-          }
-        }
-        lines.push("", "### Ceremony");
-        const c = result.ceremony;
-        lines.push(
-          `- **Ground:** ${c.ground}`,
-          `- **Build:** ${c.build}`,
-          `- **Break:** ${c.break}`,
-          `- **Evidence Map:** ${c.evidenceMap}`,
-          `- **Gate:** ${c.gate}`
-        );
-        lines.push(
-          "",
-          "---",
-          `_Next: ${result.tier === "floor" ? "Proceed directly to implementation." : "Run `forge_ground` to execute the full Ground phase."}_`
-        );
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      } catch (err) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `FORGE classify failed: ${err.message}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerStratumCardTool(server, embedder) {
-  server.registerTool(
-    "stratum_card",
-    {
-      description: "Generate STRATUM context cards from files. T1 = structural metadata (~100 tokens/file). T2 = T1 + compressed content (~300 tokens/file). Replaces reading full files \u2014 10-100x token reduction.",
-      inputSchema: {
-        files: z.array(z.string()).min(1).describe("Absolute file paths to generate cards for"),
-        query: z.string().describe("Current task query \u2014 guides relevance scoring"),
-        tier: z.enum(["T1", "T2"]).default("T1").describe("Card tier: T1 = structural only, T2 = T1 + compressed content"),
-        max_content_chars: z.number().min(100).max(5e3).default(800).describe("For T2: max chars for compressed content section")
-      }
-    },
-    async ({ files, query, tier, max_content_chars }) => {
-      try {
-        const result = await stratumCard(embedder, {
-          files,
-          query,
-          tier,
-          maxContentChars: max_content_chars
-        });
-        const lines = [
-          `## STRATUM Cards (${tier}) \u2014 ${result.cards.length} files`,
-          `Total: ~${result.totalTokenEstimate} tokens (was ~${result.totalOriginalTokenEstimate}, ${(result.compressionRatio * 100).toFixed(0)}% of original)`,
-          ""
-        ];
-        for (const card of result.cards) {
-          lines.push(card.card, "");
-        }
-        lines.push(
-          "---",
-          `_Next: Use these cards as context instead of reading full files. Use \`compact\` for deeper content extraction on specific files._`
-        );
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      } catch (err) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `STRATUM cards failed: ${err.message}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-function registerForgeGroundTool(server, embedder, store) {
-  server.registerTool(
-    "forge_ground",
-    {
-      description: "Execute the complete FORGE Ground phase in a single call. Chains: tier classification \u2192 scope map \u2192 typed unknown seeds \u2192 constraint loading \u2192 file summaries \u2192 evidence map creation. Replaces 5-15 manual tool calls.",
-      inputSchema: {
-        task: z.string().describe("Task description"),
-        files: z.array(z.string()).min(1).describe("Target files being modified (absolute paths)"),
-        root_path: z.string().describe("Root path of the codebase"),
-        max_constraints: z.number().min(0).max(10).default(3).describe("Max constraint entries to load from KB"),
-        force_tier: z.enum(["floor", "standard", "critical"]).optional().describe("Force a specific tier (skips auto-classification)"),
-        task_id: z.string().optional().describe("Custom task ID for evidence map (auto-generated if omitted)")
-      }
-    },
-    async ({ task, files, root_path, max_constraints, force_tier, task_id }) => {
-      try {
-        const result = await forgeGround(embedder, store, {
-          task,
-          files,
-          rootPath: root_path,
-          maxConstraints: max_constraints,
-          forceTier: force_tier,
-          taskId: task_id
-        });
-        const lines = [
-          `## FORGE Ground: **${result.tier.toUpperCase()}**`,
-          `Estimated output: ~${result.estimatedTokens} tokens`,
-          ""
-        ];
-        if (result.classifyTriggers.length > 0) {
-          lines.push("### Classification Triggers");
-          for (const t of result.classifyTriggers) {
-            lines.push(`- **${t.rule}** (${t.source}): ${t.detail}`);
-          }
-          lines.push("");
-        }
-        if (result.fileSummaries.length > 0) {
-          lines.push("### Target Files");
-          for (const f of result.fileSummaries) {
-            lines.push(
-              `- **${f.path}** (${f.lines} lines) \u2014 exports: ${f.exports.join(", ") || "none"} \u2014 functions: ${f.functions.join(", ") || "none"}`
-            );
-          }
-          lines.push("");
-        }
-        if (result.typedUnknownSeeds.length > 0) {
-          lines.push("### Typed Unknown Seeds");
-          for (const u of result.typedUnknownSeeds) {
-            lines.push(`- [${u.type}] ${u.description} \u2192 \`${u.suggestedTool}\``);
-          }
-          lines.push("");
-        }
-        if (result.constraints.length > 0) {
-          lines.push("### Constraint Seed");
-          for (const c2 of result.constraints) {
-            lines.push(`- **${c2.source}** (${(c2.relevance * 100).toFixed(0)}%): ${c2.snippet}`);
-          }
-          lines.push("");
-        }
-        if (result.scopeMap) {
-          lines.push(
-            `### Scope Map: ${result.scopeMap.files.length} files (~${result.scopeMap.totalEstimatedTokens} tokens)`
-          );
-          for (const f of result.scopeMap.files.slice(0, 5)) {
-            lines.push(`- ${f.path} (${(f.relevance * 100).toFixed(0)}%) \u2014 ${f.reason}`);
-          }
-          if (result.scopeMap.files.length > 5) {
-            lines.push(`- _...and ${result.scopeMap.files.length - 5} more_`);
-          }
-          lines.push("");
-        }
-        if (result.evidenceMapTaskId) {
-          lines.push(`**Evidence Map:** \`${result.evidenceMapTaskId}\` (initialized)`);
-          lines.push("");
-        }
-        lines.push("### Ceremony Guidance");
-        const c = result.ceremony;
-        lines.push(
-          `- **Ground:** ${c.ground}`,
-          `- **Build:** ${c.build}`,
-          `- **Break:** ${c.break}`,
-          `- **Evidence Map:** ${c.evidenceMap}`,
-          `- **Gate:** ${c.gate}`
-        );
-        lines.push(
-          "",
-          "---",
-          `_Next: ${result.tier === "floor" ? "Proceed to Build phase." : "Use `evidence_map` to track claims during Build, then `evidence_map` gate after Break."}_`
-        );
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      } catch (err) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `FORGE Ground failed: ${err.message}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
-  );
-}
-export {
-  registerDigestTool,
-  registerEvidenceMapTool,
-  registerForgeClassifyTool,
-  registerForgeGroundTool,
-  registerStratumCardTool
-};
-//# sourceMappingURL=forge.tools.js.map
+_Next: Use \`evidence_map\` with action "add" to record critical-path claims._`}]}}case"add":{if(!s)throw new Error("task_id required for add");if(!c)throw new Error("claim required for add");if(!i)throw new Error("status required for add");const e=g({action:"add",taskId:s,claim:c,status:i,receipt:d??"",criticalPath:p,unknownType:n},u),a=[`Added entry #${e.entry?.id} to "${s}": [${i}] ${c}`];return e.formattedMap&&a.push("",e.formattedMap),{content:[{type:"text",text:a.join(`
+`)}]}}case"update":{if(!s)throw new Error("task_id required for update");if(o===void 0)throw new Error("id required for update");if(!i)throw new Error("status required for update");const e=g({action:"update",taskId:s,id:o,status:i,receipt:d??""},u),a=[`Updated entry #${o} in "${s}" \u2192 ${i}`];return e.formattedMap&&a.push("",e.formattedMap),{content:[{type:"text",text:a.join(`
+`)}]}}case"get":{if(!s)throw new Error("task_id required for get");const e=g({action:"get",taskId:s},u);return e.state?{content:[{type:"text",text:[`## Evidence Map: ${s} (${e.state.tier})`,"",e.formattedMap??"No entries.","",`_${e.state.entries.length} entries \u2014 created ${e.state.createdAt}_`].join(`
+`)}]}:{content:[{type:"text",text:`Evidence map "${s}" not found.`}]}}case"gate":{if(!s)throw new Error("task_id required for gate");const e=g({action:"gate",taskId:s,retryCount:r},u);if(!e.gate)return{content:[{type:"text",text:`Evidence map "${s}" not found.`}]};const a=e.gate,f=[`## FORGE Gate: **${a.decision}**`,"",`**Reason:** ${a.reason}`,"",`**Stats:** ${a.stats.verified}V / ${a.stats.assumed}A / ${a.stats.unresolved}U (${a.stats.total} total)`];return a.warnings.length>0&&f.push("","**Warnings:**",...a.warnings.map($=>`- \u26A0\uFE0F ${$}`)),a.unresolvedCritical.length>0&&f.push("","**Blocking entries:**",...a.unresolvedCritical.map($=>`- #${$.id}: ${$.claim} [${$.unknownType??"untyped"}]`)),a.annotation&&f.push("","**Annotation:**",a.annotation),e.formattedMap&&f.push("","---","",e.formattedMap),f.push("","---",`_Next: ${a.decision==="YIELD"?"Proceed to implementation.":a.decision==="HOLD"?"Resolve blocking entries, then re-run gate.":a.decision==="HARD_BLOCK"?"Contract unknowns MUST be resolved. Use search or schema_validate.":"Proceed with annotation \u2014 document unresolved items in delivery."}_`),{content:[{type:"text",text:f.join(`
+`)}]}}case"list":{const e=g({action:"list"},u);return!e.states||e.states.length===0?{content:[{type:"text",text:"No evidence maps found."}]}:{content:[{type:"text",text:e.states.map(f=>`- **${f.taskId}** (${f.tier}) \u2014 ${f.entries.length} entries \u2014 ${f.updatedAt}`).join(`
+`)}]}}case"delete":{if(!s)throw new Error("task_id required for delete");return{content:[{type:"text",text:g({action:"delete",taskId:s},u).deleted?`Deleted evidence map "${s}".`:`Evidence map "${s}" not found.`}]}}}}catch(e){return{content:[{type:"text",text:`Evidence map error: ${e.message}`}],isError:!0}}})}function w(m,h){m.registerTool("digest",{description:"Compress multiple text sources (handoffs, debates, phase summaries) into a token-budgeted digest. Jointly ranks across all sources, pins structured fields (status, files, decisions, blockers), and allocates budget by priority weight.",inputSchema:{sources:t.array(t.object({id:t.string().describe('Source identifier (e.g., "phase-2-handoff")'),text:t.string().describe("Source text to compress"),weight:t.number().min(0).default(1).describe("Priority weight (higher = more budget)")})).min(1).describe("Text sources to compress"),query:t.string().describe("Focus query \u2014 what matters for the next step?"),max_chars:t.number().min(100).max(5e4).default(4e3).describe("Target budget in characters"),pin_fields:t.array(t.string()).optional().describe("Key fields to always extract (default: status, files, decisions, blockers, next)"),segmentation:t.enum(["paragraph","sentence","line"]).default("paragraph").describe("How to split text for scoring")}},async({sources:s,query:l,max_chars:c,pin_fields:i,segmentation:d})=>{try{const o=await y(h,{sources:s,query:l,maxChars:c,pinFields:i,segmentation:d}),p=[`## Digest (${o.totalOriginalChars} \u2192 ${o.totalCompressedChars} chars, ${(o.ratio*100).toFixed(0)}%)`,""],n=Object.keys(o.fields);if(n.length>0){p.push("### Extracted Fields");for(const r of n){const u=o.fields[r];p.push(`**${r}:**`);for(const e of u)p.push(`  - [${e.sourceId}] ${e.value}`)}p.push("")}p.push("### Compressed Content","",o.text),p.push("","### Source Stats");for(const r of o.sourceStats)p.push(`- **${r.id}**: ${r.originalChars} \u2192 ${r.keptChars} chars (${r.segmentsKept}/${r.segmentsTotal} segments)`);return p.push("","---","_Next: Use the digest as compressed context for the next phase. Use `stash` to persist it if needed._"),{content:[{type:"text",text:p.join(`
+`)}]}}catch(o){return{content:[{type:"text",text:`Digest failed: ${o.message}`}],isError:!0}}})}function C(m){m.registerTool("forge_classify",{description:"Classify FORGE tier (Floor/Standard/Critical) from target files and task description. Checks blast radius, cross-package boundaries, schema/contract patterns, and security signals. Returns tier, triggers, typed unknown seeds, and ceremony guidance.",inputSchema:{files:t.array(t.string()).min(1).describe("Files being modified (paths)"),task:t.string().describe("Task description"),root_path:t.string().describe("Root path of the codebase")}},async({files:h,task:s,root_path:l})=>{try{const c=await x({files:h,task:s,rootPath:l}),i=[`## FORGE Classification: **${c.tier.toUpperCase()}**`,""];if(c.triggers.length>0){i.push("### Triggers");for(const o of c.triggers)i.push(`- **${o.rule}** (${o.source}): ${o.detail}`);i.push("")}if(c.packagesCrossed.length>0&&i.push(`**Packages crossed:** ${c.packagesCrossed.join(", ")}`),c.typedUnknownSeeds.length>0){i.push("","### Typed Unknown Seeds");for(const o of c.typedUnknownSeeds)i.push(`- [${o.type}] ${o.description} \u2192 use \`${o.suggestedTool}\``)}i.push("","### Ceremony");const d=c.ceremony;return i.push(`- **Ground:** ${d.ground}`,`- **Build:** ${d.build}`,`- **Break:** ${d.break}`,`- **Evidence Map:** ${d.evidenceMap}`,`- **Gate:** ${d.gate}`),i.push("","---",`_Next: ${c.tier==="floor"?"Proceed directly to implementation.":"Run `forge_ground` to execute the full Ground phase."}_`),{content:[{type:"text",text:i.join(`
+`)}]}}catch(c){return{content:[{type:"text",text:`FORGE classify failed: ${c.message}`}],isError:!0}}})}function M(m,h){m.registerTool("stratum_card",{description:"Generate STRATUM context cards from files. T1 = structural metadata (~100 tokens/file). T2 = T1 + compressed content (~300 tokens/file). Replaces reading full files \u2014 10-100x token reduction.",inputSchema:{files:t.array(t.string()).min(1).describe("Absolute file paths to generate cards for"),query:t.string().describe("Current task query \u2014 guides relevance scoring"),tier:t.enum(["T1","T2"]).default("T1").describe("Card tier: T1 = structural only, T2 = T1 + compressed content"),max_content_chars:t.number().min(100).max(5e3).default(800).describe("For T2: max chars for compressed content section")}},async({files:s,query:l,tier:c,max_content_chars:i})=>{try{const d=await v(h,{files:s,query:l,tier:c,maxContentChars:i}),o=[`## STRATUM Cards (${c}) \u2014 ${d.cards.length} files`,`Total: ~${d.totalTokenEstimate} tokens (was ~${d.totalOriginalTokenEstimate}, ${(d.compressionRatio*100).toFixed(0)}% of original)`,""];for(const p of d.cards)o.push(p.card,"");return o.push("---","_Next: Use these cards as context instead of reading full files. Use `compact` for deeper content extraction on specific files._"),{content:[{type:"text",text:o.join(`
+`)}]}}catch(d){return{content:[{type:"text",text:`STRATUM cards failed: ${d.message}`}],isError:!0}}})}function S(m,h,s){m.registerTool("forge_ground",{description:"Execute the complete FORGE Ground phase in a single call. Chains: tier classification \u2192 scope map \u2192 typed unknown seeds \u2192 constraint loading \u2192 file summaries \u2192 evidence map creation. Replaces 5-15 manual tool calls.",inputSchema:{task:t.string().describe("Task description"),files:t.array(t.string()).min(1).describe("Target files being modified (absolute paths)"),root_path:t.string().describe("Root path of the codebase"),max_constraints:t.number().min(0).max(10).default(3).describe("Max constraint entries to load from KB"),force_tier:t.enum(["floor","standard","critical"]).optional().describe("Force a specific tier (skips auto-classification)"),task_id:t.string().optional().describe("Custom task ID for evidence map (auto-generated if omitted)")}},async({task:l,files:c,root_path:i,max_constraints:d,force_tier:o,task_id:p})=>{try{const n=await b(h,s,{task:l,files:c,rootPath:i,maxConstraints:d,forceTier:o,taskId:p}),r=[`## FORGE Ground: **${n.tier.toUpperCase()}**`,`Estimated output: ~${n.estimatedTokens} tokens`,""];if(n.classifyTriggers.length>0){r.push("### Classification Triggers");for(const e of n.classifyTriggers)r.push(`- **${e.rule}** (${e.source}): ${e.detail}`);r.push("")}if(n.fileSummaries.length>0){r.push("### Target Files");for(const e of n.fileSummaries)r.push(`- **${e.path}** (${e.lines} lines) \u2014 exports: ${e.exports.join(", ")||"none"} \u2014 functions: ${e.functions.join(", ")||"none"}`);r.push("")}if(n.typedUnknownSeeds.length>0){r.push("### Typed Unknown Seeds");for(const e of n.typedUnknownSeeds)r.push(`- [${e.type}] ${e.description} \u2192 \`${e.suggestedTool}\``);r.push("")}if(n.constraints.length>0){r.push("### Constraint Seed");for(const e of n.constraints)r.push(`- **${e.source}** (${(e.relevance*100).toFixed(0)}%): ${e.snippet}`);r.push("")}if(n.scopeMap){r.push(`### Scope Map: ${n.scopeMap.files.length} files (~${n.scopeMap.totalEstimatedTokens} tokens)`);for(const e of n.scopeMap.files.slice(0,5))r.push(`- ${e.path} (${(e.relevance*100).toFixed(0)}%) \u2014 ${e.reason}`);n.scopeMap.files.length>5&&r.push(`- _...and ${n.scopeMap.files.length-5} more_`),r.push("")}n.evidenceMapTaskId&&(r.push(`**Evidence Map:** \`${n.evidenceMapTaskId}\` (initialized)`),r.push("")),r.push("### Ceremony Guidance");const u=n.ceremony;return r.push(`- **Ground:** ${u.ground}`,`- **Build:** ${u.build}`,`- **Break:** ${u.break}`,`- **Evidence Map:** ${u.evidenceMap}`,`- **Gate:** ${u.gate}`),r.push("","---",`_Next: ${n.tier==="floor"?"Proceed to Build phase.":"Use `evidence_map` to track claims during Build, then `evidence_map` gate after Break."}_`),{content:[{type:"text",text:r.join(`
+`)}]}}catch(n){return{content:[{type:"text",text:`FORGE Ground failed: ${n.message}`}],isError:!0}}})}export{w as registerDigestTool,T as registerEvidenceMapTool,C as registerForgeClassifyTool,S as registerForgeGroundTool,M as registerStratumCardTool};

package/packages/server/dist/tools/forget.tool.js

@@ -1,43 +1,7 @@
-import { z } from "zod";
-function registerForgetTool(server, curated) {
-  server.registerTool(
-    "forget",
-    {
-      description: "Remove a curated knowledge entry. Deletes the file and removes it from the vector store.",
-      inputSchema: {
-        path: z.string().describe('Relative path within curated/ (e.g., "decisions/deprecated-approach.md")'),
-        reason: z.string().min(3).describe("Why this entry is being removed")
-      }
-    },
-    async ({ path, reason }) => {
-      try {
-        const result = await curated.forget(path, reason);
-        console.error(`[KB] Forgot: ${result.path} \u2014 reason: ${reason}`);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Forgotten: \`curated/${result.path}\`
+import{z as t}from"zod";function i(o,n){o.registerTool("forget",{description:"Remove a curated knowledge entry. Deletes the file and removes it from the vector store.",inputSchema:{path:t.string().describe('Relative path within curated/ (e.g., "decisions/deprecated-approach.md")'),reason:t.string().min(3).describe("Why this entry is being removed")}},async({path:s,reason:r})=>{try{const e=await n.forget(s,r);return console.error(`[KB] Forgot: ${e.path} \u2014 reason: ${r}`),{content:[{type:"text",text:`Forgotten: \`curated/${e.path}\`
 
 Removed from disk and vector store.
-Reason: ${reason}
+Reason: ${r}
 
 ---
-_Next: Use \`list\` to verify removal, or \`search\` to confirm the entry is no longer returned._`
-            }
-          ]
-        };
-      } catch (err) {
-        console.error("[KB] Forget failed:", err);
-        return {
-          content: [{ type: "text", text: `Forget failed: ${err.message}` }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-export {
-  registerForgetTool
-};
-//# sourceMappingURL=forget.tool.js.map
+_Next: Use \`list\` to verify removal, or \`search\` to confirm the entry is no longer returned._`}]}}catch(e){return console.error("[KB] Forget failed:",e),{content:[{type:"text",text:`Forget failed: ${e.message}`}],isError:!0}}})}export{i as registerForgetTool};