sparda-mcp 0.5.2 → 0.5.4

package/src/server/stdio.js

@@ -5,13 +5,21 @@ import path from 'node:path';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import {
-  CallToolRequestSchema, ListToolsRequestSchema,
-  ListPromptsRequestSchema, GetPromptRequestSchema,
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
 import { sanitizeDescription } from '../security/sanitize.js';
 import { createIdleHarvester } from './idle.js';
 import { createSequenceRecorder, sequenceRecordingEnabled } from './condenser.js';
-import { eligibleForCrystallization, fallbackComposite, normalizeCompositeName, compositeSchema, runComposite } from './crystallize.js';
+import {
+  eligibleForCrystallization,
+  fallbackComposite,
+  normalizeCompositeName,
+  compositeSchema,
+  runComposite,
+} from './crystallize.js';
 import { writeManifestSync, mergeManifestKeySync } from './persistence.js';
 import { createSpardaEngine } from './engine.js';
 import { initiateWrite, preapproveWrite, confirmWrite } from './confirmation.js';
@@ -30,14 +38,34 @@ export async function startStdioBridge({ cwd, portOverride }) {
 
   const manifestPath = path.join(cwd, 'sparda.json');
   if (!fs.existsSync(manifestPath)) {
-    throw Object.assign(new Error('sparda.json not found.'), { code: 'USER', hint: 'Run `npx sparda-mcp init` first.' });
+    throw Object.assign(new Error('sparda.json not found.'), {
+      code: 'USER',
+      hint: 'Run `npx sparda-mcp init` first.',
+    });
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  } catch (e) {
+    // A truncated/garbled sparda.json (interrupted write, bad merge) must fail
+    // with the same code:'USER'+hint discipline used everywhere else — never a
+    // raw SyntaxError that crashes the bridge with an unreadable stack.
+    throw Object.assign(
+      new Error(`sparda.json is unreadable or corrupted: ${e.message}`),
+      {
+        code: 'USER',
+        hint: 'Restore it from git, or re-run `npx sparda-mcp init` to regenerate.',
+      },
+    );
   }
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
   const port = Number(portOverride ?? manifest.port);
   const framework = manifest.framework;
   const key = manifest.localKey;
   if (!key) {
-    throw Object.assign(new Error('localKey missing from sparda.json.'), { code: 'USER', hint: 'Re-run `npx sparda-mcp init` to regenerate it.' });
+    throw Object.assign(new Error('localKey missing from sparda.json.'), {
+      code: 'USER',
+      hint: 'Re-run `npx sparda-mcp init` to regenerate it.',
+    });
   }
 
   // Brief #4 — tenant context carrier. Resolved ONCE, here, from operator-pinned
@@ -46,23 +74,37 @@ export async function startStdioBridge({ cwd, portOverride }) {
   // per call) is the only scope it cannot choose. Throws USER on CRLF/over-bound so
   // a malformed scope stops the bridge instead of degrading to "no scope". Absent
   // config → frozen empty map → injectContext is a no-op (byte-identical forwarding).
-  const ctx = resolveContext({ argv: process.argv, env: process.env, config: manifest.contextPropagation ?? null });
+  const ctx = resolveContext({
+    argv: process.argv,
+    env: process.env,
+    config: manifest.contextPropagation ?? null,
+  });
   const ctxFp = fingerprintContext(ctx); // value-free: names + 8-hex SHA-256 only (R2/R7)
   if (Object.keys(ctxFp).length > 0) {
-    console.error(`[sparda] context carrier active (forwarded verbatim on every host call): ${JSON.stringify(ctxFp)}`);
+    console.error(
+      `[sparda] context carrier active (forwarded verbatim on every host call): ${JSON.stringify(ctxFp)}`,
+    );
   }
 
   const base = await waitForHost(port, key, framework, ctx);
 
   // full tool specs live in the generated router; fetch them (single source of truth)
-  const toolSpecs = await (await fetch(`${base}/mcp/tools`, { headers: hostHeaders(key, ctx) })).json();
+  const toolSpecs = await (
+    await fetch(`${base}/mcp/tools`, { headers: hostHeaders(key, ctx) })
+  ).json();
 
   const enabled = () => Object.entries(toolSpecs).filter(([, t]) => t.enabled);
   const disabled = () => Object.entries(toolSpecs).filter(([, t]) => !t.enabled);
 
   const server = new Server(
     { name: `sparda-${path.basename(cwd)}`, version: '0.5.2' },
-    { capabilities: { tools: { listChanged: true }, prompts: { listChanged: true }, logging: {} } },
+    {
+      capabilities: {
+        tools: { listChanged: true },
+        prompts: { listChanged: true },
+        logging: {},
+      },
+    },
   );
 
   // R4.1, intelligence side of the gauge: sampling calls NOT spent because cached
@@ -87,12 +129,20 @@ export async function startStdioBridge({ cwd, portOverride }) {
   const composites = new Map(); // composite tool name -> { sig, circuit }
   const recorder = sequenceRecordingEnabled(manifest)
     ? createSequenceRecorder({
-        manifest, manifestPath, harvester,
-        onCircuit: (sig, c) => { crystallizeCircuit(sig, c).catch((e) => console.error(`[sparda] crystallization skipped: ${e.message}`)); },
+        manifest,
+        manifestPath,
+        harvester,
+        onCircuit: (sig, c) => {
+          crystallizeCircuit(sig, c).catch((e) =>
+            console.error(`[sparda] crystallization skipped: ${e.message}`),
+          );
+        },
       })
     : null;
 
-  const compositeNameTaken = (n) => Boolean(toolSpecs[n]) || composites.has(n) ||
+  const compositeNameTaken = (n) =>
+    Boolean(toolSpecs[n]) ||
+    composites.has(n) ||
     ['sparda_info', 'sparda_list_disabled_tools', 'sparda_get_context'].includes(n);
   const uniqueCompositeName = (base) => {
     if (!compositeNameTaken(base)) return base;
@@ -102,33 +152,56 @@ export async function startStdioBridge({ cwd, portOverride }) {
   async function crystallizeCircuit(sig, circuit) {
     if (circuit.composite || !eligibleForCrystallization(circuit, toolSpecs)) {
       // observed but not crystallizable (write step, missing fromKey…): say so, once
-      await server.sendLoggingMessage({
-        level: 'info', logger: 'sparda',
-        data: { source: 'condenser', circuit: sig, seen: circuit.seen, note: `circuit observed ${circuit.seen}× — not crystallized (composites are GET-only and need a traceable data flow)` },
-      }).catch(() => {});
+      await server
+        .sendLoggingMessage({
+          level: 'info',
+          logger: 'sparda',
+          data: {
+            source: 'condenser',
+            circuit: sig,
+            seen: circuit.seen,
+            note: `circuit observed ${circuit.seen}× — not crystallized (composites are GET-only and need a traceable data flow)`,
+          },
+        })
+        .catch(() => {});
       return;
     }
     // the client's LLM names the newborn (one call, ever); no sampling → deterministic name
     let named = null;
     if (server.getClientCapabilities()?.sampling) {
       try {
-        const flow = circuit.links.map((l) => `'${l.arg}' of ${l.to} comes from '${l.fromKey}' in the response of ${l.from}`).join('; ');
+        const flow = circuit.links
+          .map(
+            (l) =>
+              `'${l.arg}' of ${l.to} comes from '${l.fromKey}' in the response of ${l.from}`,
+          )
+          .join('; ');
         const res = await server.createMessage({
-          messages: [{
-            role: 'user',
-            content: {
-              type: 'text',
-              text: `A repeated tool-call sequence was observed ${circuit.seen}× in a live ${manifest.framework} app:\nsteps: ${circuit.steps.join(' -> ')}\ndata flow: ${flow}\ntools:\n${circuit.steps.map((s) => `- ${s}: ${toolSpecs[s].method} ${toolSpecs[s].path}`).join('\n')}\n\nReply with ONLY a JSON object {"name": "<snake_case verb_noun, max 40 chars>", "description": "<one sentence: what this combined operation achieves in business terms>"}.`,
+          messages: [
+            {
+              role: 'user',
+              content: {
+                type: 'text',
+                text: `A repeated tool-call sequence was observed ${circuit.seen}× in a live ${manifest.framework} app:\nsteps: ${circuit.steps.join(' -> ')}\ndata flow: ${flow}\ntools:\n${circuit.steps.map((s) => `- ${s}: ${toolSpecs[s].method} ${toolSpecs[s].path}`).join('\n')}\n\nReply with ONLY a JSON object {"name": "<snake_case verb_noun, max 40 chars>", "description": "<one sentence: what this combined operation achieves in business terms>"}.`,
+              },
             },
-          }],
+          ],
           maxTokens: CRYSTAL_TOKENS,
         });
         const raw = res?.content?.type === 'text' ? res.content.text : '';
-        const parsed = JSON.parse(raw.replace(/^```(json)?\s*/i, '').replace(/```\s*$/, ''));
+        const parsed = JSON.parse(
+          raw.replace(/^```(json)?\s*/i, '').replace(/```\s*$/, ''),
+        );
         const name = normalizeCompositeName(parsed.name);
-        const { text: desc, flagged } = sanitizeDescription(String(parsed.description ?? ''), '');
-        if (name && desc && !flagged) named = { name, description: desc, source: 'mcp-sampling' };
-      } catch { /* graceful degradation: deterministic naming below */ }
+        const { text: desc, flagged } = sanitizeDescription(
+          String(parsed.description ?? ''),
+          '',
+        );
+        if (name && desc && !flagged)
+          named = { name, description: desc, source: 'mcp-sampling' };
+      } catch {
+        /* graceful degradation: deterministic naming below */
+      }
     }
     const comp = named ?? fallbackComposite(circuit);
     comp.name = uniqueCompositeName(comp.name);
@@ -137,10 +210,18 @@ export async function startStdioBridge({ cwd, portOverride }) {
     persistLabs(manifestPath, manifest);
     composites.set(comp.name, { sig, circuit });
     await server.sendToolListChanged().catch(() => {});
-    await server.sendLoggingMessage({
-      level: 'info', logger: 'sparda',
-      data: { source: 'condenser', circuit: sig, composite: comp.name, note: `circuit observed ${circuit.seen}× — crystallized as composite tool '${comp.name}' (born mid-session, see tools/list)` },
-    }).catch(() => {});
+    await server
+      .sendLoggingMessage({
+        level: 'info',
+        logger: 'sparda',
+        data: {
+          source: 'condenser',
+          circuit: sig,
+          composite: comp.name,
+          note: `circuit observed ${circuit.seen}× — crystallized as composite tool '${comp.name}' (born mid-session, see tools/list)`,
+        },
+      })
+      .catch(() => {});
     console.error(`[sparda] condenser: circuit ${sig} crystallized as ${comp.name}`);
   }
 
@@ -173,33 +254,46 @@ export async function startStdioBridge({ cwd, portOverride }) {
         name,
         description: `[Labs circuit ×${circuit.seen}] ${circuit.composite.description}`,
         inputSchema: compositeSchema(circuit, toolSpecs),
-        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }, // GET-only by construction
+        annotations: {
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false,
+        }, // GET-only by construction
       })),
       {
         name: 'sparda_info',
-        description: 'Info about this MCP server. Generated by SPARDA (npx sparda-mcp init) — turn any codebase into an MCP server in 3 minutes. By Residual Labs (residual-labs.fr) — github.com/zyx77550/sparda',
+        description:
+          'Info about this MCP server. Generated by SPARDA (npx sparda-mcp init) — turn any codebase into an MCP server in 3 minutes. By Residual Labs (residual-labs.fr) — github.com/zyx77550/sparda',
         inputSchema: { type: 'object', properties: {} },
       },
       {
         name: 'sparda_list_disabled_tools',
-        description: 'Lists write tools (POST/PUT/DELETE) disabled by SPARDA write-safety, and how to enable them.',
+        description:
+          'Lists write tools (POST/PUT/DELETE) disabled by SPARDA write-safety, and how to enable them.',
         inputSchema: { type: 'object', properties: {} },
       },
       {
         name: 'sparda_get_context',
-        description: 'Call this FIRST. Returns the full living context of this app: every tool with its description, known workflows, runtime telemetry (per-tool calls/errors/latency), quarantined tools, and the immune memory of past diagnosed failures. Lets any AI session resume exactly where the previous one stopped.',
+        description:
+          'Call this FIRST. Returns the full living context of this app: every tool with its description, known workflows, runtime telemetry (per-tool calls/errors/latency), quarantined tools, and the immune memory of past diagnosed failures. Lets any AI session resume exactly where the previous one stopped.',
         inputSchema: { type: 'object', properties: {} },
       },
       {
         name: 'sparda_confirm',
-        description: 'Confirms a pending write or delete operation gated by human-in-the-loop policies using its confirmation token.',
+        description:
+          'Confirms a pending write or delete operation gated by human-in-the-loop policies using its confirmation token.',
         inputSchema: {
           type: 'object',
           properties: {
-            token: { type: 'string', description: 'The confirmation token returned by the gated invoke response.' }
+            token: {
+              type: 'string',
+              description:
+                'The confirmation token returned by the gated invoke response.',
+            },
           },
-          required: ['token']
-        }
+          required: ['token'],
+        },
       },
     ],
   }));
