wyrm-mcp 7.3.2 → 7.3.3

package/dist/handlers/recall.js

@@ -1,13 +1,237 @@
-import{TOOL_ANNOTATIONS as E}from"../tool-annotations.js";import{renderResult as R,withGlyph as d}from"../render.js";import{memoryUri as P,resourceLink as D}from"./resources.js";import{buildDeterminismReceipt as L,attestation as S}from"../receipt.js";import{rerankConfigured as T}from"../rerank.js";const F=[{name:"wyrm_recall",description:"Use before starting any non-trivial task - what do we know about this? Pull up relevant lessons learned, proven patterns, anti-patterns, and reasoning traces from past work. Hybrid lexical+semantic retrieval, fully local, no LLM. Mark what you recalled as useful (or not) with wyrm_feedback.",inputSchema:{type:"object",properties:{projectPath:{type:"string"},query:{type:"string",description:"The task or problem"},kind:{type:"string",enum:["reasoning_trace","lesson","pattern","anti_pattern","heuristic"]},limit:{type:"number",description:"Default 10"},minConfidence:{type:"number",description:"0-1 (default 0)"},detail:{type:"string",enum:["full","link"],description:"Default full"}},required:["projectPath","query"]},outputSchema:{type:"object",properties:{query:{type:"string"},count:{type:"integer"},results:{type:"array",items:{type:"object",properties:{id:{type:"integer"},kind:{type:"string"},relevance:{type:"number"},problem:{type:"string"},validated_fix:{type:["string","null"]},confidence:{type:"number"},reuse_count:{type:"integer"}},required:["id","kind","relevance","problem","confidence","reuse_count"]}}},required:["query","count","results"]},annotations:E.wyrm_recall,aliases:[],handler:async(w,{store:h,raw:v,memory:p,vectors:b,clientSupportsResources:$})=>{const{projectPath:m,query:s,kind:g,limit:x,minConfidence:M,detail:f}=w,c=h.getProject(m);if(!c)return{content:[{type:"text",text:`Project not found: ${m}`}],isError:!0};const a=!!b(),y=a&&T()&&/^(1|true|yes|on)$/i.test(process.env.WYRM_RERANK??""),_={kind:g,limit:x??10,minConfidence:M,rerank:y},i=a?await p.recallHybrid(c.id,s,_):p.recall(c.id,s,_),j=L({vectorsAvailable:a,rerankActive:y,embedModel:process.env.WYRM_EMBED_MODEL||"nomic-embed-text",rerankModel:process.env.WYRM_RERANK_MODEL||null});if(i.length>0){const n=i.map(r=>r.artifact.id),e=n.map(()=>"?").join(",");v().prepare(`UPDATE memory_artifacts SET last_accessed_at = datetime('now'), access_count = access_count + 1 WHERE id IN (${e})`).run(...n)}const k=n=>Math.round(n*1e4)/1e4,l={query:s,count:i.length,results:i.map(n=>{const e=n.artifact,r={id:e.id,kind:e.kind,relevance:k(n.relevance_score),problem:e.problem,outcome:e.outcome,confidence:e.confidence==null?e.confidence:k(e.confidence),reuse_count:e.reuse_count,reuse_success_count:e.reuse_success_count};return e.constraints!=null&&(r.constraints=e.constraints),e.validated_fix!=null&&(r.validated_fix=e.validated_fix),e.why_it_worked!=null&&(r.why_it_worked=e.why_it_worked),r}),receipt:j},u=R(l,(n,e)=>{const r=`
-
-_${S(n.receipt)}_`;if(n.count===0)return d(e.brand,`No relevant memory found for: "${n.query}"`)+"\n\nUse `wyrm_remember` to store knowledge as you work."+r;let o=d(e.brand,`**Memory Recall** -- "${n.query}" (${n.count} found)`)+`
-
-`;for(const t of n.results){o+=`### ${t.kind} (ID: ${t.id}) -- relevance ${(t.relevance*100).toFixed(0)}%
-`,o+=`**Problem:** ${t.problem}
-`,t.constraints&&(o+=`**Constraints:** ${t.constraints}
-`),t.validated_fix&&(o+=`**Solution:** ${t.validated_fix}
-`),t.why_it_worked&&(o+=`**Why:** ${t.why_it_worked}
-`),t.outcome==="negative"&&(o+=d(e.warn,"_This approach failed -- see solution for what to do instead_")+`
-`);const q=t.confidence==null?"unknown":`${(t.confidence*100).toFixed(0)}%`;o+=`_Confidence: ${q} | Used ${t.reuse_count}x | Success rate: ${t.reuse_count>0?(t.reuse_success_count/t.reuse_count*100).toFixed(0)+"%":"not yet used"}_
-
-`}return o+="_Use `wyrm_feedback` to record whether these were helpful._",o+r},{exemptStructured:!0});if((f==="link"||f!=="full"&&!!$?.())&&l.count>0){const n=l.results.map(e=>D(P(e.id),`memory #${e.id} (${e.kind})`,{description:e.problem.slice(0,120),mimeType:"application/json"}));return{...u,content:[...u.content,...n]}}return u}}];export{F as recallToolSpecs};
+/**
+ * Recall domain — ToolSpec contract v2 (v7 F3 T026, hot-path extraction).
+ *
+ * wyrm_recall, moved VERBATIM from the index.ts dispatch switch +
+ * buildAllTools(). Hybrid (FTS ⊕ vectors, RRF) when a vector store is
+ * configured, lexical otherwise — exactly the 6.x routing. The access-decay
+ * UPDATE moved with the handler (the ctx.raw() verbatim-SQL seam).
+ *
+ * T019 renderer: the result list is the canonical structured body; the 6.x
+ * prose derives from it (ASCII default — the kind emoji moved off the default
+ * text, spec §6 reformat).
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { TOOL_ANNOTATIONS } from '../tool-annotations.js';
+import { renderResult, withGlyph } from '../render.js';
+import { memoryUri, resourceLink } from './resources.js';
+import { buildDeterminismReceipt, attestation } from '../receipt.js';
+import { rerankConfigured } from '../rerank.js';
+export const recallToolSpecs = [
+    {
+        name: "wyrm_recall",
+        description: "Use before starting any non-trivial task - what do we know about this? Pull up relevant lessons learned, proven patterns, anti-patterns, and reasoning traces from past work. Hybrid lexical+semantic retrieval, fully local, no LLM. Mark what you recalled as useful (or not) with wyrm_feedback.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                // v7 F3 (T026): property prose compressed to fund the hot-path
+                // outputSchemas under the 8K default-surface pin (T022/T025 trade).
+                projectPath: { type: "string" },
+                query: { type: "string", description: "The task or problem" },
+                kind: {
+                    type: "string",
+                    enum: ["reasoning_trace", "lesson", "pattern", "anti_pattern", "heuristic"],
+                },
+                limit: { type: "number", description: "Default 10" },
+                minConfidence: { type: "number", description: "0-1 (default 0)" },
+                // v7 F4 (T034): 'full' (default) inlines the complete result bodies;
+                // 'link' ALSO appends a wyrm://memory/{id} resource_link per result for
+                // resource-capable clients. Either way the full body rides — the link
+                // is additive, never a substitution (no data loss).
+                detail: { type: "string", enum: ["full", "link"], description: "Default full" },
+            },
+            required: ["projectPath", "query"],
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string" },
+                count: { type: "integer" },
+                results: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            id: { type: "integer" },
+                            kind: { type: "string" },
+                            relevance: { type: "number" },
+                            problem: { type: "string" },
+                            // FEATHERWEIGHT review (major): constraints/why_it_worked/outcome/
+                            // reuse_success_count carry the fix rationale + the negative-
+                            // learning signal. They ride the body undeclared (declaring them
+                            // here would push the default ListTools surface OVER the §7.1 8K
+                            // pin). Losslessness under WYRM_CHANNEL=structured is instead
+                            // guaranteed by recall being exemptStructured (handler below): its
+                            // FULL per-result prose always rides the text channel, so the
+                            // rationale never depends on a consumer preserving undeclared
+                            // structured fields.
+                            validated_fix: { type: ["string", "null"] },
+                            confidence: { type: "number" },
+                            reuse_count: { type: "integer" },
+                        },
+                        required: ["id", "kind", "relevance", "problem", "confidence", "reuse_count"],
+                    },
+                },
+            },
+            required: ["query", "count", "results"],
+        },
+        annotations: TOOL_ANNOTATIONS.wyrm_recall,
+        aliases: [],
+        handler: async (args, { store, raw, memory, vectors, clientSupportsResources }) => {
+            const { projectPath: rcPath, query: rcQuery, kind: rcKind, limit: rcLimit, minConfidence: rcMinConf, detail: rcDetail } = args;
+            const rcProject = store.getProject(rcPath);
+            if (!rcProject)
+                return { content: [{ type: "text", text: `Project not found: ${rcPath}` }], isError: true };
+            // Hybrid (FTS ⊕ vectors, RRF) when a vector store is available; lexical otherwise.
+            const vectorsOn = !!vectors();
+            // WYRM_RERANK=1 engages the opt-in, env-configured cross-encoder rerank
+            // stage on the hybrid path (only meaningful when WYRM_RERANK_MODEL is set;
+            // rerank.ts degrades to the fusion order on any failure — never throws).
+            const rerankActive = vectorsOn && rerankConfigured() && /^(1|true|yes|on)$/i.test(process.env.WYRM_RERANK ?? '');
+            const rcOpts = { kind: rcKind, limit: rcLimit ?? 10, minConfidence: rcMinConf, rerank: rerankActive };
+            const results = vectorsOn
+                ? await memory.recallHybrid(rcProject.id, rcQuery, rcOpts)
+                : memory.recall(rcProject.id, rcQuery, rcOpts);
+            // Determinism Receipt — proof THIS recall ran locally with no generative
+            // LLM and no data egress; reflects the path that actually executed.
+            const receipt = buildDeterminismReceipt({
+                vectorsAvailable: vectorsOn,
+                rerankActive,
+                embedModel: process.env.WYRM_EMBED_MODEL || 'nomic-embed-text',
+                rerankModel: process.env.WYRM_RERANK_MODEL || null,
+            });
+            // Track access for memory decay
+            if (results.length > 0) {
+                const ids = results.map(r => r.artifact.id);
+                const placeholders = ids.map(() => '?').join(',');
+                raw().prepare(`UPDATE memory_artifacts SET last_accessed_at = datetime('now'), access_count = access_count + 1 WHERE id IN (${placeholders})`).run(...ids);
+            }
+            // FEATHERWEIGHT #5 — number & null hygiene (default, lossless):
+            //  (a) `relevance` is an internal RRF/FTS ranking score in [0,1] the
+            //      consumer only ever reads as an ORDER and renders as an integer %
+            //      (text channel: `(relevance*100).toFixed(0)`). Its raw form carries
+            //      up to 17 significant digits of float noise (0.9992261132463348)
+            //      that no consumer compares on. Rounding to 4 dp (0.0001 resolution —
+            //      100× finer than the integer-% display and far below any tie the
+            //      sort could surface) drops only excess precision, never a value a
+            //      consumer distinguishes. `confidence` is rounded the same way (it is
+            //      stored ≤2 dp; the round is a no-op on clean rows and a safety clamp
+            //      on any future sub-percent float).
+            //  (b) `constraints`/`validated_fix`/`why_it_worked` are `string | null`.
+            //      A null is the ABSENCE of that rationale — it carries no information,
+            //      and the text derivation already guards each with a truthy check
+            //      (`if (a.validated_fix) …`), so an absent key reads identically to a
+            //      null one for every consumer. Omitting the key when null is lossless
+            //      null-elision (a present non-null value is ALWAYS kept). `outcome`,
+            //      `reuse_count`, `reuse_success_count` are non-null by construction
+            //      (enum default 'neutral' / integer counters) and ride unchanged.
+            const round4 = (n) => Math.round(n * 10000) / 10000;
+            const body = {
+                query: rcQuery,
+                count: results.length,
+                results: results.map((r) => {
+                    const a = r.artifact;
+                    const result = {
+                        id: a.id,
+                        kind: a.kind,
+                        relevance: round4(r.relevance_score),
+                        problem: a.problem,
+                        outcome: a.outcome,
+                        // round4(null) === 0 in JS, which would present an UNKNOWN
+                        // confidence as a meaningful 0%. The `confidence` column is `REAL
+                        // DEFAULT 1.0` but NOT NULL-constrained (migrations.ts), so a
+                        // synced/foreign row can carry null; preserve it rather than
+                        // coerce. round4 only ever drops excess float precision (lossless).
+                        confidence: a.confidence == null ? a.confidence : round4(a.confidence),
+                        reuse_count: a.reuse_count,
+                        reuse_success_count: a.reuse_success_count,
+                    };
+                    // Lossless null-elision: include the rationale fields only when they
+                    // carry a value (a null = no rationale = nothing to transmit; the text
+                    // derivation already guards each with a truthy check, so an absent key
+                    // reads identically to a null one for every consumer).
+                    if (a.constraints != null)
+                        result.constraints = a.constraints;
+                    if (a.validated_fix != null)
+                        result.validated_fix = a.validated_fix;
+                    if (a.why_it_worked != null)
+                        result.why_it_worked = a.why_it_worked;
+                    return result;
+                }),
+                receipt,
+            };
+            const rendered = renderResult(body, (b, g) => {
+                // The determinism receipt rides the text channel too (ASCII, lossless
+                // under exemptStructured) — the proof a schema-trimming consumer keeps.
+                const attest = `\n\n_${attestation(b.receipt)}_`;
+                if (b.count === 0) {
+                    return withGlyph(g.brand, `No relevant memory found for: "${b.query}"`) +
+                        `\n\nUse \`wyrm_remember\` to store knowledge as you work.` + attest;
+                }
+                let text = withGlyph(g.brand, `**Memory Recall** -- "${b.query}" (${b.count} found)`) + '\n\n';
+                for (const a of b.results) {
+                    text += `### ${a.kind} (ID: ${a.id}) -- relevance ${(a.relevance * 100).toFixed(0)}%\n`;
+                    text += `**Problem:** ${a.problem}\n`;
+                    if (a.constraints)
+                        text += `**Constraints:** ${a.constraints}\n`;
+                    if (a.validated_fix)
+                        text += `**Solution:** ${a.validated_fix}\n`;
+                    if (a.why_it_worked)
+                        text += `**Why:** ${a.why_it_worked}\n`;
+                    if (a.outcome === 'negative')
+                        text += withGlyph(g.warn, `_This approach failed -- see solution for what to do instead_`) + '\n';
+                    // Mirror the structured-body null guard (FW follow-up second-round):
+                    // a synced/foreign row can carry a null confidence (`REAL DEFAULT 1.0`
+                    // but NOT NULL-constrained in migrations.ts). null * 100 === 0 in JS
+                    // would render an UNKNOWN confidence as a meaningful "0%" on the text
+                    // channel — the SAME invented-value bug the minors commit fixed in the
+                    // structured body, but on recall's dominant (exemptStructured) channel.
+                    // Render "unknown" so unknown ≠ 0%.
+                    const confStr = a.confidence == null ? 'unknown' : `${(a.confidence * 100).toFixed(0)}%`;
+                    text += `_Confidence: ${confStr} | Used ${a.reuse_count}x | Success rate: ${a.reuse_count > 0 ? ((a.reuse_success_count / a.reuse_count) * 100).toFixed(0) + '%' : 'not yet used'}_\n\n`;
+                }
+                text += `_Use \`wyrm_feedback\` to record whether these were helpful._`;
+                return text + attest;
+            }, {
+                // FEATHERWEIGHT review (major): recall's per-result rationale lives in
+                // body fields NOT declared in outputSchema (declaring them would push
+                // the default ListTools surface over the §7.1 8K pin). A strict harness
+                // that trims structuredContent to declared properties under
+                // WYRM_CHANNEL=structured would therefore drop the fix rationale + the
+                // negative-learning signal — UNLESS the text channel keeps carrying the
+                // full prose. So recall is exemptStructured: its complete per-result
+                // detail (problem/constraints/validated_fix/why_it_worked/outcome) rides
+                // the text channel on EVERY channel policy, never collapsing to a one-
+                // line header. Losslessness is then independent of consumer schema-
+                // trimming — the hard-gate-5 contract.
+                exemptStructured: true,
+            });
+            // v7 F4 (T034): resourceLink affordance. The full result bodies ALWAYS
+            // ride above (the detail=full FALLBACK is the default and is never
+            // dropped — no data loss for any client). ADDITIONALLY, append one
+            // wyrm://memory/{id} resource_link per result so a resource-capable client
+            // can re-fetch the canonical artifact on demand without re-running recall.
+            // The gate is EITHER honest signal that the client can resolve a link:
+            //   • the caller explicitly asked (detail='link') — an explicit request IS
+            //     the client telling us it understands wyrm:// links; OR
+            //   • the client advertised experimental.resources at initialize.
+            // detail='full' (the default) NEVER appends links — it is the resource-less
+            // fallback, the full inline body and nothing dangling. Either way the body
+            // is unchanged; the link is purely additive, so no client loses data and a
+            // resource-less client (no opt-in, no advertised capability) gets no link
+            // it cannot resolve. The links append to content[] AFTER the text block, so
+            // content[0].text + structuredContent are byte-identical to the base return.
+            const wantsLinks = rcDetail === 'link' || (rcDetail !== 'full' && !!clientSupportsResources?.());
+            if (wantsLinks && body.count > 0) {
+                const links = body.results.map((r) => resourceLink(memoryUri(r.id), `memory #${r.id} (${r.kind})`, {
+                    description: r.problem.slice(0, 120),
+                    mimeType: 'application/json',
+                }));
+                return { ...rendered, content: [...rendered.content, ...links] };
+            }
+            return rendered;
+        },
+    },
+];
+//# sourceMappingURL=recall.js.map

package/dist/handlers/registry.js

@@ -1 +1,167 @@
-import{goalToolSpecs as n}from"./goals.js";import{captureToolSpecs as s}from"./capture.js";import{recallToolSpecs as l}from"./recall.js";import{searchToolSpecs as a}from"./search.js";import{failureToolSpecs as f}from"./failure.js";import{questToolSpecs as u}from"./quest.js";import{sessionToolSpecs as S}from"./session.js";import{reviewToolSpecs as T}from"./review.js";import{runToolSpecs as d}from"./run.js";import{declaredOutputSchemas as h}from"./output-schemas.js";import{projectToolSpecs as y}from"./project.js";import{eventsToolSpecs as g}from"./events.js";import{skillToolSpecs as O}from"./skill.js";import{datalakeToolSpecs as x}from"./datalake.js";import{entityToolSpecs as k}from"./entity.js";import{intelligenceToolSpecs as b}from"./intelligence.js";import{orchestrationToolSpecs as v}from"./orchestration.js";import{cloudToolSpecs as L}from"./cloud.js";import{companionToolSpecs as j}from"./companion.js";import{syncopsToolSpecs as w}from"./syncops.js";import{presenceToolSpecs as A}from"./presence.js";import{causalityToolSpecs as C}from"./causality.js";import{symbolsToolSpecs as D}from"./symbols.js";import{invoicingToolSpecs as N}from"./invoicing.js";import{auditToolSpecs as _}from"./audit.js";import{shareToolSpecs as q}from"./share.js";import{agentToolSpecs as E}from"./agent.js";import{mcpclientToolSpecs as I}from"./mcpclient.js";const p=[...n,...s,...l,...a,...f,...u,...S,...T,...d,...y,...g,...O,...x,...k,...b,...v,...L,...j,...w,...A,...C,...D,...N,..._,...q,...E,...I],lo=new Map(p.map(o=>[o.name,o.handler]));function ao(){return p.map(o=>({name:o.name,description:o.description,inputSchema:o.inputSchema,...o.outputSchema!==void 0?{outputSchema:o.outputSchema}:{}}))}function fo(o){return o.map(t=>{const e=h[t.name];return!e||t.outputSchema!==void 0?t:{...t,outputSchema:e}})}const c=["name","description","inputSchema","outputSchema","annotations"];function uo(o){return[...o].sort((t,e)=>t.name<e.name?-1:t.name>e.name?1:0).map(t=>{const e=t,m={};for(const r of c)r in e&&e[r]!==void 0&&(m[r]=e[r]);const i=Object.keys(e).filter(r=>!c.includes(r)&&e[r]!==void 0).sort();for(const r of i)m[r]=e[r];return m})}export{fo as applyDeclaredOutputSchemas,uo as buildStableToolList,lo as handlerRegistry,ao as registryToolDefs,p as toolSpecs};
+/**
+ * Tool-handler registry (v7 A2; upgraded to the ToolSpec contract v2 in
+ * v7 F3 T018). Domain modules export `ToolSpec[]` — ONE object per tool
+ * carrying {name, description, inputSchema, outputSchema, annotations,
+ * examples, aliases, handler} — and this registry derives from those specs:
+ *
+ *  (a) the DISPATCH map (`handlerRegistry`): the CallTool dispatcher consults
+ *      it BEFORE the legacy `switch (name)` in index.ts, so an extracted tool
+ *      is served from here while every tool still in the switch keeps its
+ *      exact original path. Domains migrate in, one green-suite commit at a
+ *      time, until the switch is empty (T036).
+ *
+ *  (b) the ADVERTISED wire entries (`registryToolDefs`): merged with
+ *      buildAllTools() in the ListTools handler, then canonicalized by
+ *      `buildStableToolList` — a byte-stable, deterministically ordered list
+ *      (stable tool order, stable key order, no Date/random anywhere in the
+ *      serialization; locked by tests/listtools-byte-stability.test.ts).
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { goalToolSpecs } from './goals.js';
+import { captureToolSpecs } from './capture.js';
+import { recallToolSpecs } from './recall.js';
+import { searchToolSpecs } from './search.js';
+import { failureToolSpecs } from './failure.js';
+import { questToolSpecs } from './quest.js';
+import { sessionToolSpecs } from './session.js';
+import { reviewToolSpecs } from './review.js';
+import { runToolSpecs } from './run.js';
+import { declaredOutputSchemas } from './output-schemas.js';
+// v7 F4 (T036): the drained non-hot domains — every formerly switch-resident
+// tool, lifted VERBATIM into per-domain ToolSpec modules behind the broad
+// DispatcherContext slice. These complete the monolith drain (quest #80):
+// buildAllTools() + the 142-case switch are deleted; index.ts ≤1,000 lines.
+import { projectToolSpecs } from './project.js';
+import { eventsToolSpecs } from './events.js';
+import { skillToolSpecs } from './skill.js';
+import { datalakeToolSpecs } from './datalake.js';
+import { entityToolSpecs } from './entity.js';
+import { intelligenceToolSpecs } from './intelligence.js';
+import { orchestrationToolSpecs } from './orchestration.js';
+import { cloudToolSpecs } from './cloud.js';
+import { companionToolSpecs } from './companion.js';
+import { syncopsToolSpecs } from './syncops.js';
+import { presenceToolSpecs } from './presence.js';
+import { causalityToolSpecs } from './causality.js';
+import { symbolsToolSpecs } from './symbols.js';
+import { invoicingToolSpecs } from './invoicing.js';
+import { auditToolSpecs } from './audit.js';
+import { shareToolSpecs } from './share.js';
+import { agentToolSpecs } from './agent.js';
+import { mcpclientToolSpecs } from './mcpclient.js';
+/**
+ * Every ToolSpec from every migrated domain. A domain's specs are typed
+ * against its narrow context slice; they widen to ToolSpec<HandlerContext>
+ * here by structural contravariance (HandlerContext implements every slice).
+ * v7 F3 (T026): + the seven hot-path domains (capture write funnel, recall,
+ * search incl. constellation, failure, quest, session+prime, review).
+ */
+export const toolSpecs = [
+    ...goalToolSpecs,
+    ...captureToolSpecs,
+    ...recallToolSpecs,
+    ...searchToolSpecs,
+    ...failureToolSpecs,
+    ...questToolSpecs,
+    ...sessionToolSpecs,
+    ...reviewToolSpecs,
+    // v7 F3 (T027): the run loop — wyrm_run is a NEW first-class tool (the
+    // 32nd survivor), not an extraction; see handlers/run.ts + survivors.ts.
+    ...runToolSpecs,
+    // v7 F4 (T036): the drained non-hot domains (quest #80). Typed against the
+    // broad DispatcherContext slice; they widen to ToolSpec<HandlerContext> here
+    // by the same structural contravariance (DispatcherContext extends
+    // HandlerContext). index.ts wires `dispatcherCtx` once and the registry
+    // dispatches every name from this list — the switch is gone.
+    ...projectToolSpecs,
+    ...eventsToolSpecs,
+    ...skillToolSpecs,
+    ...datalakeToolSpecs,
+    ...entityToolSpecs,
+    ...intelligenceToolSpecs,
+    ...orchestrationToolSpecs,
+    ...cloudToolSpecs,
+    ...companionToolSpecs,
+    ...syncopsToolSpecs,
+    ...presenceToolSpecs,
+    ...causalityToolSpecs,
+    ...symbolsToolSpecs,
+    ...invoicingToolSpecs,
+    ...auditToolSpecs,
+    ...shareToolSpecs,
+    ...agentToolSpecs,
+    ...mcpclientToolSpecs,
+];
+/** Tool-name → handler, derived from the specs (never built by hand). */
+export const handlerRegistry = new Map(toolSpecs.map((spec) => [spec.name, spec.handler]));
+/**
+ * Advertised ListTools entries for every registry-resident tool, derived from
+ * the SAME ToolSpec objects that carry the handlers — surface and behavior
+ * cannot drift. Annotations are deliberately NOT emitted here: the ListTools
+ * pipeline merges them centrally via annotateTools() (tool-annotations.ts)
+ * for switch- and registry-resident tools alike, and each ToolSpec.annotations
+ * is locked to be the same registry entry by tests/toolspec-registry.test.ts.
+ */
+export function registryToolDefs() {
+    return toolSpecs.map((spec) => ({
+        name: spec.name,
+        description: spec.description,
+        inputSchema: spec.inputSchema,
+        ...(spec.outputSchema !== undefined ? { outputSchema: spec.outputSchema } : {}),
+    }));
+}
+/**
+ * Attach declared outputSchemas (handlers/output-schemas.ts) to
+ * switch-resident tools that already return structuredContent — T014's
+ * wyrm_failure_check verdict is the first. Non-mutating; a tool that already
+ * carries an outputSchema (a ToolSpec one) is left untouched.
+ */
+export function applyDeclaredOutputSchemas(tools) {
+    return tools.map((tool) => {
+        const schema = declaredOutputSchemas[tool.name];
+        if (!schema || tool.outputSchema !== undefined)
+            return tool;
+        return { ...tool, outputSchema: schema };
+    });
+}
+// ── Byte-stable ListTools canonicalization (T018) ───────────────────────────
+/** Canonical top-level key order for one advertised tool entry. */
+const CANONICAL_TOOL_KEYS = ['name', 'description', 'inputSchema', 'outputSchema', 'annotations'];
+/**
+ * Canonicalize the final advertised tool list so consecutive ListTools
+ * serializations are BYTE-IDENTICAL (spec §7.1):
+ *
+ *  - stable TOOL order: sorted by name via codepoint comparison (never
+ *    localeCompare — locale-dependent collation would make the bytes depend
+ *    on the host environment);
+ *  - stable KEY order per entry: the canonical keys above first, then any
+ *    remaining keys in codepoint order (future-proof against new fields);
+ *  - values are passed through UNTOUCHED: schemas/annotations are static
+ *    literals whose insertion order is fixed at author time, and nothing in
+ *    the pipeline derives from Date/random. (Deep key-sorting is deliberately
+ *    avoided — it would rewrite inputSchema property order and break the
+ *    golden-fixture schema_sha256 drift guards for zero stability gain.)
+ *
+ * Pure and non-mutating: same input ⇒ same output, fresh objects.
+ */
+export function buildStableToolList(tools) {
+    return [...tools]
+        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+        .map((tool) => {
+        const source = tool;
+        const out = {};
+        for (const key of CANONICAL_TOOL_KEYS) {
+            if (key in source && source[key] !== undefined)
+                out[key] = source[key];
+        }
+        const rest = Object.keys(source)
+            .filter((k) => !CANONICAL_TOOL_KEYS.includes(k) && source[k] !== undefined)
+            .sort();
+        for (const key of rest)
+            out[key] = source[key];
+        return out;
+    });
+}
+//# sourceMappingURL=registry.js.map