musubix2 0.5.9 → 0.5.10

package/.claude/.musubix-managed

@@ -1 +1 @@
-{"generator":"musubix2","version":"0.5.9","timestamp":"2026-07-09T10:34:18.313Z"}
+{"generator":"musubix2","version":"0.5.10","timestamp":"2026-07-09T10:42:36.515Z"}

package/dist/assets/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0",
-  "generatedAt": "2026-07-09T10:34:18.341Z",
+  "generatedAt": "2026-07-09T10:42:36.544Z",
   "entries": [
     {
       "platform": "copilot",

package/dist/cli.js

@@ -14431,93 +14431,129 @@ function researchTools() {
       param("depth", "string", "Research depth: shallow | medium | deep", false, "medium")
     ], async (params) => {
       try {
-        const research = await Promise.resolve().then(() => (init_dist10(), dist_exports10));
-        const result = research.query?.(params["topic"], params["depth"] ?? "medium");
-        return ok(result ?? { findings: [], topic: params["topic"] });
+        const { createResearchEngine: createResearchEngine2 } = await Promise.resolve().then(() => (init_dist10(), dist_exports10));
+        const sources = normalizeSources(params["sources"]);
+        const result = createResearchEngine2().research({ topic: params["topic"] ?? "", depth: params["depth"] ?? "medium" }, sources);
+        return ok(result);
       } catch {
-        return ok({ findings: [], topic: params["topic"] });
+        return fail("Deep-research package not available");
       }
     }),
-    tool("research.iterative", "Perform iterative deep research with progressive refinement", "research", [
+    tool("research.iterative", "Perform iterative research with progressive refinement over provided sources", "research", [
       param("topic", "string", "Research topic"),
-      param("iterations", "number", "Number of refinement iterations", false, 3)
+      param("depth", "string", "Depth: shallow | medium | deep", false, "medium"),
+      param("sources", "array", "Sources as {title,type,relevance,content} objects")
     ], async (params) => {
       try {
-        const research = await Promise.resolve().then(() => (init_dist10(), dist_exports10));
-        const result = research.iterativeResearch?.(params["topic"], params["iterations"] ?? 3);
-        return ok(result ?? { findings: [], iterations: 0, topic: params["topic"] });
+        const { createResearchEngine: createResearchEngine2 } = await Promise.resolve().then(() => (init_dist10(), dist_exports10));
+        const sources = normalizeSources(params["sources"]);
+        const result = createResearchEngine2().researchIterative({ topic: params["topic"] ?? "", depth: params["depth"] ?? "medium" }, () => sources);
+        return ok(result);
       } catch {
-        return ok({ findings: [], iterations: 0, topic: params["topic"] });
+        return fail("Deep-research package not available");
       }
     }),
-    tool("research.evidence", "Generate evidence chain for a claim or hypothesis", "research", [
-      param("claim", "string", "Claim or hypothesis to evaluate"),
-      param("sources", "array", "Evidence sources to consider", false)
+    tool("research.evidence", "Accumulate research results and retrieve evidence for a topic", "research", [
+      param("topic", "string", "Topic to gather evidence for"),
+      param("sources", "array", "Sources as {title,type,relevance,content} objects")
     ], async (params) => {
       try {
-        const research = await Promise.resolve().then(() => (init_dist10(), dist_exports10));
-        const result = research.generateEvidence?.(params["claim"], params["sources"]);
-        return ok(result ?? { evidence: [], confidence: 0 });
+        const { createResearchEngine: createResearchEngine2, createKnowledgeAccumulator: createKnowledgeAccumulator2 } = await Promise.resolve().then(() => (init_dist10(), dist_exports10));
+        const sources = normalizeSources(params["sources"]);
+        const topic = params["topic"] ?? "";
+        const result = createResearchEngine2().research({ topic, depth: "medium" }, sources);
+        const acc = createKnowledgeAccumulator2();
+        acc.accumulate(result);
+        return ok({ evidence: acc.query(topic), summary: result.summary, confidence: result.confidence });
       } catch {
-        return ok({ evidence: [], confidence: 0 });
+        return fail("Deep-research package not available");
       }
     })
   ];
 }
+function normalizeSources(raw) {
+  const valid = /* @__PURE__ */ new Set(["code", "documentation", "article", "api-reference"]);
+  const arr = Array.isArray(raw) ? raw : [];
+  return arr.map((s, i) => {
+    const o = s ?? {};
+    const t = String(o["type"] ?? "documentation");
+    return {
+      title: String(o["title"] ?? `source-${i + 1}`),
+      type: valid.has(t) ? t : "documentation",
+      relevance: typeof o["relevance"] === "number" ? o["relevance"] : 0.5,
+      content: String(o["content"] ?? (typeof s === "string" ? s : ""))
+    };
+  });
+}
 function neuralTools() {
   return [
-    tool("neural.search", "Neural similarity search across embeddings", "neural", [
+    tool("neural.search", "Neural (TF-IDF) similarity search over provided documents", "neural", [
       param("query", "string", "Search query"),
+      param("documents", "array", "Documents to index: strings or {id,text} objects"),
       param("topK", "number", "Number of results", false, 10)
     ], async (params) => {
       try {
-        const ns = await Promise.resolve().then(() => (init_dist14(), dist_exports14));
-        const results = ns.search?.(params["query"], params["topK"] ?? 10);
-        return ok(results ?? []);
+        const { createNeuralSearchEngine: createNeuralSearchEngine2, createTfIdfEmbeddingModel: createTfIdfEmbeddingModel2 } = await Promise.resolve().then(() => (init_dist14(), dist_exports14));
+        const model = createTfIdfEmbeddingModel2();
+        const engine = createNeuralSearchEngine2();
+        const docs = params["documents"] ?? [];
+        const texts = docs.map((d) => typeof d === "string" ? d : d.text ?? "");
+        const model2 = createTfIdfEmbeddingModel2();
+        if (typeof model2.fit === "function") {
+          model2.fit(texts);
+        }
+        const embedder = typeof model2.fit === "function" ? model2 : model;
+        for (let i = 0; i < docs.length; i++) {
+          const d = docs[i];
+          const id = typeof d === "string" ? `doc-${i}` : d.id ?? `doc-${i}`;
+          engine.addDocument(id, await embedder.embed(texts[i]), { text: texts[i] });
+        }
+        const hits = engine.search(await embedder.embed(params["query"] ?? ""), params["topK"] ?? 10);
+        return ok({ query: params["query"], hits });
       } catch {
-        return ok([]);
+        return fail("Neural-search package not available");
       }
     }),
-    tool("neural.embed", "Generate embeddings for text", "neural", [param("text", "string", "Text to embed")], async (params) => {
+    tool("neural.embed", "Generate a TF-IDF embedding vector for text", "neural", [param("text", "string", "Text to embed")], async (params) => {
       try {
-        const ns = await Promise.resolve().then(() => (init_dist14(), dist_exports14));
-        const embedding = ns.embed?.(params["text"]);
-        return ok(embedding ?? { vector: [], dimensions: 0 });
+        const { createTfIdfEmbeddingModel: createTfIdfEmbeddingModel2 } = await Promise.resolve().then(() => (init_dist14(), dist_exports14));
+        const model = createTfIdfEmbeddingModel2();
+        const text = params["text"] ?? "";
+        if (typeof model.fit === "function") {
+          model.fit([text]);
+        }
+        const vector = await model.embed(text);
+        return ok({ vector, dimensions: Array.isArray(vector) ? vector.length : vector.values?.length ?? 0 });
       } catch {
-        return ok({ vector: [], dimensions: 0 });
+        return fail("Neural-search package not available");
       }
     }),
-    tool("neural.patterns.extract", "Wake phase: extract patterns from code or data", "neural", [
-      param("source", "string", "Source code or data to extract patterns from"),
-      param("type", "string", "Pattern type: structural | behavioral | api", false, "structural")
-    ], async (params) => {
+    tool("neural.patterns.extract", "Wake phase: extract patterns from a list of items", "neural", [param("items", "array", "Items (strings) to process for pattern extraction")], async (params) => {
       try {
-        const ws = await Promise.resolve().then(() => (init_dist15(), dist_exports15));
-        const patterns = ws.extractPatterns?.(params["source"], params["type"] ?? "structural");
-        return ok(patterns ?? { patterns: [], type: params["type"] ?? "structural" });
+        const { createWakePhase: createWakePhase2 } = await Promise.resolve().then(() => (init_dist15(), dist_exports15));
+        const items = (params["items"] ?? []).map(String);
+        return ok(createWakePhase2().process(items));
       } catch {
-        return ok({ patterns: [], type: params["type"] ?? "structural" });
+        return fail("Wake-sleep package not available");
       }
     }),
-    tool("neural.patterns.consolidate", "Sleep phase: consolidate and compress learned patterns", "neural", [param("patterns", "array", "Patterns to consolidate", false)], async (params) => {
+    tool("neural.patterns.consolidate", "Sleep phase: consolidate and compress learned patterns", "neural", [param("patterns", "array", "Pattern strings to consolidate")], async (params) => {
       try {
-        const ws = await Promise.resolve().then(() => (init_dist15(), dist_exports15));
-        const result = ws.consolidatePatterns?.(params["patterns"]);
-        return ok(result ?? { consolidated: [], count: 0 });
+        const { createSleepPhase: createSleepPhase2 } = await Promise.resolve().then(() => (init_dist15(), dist_exports15));
+        const patterns = (params["patterns"] ?? []).map(String);
+        return ok(createSleepPhase2().consolidate(patterns));
       } catch {
-        return ok({ consolidated: [], count: 0 });
+        return fail("Wake-sleep package not available");
       }
     }),
-    tool("neural.library.learn", "Learn patterns from a library or framework", "neural", [
-      param("library", "string", "Library name or path"),
-      param("depth", "string", "Analysis depth: api | usage | deep", false, "api")
-    ], async (params) => {
+    tool("neural.library.learn", "Learn reusable patterns from code snippets (E-graph library learning)", "neural", [param("snippets", "array", "Array of code snippet strings to learn from")], async (params) => {
       try {
-        const ll = await Promise.resolve().then(() => (init_dist11(), dist_exports11));
-        const result = ll.learnLibrary?.(params["library"], params["depth"] ?? "api");
-        return ok(result ?? { patterns: [], library: params["library"] });
+        const { createLibraryLearner: createLibraryLearner2 } = await Promise.resolve().then(() => (init_dist11(), dist_exports11));
+        const snippets = (params["snippets"] ?? []).map(String);
+        const patterns = createLibraryLearner2().learn(snippets);
+        return ok({ patterns, count: patterns.length });
       } catch {
-        return ok({ patterns: [], library: params["library"] });
+        return fail("Library-learner package not available");
       }
     })
   ];
@@ -14671,52 +14707,81 @@ function formalVerifyTools() {
     })
   ];
 }
+async function loadTracker(basePath) {
+  const { createStateTracker: createStateTracker2 } = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
+  const { existsSync: existsSync12, readFileSync: readFileSync7 } = await import("node:fs");
+  const { join: join8 } = await import("node:path");
+  const tracker = createStateTracker2();
+  const file = join8(basePath, ".musubix", "workflow-state.json");
+  try {
+    if (existsSync12(file))
+      tracker.restore(JSON.parse(readFileSync7(file, "utf-8")));
+  } catch {
+  }
+  return { tracker, file };
+}
+async function saveTracker(tracker, file) {
+  const { writeFileSync: writeFileSync4, mkdirSync: mkdirSync4 } = await import("node:fs");
+  const { dirname: dirname4 } = await import("node:path");
+  mkdirSync4(dirname4(file), { recursive: true });
+  writeFileSync4(file, JSON.stringify(tracker.toJSON(), null, 2), "utf-8");
+}
 function workflowTools() {
   return [
-    tool("workflow.phase.current", "Get the current SDD workflow phase", "workflow", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
+    tool("workflow.phase.current", "Get the current SDD workflow phase and approvals", "workflow", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
       try {
-        const wf = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
-        const engine = wf.createWorkflowEngine?.(params["basePath"] ?? ".");
-        const phase = engine?.getCurrentPhase();
-        return ok(phase ?? { phase: "requirements", index: 0 });
+        const { PHASE_ORDER: PHASE_ORDER2 } = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
+        const { tracker } = await loadTracker(params["basePath"] ?? ".");
+        const state = tracker.getState();
+        return ok({
+          currentPhase: state.currentPhase,
+          approvals: PHASE_ORDER2.map((p) => ({ phase: p, approved: tracker.isApproved(p) }))
+        });
       } catch {
-        return ok({ phase: "requirements", index: 0 });
+        return fail("Workflow-engine package not available");
       }
     }),
-    tool("workflow.phase.transition", "Transition to the next SDD workflow phase", "workflow", [
+    tool("workflow.phase.transition", "Transition to a target SDD workflow phase (persisted)", "workflow", [
       param("targetPhase", "string", "Target phase to transition to"),
       param("basePath", "string", "Project base path", false, ".")
     ], async (params) => {
       try {
-        const wf = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
-        const engine = wf.createWorkflowEngine?.(params["basePath"] ?? ".");
-        const result = engine?.transition(params["targetPhase"]);
-        return ok(result ?? { success: false, phase: params["targetPhase"] });
+        const { createPhaseController: createPhaseController2 } = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
+        const { tracker, file } = await loadTracker(params["basePath"] ?? ".");
+        const result = await createPhaseController2(tracker).transitionTo(params["targetPhase"]);
+        if (result.success)
+          await saveTracker(tracker, file);
+        return ok(result);
       } catch {
-        return ok({ success: false, phase: params["targetPhase"] });
+        return fail("Workflow-engine package not available");
       }
     }),
-    tool("workflow.gate.check", "Check if a quality gate can be passed", "workflow", [
-      param("gate", "string", "Gate name"),
+    tool("workflow.gate.check", "Check whether the workflow can transition to a target phase (quality gates)", "workflow", [
+      param("targetPhase", "string", "Target phase to check"),
       param("basePath", "string", "Project base path", false, ".")
     ], async (params) => {
       try {
-        const wf = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
-        const engine = wf.createWorkflowEngine?.(params["basePath"] ?? ".");
-        const result = engine?.checkGate(params["gate"]);
-        return ok(result ?? { passed: false, gate: params["gate"] });
+        const { createPhaseController: createPhaseController2 } = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
+        const { tracker } = await loadTracker(params["basePath"] ?? ".");
+        const target = params["targetPhase"] ?? params["gate"];
+        const canTransition = await createPhaseController2(tracker).canTransition(target);
+        return ok({ targetPhase: target, canTransition });
       } catch {
-        return ok({ passed: false, gate: params["gate"] });
+        return fail("Workflow-engine package not available");
       }
     }),
-    tool("workflow.tasks.list", "List tasks for the current workflow phase", "workflow", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
+    tool("workflow.approve", "Approve the current (or a named) SDD phase (persisted)", "workflow", [
+      param("phase", "string", "Phase to approve"),
+      param("basePath", "string", "Project base path", false, ".")
+    ], async (params) => {
       try {
-        const wf = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
-        const engine = wf.createWorkflowEngine?.(params["basePath"] ?? ".");
-        const tasks = engine?.listTasks();
-        return ok(tasks ?? []);
+        const { tracker, file } = await loadTracker(params["basePath"] ?? ".");
+        const phase = params["phase"] ?? tracker.getState().currentPhase;
+        tracker.approve(phase);
+        await saveTracker(tracker, file);
+        return ok({ phase, approved: true });
       } catch {
-        return ok([]);
+        return fail("Workflow-engine package not available");
       }
     })
   ];

package/dist/index.js

@@ -14431,93 +14431,129 @@ function researchTools() {
       param("depth", "string", "Research depth: shallow | medium | deep", false, "medium")
     ], async (params) => {
       try {
-        const research = await Promise.resolve().then(() => (init_dist10(), dist_exports10));
-        const result = research.query?.(params["topic"], params["depth"] ?? "medium");
-        return ok(result ?? { findings: [], topic: params["topic"] });
+        const { createResearchEngine: createResearchEngine2 } = await Promise.resolve().then(() => (init_dist10(), dist_exports10));
+        const sources = normalizeSources(params["sources"]);
+        const result = createResearchEngine2().research({ topic: params["topic"] ?? "", depth: params["depth"] ?? "medium" }, sources);
+        return ok(result);
       } catch {
-        return ok({ findings: [], topic: params["topic"] });
+        return fail("Deep-research package not available");
       }
     }),
-    tool("research.iterative", "Perform iterative deep research with progressive refinement", "research", [
+    tool("research.iterative", "Perform iterative research with progressive refinement over provided sources", "research", [
       param("topic", "string", "Research topic"),
-      param("iterations", "number", "Number of refinement iterations", false, 3)
+      param("depth", "string", "Depth: shallow | medium | deep", false, "medium"),
+      param("sources", "array", "Sources as {title,type,relevance,content} objects")
     ], async (params) => {
       try {
-        const research = await Promise.resolve().then(() => (init_dist10(), dist_exports10));
-        const result = research.iterativeResearch?.(params["topic"], params["iterations"] ?? 3);
-        return ok(result ?? { findings: [], iterations: 0, topic: params["topic"] });
+        const { createResearchEngine: createResearchEngine2 } = await Promise.resolve().then(() => (init_dist10(), dist_exports10));
+        const sources = normalizeSources(params["sources"]);
+        const result = createResearchEngine2().researchIterative({ topic: params["topic"] ?? "", depth: params["depth"] ?? "medium" }, () => sources);
+        return ok(result);
       } catch {
-        return ok({ findings: [], iterations: 0, topic: params["topic"] });
+        return fail("Deep-research package not available");
       }
     }),
-    tool("research.evidence", "Generate evidence chain for a claim or hypothesis", "research", [
-      param("claim", "string", "Claim or hypothesis to evaluate"),
-      param("sources", "array", "Evidence sources to consider", false)
+    tool("research.evidence", "Accumulate research results and retrieve evidence for a topic", "research", [
+      param("topic", "string", "Topic to gather evidence for"),
+      param("sources", "array", "Sources as {title,type,relevance,content} objects")
     ], async (params) => {
       try {
-        const research = await Promise.resolve().then(() => (init_dist10(), dist_exports10));
-        const result = research.generateEvidence?.(params["claim"], params["sources"]);
-        return ok(result ?? { evidence: [], confidence: 0 });
+        const { createResearchEngine: createResearchEngine2, createKnowledgeAccumulator: createKnowledgeAccumulator2 } = await Promise.resolve().then(() => (init_dist10(), dist_exports10));
+        const sources = normalizeSources(params["sources"]);
+        const topic = params["topic"] ?? "";
+        const result = createResearchEngine2().research({ topic, depth: "medium" }, sources);
+        const acc = createKnowledgeAccumulator2();
+        acc.accumulate(result);
+        return ok({ evidence: acc.query(topic), summary: result.summary, confidence: result.confidence });
       } catch {
-        return ok({ evidence: [], confidence: 0 });
+        return fail("Deep-research package not available");
       }
     })
   ];
 }
+function normalizeSources(raw) {
+  const valid = /* @__PURE__ */ new Set(["code", "documentation", "article", "api-reference"]);
+  const arr = Array.isArray(raw) ? raw : [];
+  return arr.map((s, i) => {
+    const o = s ?? {};
+    const t = String(o["type"] ?? "documentation");
+    return {
+      title: String(o["title"] ?? `source-${i + 1}`),
+      type: valid.has(t) ? t : "documentation",
+      relevance: typeof o["relevance"] === "number" ? o["relevance"] : 0.5,
+      content: String(o["content"] ?? (typeof s === "string" ? s : ""))
+    };
+  });
+}
 function neuralTools() {
   return [
-    tool("neural.search", "Neural similarity search across embeddings", "neural", [
+    tool("neural.search", "Neural (TF-IDF) similarity search over provided documents", "neural", [
       param("query", "string", "Search query"),
+      param("documents", "array", "Documents to index: strings or {id,text} objects"),
       param("topK", "number", "Number of results", false, 10)
     ], async (params) => {
       try {
-        const ns = await Promise.resolve().then(() => (init_dist14(), dist_exports14));
-        const results = ns.search?.(params["query"], params["topK"] ?? 10);
-        return ok(results ?? []);
+        const { createNeuralSearchEngine: createNeuralSearchEngine2, createTfIdfEmbeddingModel: createTfIdfEmbeddingModel2 } = await Promise.resolve().then(() => (init_dist14(), dist_exports14));
+        const model = createTfIdfEmbeddingModel2();
+        const engine = createNeuralSearchEngine2();
+        const docs = params["documents"] ?? [];
+        const texts = docs.map((d) => typeof d === "string" ? d : d.text ?? "");
+        const model2 = createTfIdfEmbeddingModel2();
+        if (typeof model2.fit === "function") {
+          model2.fit(texts);
+        }
+        const embedder = typeof model2.fit === "function" ? model2 : model;
+        for (let i = 0; i < docs.length; i++) {
+          const d = docs[i];
+          const id = typeof d === "string" ? `doc-${i}` : d.id ?? `doc-${i}`;
+          engine.addDocument(id, await embedder.embed(texts[i]), { text: texts[i] });
+        }
+        const hits = engine.search(await embedder.embed(params["query"] ?? ""), params["topK"] ?? 10);
+        return ok({ query: params["query"], hits });
       } catch {
-        return ok([]);
+        return fail("Neural-search package not available");
       }
     }),
-    tool("neural.embed", "Generate embeddings for text", "neural", [param("text", "string", "Text to embed")], async (params) => {
+    tool("neural.embed", "Generate a TF-IDF embedding vector for text", "neural", [param("text", "string", "Text to embed")], async (params) => {
       try {
-        const ns = await Promise.resolve().then(() => (init_dist14(), dist_exports14));
-        const embedding = ns.embed?.(params["text"]);
-        return ok(embedding ?? { vector: [], dimensions: 0 });
+        const { createTfIdfEmbeddingModel: createTfIdfEmbeddingModel2 } = await Promise.resolve().then(() => (init_dist14(), dist_exports14));
+        const model = createTfIdfEmbeddingModel2();
+        const text = params["text"] ?? "";
+        if (typeof model.fit === "function") {
+          model.fit([text]);
+        }
+        const vector = await model.embed(text);
+        return ok({ vector, dimensions: Array.isArray(vector) ? vector.length : vector.values?.length ?? 0 });
       } catch {
-        return ok({ vector: [], dimensions: 0 });
+        return fail("Neural-search package not available");
       }
     }),
-    tool("neural.patterns.extract", "Wake phase: extract patterns from code or data", "neural", [
-      param("source", "string", "Source code or data to extract patterns from"),
-      param("type", "string", "Pattern type: structural | behavioral | api", false, "structural")
-    ], async (params) => {
+    tool("neural.patterns.extract", "Wake phase: extract patterns from a list of items", "neural", [param("items", "array", "Items (strings) to process for pattern extraction")], async (params) => {
       try {
-        const ws = await Promise.resolve().then(() => (init_dist15(), dist_exports15));
-        const patterns = ws.extractPatterns?.(params["source"], params["type"] ?? "structural");
-        return ok(patterns ?? { patterns: [], type: params["type"] ?? "structural" });
+        const { createWakePhase: createWakePhase2 } = await Promise.resolve().then(() => (init_dist15(), dist_exports15));
+        const items = (params["items"] ?? []).map(String);
+        return ok(createWakePhase2().process(items));
       } catch {
-        return ok({ patterns: [], type: params["type"] ?? "structural" });
+        return fail("Wake-sleep package not available");
       }
     }),
-    tool("neural.patterns.consolidate", "Sleep phase: consolidate and compress learned patterns", "neural", [param("patterns", "array", "Patterns to consolidate", false)], async (params) => {
+    tool("neural.patterns.consolidate", "Sleep phase: consolidate and compress learned patterns", "neural", [param("patterns", "array", "Pattern strings to consolidate")], async (params) => {
       try {
-        const ws = await Promise.resolve().then(() => (init_dist15(), dist_exports15));
-        const result = ws.consolidatePatterns?.(params["patterns"]);
-        return ok(result ?? { consolidated: [], count: 0 });
+        const { createSleepPhase: createSleepPhase2 } = await Promise.resolve().then(() => (init_dist15(), dist_exports15));
+        const patterns = (params["patterns"] ?? []).map(String);
+        return ok(createSleepPhase2().consolidate(patterns));
       } catch {
-        return ok({ consolidated: [], count: 0 });
+        return fail("Wake-sleep package not available");
       }
     }),
-    tool("neural.library.learn", "Learn patterns from a library or framework", "neural", [
-      param("library", "string", "Library name or path"),
-      param("depth", "string", "Analysis depth: api | usage | deep", false, "api")
-    ], async (params) => {
+    tool("neural.library.learn", "Learn reusable patterns from code snippets (E-graph library learning)", "neural", [param("snippets", "array", "Array of code snippet strings to learn from")], async (params) => {
       try {
-        const ll = await Promise.resolve().then(() => (init_dist11(), dist_exports11));
-        const result = ll.learnLibrary?.(params["library"], params["depth"] ?? "api");
-        return ok(result ?? { patterns: [], library: params["library"] });
+        const { createLibraryLearner: createLibraryLearner2 } = await Promise.resolve().then(() => (init_dist11(), dist_exports11));
+        const snippets = (params["snippets"] ?? []).map(String);
+        const patterns = createLibraryLearner2().learn(snippets);
+        return ok({ patterns, count: patterns.length });
       } catch {
-        return ok({ patterns: [], library: params["library"] });
+        return fail("Library-learner package not available");
       }
     })
   ];
@@ -14671,52 +14707,81 @@ function formalVerifyTools() {
     })
   ];
 }
+async function loadTracker(basePath) {
+  const { createStateTracker: createStateTracker2 } = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
+  const { existsSync: existsSync12, readFileSync: readFileSync7 } = await import("node:fs");
+  const { join: join8 } = await import("node:path");
+  const tracker = createStateTracker2();
+  const file = join8(basePath, ".musubix", "workflow-state.json");
+  try {
+    if (existsSync12(file))
+      tracker.restore(JSON.parse(readFileSync7(file, "utf-8")));
+  } catch {
+  }
+  return { tracker, file };
+}
+async function saveTracker(tracker, file) {
+  const { writeFileSync: writeFileSync4, mkdirSync: mkdirSync4 } = await import("node:fs");
+  const { dirname: dirname4 } = await import("node:path");
+  mkdirSync4(dirname4(file), { recursive: true });
+  writeFileSync4(file, JSON.stringify(tracker.toJSON(), null, 2), "utf-8");
+}
 function workflowTools() {
   return [
-    tool("workflow.phase.current", "Get the current SDD workflow phase", "workflow", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
+    tool("workflow.phase.current", "Get the current SDD workflow phase and approvals", "workflow", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
       try {
-        const wf = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
-        const engine = wf.createWorkflowEngine?.(params["basePath"] ?? ".");
-        const phase = engine?.getCurrentPhase();
-        return ok(phase ?? { phase: "requirements", index: 0 });
+        const { PHASE_ORDER: PHASE_ORDER2 } = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
+        const { tracker } = await loadTracker(params["basePath"] ?? ".");
+        const state = tracker.getState();
+        return ok({
+          currentPhase: state.currentPhase,
+          approvals: PHASE_ORDER2.map((p) => ({ phase: p, approved: tracker.isApproved(p) }))
+        });
       } catch {
-        return ok({ phase: "requirements", index: 0 });
+        return fail("Workflow-engine package not available");
       }
     }),
-    tool("workflow.phase.transition", "Transition to the next SDD workflow phase", "workflow", [
+    tool("workflow.phase.transition", "Transition to a target SDD workflow phase (persisted)", "workflow", [
       param("targetPhase", "string", "Target phase to transition to"),
       param("basePath", "string", "Project base path", false, ".")
     ], async (params) => {
       try {
-        const wf = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
-        const engine = wf.createWorkflowEngine?.(params["basePath"] ?? ".");
-        const result = engine?.transition(params["targetPhase"]);
-        return ok(result ?? { success: false, phase: params["targetPhase"] });
+        const { createPhaseController: createPhaseController2 } = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
+        const { tracker, file } = await loadTracker(params["basePath"] ?? ".");
+        const result = await createPhaseController2(tracker).transitionTo(params["targetPhase"]);
+        if (result.success)
+          await saveTracker(tracker, file);
+        return ok(result);
       } catch {
-        return ok({ success: false, phase: params["targetPhase"] });
+        return fail("Workflow-engine package not available");
       }
     }),
-    tool("workflow.gate.check", "Check if a quality gate can be passed", "workflow", [
-      param("gate", "string", "Gate name"),
+    tool("workflow.gate.check", "Check whether the workflow can transition to a target phase (quality gates)", "workflow", [
+      param("targetPhase", "string", "Target phase to check"),
       param("basePath", "string", "Project base path", false, ".")
     ], async (params) => {
       try {
-        const wf = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
-        const engine = wf.createWorkflowEngine?.(params["basePath"] ?? ".");
-        const result = engine?.checkGate(params["gate"]);
-        return ok(result ?? { passed: false, gate: params["gate"] });
+        const { createPhaseController: createPhaseController2 } = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
+        const { tracker } = await loadTracker(params["basePath"] ?? ".");
+        const target = params["targetPhase"] ?? params["gate"];
+        const canTransition = await createPhaseController2(tracker).canTransition(target);
+        return ok({ targetPhase: target, canTransition });
       } catch {
-        return ok({ passed: false, gate: params["gate"] });
+        return fail("Workflow-engine package not available");
       }
     }),
-    tool("workflow.tasks.list", "List tasks for the current workflow phase", "workflow", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
+    tool("workflow.approve", "Approve the current (or a named) SDD phase (persisted)", "workflow", [
+      param("phase", "string", "Phase to approve"),
+      param("basePath", "string", "Project base path", false, ".")
+    ], async (params) => {
       try {
-        const wf = await Promise.resolve().then(() => (init_dist6(), dist_exports6));
-        const engine = wf.createWorkflowEngine?.(params["basePath"] ?? ".");
-        const tasks = engine?.listTasks();
-        return ok(tasks ?? []);
+        const { tracker, file } = await loadTracker(params["basePath"] ?? ".");
+        const phase = params["phase"] ?? tracker.getState().currentPhase;
+        tracker.approve(phase);
+        await saveTracker(tracker, file);
+        return ok({ phase, approved: true });
       } catch {
-        return ok([]);
+        return fail("Workflow-engine package not available");
       }
     })
   ];

package/package.json

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