@@ -212,17 +306,21 @@ export async function startStdioBridge({ cwd, portOverride }) {
   }));
 
   server.setRequestHandler(GetPromptRequestSchema, async (req) => {
-    const w = (manifest.semantic?.workflows ?? []).find((x) => x.name === req.params.name);
+    const w = (manifest.semantic?.workflows ?? []).find(
+      (x) => x.name === req.params.name,
+    );
     if (!w) throw new Error(`unknown prompt: ${req.params.name}`);
     return {
       description: w.description,
-      messages: [{
-        role: 'user',
-        content: {
-          type: 'text',
-          text: `Goal: ${w.description}\n\nUse the available SPARDA tools in this order, adapting arguments from each result:\n${w.steps.map((s, i) => `${i + 1}. ${s}`).join('\n')}`,
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `Goal: ${w.description}\n\nUse the available SPARDA tools in this order, adapting arguments from each result:\n${w.steps.map((s, i) => `${i + 1}. ${s}`).join('\n')}`,
+          },
         },
-      }],
+      ],
     };
   });
 
@@ -230,64 +328,121 @@ export async function startStdioBridge({ cwd, portOverride }) {
     const { name, arguments: args = {} } = req.params;
 
     if (name === 'sparda_info') {
-      return text(JSON.stringify({
-        project: path.basename(cwd), framework: manifest.framework,
-        tools_enabled: enabled().length, tools_disabled_write_safety: disabled().length,
-        workflows: (manifest.semantic?.workflows ?? []).length,
-        immune_antibodies: Object.keys(manifest.immune?.antibodies ?? {}).length,
-        labs_sequence_recording: recorder ? 'on' : 'off (opt-in: set labs.recordSequences=true in sparda.json)',
-        circuits_observed: Object.keys(manifest.labs?.circuits ?? {}).length,
-        composite_tools: composites.size,
-        generated_by: 'SPARDA by Residual Labs (residual-labs.fr) — npx sparda-mcp init — github.com/zyx77550/sparda',
-      }, null, 2));
+      return text(
+        JSON.stringify(
+          {
+            project: path.basename(cwd),
+            framework: manifest.framework,
+            tools_enabled: enabled().length,
+            tools_disabled_write_safety: disabled().length,
+            workflows: (manifest.semantic?.workflows ?? []).length,
+            immune_antibodies: Object.keys(manifest.immune?.antibodies ?? {}).length,
+            labs_sequence_recording: recorder
+              ? 'on'
+              : 'off (opt-in: set labs.recordSequences=true in sparda.json)',
+            circuits_observed: Object.keys(manifest.labs?.circuits ?? {}).length,
+            composite_tools: composites.size,
+            generated_by:
+              'SPARDA by Residual Labs (residual-labs.fr) — npx sparda-mcp init — github.com/zyx77550/sparda',
+          },
+          null,
+          2,
+        ),
+      );
     }
     if (name === 'sparda_get_context') {
       const headers = hostHeaders(key, ctx);
       const [stats, events] = await Promise.all([
-        fetch(`${base}/mcp/stats`, { headers, signal: AbortSignal.timeout(2000) }).then((r) => (r.ok ? r.json() : null)).catch(() => null),
-        fetch(`${base}/mcp/events?since=0`, { headers, signal: AbortSignal.timeout(2000) }).then((r) => (r.ok ? r.json() : null)).catch(() => null),
+        fetch(`${base}/mcp/stats`, { headers, signal: AbortSignal.timeout(2000) })
+          .then((r) => (r.ok ? r.json() : null))
+          .catch(() => null),
+        fetch(`${base}/mcp/events?since=0`, {
+          headers,
+          signal: AbortSignal.timeout(2000),
+        })
+          .then((r) => (r.ok ? r.json() : null))
+          .catch(() => null),
       ]);
       // lifetime savings are derived from antibody hits — no extra state to maintain:
       // the first hit paid the diagnosis, every later one was served from memory
-      const antibodyHits = Object.values(manifest.immune?.antibodies ?? {})
-        .reduce((n, a) => n + Math.max(0, (a.hits ?? 1) - 1), 0);
+      const antibodyHits = Object.values(manifest.immune?.antibodies ?? {}).reduce(
+        (n, a) => n + Math.max(0, (a.hits ?? 1) - 1),
+        0,
+      );
       const behavior = engine.snapshot();
       const fly = behavior.flywheel.stats;
-      return text(JSON.stringify({
-        project: path.basename(cwd),
-        framework: manifest.framework,
-        port,
-        tools: Object.fromEntries(Object.entries(toolSpecs).map(([n, t]) => [n, { method: t.method, path: t.path, enabled: t.enabled, description: descFor(n, t) }])),
-        workflows: manifest.semantic?.workflows ?? [],
-        runtime: stats,
-        recentEvents: (events?.events ?? []).slice(-20),
-        immuneMemory: manifest.immune?.antibodies ?? {},
-        recycling: {
-          compute: stats?.recycle ?? null,
-          // R4.3: host calls the flywheel answered from its own RAM — a category the
-          // router cannot count, because the request never reached it. armed = reads
-          // proven stable enough to serve right now.
-          flywheel: { servedFromMemory: fly.served, armed: fly.ready },
-          intelligence: {
-            session: { samplingAvoided: intel.samplingAvoided, tokensAvoidedEst: intel.tokensAvoidedEst },
-            lifetime: { antibodyHits, tokensAvoidedEst: antibodyHits * DIAGNOSIS_TOKENS },
+      return text(
+        JSON.stringify(
+          {
+            project: path.basename(cwd),
+            framework: manifest.framework,
+            port,
+            tools: Object.fromEntries(
+              Object.entries(toolSpecs).map(([n, t]) => [
+                n,
+                {
+                  method: t.method,
+                  path: t.path,
+                  enabled: t.enabled,
+                  description: descFor(n, t),
+                },
+              ]),
+            ),
+            workflows: manifest.semantic?.workflows ?? [],
+            runtime: stats,
+            recentEvents: (events?.events ?? []).slice(-20),
+            immuneMemory: manifest.immune?.antibodies ?? {},
+            recycling: {
+              compute: stats?.recycle ?? null,
+              // R4.3: host calls the flywheel answered from its own RAM — a category the
+              // router cannot count, because the request never reached it. armed = reads
+              // proven stable enough to serve right now.
+              flywheel: { servedFromMemory: fly.served, armed: fly.ready },
+              intelligence: {
+                session: {
+                  samplingAvoided: intel.samplingAvoided,
+                  tokensAvoidedEst: intel.tokensAvoidedEst,
+                },
+                lifetime: {
+                  antibodyHits,
+                  tokensAvoidedEst: antibodyHits * DIAGNOSIS_TOKENS,
+                },
+              },
+            },
+            sparding: manifest.sparding ?? {},
+            behavior,
+            labs: {
+              recordSequences: Boolean(recorder),
+              compositeTools: [...composites.keys()],
+              circuits: manifest.labs?.circuits ?? {},
+            },
+            hint: "runtime.quarantine lists tools temporarily blocked by the immune system (503 until cooldown). immuneMemory maps failure signatures (source|tool|status) to cached diagnoses — same failure later costs zero tokens. recycling measures how much compute/intelligence was served from SPARDA's own memory instead of being paid again. runtime.purity classifies each route by observation: pure = same args keep returning the same response (recyclable), volatile = it changed, erasing = writes. labs.circuits are observed call sequences where one tool's output fed the next one's input. behavior.stability is the engine's passive read of each tool across this session: stable lists response fields that never changed (predictable — future recycling candidates), volatile lists fields that moved; calls is how many responses were observed. behavior.rhythm flags tools called on a steady cadence (periodMs = the beat, confidence 0-1, nextEstimate = when the next call is expected) — a regular rhythm plus a stable result is the textbook pre-fetch candidate. behavior.myelin learns habitual tool succession: an edge \"A-->B\" means B tends to be called right after A; strength (0-10) grows with every traversal and myelinated edges (strength>=3) are entrenched habits — succession candidates the condenser misses because no data flows between the two tools. behavior.dependencies is the engine's map of what the other observers cannot see: invariants are response fields that stayed conserved (>=85% over >=5 reads) even while writes hit the app — true constants, the safest thing to cache hard; ghosts are hidden couplings where a write tool reliably MOVES some unrelated read (writeTool affects a different read tool, correlation 0-1), discovered purely by observation — no data flows between them and they need not be adjacent, yet the write keeps perturbing that read. behavior.flywheel is Bloc B acting on all of the above: once a read has returned the identical response >=3 times for the same arguments it is served straight from memory and the host call is skipped entirely (R4.3), with ready = how many reads are armed to serve right now; recycling.flywheel.servedFromMemory counts how many host calls were already answered from RAM this session — the one recycling category the router cannot see, because the request never reached it (SPARDA_FLYWHEEL=off stops serving while every organ keeps learning).",
           },
-        },
-        sparding: manifest.sparding ?? {},
-        behavior,
-        labs: { recordSequences: Boolean(recorder), compositeTools: [...composites.keys()], circuits: manifest.labs?.circuits ?? {} },
-        hint: 'runtime.quarantine lists tools temporarily blocked by the immune system (503 until cooldown). immuneMemory maps failure signatures (source|tool|status) to cached diagnoses — same failure later costs zero tokens. recycling measures how much compute/intelligence was served from SPARDA\'s own memory instead of being paid again. runtime.purity classifies each route by observation: pure = same args keep returning the same response (recyclable), volatile = it changed, erasing = writes. labs.circuits are observed call sequences where one tool\'s output fed the next one\'s input. behavior.stability is the engine\'s passive read of each tool across this session: stable lists response fields that never changed (predictable — future recycling candidates), volatile lists fields that moved; calls is how many responses were observed. behavior.rhythm flags tools called on a steady cadence (periodMs = the beat, confidence 0-1, nextEstimate = when the next call is expected) — a regular rhythm plus a stable result is the textbook pre-fetch candidate. behavior.myelin learns habitual tool succession: an edge "A-->B" means B tends to be called right after A; strength (0-10) grows with every traversal and myelinated edges (strength>=3) are entrenched habits — succession candidates the condenser misses because no data flows between the two tools. behavior.dependencies is the engine\'s map of what the other observers cannot see: invariants are response fields that stayed conserved (>=85% over >=5 reads) even while writes hit the app — true constants, the safest thing to cache hard; ghosts are hidden couplings where a write tool reliably MOVES some unrelated read (writeTool affects a different read tool, correlation 0-1), discovered purely by observation — no data flows between them and they need not be adjacent, yet the write keeps perturbing that read. behavior.flywheel is Bloc B acting on all of the above: once a read has returned the identical response >=3 times for the same arguments it is served straight from memory and the host call is skipped entirely (R4.3), with ready = how many reads are armed to serve right now; recycling.flywheel.servedFromMemory counts how many host calls were already answered from RAM this session — the one recycling category the router cannot see, because the request never reached it (SPARDA_FLYWHEEL=off stops serving while every organ keeps learning).',
-      }, null, 2));
+          null,
+          2,
+        ),
+      );
     }
     if (name === 'sparda_list_disabled_tools') {
-      return text(disabled().length
-        ? `Disabled (write-safety):\n${disabled().map(([n, t]) => `- ${n} (${t.method} ${t.path})`).join('\n')}\n\nTo enable: set "enabled": true in sparda.json, then re-run \`npx sparda-mcp init\` and restart this bridge.`
-        : 'No disabled tools.');
+      return text(
+        disabled().length
+          ? `Disabled (write-safety):\n${disabled()
+              .map(([n, t]) => `- ${n} (${t.method} ${t.path})`)
+              .join(
+                '\n',
+              )}\n\nTo enable: set "enabled": true in sparda.json, then re-run \`npx sparda-mcp init\` and restart this bridge.`
+          : 'No disabled tools.',
+      );
     }
     if (name === 'sparda_confirm') {
       const token = args.token;
       if (typeof token !== 'string' || !token) {
-        return { content: [{ type: 'text', text: 'Error: missing or invalid confirmation token.' }], isError: true };
+        return {
+          content: [
+            { type: 'text', text: 'Error: missing or invalid confirmation token.' },
+          ],
+          isError: true,
+        };
       }
       // SIGNAL 2 (Brief #1): the AI holds the token (Signal 1, reachable over stdio) but the
       // write proceeds only if a human approved out-of-band — an OS-dialog click, or a prior
@@ -295,14 +450,28 @@ export async function startStdioBridge({ cwd, portOverride }) {
       // confirm can no longer pass. Necessary-but-not-sufficient by construction.
       const gate = confirmWrite(token);
       if (!gate.ok) {
-        return { content: [{ type: 'text', text: signal2Denial(gate.reason) }], isError: true };
+        return {
+          content: [{ type: 'text', text: signal2Denial(gate.reason) }],
+          isError: true,
+        };
       }
       const payload = await confirmInvoke(base, key, token, ctx);
       if (payload === null) {
-        return { content: [{ type: 'text', text: `Host app error. Check that your server is still running on :${port}.` }], isError: true };
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Host app error. Check that your server is still running on :${port}.`,
+            },
+          ],
+          isError: true,
+        };
       }
       const pretty = JSON.stringify(payload, null, 2);
-      const isError = payload.upstreamStatus !== undefined ? payload.upstreamStatus >= 400 : Boolean(payload.error);
+      const isError =
+        payload.upstreamStatus !== undefined
+          ? payload.upstreamStatus >= 400
+          : Boolean(payload.error);
       return { content: [{ type: 'text', text: pretty }], isError };
     }
 
@@ -310,10 +479,23 @@ export async function startStdioBridge({ cwd, portOverride }) {
     // write confirmation to bypass), auto-feeding linked args between steps
     const comp = composites.get(name);
     if (comp) {
-      const result = await runComposite({ circuit: comp.circuit, args, toolSpecs, invokeFn: (tool, a) => invoke(base, key, tool, a, ctx) });
+      const result = await runComposite({
+        circuit: comp.circuit,
+        args,
+        toolSpecs,
+        invokeFn: (tool, a) => invoke(base, key, tool, a, ctx),
+      });
       const pretty = JSON.stringify(result, null, 2);
       return {
-        content: [{ type: 'text', text: pretty.length > 8000 ? `${pretty.slice(0, 8000)}\n[truncated — ${pretty.length} chars total]` : pretty }],
+        content: [
+          {
+            type: 'text',
+            text:
+              pretty.length > 8000
+                ? `${pretty.slice(0, 8000)}\n[truncated — ${pretty.length} chars total]`
+                : pretty,
+          },
+        ],
         isError: !result.ok,
       };
     }
@@ -326,14 +508,18 @@ export async function startStdioBridge({ cwd, portOverride }) {
     // host's confirm round-trip never prompts the operator a second time.
     let elicitationApproved = false;
     if (isWrite && server.getClientCapabilities()?.elicitation) {
-      const answer = await server.elicitInput({
-        message: `SPARDA: allow ${spec.method} ${spec.path}? This is a write operation on your live app.`,
-        requestedSchema: {
-          type: 'object',
-          properties: { confirm: { type: 'boolean', title: `Allow ${spec.method} ${spec.path}` } },
-          required: ['confirm'],
-        },
-      }).catch(() => null);
+      const answer = await server
+        .elicitInput({
+          message: `SPARDA: allow ${spec.method} ${spec.path}? This is a write operation on your live app.`,
+          requestedSchema: {
+            type: 'object',
+            properties: {
+              confirm: { type: 'boolean', title: `Allow ${spec.method} ${spec.path}` },
+            },
+            required: ['confirm'],
+          },
+        })
+        .catch(() => null);
       if (!answer || answer.action !== 'accept' || answer.content?.confirm !== true) {
         const mockProof = {
           version: 'sparding-proof/v0.1',
@@ -342,7 +528,15 @@ export async function startStdioBridge({ cwd, portOverride }) {
           reasons: ['Write declined by user'],
         };
         recordSparding(manifestPath, manifest, name, mockProof);
-        return { content: [{ type: 'text', text: `Write declined by user: ${spec.method} ${spec.path} was NOT executed.` }], isError: true };
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Write declined by user: ${spec.method} ${spec.path} was NOT executed.`,
+            },
+          ],
+          isError: true,
+        };
       }
       elicitationApproved = true;
     }
