musubix2 0.5.7 → 0.5.8

package/.claude/.musubix-managed

@@ -1 +1 @@
-{"generator":"musubix2","version":"0.5.7","timestamp":"2026-07-09T10:10:51.798Z"}
+{"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-09T10:10:51.826Z",
+  "generatedAt": "2026-07-09T10:18:54.648Z",
   "entries": [
     {
       "platform": "copilot",

package/dist/cli.js

@@ -13836,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 ──
@@ -14424,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");
       }
     })
   ];
@@ -14579,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");
       }
     })
   ];

package/dist/index.js

@@ -13836,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 ──
@@ -14424,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");
       }
     })
   ];
@@ -14579,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");
       }
     })
   ];

package/package.json

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