musubix2 0.5.6 → 0.5.8

package/.claude/.musubix-managed

@@ -1 +1 @@
-{"generator":"musubix2","version":"0.5.6","timestamp":"2026-07-09T09:46:29.695Z"}
+{"generator":"musubix2","version":"0.5.8","timestamp":"2026-07-09T10:18:54.616Z"}

package/dist/assets/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0",
-  "generatedAt": "2026-07-09T09:46:29.725Z",
+  "generatedAt": "2026-07-09T10:18:54.648Z",
   "entries": [
     {
       "platform": "copilot",

package/dist/cli.js

@@ -12124,6 +12124,19 @@ var init_transport = __esm({
           this.rl = null;
         }
       }
+      /**
+       * Resolve once the input stream closes (client disconnect / stdin EOF).
+       * Used by the CLI launcher to keep the process alive for the lifetime of
+       * the connection — `start()` intentionally resolves immediately so callers
+       * can begin writing, so a separate wait hook is needed to block on.
+       */
+      async waitForClose() {
+        if (!this.rl)
+          return;
+        await new Promise((resolve9) => {
+          this.rl.once("close", () => resolve9());
+        });
+      }
       send(message) {
         this.output.write(JSON.stringify(message) + "\n");
       }
@@ -13823,108 +13836,139 @@ function fail(error) {
 }
 function sddCoreTools() {
   return [
-    tool("sdd.requirements.create", "Create an EARS requirement (Easy Approach to Requirements Syntax)", "sdd-core", [
-      param("pattern", "string", "EARS pattern: ubiquitous | event-driven | unwanted | state-driven | optional"),
-      param("text", "string", "Requirement text"),
+    tool("sdd.requirements.create", "Create and classify an EARS requirement (Easy Approach to Requirements Syntax)", "sdd-core", [
+      param("text", "string", "Requirement text (EARS sentence)"),
       param("id", "string", "Requirement ID", false)
     ], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const req = core.createRequirement?.({
-          pattern: params["pattern"],
-          text: params["text"],
-          id: params["id"]
+        const { createEARSValidator: createEARSValidator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const v = createEARSValidator2();
+        const text = params["text"];
+        const analysis = v.analyze(text);
+        const validation = v.validate(text);
+        return ok({
+          id: params["id"] ?? "REQ-XXX-001",
+          text,
+          pattern: analysis.pattern,
+          confidence: analysis.confidence,
+          valid: validation.valid,
+          issues: validation.issues
         });
-        return ok(req ?? { pattern: params["pattern"], text: params["text"], id: params["id"] ?? "REQ-001" });
       } catch {
-        return ok({ pattern: params["pattern"], text: params["text"], id: params["id"] ?? "REQ-001" });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.requirements.validate", "Validate requirements for completeness and consistency", "sdd-core", [param("requirements", "array", "Array of requirement objects to validate")], async (params) => {
+    tool("sdd.requirements.validate", "Validate requirements (EARS pattern + issues) for a list of requirement texts", "sdd-core", [param("requirements", "array", "Array of requirement texts or {text} objects")], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const result = core.validateRequirements?.(params["requirements"]);
-        return ok(result ?? { valid: true, issues: [] });
+        const { createEARSValidator: createEARSValidator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const v = createEARSValidator2();
+        const items = params["requirements"] ?? [];
+        const results = items.map((it) => {
+          const text = typeof it === "string" ? it : it.text ?? "";
+          const analysis = v.analyze(text);
+          const validation = v.validate(text);
+          return { text, pattern: analysis.pattern, valid: validation.valid, issues: validation.issues };
+        });
+        return ok({ results, allValid: results.every((r) => r.valid) });
       } catch {
-        return ok({ valid: true, issues: [] });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.requirements.list", "List all requirements in the current project", "sdd-core", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
+    tool("sdd.requirements.list", "Parse and list requirements from a Markdown requirements document", "sdd-core", [param("markdown", "string", "Requirements document contents (Markdown)")], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const list = core.listRequirements?.(params["basePath"] ?? ".");
-        return ok(list ?? []);
+        const { MarkdownEARSParser: MarkdownEARSParser2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const parsed = new MarkdownEARSParser2().parse(params["markdown"] ?? "");
+        return ok(parsed.map((r) => ({ id: r.id, title: r.title, pattern: r.pattern, text: r.text })));
       } catch {
-        return ok([]);
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.design.generate", "Generate a design document from requirements", "sdd-core", [
-      param("requirements", "array", "Requirements to generate design from"),
-      param("format", "string", "Output format: markdown | json", false, "markdown")
-    ], async (params) => {
+    tool("sdd.design.generate", "Generate a design document from parsed requirements", "sdd-core", [param("requirements", "array", "Requirements as {id,title,text,pattern} objects")], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const design = core.generateDesign?.({
-          requirements: params["requirements"],
-          format: params["format"] ?? "markdown"
-        });
-        return ok(design ?? { sections: [], format: params["format"] ?? "markdown" });
+        const { createDesignGenerator: createDesignGenerator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const reqs = params["requirements"] ?? [];
+        const mapped = reqs.map((r) => ({
+          id: String(r["id"] ?? "REQ-XXX-001"),
+          title: String(r["title"] ?? ""),
+          text: String(r["text"] ?? ""),
+          pattern: String(r["pattern"] ?? "ubiquitous")
+        }));
+        return ok(createDesignGenerator2().generate(mapped));
       } catch {
-        return ok({ sections: [], format: params["format"] ?? "markdown" });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.design.verify", "Verify design traceability back to requirements", "sdd-core", [
-      param("design", "object", "Design document to verify"),
-      param("requirements", "array", "Requirements to trace against")
-    ], async (params) => {
+    tool("sdd.design.verify", "Verify a design against SOLID principles", "sdd-core", [param("requirements", "array", "Requirements the design is generated from")], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const result = core.verifyTraceability?.({
-          design: params["design"],
-          requirements: params["requirements"]
-        });
-        return ok(result ?? { complete: true, gaps: [] });
+        const { createDesignGenerator: createDesignGenerator2, createSOLIDValidator: createSOLIDValidator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const reqs = params["requirements"] ?? [];
+        const mapped = reqs.map((r) => ({
+          id: String(r["id"] ?? "REQ-XXX-001"),
+          title: String(r["title"] ?? ""),
+          text: String(r["text"] ?? ""),
+          pattern: String(r["pattern"] ?? "ubiquitous")
+        }));
+        const design = createDesignGenerator2().generate(mapped);
+        return ok(createSOLIDValidator2().validate(design));
       } catch {
-        return ok({ complete: true, gaps: [] });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.codegen.generate", "Generate code from a design document", "sdd-core", [
-      param("design", "object", "Design document"),
-      param("language", "string", "Target language: typescript | python", false, "typescript")
+    tool("sdd.codegen.generate", "Generate a code skeleton (class/interface/function) from a name", "sdd-core", [
+      param("name", "string", "Symbol name to generate"),
+      param("templateType", "string", "class | interface | function | enum | type", false, "class"),
+      param("description", "string", "Doc description", false)
     ], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const code = core.generateCode?.({
-          design: params["design"],
-          language: params["language"] ?? "typescript"
+        const { createCodeGenerator: createCodeGenerator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const code = createCodeGenerator2().generate({
+          templateType: params["templateType"] ?? "class",
+          name: params["name"] ?? "Generated",
+          description: params["description"]
         });
-        return ok(code ?? { files: [], language: params["language"] ?? "typescript" });
+        return ok(code);
       } catch {
-        return ok({ files: [], language: params["language"] ?? "typescript" });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.test.generate", "Generate tests from a design document", "sdd-core", [
-      param("design", "object", "Design document"),
-      param("framework", "string", "Test framework: vitest | jest | pytest", false, "vitest")
+    tool("sdd.test.generate", "Generate a unit-test skeleton from source code", "sdd-core", [
+      param("code", "string", "Source code to generate tests for"),
+      param("style", "string", "Test style: unit | integration", false, "unit")
     ], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const tests = core.generateTests?.({
-          design: params["design"],
-          framework: params["framework"] ?? "vitest"
-        });
-        return ok(tests ?? { files: [], framework: params["framework"] ?? "vitest" });
+        const { createUnitTestGenerator: createUnitTestGenerator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const suite = createUnitTestGenerator2().generate(params["code"] ?? "", params["style"] ?? "unit");
+        return ok(suite);
       } catch {
-        return ok({ files: [], framework: params["framework"] ?? "vitest" });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.trace.verify", "Verify full traceability matrix (requirements \u2192 design \u2192 code \u2192 tests)", "sdd-core", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
+    tool("sdd.trace.verify", "Verify requirement \u2192 code coverage by scanning source references (REQ-XXX-NNN)", "sdd-core", [
+      param("requirementIds", "array", 'Requirement IDs to check (e.g. ["REQ-AUT-001"])'),
+      param("sources", "array", "Sources as {file, code} objects to scan for references")
+    ], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const result = core.verifyTraceabilityMatrix?.(params["basePath"] ?? ".");
-        return ok(result ?? { complete: true, matrix: [], gaps: [] });
+        const reqIds = [...new Set(params["requirementIds"] ?? [])];
+        const sources = params["sources"] ?? [];
+        const refRe = /REQ-[A-Z]{3}-\d{3}/g;
+        const covered = /* @__PURE__ */ new Set();
+        for (const s of sources) {
+          for (const m of (s.code ?? "").matchAll(refRe)) {
+            if (reqIds.includes(m[0]))
+              covered.add(m[0]);
+          }
+        }
+        const gaps = reqIds.filter((r) => !covered.has(r));
+        const coverage = reqIds.length === 0 ? 0 : Math.round(covered.size / reqIds.length * 100);
+        return ok({
+          total: reqIds.length,
+          covered: covered.size,
+          coverage,
+          gaps,
+          complete: gaps.length === 0 && reqIds.length > 0
+        });
       } catch {
-        return ok({ complete: true, matrix: [], gaps: [] });
+        return fail("Trace verification failed");
       }
     }),
     // ── Requirements Interview tools ──
@@ -13989,7 +14033,7 @@ function knowledgeTools() {
         const { createKnowledgeStore: createKnowledgeStore2 } = await Promise.resolve().then(() => (init_dist8(), dist_exports8));
         const store = createKnowledgeStore2(params["basePath"] ?? ".knowledge");
         await store.load();
-        const entity = store.getEntity(params["id"]);
+        const entity = await store.getEntity(params["id"]);
         return entity ? ok(entity) : fail("Entity not found");
       } catch {
         return fail("Knowledge package not available");
@@ -14062,7 +14106,7 @@ function knowledgeTools() {
         const { createKnowledgeStore: createKnowledgeStore2 } = await Promise.resolve().then(() => (init_dist8(), dist_exports8));
         const store = createKnowledgeStore2(params["basePath"] ?? ".knowledge");
         await store.load();
-        const results = store.search(params["query"], { limit: params["limit"] ?? 10 });
+        const results = await store.search(params["query"], { limit: params["limit"] ?? 10 });
         return ok(results);
       } catch {
         return fail("Knowledge package not available");
@@ -14077,7 +14121,7 @@ function knowledgeTools() {
         const { createKnowledgeStore: createKnowledgeStore2 } = await Promise.resolve().then(() => (init_dist8(), dist_exports8));
         const store = createKnowledgeStore2(params["basePath"] ?? ".knowledge");
         await store.load();
-        const result = store.traverse(params["startId"], { depth: params["depth"] ?? 2 });
+        const result = await store.traverse(params["startId"], { depth: params["depth"] ?? 2 });
         return ok(result);
       } catch {
         return fail("Knowledge package not available");
@@ -14249,52 +14293,64 @@ function codeAnalysisTools() {
     })
   ];
 }
+function sourceOf(params) {
+  return params["code"] ?? params["source"] ?? params["target"] ?? "";
+}
+function severityOf(findings) {
+  const order = ["critical", "high", "medium", "low", "info"];
+  for (const s of order)
+    if (findings.some((f) => f.severity === s))
+      return s;
+  return "none";
+}
 function securityTools() {
   return [
     tool("security.scan", "Run a security scan on source code", "security", [
-      param("target", "string", "File or directory path to scan"),
-      param("rules", "array", "Specific rules to apply", false)
+      param("code", "string", "Source code to scan"),
+      param("filePath", "string", "File path for the source (for reporting)", false, "inline")
     ], async (params) => {
       try {
-        const sec = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
-        const result = sec.scan?.(params["target"], params["rules"]);
-        return ok(result ?? { findings: [], severity: "none" });
+        const { createSecurityScanner: createSecurityScanner2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
+        const result = createSecurityScanner2().scan(sourceOf(params), params["filePath"] ?? "inline");
+        return ok({ findings: result.findings, severity: severityOf(result.findings) });
       } catch {
-        return ok({ findings: [], severity: "none" });
+        return fail("Security package not available");
       }
     }),
-    tool("security.secrets.detect", "Detect secrets and credentials in source code", "security", [param("target", "string", "File or directory path to scan")], async (params) => {
+    tool("security.secrets.detect", "Detect secrets and credentials in source code", "security", [
+      param("code", "string", "Source code to scan"),
+      param("filePath", "string", "File path for the source", false, "inline")
+    ], async (params) => {
       try {
-        const sec = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
-        const result = sec.detectSecrets?.(params["target"]);
-        return ok(result ?? { secrets: [], count: 0 });
+        const { createSecretDetector: createSecretDetector2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
+        const secrets = createSecretDetector2().scan(sourceOf(params), params["filePath"] ?? "inline");
+        return ok({ secrets, count: secrets.length });
       } catch {
-        return ok({ secrets: [], count: 0 });
+        return fail("Security package not available");
       }
     }),
     tool("security.taint.analyze", "Perform taint analysis to track untrusted data flow", "security", [
-      param("source", "string", "Source code to analyze"),
-      param("sources", "array", "Taint sources", false),
-      param("sinks", "array", "Taint sinks", false)
+      param("code", "string", "Source code to analyze"),
+      param("filePath", "string", "File path for the source", false, "inline")
     ], async (params) => {
       try {
-        const sec = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
-        const result = sec.taintAnalysis?.(params["source"], params["sources"], params["sinks"]);
-        return ok(result ?? { tainted: [], paths: [] });
+        const { TaintAnalyzer: TaintAnalyzer2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
+        const tainted = new TaintAnalyzer2().analyze(sourceOf(params), params["filePath"] ?? "inline");
+        return ok({ tainted, count: tainted.length });
       } catch {
-        return ok({ tainted: [], paths: [] });
+        return fail("Security package not available");
       }
     }),
-    tool("security.compliance.check", "Check code compliance against security standards", "security", [
-      param("target", "string", "File or directory path"),
-      param("standard", "string", "Compliance standard: owasp | cwe | sans", false, "owasp")
+    tool("security.compliance.check", "Check code compliance against registered security policies", "security", [
+      param("code", "string", "Source code to check"),
+      param("filePath", "string", "File path for the source", false, "inline")
     ], async (params) => {
       try {
-        const sec = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
-        const result = sec.complianceCheck?.(params["target"], params["standard"] ?? "owasp");
-        return ok(result ?? { compliant: true, issues: [] });
+        const { createComplianceChecker: createComplianceChecker2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
+        const result = createComplianceChecker2().check(sourceOf(params), params["filePath"] ?? "inline", []);
+        return ok(result);
       } catch {
-        return ok({ compliant: true, issues: [] });
+        return fail("Security package not available");
       }
     })
   ];
@@ -14399,40 +14455,91 @@ function neuralTools() {
 }
 function synthesisTools() {
   return [
-    tool("synthesis.dsl.build", "Build a DSL transformation from specification", "synthesis", [
-      param("spec", "object", "DSL specification"),
-      param("examples", "array", "Input/output examples", false)
+    tool("synthesis.dsl.build", "Apply a DSL transform pipeline to an input string", "synthesis", [
+      param("input", "string", "Input string to transform"),
+      param("ops", "array", "Ops: trim | upper | lower | reverse | capitalize | camelCase | snakeCase | replace:from:to")
     ], async (params) => {
       try {
-        const syn = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
-        const result = syn.buildDSL?.(params["spec"], params["examples"]);
-        return ok(result ?? { dsl: null, spec: params["spec"] });
+        const { createDSLBuilder: createDSLBuilder2 } = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
+        const builder = createDSLBuilder2();
+        const ops = params["ops"] ?? [];
+        for (const op of ops) {
+          const [name, ...a] = String(op).split(":");
+          switch (name) {
+            case "trim":
+              builder.trim();
+              break;
+            case "upper":
+            case "toUpperCase":
+              builder.toUpperCase();
+              break;
+            case "lower":
+            case "toLowerCase":
+              builder.toLowerCase();
+              break;
+            case "reverse":
+              builder.reverse();
+              break;
+            case "capitalize":
+              builder.capitalize();
+              break;
+            case "camelCase":
+            case "camel":
+              builder.camelCase();
+              break;
+            case "snakeCase":
+            case "snake":
+              builder.snakeCase();
+              break;
+            case "replace":
+              builder.replace(a[0] ?? "", a[1] ?? "");
+              break;
+            case "prefixRemove":
+              builder.prefixRemove(a[0] ?? "");
+              break;
+            case "suffixAppend":
+              builder.suffixAppend(a[0] ?? "");
+              break;
+            default:
+              return fail(`Unknown DSL op: ${name}`);
+          }
+        }
+        const result = builder.execute(params["input"] ?? "");
+        return ok({ input: params["input"], ops, result });
       } catch {
-        return ok({ dsl: null, spec: params["spec"] });
+        return fail("Synthesis package not available");
       }
     }),
-    tool("synthesis.synthesize", "Synthesize a program from input/output examples", "synthesis", [
-      param("examples", "array", "Input/output example pairs"),
-      param("constraints", "object", "Synthesis constraints", false)
-    ], async (params) => {
+    tool("synthesis.synthesize", "Synthesize a transformation rule from input/output examples", "synthesis", [param("examples", "array", "Array of {input, output} example pairs")], async (params) => {
       try {
-        const syn = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
-        const result = syn.synthesize?.(params["examples"], params["constraints"]);
-        return ok(result ?? { program: null, confidence: 0 });
+        const { createSynthesisEngine: createSynthesisEngine2 } = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
+        const examples = (params["examples"] ?? []).map((e) => ({
+          input: e.input ?? "",
+          output: e.output ?? ""
+        }));
+        const rule = createSynthesisEngine2().synthesize(examples);
+        return ok({ rule, synthesized: rule !== null });
       } catch {
-        return ok({ program: null, confidence: 0 });
+        return fail("Synthesis package not available");
       }
     }),
-    tool("synthesis.version-space", "Manage version spaces for program synthesis", "synthesis", [
-      param("action", "string", "Action: create | update | query"),
-      param("examples", "array", "Examples for version space", false)
+    tool("synthesis.version-space", "Build a version space from positive/negative examples and get consistent hypotheses", "synthesis", [
+      param("name", "string", "Version space name", false, "default"),
+      param("positive", "array", "Positive examples", false),
+      param("negative", "array", "Negative examples", false)
     ], async (params) => {
       try {
-        const syn = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
-        const result = syn.versionSpace?.(params["action"], params["examples"]);
-        return ok(result ?? { action: params["action"], spaces: [] });
+        const { createVersionSpaceManager: createVersionSpaceManager2 } = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
+        const mgr = createVersionSpaceManager2();
+        const name = params["name"] ?? "default";
+        mgr.create(name);
+        for (const p of params["positive"] ?? [])
+          mgr.addPositive(name, p);
+        for (const n of params["negative"] ?? [])
+          mgr.addNegative(name, n);
+        return ok({ name, hypotheses: mgr.getConsistentHypotheses(name), spaces: mgr.getSpaces().size });
       } catch {
-        return ok({ action: params["action"], spaces: [] });
+        return fail("Synthesis package not available");
       }
     })
   ];
@@ -14554,37 +14661,41 @@ function decisionsTools() {
       param("consequences", "string", "Consequences of the decision", false)
     ], async (params) => {
       try {
-        const dec = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
-        const adr = dec.createADR?.({
+        const { createDecisionManager: createDecisionManager2 } = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
+        const mgr = createDecisionManager2(params["basePath"] ?? ".decisions");
+        await mgr.load();
+        const adr = await mgr.create({
           title: params["title"],
-          context: params["context"],
-          decision: params["decision"],
-          consequences: params["consequences"]
+          context: params["context"] ?? "",
+          decision: params["decision"] ?? "",
+          consequences: params["consequences"] ?? ""
         });
-        return ok(adr ?? { title: params["title"], status: "proposed" });
+        return ok(adr);
       } catch {
-        return ok({ title: params["title"], status: "proposed" });
+        return fail("Decisions package not available");
       }
     }),
-    tool("decisions.list", "List all Architecture Decision Records", "decisions", [param("basePath", "string", "ADR directory path", false, ".")], async (params) => {
+    tool("decisions.list", "List all Architecture Decision Records", "decisions", [param("basePath", "string", "ADR base path", false, ".decisions")], async (params) => {
       try {
-        const dec = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
-        const adrs = dec.listADRs?.(params["basePath"] ?? ".");
-        return ok(adrs ?? []);
+        const { createDecisionManager: createDecisionManager2 } = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
+        const mgr = createDecisionManager2(params["basePath"] ?? ".decisions");
+        await mgr.load();
+        return ok(await mgr.list());
       } catch {
-        return ok([]);
+        return fail("Decisions package not available");
       }
     }),
     tool("decisions.search", "Search Architecture Decision Records by keyword", "decisions", [
       param("query", "string", "Search query"),
-      param("basePath", "string", "ADR directory path", false, ".")
+      param("basePath", "string", "ADR base path", false, ".decisions")
     ], async (params) => {
       try {
-        const dec = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
-        const results = dec.searchADRs?.(params["query"], params["basePath"] ?? ".");
-        return ok(results ?? []);
+        const { createDecisionManager: createDecisionManager2 } = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
+        const mgr = createDecisionManager2(params["basePath"] ?? ".decisions");
+        await mgr.load();
+        return ok(await mgr.search(params["query"]));
       } catch {
-        return ok([]);
+        return fail("Decisions package not available");
       }
     })
   ];
@@ -15307,6 +15418,7 @@ var init_mcp_cli_launcher = __esm({
         } else {
           const transport = new StdioTransport2();
           await server.start(transport);
+          await transport.waitForClose();
         }
       }
     };

package/dist/index.js

@@ -12124,6 +12124,19 @@ var init_transport = __esm({
           this.rl = null;
         }
       }
+      /**
+       * Resolve once the input stream closes (client disconnect / stdin EOF).
+       * Used by the CLI launcher to keep the process alive for the lifetime of
+       * the connection — `start()` intentionally resolves immediately so callers
+       * can begin writing, so a separate wait hook is needed to block on.
+       */
+      async waitForClose() {
+        if (!this.rl)
+          return;
+        await new Promise((resolve9) => {
+          this.rl.once("close", () => resolve9());
+        });
+      }
       send(message) {
         this.output.write(JSON.stringify(message) + "\n");
       }
@@ -13823,108 +13836,139 @@ function fail(error) {
 }
 function sddCoreTools() {
   return [
-    tool("sdd.requirements.create", "Create an EARS requirement (Easy Approach to Requirements Syntax)", "sdd-core", [
-      param("pattern", "string", "EARS pattern: ubiquitous | event-driven | unwanted | state-driven | optional"),
-      param("text", "string", "Requirement text"),
+    tool("sdd.requirements.create", "Create and classify an EARS requirement (Easy Approach to Requirements Syntax)", "sdd-core", [
+      param("text", "string", "Requirement text (EARS sentence)"),
       param("id", "string", "Requirement ID", false)
     ], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const req = core.createRequirement?.({
-          pattern: params["pattern"],
-          text: params["text"],
-          id: params["id"]
+        const { createEARSValidator: createEARSValidator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const v = createEARSValidator2();
+        const text = params["text"];
+        const analysis = v.analyze(text);
+        const validation = v.validate(text);
+        return ok({
+          id: params["id"] ?? "REQ-XXX-001",
+          text,
+          pattern: analysis.pattern,
+          confidence: analysis.confidence,
+          valid: validation.valid,
+          issues: validation.issues
         });
-        return ok(req ?? { pattern: params["pattern"], text: params["text"], id: params["id"] ?? "REQ-001" });
       } catch {
-        return ok({ pattern: params["pattern"], text: params["text"], id: params["id"] ?? "REQ-001" });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.requirements.validate", "Validate requirements for completeness and consistency", "sdd-core", [param("requirements", "array", "Array of requirement objects to validate")], async (params) => {
+    tool("sdd.requirements.validate", "Validate requirements (EARS pattern + issues) for a list of requirement texts", "sdd-core", [param("requirements", "array", "Array of requirement texts or {text} objects")], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const result = core.validateRequirements?.(params["requirements"]);
-        return ok(result ?? { valid: true, issues: [] });
+        const { createEARSValidator: createEARSValidator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const v = createEARSValidator2();
+        const items = params["requirements"] ?? [];
+        const results = items.map((it) => {
+          const text = typeof it === "string" ? it : it.text ?? "";
+          const analysis = v.analyze(text);
+          const validation = v.validate(text);
+          return { text, pattern: analysis.pattern, valid: validation.valid, issues: validation.issues };
+        });
+        return ok({ results, allValid: results.every((r) => r.valid) });
       } catch {
-        return ok({ valid: true, issues: [] });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.requirements.list", "List all requirements in the current project", "sdd-core", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
+    tool("sdd.requirements.list", "Parse and list requirements from a Markdown requirements document", "sdd-core", [param("markdown", "string", "Requirements document contents (Markdown)")], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const list = core.listRequirements?.(params["basePath"] ?? ".");
-        return ok(list ?? []);
+        const { MarkdownEARSParser: MarkdownEARSParser2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const parsed = new MarkdownEARSParser2().parse(params["markdown"] ?? "");
+        return ok(parsed.map((r) => ({ id: r.id, title: r.title, pattern: r.pattern, text: r.text })));
       } catch {
-        return ok([]);
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.design.generate", "Generate a design document from requirements", "sdd-core", [
-      param("requirements", "array", "Requirements to generate design from"),
-      param("format", "string", "Output format: markdown | json", false, "markdown")
-    ], async (params) => {
+    tool("sdd.design.generate", "Generate a design document from parsed requirements", "sdd-core", [param("requirements", "array", "Requirements as {id,title,text,pattern} objects")], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const design = core.generateDesign?.({
-          requirements: params["requirements"],
-          format: params["format"] ?? "markdown"
-        });
-        return ok(design ?? { sections: [], format: params["format"] ?? "markdown" });
+        const { createDesignGenerator: createDesignGenerator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const reqs = params["requirements"] ?? [];
+        const mapped = reqs.map((r) => ({
+          id: String(r["id"] ?? "REQ-XXX-001"),
+          title: String(r["title"] ?? ""),
+          text: String(r["text"] ?? ""),
+          pattern: String(r["pattern"] ?? "ubiquitous")
+        }));
+        return ok(createDesignGenerator2().generate(mapped));
       } catch {
-        return ok({ sections: [], format: params["format"] ?? "markdown" });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.design.verify", "Verify design traceability back to requirements", "sdd-core", [
-      param("design", "object", "Design document to verify"),
-      param("requirements", "array", "Requirements to trace against")
-    ], async (params) => {
+    tool("sdd.design.verify", "Verify a design against SOLID principles", "sdd-core", [param("requirements", "array", "Requirements the design is generated from")], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const result = core.verifyTraceability?.({
-          design: params["design"],
-          requirements: params["requirements"]
-        });
-        return ok(result ?? { complete: true, gaps: [] });
+        const { createDesignGenerator: createDesignGenerator2, createSOLIDValidator: createSOLIDValidator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const reqs = params["requirements"] ?? [];
+        const mapped = reqs.map((r) => ({
+          id: String(r["id"] ?? "REQ-XXX-001"),
+          title: String(r["title"] ?? ""),
+          text: String(r["text"] ?? ""),
+          pattern: String(r["pattern"] ?? "ubiquitous")
+        }));
+        const design = createDesignGenerator2().generate(mapped);
+        return ok(createSOLIDValidator2().validate(design));
       } catch {
-        return ok({ complete: true, gaps: [] });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.codegen.generate", "Generate code from a design document", "sdd-core", [
-      param("design", "object", "Design document"),
-      param("language", "string", "Target language: typescript | python", false, "typescript")
+    tool("sdd.codegen.generate", "Generate a code skeleton (class/interface/function) from a name", "sdd-core", [
+      param("name", "string", "Symbol name to generate"),
+      param("templateType", "string", "class | interface | function | enum | type", false, "class"),
+      param("description", "string", "Doc description", false)
     ], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const code = core.generateCode?.({
-          design: params["design"],
-          language: params["language"] ?? "typescript"
+        const { createCodeGenerator: createCodeGenerator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const code = createCodeGenerator2().generate({
+          templateType: params["templateType"] ?? "class",
+          name: params["name"] ?? "Generated",
+          description: params["description"]
         });
-        return ok(code ?? { files: [], language: params["language"] ?? "typescript" });
+        return ok(code);
       } catch {
-        return ok({ files: [], language: params["language"] ?? "typescript" });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.test.generate", "Generate tests from a design document", "sdd-core", [
-      param("design", "object", "Design document"),
-      param("framework", "string", "Test framework: vitest | jest | pytest", false, "vitest")
+    tool("sdd.test.generate", "Generate a unit-test skeleton from source code", "sdd-core", [
+      param("code", "string", "Source code to generate tests for"),
+      param("style", "string", "Test style: unit | integration", false, "unit")
     ], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const tests = core.generateTests?.({
-          design: params["design"],
-          framework: params["framework"] ?? "vitest"
-        });
-        return ok(tests ?? { files: [], framework: params["framework"] ?? "vitest" });
+        const { createUnitTestGenerator: createUnitTestGenerator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const suite = createUnitTestGenerator2().generate(params["code"] ?? "", params["style"] ?? "unit");
+        return ok(suite);
       } catch {
-        return ok({ files: [], framework: params["framework"] ?? "vitest" });
+        return fail("Core package not available");
       }
     }),
-    tool("sdd.trace.verify", "Verify full traceability matrix (requirements \u2192 design \u2192 code \u2192 tests)", "sdd-core", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
+    tool("sdd.trace.verify", "Verify requirement \u2192 code coverage by scanning source references (REQ-XXX-NNN)", "sdd-core", [
+      param("requirementIds", "array", 'Requirement IDs to check (e.g. ["REQ-AUT-001"])'),
+      param("sources", "array", "Sources as {file, code} objects to scan for references")
+    ], async (params) => {
       try {
-        const core = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        const result = core.verifyTraceabilityMatrix?.(params["basePath"] ?? ".");
-        return ok(result ?? { complete: true, matrix: [], gaps: [] });
+        const reqIds = [...new Set(params["requirementIds"] ?? [])];
+        const sources = params["sources"] ?? [];
+        const refRe = /REQ-[A-Z]{3}-\d{3}/g;
+        const covered = /* @__PURE__ */ new Set();
+        for (const s of sources) {
+          for (const m of (s.code ?? "").matchAll(refRe)) {
+            if (reqIds.includes(m[0]))
+              covered.add(m[0]);
+          }
+        }
+        const gaps = reqIds.filter((r) => !covered.has(r));
+        const coverage = reqIds.length === 0 ? 0 : Math.round(covered.size / reqIds.length * 100);
+        return ok({
+          total: reqIds.length,
+          covered: covered.size,
+          coverage,
+          gaps,
+          complete: gaps.length === 0 && reqIds.length > 0
+        });
       } catch {
-        return ok({ complete: true, matrix: [], gaps: [] });
+        return fail("Trace verification failed");
       }
     }),
     // ── Requirements Interview tools ──
@@ -13989,7 +14033,7 @@ function knowledgeTools() {
         const { createKnowledgeStore: createKnowledgeStore2 } = await Promise.resolve().then(() => (init_dist8(), dist_exports8));
         const store = createKnowledgeStore2(params["basePath"] ?? ".knowledge");
         await store.load();
-        const entity = store.getEntity(params["id"]);
+        const entity = await store.getEntity(params["id"]);
         return entity ? ok(entity) : fail("Entity not found");
       } catch {
         return fail("Knowledge package not available");
@@ -14062,7 +14106,7 @@ function knowledgeTools() {
         const { createKnowledgeStore: createKnowledgeStore2 } = await Promise.resolve().then(() => (init_dist8(), dist_exports8));
         const store = createKnowledgeStore2(params["basePath"] ?? ".knowledge");
         await store.load();
-        const results = store.search(params["query"], { limit: params["limit"] ?? 10 });
+        const results = await store.search(params["query"], { limit: params["limit"] ?? 10 });
         return ok(results);
       } catch {
         return fail("Knowledge package not available");
@@ -14077,7 +14121,7 @@ function knowledgeTools() {
         const { createKnowledgeStore: createKnowledgeStore2 } = await Promise.resolve().then(() => (init_dist8(), dist_exports8));
         const store = createKnowledgeStore2(params["basePath"] ?? ".knowledge");
         await store.load();
-        const result = store.traverse(params["startId"], { depth: params["depth"] ?? 2 });
+        const result = await store.traverse(params["startId"], { depth: params["depth"] ?? 2 });
         return ok(result);
       } catch {
         return fail("Knowledge package not available");
@@ -14249,52 +14293,64 @@ function codeAnalysisTools() {
     })
   ];
 }
+function sourceOf(params) {
+  return params["code"] ?? params["source"] ?? params["target"] ?? "";
+}
+function severityOf(findings) {
+  const order = ["critical", "high", "medium", "low", "info"];
+  for (const s of order)
+    if (findings.some((f) => f.severity === s))
+      return s;
+  return "none";
+}
 function securityTools() {
   return [
     tool("security.scan", "Run a security scan on source code", "security", [
-      param("target", "string", "File or directory path to scan"),
-      param("rules", "array", "Specific rules to apply", false)
+      param("code", "string", "Source code to scan"),
+      param("filePath", "string", "File path for the source (for reporting)", false, "inline")
     ], async (params) => {
       try {
-        const sec = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
-        const result = sec.scan?.(params["target"], params["rules"]);
-        return ok(result ?? { findings: [], severity: "none" });
+        const { createSecurityScanner: createSecurityScanner2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
+        const result = createSecurityScanner2().scan(sourceOf(params), params["filePath"] ?? "inline");
+        return ok({ findings: result.findings, severity: severityOf(result.findings) });
       } catch {
-        return ok({ findings: [], severity: "none" });
+        return fail("Security package not available");
       }
     }),
-    tool("security.secrets.detect", "Detect secrets and credentials in source code", "security", [param("target", "string", "File or directory path to scan")], async (params) => {
+    tool("security.secrets.detect", "Detect secrets and credentials in source code", "security", [
+      param("code", "string", "Source code to scan"),
+      param("filePath", "string", "File path for the source", false, "inline")
+    ], async (params) => {
       try {
-        const sec = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
-        const result = sec.detectSecrets?.(params["target"]);
-        return ok(result ?? { secrets: [], count: 0 });
+        const { createSecretDetector: createSecretDetector2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
+        const secrets = createSecretDetector2().scan(sourceOf(params), params["filePath"] ?? "inline");
+        return ok({ secrets, count: secrets.length });
       } catch {
-        return ok({ secrets: [], count: 0 });
+        return fail("Security package not available");
       }
     }),
     tool("security.taint.analyze", "Perform taint analysis to track untrusted data flow", "security", [
-      param("source", "string", "Source code to analyze"),
-      param("sources", "array", "Taint sources", false),
-      param("sinks", "array", "Taint sinks", false)
+      param("code", "string", "Source code to analyze"),
+      param("filePath", "string", "File path for the source", false, "inline")
     ], async (params) => {
       try {
-        const sec = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
-        const result = sec.taintAnalysis?.(params["source"], params["sources"], params["sinks"]);
-        return ok(result ?? { tainted: [], paths: [] });
+        const { TaintAnalyzer: TaintAnalyzer2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
+        const tainted = new TaintAnalyzer2().analyze(sourceOf(params), params["filePath"] ?? "inline");
+        return ok({ tainted, count: tainted.length });
       } catch {
-        return ok({ tainted: [], paths: [] });
+        return fail("Security package not available");
       }
     }),
-    tool("security.compliance.check", "Check code compliance against security standards", "security", [
-      param("target", "string", "File or directory path"),
-      param("standard", "string", "Compliance standard: owasp | cwe | sans", false, "owasp")
+    tool("security.compliance.check", "Check code compliance against registered security policies", "security", [
+      param("code", "string", "Source code to check"),
+      param("filePath", "string", "File path for the source", false, "inline")
     ], async (params) => {
       try {
-        const sec = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
-        const result = sec.complianceCheck?.(params["target"], params["standard"] ?? "owasp");
-        return ok(result ?? { compliant: true, issues: [] });
+        const { createComplianceChecker: createComplianceChecker2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports5));
+        const result = createComplianceChecker2().check(sourceOf(params), params["filePath"] ?? "inline", []);
+        return ok(result);
       } catch {
-        return ok({ compliant: true, issues: [] });
+        return fail("Security package not available");
       }
     })
   ];
@@ -14399,40 +14455,91 @@ function neuralTools() {
 }
 function synthesisTools() {
   return [
-    tool("synthesis.dsl.build", "Build a DSL transformation from specification", "synthesis", [
-      param("spec", "object", "DSL specification"),
-      param("examples", "array", "Input/output examples", false)
+    tool("synthesis.dsl.build", "Apply a DSL transform pipeline to an input string", "synthesis", [
+      param("input", "string", "Input string to transform"),
+      param("ops", "array", "Ops: trim | upper | lower | reverse | capitalize | camelCase | snakeCase | replace:from:to")
     ], async (params) => {
       try {
-        const syn = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
-        const result = syn.buildDSL?.(params["spec"], params["examples"]);
-        return ok(result ?? { dsl: null, spec: params["spec"] });
+        const { createDSLBuilder: createDSLBuilder2 } = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
+        const builder = createDSLBuilder2();
+        const ops = params["ops"] ?? [];
+        for (const op of ops) {
+          const [name, ...a] = String(op).split(":");
+          switch (name) {
+            case "trim":
+              builder.trim();
+              break;
+            case "upper":
+            case "toUpperCase":
+              builder.toUpperCase();
+              break;
+            case "lower":
+            case "toLowerCase":
+              builder.toLowerCase();
+              break;
+            case "reverse":
+              builder.reverse();
+              break;
+            case "capitalize":
+              builder.capitalize();
+              break;
+            case "camelCase":
+            case "camel":
+              builder.camelCase();
+              break;
+            case "snakeCase":
+            case "snake":
+              builder.snakeCase();
+              break;
+            case "replace":
+              builder.replace(a[0] ?? "", a[1] ?? "");
+              break;
+            case "prefixRemove":
+              builder.prefixRemove(a[0] ?? "");
+              break;
+            case "suffixAppend":
+              builder.suffixAppend(a[0] ?? "");
+              break;
+            default:
+              return fail(`Unknown DSL op: ${name}`);
+          }
+        }
+        const result = builder.execute(params["input"] ?? "");
+        return ok({ input: params["input"], ops, result });
       } catch {
-        return ok({ dsl: null, spec: params["spec"] });
+        return fail("Synthesis package not available");
       }
     }),
-    tool("synthesis.synthesize", "Synthesize a program from input/output examples", "synthesis", [
-      param("examples", "array", "Input/output example pairs"),
-      param("constraints", "object", "Synthesis constraints", false)
-    ], async (params) => {
+    tool("synthesis.synthesize", "Synthesize a transformation rule from input/output examples", "synthesis", [param("examples", "array", "Array of {input, output} example pairs")], async (params) => {
       try {
-        const syn = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
-        const result = syn.synthesize?.(params["examples"], params["constraints"]);
-        return ok(result ?? { program: null, confidence: 0 });
+        const { createSynthesisEngine: createSynthesisEngine2 } = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
+        const examples = (params["examples"] ?? []).map((e) => ({
+          input: e.input ?? "",
+          output: e.output ?? ""
+        }));
+        const rule = createSynthesisEngine2().synthesize(examples);
+        return ok({ rule, synthesized: rule !== null });
       } catch {
-        return ok({ program: null, confidence: 0 });
+        return fail("Synthesis package not available");
       }
     }),
-    tool("synthesis.version-space", "Manage version spaces for program synthesis", "synthesis", [
-      param("action", "string", "Action: create | update | query"),
-      param("examples", "array", "Examples for version space", false)
+    tool("synthesis.version-space", "Build a version space from positive/negative examples and get consistent hypotheses", "synthesis", [
+      param("name", "string", "Version space name", false, "default"),
+      param("positive", "array", "Positive examples", false),
+      param("negative", "array", "Negative examples", false)
     ], async (params) => {
       try {
-        const syn = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
-        const result = syn.versionSpace?.(params["action"], params["examples"]);
-        return ok(result ?? { action: params["action"], spaces: [] });
+        const { createVersionSpaceManager: createVersionSpaceManager2 } = await Promise.resolve().then(() => (init_dist12(), dist_exports12));
+        const mgr = createVersionSpaceManager2();
+        const name = params["name"] ?? "default";
+        mgr.create(name);
+        for (const p of params["positive"] ?? [])
+          mgr.addPositive(name, p);
+        for (const n of params["negative"] ?? [])
+          mgr.addNegative(name, n);
+        return ok({ name, hypotheses: mgr.getConsistentHypotheses(name), spaces: mgr.getSpaces().size });
       } catch {
-        return ok({ action: params["action"], spaces: [] });
+        return fail("Synthesis package not available");
       }
     })
   ];
@@ -14554,37 +14661,41 @@ function decisionsTools() {
       param("consequences", "string", "Consequences of the decision", false)
     ], async (params) => {
       try {
-        const dec = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
-        const adr = dec.createADR?.({
+        const { createDecisionManager: createDecisionManager2 } = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
+        const mgr = createDecisionManager2(params["basePath"] ?? ".decisions");
+        await mgr.load();
+        const adr = await mgr.create({
           title: params["title"],
-          context: params["context"],
-          decision: params["decision"],
-          consequences: params["consequences"]
+          context: params["context"] ?? "",
+          decision: params["decision"] ?? "",
+          consequences: params["consequences"] ?? ""
         });
-        return ok(adr ?? { title: params["title"], status: "proposed" });
+        return ok(adr);
       } catch {
-        return ok({ title: params["title"], status: "proposed" });
+        return fail("Decisions package not available");
       }
     }),
-    tool("decisions.list", "List all Architecture Decision Records", "decisions", [param("basePath", "string", "ADR directory path", false, ".")], async (params) => {
+    tool("decisions.list", "List all Architecture Decision Records", "decisions", [param("basePath", "string", "ADR base path", false, ".decisions")], async (params) => {
       try {
-        const dec = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
-        const adrs = dec.listADRs?.(params["basePath"] ?? ".");
-        return ok(adrs ?? []);
+        const { createDecisionManager: createDecisionManager2 } = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
+        const mgr = createDecisionManager2(params["basePath"] ?? ".decisions");
+        await mgr.load();
+        return ok(await mgr.list());
       } catch {
-        return ok([]);
+        return fail("Decisions package not available");
       }
     }),
     tool("decisions.search", "Search Architecture Decision Records by keyword", "decisions", [
       param("query", "string", "Search query"),
-      param("basePath", "string", "ADR directory path", false, ".")
+      param("basePath", "string", "ADR base path", false, ".decisions")
     ], async (params) => {
       try {
-        const dec = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
-        const results = dec.searchADRs?.(params["query"], params["basePath"] ?? ".");
-        return ok(results ?? []);
+        const { createDecisionManager: createDecisionManager2 } = await Promise.resolve().then(() => (init_dist9(), dist_exports9));
+        const mgr = createDecisionManager2(params["basePath"] ?? ".decisions");
+        await mgr.load();
+        return ok(await mgr.search(params["query"]));
       } catch {
-        return ok([]);
+        return fail("Decisions package not available");
       }
     })
   ];
@@ -15307,6 +15418,7 @@ var init_mcp_cli_launcher = __esm({
         } else {
           const transport = new StdioTransport2();
           await server.start(transport);
+          await transport.waitForClose();
         }
       }
     };

package/dist/interface/cli/mcp-cli-launcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-cli-launcher.d.ts","sourceRoot":"","sources":["../../../src/interface/cli/mcp-cli-launcher.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,qBAAa,cAAc;IACnB,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAiBnD"}
+{"version":3,"file":"mcp-cli-launcher.d.ts","sourceRoot":"","sources":["../../../src/interface/cli/mcp-cli-launcher.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,qBAAa,cAAc;IACnB,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAqBnD"}

package/dist/interface/cli/mcp-cli-launcher.js

@@ -14,6 +14,10 @@ export class McpCliLauncher {
         else {
             const transport = new StdioTransport();
             await server.start(transport);
+            // StdioTransport.start() resolves immediately; without this the CLI's
+            // top-level `process.exit()` would kill the server before it handles any
+            // request. Block until the client disconnects (stdin EOF).
+            await transport.waitForClose();
         }
     }
 }

package/dist/interface/cli/mcp-cli-launcher.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-cli-launcher.js","sourceRoot":"","sources":["../../../src/interface/cli/mcp-cli-launcher.ts"],"names":[],"mappings":"AAKA,MAAM,OAAO,cAAc;IACzB,KAAK,CAAC,KAAK,CAAC,OAAsB;QAChC,MAAM,EAAE,mBAAmB,EAAE,cAAc,EAAE,GAAG,MAAM,MAAM,CAAC,sBAAsB,CAAC,CAAC;QACrF,MAAM,MAAM,GAAG,mBAAmB,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QAE/E,IAAI,OAAO,CAAC,SAAS,KAAK,KAAK,EAAE,CAAC;YAChC,MAAM,EAAE,mBAAmB,EAAE,GAAG,MAAM,MAAM,CAAC,2BAA2B,CAAC,CAAC;YAC1E,MAAM,OAAO,GAAG,IAAI,mBAAmB,EAAE,CAAC;YAC1C,MAAM,OAAO,CAAC,MAAM,CAAC;gBACnB,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,IAAI;gBAC1B,YAAY,EAAE,MAAM;gBACpB,WAAW,EAAE,WAAW;aACzB,EAAE,MAAqE,CAAC,CAAC;QAC5E,CAAC;aAAM,CAAC;YACN,MAAM,SAAS,GAAG,IAAI,cAAc,EAAE,CAAC;YACvC,MAAM,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;CACF"}
+{"version":3,"file":"mcp-cli-launcher.js","sourceRoot":"","sources":["../../../src/interface/cli/mcp-cli-launcher.ts"],"names":[],"mappings":"AAKA,MAAM,OAAO,cAAc;IACzB,KAAK,CAAC,KAAK,CAAC,OAAsB;QAChC,MAAM,EAAE,mBAAmB,EAAE,cAAc,EAAE,GAAG,MAAM,MAAM,CAAC,sBAAsB,CAAC,CAAC;QACrF,MAAM,MAAM,GAAG,mBAAmB,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QAE/E,IAAI,OAAO,CAAC,SAAS,KAAK,KAAK,EAAE,CAAC;YAChC,MAAM,EAAE,mBAAmB,EAAE,GAAG,MAAM,MAAM,CAAC,2BAA2B,CAAC,CAAC;YAC1E,MAAM,OAAO,GAAG,IAAI,mBAAmB,EAAE,CAAC;YAC1C,MAAM,OAAO,CAAC,MAAM,CAAC;gBACnB,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,IAAI;gBAC1B,YAAY,EAAE,MAAM;gBACpB,WAAW,EAAE,WAAW;aACzB,EAAE,MAAqE,CAAC,CAAC;QAC5E,CAAC;aAAM,CAAC;YACN,MAAM,SAAS,GAAG,IAAI,cAAc,EAAE,CAAC;YACvC,MAAM,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;YAC9B,sEAAsE;YACtE,yEAAyE;YACzE,2DAA2D;YAC3D,MAAM,SAAS,CAAC,YAAY,EAAE,CAAC;QACjC,CAAC;IACH,CAAC;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musubix2",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "MUSUBIX2 — Specification Driven Development System",
   "type": "module",
   "main": "./dist/index.js",