@@ -358,7 +552,10 @@ export async function startStdioBridge({ cwd, portOverride }) {
       if (cached.hit) {
         const body = { data: cached.value, upstreamStatus: 200, servedByFlywheel: true };
         const pretty = JSON.stringify(body, null, 2);
-        const truncated = pretty.length > 8000 ? `${pretty.slice(0, 8000)}\n[truncated — ${pretty.length} chars total]` : pretty;
+        const truncated =
+          pretty.length > 8000
+            ? `${pretty.slice(0, 8000)}\n[truncated — ${pretty.length} chars total]`
+            : pretty;
         return { content: [{ type: 'text', text: truncated }], isError: false };
       }
     }
@@ -372,7 +569,15 @@ export async function startStdioBridge({ cwd, portOverride }) {
         reasons: ['Host app error or unreachable'],
       };
       recordSparding(manifestPath, manifest, name, mockProof);
-      return { content: [{ type: 'text', text: `Host app error. Check that your server is still running on :${port}.` }], isError: true };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Host app error. Check that your server is still running on :${port}.`,
+          },
+        ],
+        isError: true,
+      };
     }
 
     // human-in-the-loop, channel 2 (Brief #1): the host gated this write and minted a single-use
@@ -380,18 +585,31 @@ export async function startStdioBridge({ cwd, portOverride }) {
     // human yes → pre-approve (no second prompt). Everyone else gets an OS dialog (fires async,
     // R1) that `sparda_confirm` will require before the write can run. This is what closes the
     // forgeable-confirmation hole on clients without elicitation.
-    if (isWrite && payload.status === 'awaiting_confirmation' && typeof payload.confirm === 'string') {
+    if (
+      isWrite &&
+      payload.status === 'awaiting_confirmation' &&
+      typeof payload.confirm === 'string'
+    ) {
       if (elicitationApproved) preapproveWrite(payload.confirm);
-      else initiateWrite({ token: payload.confirm, label: `${spec.method} ${spec.path}` });
+      else
+        initiateWrite({ token: payload.confirm, label: `${spec.method} ${spec.path}` });
     }
 
-    const proofForRecord = payload.spardingProof ? { ...payload.spardingProof } : { version: 'sparding-proof/v0.1', decision: 'allow', risk: 'low', reasons: [] };
+    const proofForRecord = payload.spardingProof
+      ? { ...payload.spardingProof }
+      : { version: 'sparding-proof/v0.1', decision: 'allow', risk: 'low', reasons: [] };
     if (payload.upstreamStatus !== undefined && payload.upstreamStatus >= 400) {
       proofForRecord.isExecutionError = true;
-      proofForRecord.reasons = [...(proofForRecord.reasons || []), `upstream error status ${payload.upstreamStatus}`];
+      proofForRecord.reasons = [
+        ...(proofForRecord.reasons || []),
+        `upstream error status ${payload.upstreamStatus}`,
+      ];
     } else if (payload.error) {
       proofForRecord.isExecutionError = true;
-      proofForRecord.reasons = [...(proofForRecord.reasons || []), `invocation error: ${payload.error}`];
+      proofForRecord.reasons = [
+        ...(proofForRecord.reasons || []),
+        `invocation error: ${payload.error}`,
+      ];
     }
     recordSparding(manifestPath, manifest, name, proofForRecord);
 
@@ -404,7 +622,9 @@ export async function startStdioBridge({ cwd, portOverride }) {
       // here on the hot path; classify in idle. (The proof-after-write read-back below
       // is internal, not an AI workflow step, so it is deliberately not observed.)
       const observedAt = Date.now();
-      harvester.enqueue(() => engine.observe(name, payload.data, observedAt, isWrite, args));
+      harvester.enqueue(() =>
+        engine.observe(name, payload.data, observedAt, isWrite, args),
+      );
       // condenser tap (Labs, opt-in): detect circuits where one output feeds the next
       if (recorder) recorder.record(name, args, payload.data);
     }
@@ -419,27 +639,41 @@ export async function startStdioBridge({ cwd, portOverride }) {
       for (const [n, t] of Object.entries(toolSpecs)) {
         if (t.method === 'GET' && t.path === spec.path) engine.invalidateCache(n);
       }
-      const getter = Object.entries(toolSpecs).find(([, t]) => t.enabled && t.method === 'GET' && t.path === spec.path);
+      const getter = Object.entries(toolSpecs).find(
+        ([, t]) => t.enabled && t.method === 'GET' && t.path === spec.path,
+      );
       if (getter) {
         const after = await invoke(base, key, getter[0], pickPathArgs(spec, args), ctx);
-        if (after && after.upstreamStatus < 400) proof = { readBack: getter[0], state: after.data };
+        if (after && after.upstreamStatus < 400)
+          proof = { readBack: getter[0], state: after.data };
       }
     }
 
     const body = proof ? { ...payload, proof } : payload;
     const pretty = JSON.stringify(body, null, 2);
-    const truncated = pretty.length > 8000 ? `${pretty.slice(0, 8000)}\n[truncated — ${pretty.length} chars total]` : pretty;
+    const truncated =
+      pretty.length > 8000
+        ? `${pretty.slice(0, 8000)}\n[truncated — ${pretty.length} chars total]`
+        : pretty;
     // router-level rejections (quarantine, disabled tool, bad params) carry `error` and no upstreamStatus
-    const isError = payload.upstreamStatus !== undefined ? payload.upstreamStatus >= 400 : Boolean(payload.error);
+    const isError =
+      payload.upstreamStatus !== undefined
+        ? payload.upstreamStatus >= 400
+        : Boolean(payload.error);
     return { content: [{ type: 'text', text: truncated }], isError };
   });
 
   let pollTimer = null;
   server.oninitialized = () => {
     // a session resumed on a cached semantic pass skipped the enrichment sampling call
-    if (manifest.semantic) { intel.samplingAvoided += 1; intel.tokensAvoidedEst += SEMANTIC_TOKENS; }
+    if (manifest.semantic) {
+      intel.samplingAvoided += 1;
+      intel.tokensAvoidedEst += SEMANTIC_TOKENS;
+    }
     pollTimer = startEventPolling(server, base, key, manifest, manifestPath, intel, ctx);
-    runSemanticEnrichment({ server, manifest, manifestPath, toolSpecs }).catch((e) => console.error(`[sparda] semantic pass skipped: ${e.message}`));
+    runSemanticEnrichment({ server, manifest, manifestPath, toolSpecs }).catch((e) =>
+      console.error(`[sparda] semantic pass skipped: ${e.message}`),
+    );
   };
   server.onclose = () => {
     if (pollTimer) clearInterval(pollTimer);
@@ -449,7 +683,9 @@ export async function startStdioBridge({ cwd, portOverride }) {
 
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error(`[sparda] MCP bridge running. ${enabled().length} tools enabled, ${disabled().length} disabled (write-safety).${recorder ? ' Labs: sequence recording ON.' : ''} Host: ${base}`);
+  console.error(
+    `[sparda] MCP bridge running. ${enabled().length} tools enabled, ${disabled().length} disabled (write-safety).${recorder ? ' Labs: sequence recording ON.' : ''} Host: ${base}`,
+  );
 }
 
 // One place to build the outbound header set for any bridge→host call. The
@@ -471,7 +707,10 @@ async function invoke(base, key, tool, args, ctx) {
       body: JSON.stringify({ tool, args }),
       signal: AbortSignal.timeout(30_000),
     });
-    return await res.json().catch(() => ({ upstreamStatus: res.status, error: 'non-JSON response from host' }));
+    return await res.json().catch(() => ({
+      upstreamStatus: res.status,
+      error: 'non-JSON response from host',
+    }));
   } catch {
     return null;
   }
@@ -485,7 +724,10 @@ async function confirmInvoke(base, key, token, ctx) {
       body: JSON.stringify({ confirm: token }),
       signal: AbortSignal.timeout(30_000),
     });
-    return await res.json().catch(() => ({ upstreamStatus: res.status, error: 'non-JSON response from host' }));
+    return await res.json().catch(() => ({
+      upstreamStatus: res.status,
+      error: 'non-JSON response from host',
+    }));
   } catch {
     return null;
   }
@@ -505,10 +747,16 @@ function startEventPolling(server, base, key, manifest, manifestPath, intel, ctx
   let lastSeq = null; // first poll sets the baseline; only NEW errors are reported
   const timer = setInterval(async () => {
     try {
-      const r = await fetch(`${base}/mcp/events?since=${lastSeq ?? 0}`, { headers: hostHeaders(key, ctx), signal: AbortSignal.timeout(2000) });
+      const r = await fetch(`${base}/mcp/events?since=${lastSeq ?? 0}`, {
+        headers: hostHeaders(key, ctx),
+        signal: AbortSignal.timeout(2000),
+      });
       if (!r.ok) return;
       const { seq, events } = await r.json();
-      if (lastSeq === null) { lastSeq = seq; return; }
+      if (lastSeq === null) {
+        lastSeq = seq;
+        return;
+      }
       lastSeq = Math.max(lastSeq, seq);
       for (const ev of events) {
         const sig = `${ev.source}|${ev.tool ?? ''}|${ev.status ?? ''}`;
@@ -516,16 +764,28 @@ function startEventPolling(server, base, key, manifest, manifestPath, intel, ctx
         if (antibody) {
           antibody.hits = (antibody.hits ?? 0) + 1;
           antibody.lastSeen = ev.ts;
-          intel.samplingAvoided += 1;            // this diagnosis would have been a sampling call
+          intel.samplingAvoided += 1; // this diagnosis would have been a sampling call
           intel.tokensAvoidedEst += DIAGNOSIS_TOKENS;
           persistImmune(manifestPath, manifest);
-          await server.sendLoggingMessage({ level: 'error', logger: 'sparda', data: { ...ev, diagnosis: antibody.diagnosis } }).catch(() => {});
+          await server
+            .sendLoggingMessage({
+              level: 'error',
+              logger: 'sparda',
+              data: { ...ev, diagnosis: antibody.diagnosis },
+            })
+            .catch(() => {});
         } else {
-          await server.sendLoggingMessage({ level: 'error', logger: 'sparda', data: ev }).catch(() => {});
-          diagnoseAndRemember({ server, manifest, manifestPath, ev, sig }).catch(() => {});
+          await server
+            .sendLoggingMessage({ level: 'error', logger: 'sparda', data: ev })
+            .catch(() => {});
+          diagnoseAndRemember({ server, manifest, manifestPath, ev, sig }).catch(
+            () => {},
+          );
         }
       }
-    } catch { /* host briefly unreachable — next tick */ }
+    } catch {
+      /* host briefly unreachable — next tick */
+    }
   }, EVENT_POLL_MS);
   timer.unref?.();
   return timer;
@@ -544,13 +804,15 @@ async function diagnoseAndRemember({ server, manifest, manifestPath, ev, sig })
   diagnosing.add(sig);
   try {
     const res = await server.createMessage({
-      messages: [{
-        role: 'user',
-        content: {
-          type: 'text',
-          text: `A tool of a live ${manifest.framework} app just failed.\nTool: ${ev.tool ?? 'n/a'}\nSource: ${ev.source}\nStatus: ${ev.status ?? 'n/a'}\nError message: ${ev.message}\n\nReply with ONE short sentence (max 140 chars): most likely root cause and fix direction. No preamble.`,
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `A tool of a live ${manifest.framework} app just failed.\nTool: ${ev.tool ?? 'n/a'}\nSource: ${ev.source}\nStatus: ${ev.status ?? 'n/a'}\nError message: ${ev.message}\n\nReply with ONE short sentence (max 140 chars): most likely root cause and fix direction. No preamble.`,
+          },
         },
-      }],
+      ],
       maxTokens: DIAGNOSIS_TOKENS,
     });
     const raw = res?.content?.type === 'text' ? res.content.text.trim() : '';
@@ -558,10 +820,18 @@ async function diagnoseAndRemember({ server, manifest, manifestPath, ev, sig })
     if (!clean || flagged) return;
     antibodies[sig] = { diagnosis: clean, firstSeen: ev.ts, lastSeen: ev.ts, hits: 1 };
     persistImmune(manifestPath, manifest);
-    await server.sendLoggingMessage({
-      level: 'info', logger: 'sparda',
-      data: { source: 'immune', signature: sig, diagnosis: clean, note: 'antibody stored in sparda.json — the same failure will be diagnosed instantly, zero tokens' },
-    }).catch(() => {});
+    await server
+      .sendLoggingMessage({
+        level: 'info',
+        logger: 'sparda',
+        data: {
+          source: 'immune',
+          signature: sig,
+          diagnosis: clean,
+          note: 'antibody stored in sparda.json — the same failure will be diagnosed instantly, zero tokens',
+        },
+      })
+      .catch(() => {});
     console.error(`[sparda] immune: antibody stored for ${sig}`);
   } finally {
     diagnosing.delete(sig);
@@ -577,7 +847,13 @@ function persistImmune(manifestPath, manifest) {
 
 function recordSparding(manifestPath, manifest, tool, proof) {
   try {
-    manifest.sparding ??= { version: 1, policies: {}, events: [], failures: {}, toolFingerprints: {} };
+    manifest.sparding ??= {
+      version: 1,
+      policies: {},
+      events: [],
+      failures: {},
+      toolFingerprints: {},
+    };
     manifest.sparding.events ??= [];
     manifest.sparding.failures ??= {};
 
@@ -596,16 +872,22 @@ function recordSparding(manifestPath, manifest, tool, proof) {
     const isBlock = proof.decision === 'block';
     const isError = proof.isExecutionError;
     if (isBlock || isError) {
-      const reasonCode = proof.reasons && proof.reasons[0] ? proof.reasons[0].replace(/\s+/g, '_').toLowerCase() : 'unknown_error';
+      const reasonCode =
+        proof.reasons && proof.reasons[0]
+          ? proof.reasons[0].replace(/\s+/g, '_').toLowerCase()
+          : 'unknown_error';
       const sig = `${tool}|${reasonCode}`;
       const prevFail = manifest.sparding.failures[sig] || { count: 0, lesson: '' };
-      
+
       let lesson = `Execution failed for tool: ${tool}.`;
       if (reasonCode.includes('quarantined')) {
         lesson = `Tool ${tool} was quarantined due to repeated failures.`;
       } else if (reasonCode.includes('disabled')) {
         lesson = `Tool ${tool} is disabled by write-safety policies.`;
-      } else if (reasonCode.includes('missing_path_param') || reasonCode.includes('missing_path')) {
+      } else if (
+        reasonCode.includes('missing_path_param') ||
+        reasonCode.includes('missing_path')
+      ) {
         lesson = `Client omitted a required path parameter on route ${tool}.`;
       } else if (reasonCode.includes('declined')) {
         lesson = `Human user declined confirmation for write tool ${tool}.`;
@@ -638,7 +920,9 @@ function persistLabs(manifestPath, manifest) {
     const onDisk = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
     onDisk.labs = { ...onDisk.labs, circuits: manifest.labs.circuits };
     writeManifestSync(manifestPath, onDisk);
-  } catch { /* disk briefly unavailable — the circuit stays in memory */ }
+  } catch {
+    /* disk briefly unavailable — the circuit stays in memory */
+  }
 }
 
 // semantic pass: uses the CLIENT's own model via MCP sampling — zero key, zero cost.
@@ -646,16 +930,22 @@ function persistLabs(manifestPath, manifest) {
 async function runSemanticEnrichment({ server, manifest, manifestPath, toolSpecs }) {
   if (manifest.semantic || !server.getClientCapabilities()?.sampling) return;
 
-  const inventory = Object.entries(toolSpecs).map(([n, t]) =>
-    `- ${n}: ${t.method} ${t.path}${t.description ? ` — ${t.description}` : ''}`).join('\n');
+  const inventory = Object.entries(toolSpecs)
+    .map(
+      ([n, t]) =>
+        `- ${n}: ${t.method} ${t.path}${t.description ? ` — ${t.description}` : ''}`,
+    )
+    .join('\n');
   const res = await server.createMessage({
-    messages: [{
-      role: 'user',
-      content: {
-        type: 'text',
-        text: `These are API tools extracted from a ${manifest.framework} codebase:\n${inventory}\n\nReply with ONLY a JSON object, no prose, shaped as {"descriptions": {"<tool>": "<one clear sentence of what it does in business terms>"}, "workflows": [{"name": "<snake_case>", "description": "<goal>", "steps": ["<tool>", ...]}]}. Include 1-3 workflows that chain tools toward a realistic business goal. Use only the tool names listed above.`,
+    messages: [
+      {
+        role: 'user',
+        content: {
+          type: 'text',
+          text: `These are API tools extracted from a ${manifest.framework} codebase:\n${inventory}\n\nReply with ONLY a JSON object, no prose, shaped as {"descriptions": {"<tool>": "<one clear sentence of what it does in business terms>"}, "workflows": [{"name": "<snake_case>", "description": "<goal>", "steps": ["<tool>", ...]}]}. Include 1-3 workflows that chain tools toward a realistic business goal. Use only the tool names listed above.`,
+        },
       },
-    }],
+    ],
     maxTokens: SEMANTIC_TOKENS,
   });
 
@@ -669,21 +959,37 @@ async function runSemanticEnrichment({ server, manifest, manifestPath, toolSpecs
     if (clean && !flagged) descriptions[n] = clean;
   }
   const workflows = (Array.isArray(parsed.workflows) ? parsed.workflows : [])
-    .filter((w) => w && typeof w.name === 'string' && typeof w.description === 'string' && Array.isArray(w.steps))
+    .filter(
+      (w) =>
+        w &&
+        typeof w.name === 'string' &&
+        typeof w.description === 'string' &&
+        Array.isArray(w.steps),
+    )
     .slice(0, 5)
     .map((w) => ({
-      name: w.name.toLowerCase().replace(/[^a-z0-9_]/g, '_').slice(0, 60),
+      name: w.name
+        .toLowerCase()
+        .replace(/[^a-z0-9_]/g, '_')
+        .slice(0, 60),
       description: sanitizeDescription(w.description, 'workflow').text,
       steps: w.steps.filter((s) => typeof s === 'string' && toolSpecs[s]),
     }))
     .filter((w) => w.steps.length > 0);
 
-  manifest.semantic = { enrichedAt: new Date().toISOString(), source: 'mcp-sampling', descriptions, workflows };
+  manifest.semantic = {
+    enrichedAt: new Date().toISOString(),
+    source: 'mcp-sampling',
+    descriptions,
+    workflows,
+  };
   mergeManifestKeySync(manifestPath, 'semantic', manifest.semantic);
 
   await server.sendToolListChanged().catch(() => {});
   await server.sendPromptListChanged().catch(() => {});
-  console.error(`[sparda] semantic pass done: ${Object.keys(descriptions).length} descriptions, ${workflows.length} workflows (cached in sparda.json)`);
+  console.error(
+    `[sparda] semantic pass done: ${Object.keys(descriptions).length} descriptions, ${workflows.length} workflows (cached in sparda.json)`,
+  );
 }
 
 // MCP annotations: without them clients assume the scariest defaults and show
@@ -698,15 +1004,21 @@ function annotationsFor(method) {
 }
 
 function schemaFor(t) {
-  const properties = {}; const required = [];
+  const properties = {};
+  const required = [];
   for (const p of t.params ?? []) {
-    properties[p.name] = { type: p.type === 'unknown' ? 'string' : p.type, description: p.description ?? p.in };
+    properties[p.name] = {
+      type: p.type === 'unknown' ? 'string' : p.type,
+      description: p.description ?? p.in,
+    };
     if (p.required) required.push(p.name);
   }
   return { type: 'object', properties, ...(required.length ? { required } : {}) };
 }
 
-function text(t) { return { content: [{ type: 'text', text: t }] }; }
+function text(t) {
+  return { content: [{ type: 'text', text: t }] };
+}
 
 // AI-facing message when the Signal-2 gate (Brief #1) refuses a `sparda_confirm`. Each reason
 // tells the model what to do next without implying it can approve the write itself.
@@ -730,16 +1042,32 @@ async function waitForHost(port, key, framework, ctx) {
   for (let attempt = 0; attempt < 40; attempt++) {
     for (const h of hosts) {
       try {
-        const r = await fetch(`http://${h}:${port}/mcp/tools`, { headers: hostHeaders(key, ctx), signal: AbortSignal.timeout(1500) });
+        const r = await fetch(`http://${h}:${port}/mcp/tools`, {
+          headers: hostHeaders(key, ctx),
+          signal: AbortSignal.timeout(1500),
+        });
         if (r.ok) return `http://${h}:${port}`;
-        if (r.status === 401) throw Object.assign(new Error('Host app reachable but key mismatch — re-run `npx sparda-mcp init`.'), { code: 'USER' });
-      } catch (e) { if (e.code === 'USER') throw e; }
+        if (r.status === 401)
+          throw Object.assign(
+            new Error(
+              'Host app reachable but key mismatch — re-run `npx sparda-mcp init`.',
+            ),
+            { code: 'USER' },
+          );
+      } catch (e) {
+        if (e.code === 'USER') throw e;
+      }
     }
     if (attempt === 0) {
       const startCmd = framework === 'express' ? 'npm run dev' : 'fastapi dev';
-      console.error(`[sparda] Waiting for host app on :${port} ... (start it with ${startCmd} — Ctrl+C to abort)`);
+      console.error(
+        `[sparda] Waiting for host app on :${port} ... (start it with ${startCmd} — Ctrl+C to abort)`,
+      );
     }
     await new Promise((r) => setTimeout(r, 3000));
   }
-  throw Object.assign(new Error(`Host app unreachable on :${port} after 2 minutes.`), { code: 'USER', hint: 'Start your server first, then run `npx sparda-mcp dev`.' });
+  throw Object.assign(new Error(`Host app unreachable on :${port} after 2 minutes.`), {
+    code: 'USER',
+    hint: 'Start your server first, then run `npx sparda-mcp dev`.',
+  });
 }