musubix2 0.5.8 → 0.5.10

package/.claude/.musubix-managed

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

package/dist/cli.js

@@ -14180,63 +14180,101 @@ function policyTools() {
     })
   ];
 }
+async function loadTripleStore(basePath) {
+  const { createOntologyStore: createOntologyStore2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
+  const store = createOntologyStore2();
+  const { existsSync: existsSync12, readFileSync: readFileSync7 } = await import("node:fs");
+  const { join: join8 } = await import("node:path");
+  const file = join8(basePath, ".musubix", "ontology.json");
+  try {
+    if (existsSync12(file)) {
+      store.addTriples(JSON.parse(readFileSync7(file, "utf-8")));
+    }
+  } catch {
+  }
+  return { store, file };
+}
+async function saveTripleStore(store, 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(store.getAll(), null, 2), "utf-8");
+}
 function ontologyTools() {
   return [
-    tool("ontology.triple.add", "Add a triple (subject, predicate, object) to the ontology store", "ontology", [
-      param("subject", "string", "Subject URI"),
-      param("predicate", "string", "Predicate URI"),
-      param("object", "string", "Object URI or literal")
+    tool("ontology.triple.add", "Add a triple (subject, predicate, object) to the persisted ontology store", "ontology", [
+      param("subject", "string", "Subject"),
+      param("predicate", "string", "Predicate"),
+      param("object", "string", "Object (URI or literal)"),
+      param("basePath", "string", "Project base path", false, ".")
     ], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const store = ont.createTripleStore?.();
-        store?.add(params["subject"], params["predicate"], params["object"]);
-        return ok({ added: true, subject: params["subject"], predicate: params["predicate"], object: params["object"] });
+        const { store, file } = await loadTripleStore(params["basePath"] ?? ".");
+        store.addTriple({
+          subject: params["subject"],
+          predicate: params["predicate"],
+          object: params["object"]
+        });
+        await saveTripleStore(store, file);
+        return ok({ added: true, total: store.size() });
       } catch {
-        return ok({ added: true, subject: params["subject"], predicate: params["predicate"], object: params["object"] });
+        return fail("Ontology package not available");
       }
     }),
-    tool("ontology.triple.query", "Query triples by pattern matching", "ontology", [
-      param("subject", "string", "Subject pattern (empty for wildcard)", false),
-      param("predicate", "string", "Predicate pattern (empty for wildcard)", false),
-      param("object", "string", "Object pattern (empty for wildcard)", false)
+    tool("ontology.triple.query", "Query triples by pattern (omit a term to wildcard it)", "ontology", [
+      param("subject", "string", "Subject pattern", false),
+      param("predicate", "string", "Predicate pattern", false),
+      param("object", "string", "Object pattern", false),
+      param("basePath", "string", "Project base path", false, ".")
     ], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const store = ont.createTripleStore?.();
-        const results = store?.query(params["subject"], params["predicate"], params["object"]);
-        return ok(results ?? []);
+        const { store } = await loadTripleStore(params["basePath"] ?? ".");
+        const results = store.query({
+          subject: params["subject"],
+          predicate: params["predicate"],
+          object: params["object"]
+        });
+        return ok({ results, count: results.length });
       } catch {
-        return ok([]);
+        return fail("Ontology package not available");
       }
     }),
-    tool("ontology.rules.apply", "Apply rule engine to infer new triples", "ontology", [param("rules", "array", "Rules to apply", false)], async (params) => {
+    tool("ontology.rules.apply", "Apply the default OWL 2 RL rule engine to infer new triples", "ontology", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const engine = ont.createRuleEngine?.();
-        const result = engine?.apply(params["rules"]);
-        return ok(result ?? { inferred: 0, triples: [] });
+        const { createRuleEngine: createRuleEngine2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
+        const { store, file } = await loadTripleStore(params["basePath"] ?? ".");
+        const result = createRuleEngine2(true).applyRules(store);
+        await saveTripleStore(store, file);
+        return ok(result);
       } catch {
-        return ok({ inferred: 0, triples: [] });
+        return fail("Ontology package not available");
       }
     }),
-    tool("ontology.consistency.check", "Check ontology consistency", "ontology", [], async () => {
+    tool("ontology.consistency.check", "Check ontology consistency against the persisted store", "ontology", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const checker = ont.createConsistencyChecker?.();
-        const result = checker?.check();
-        return ok(result ?? { consistent: true, issues: [] });
+        const { createConsistencyValidator: createConsistencyValidator2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
+        const { store } = await loadTripleStore(params["basePath"] ?? ".");
+        return ok(createConsistencyValidator2().validate(store));
       } catch {
-        return ok({ consistent: true, issues: [] });
+        return fail("Ontology package not available");
       }
     }),
-    tool("ontology.sparql.query", "Execute a SPARQL-like query against the ontology", "ontology", [param("query", "string", "SPARQL-like query string")], async (params) => {
+    tool("ontology.sparql.query", "Pattern query over the store (basic subject/predicate/object matching)", "ontology", [
+      param("subject", "string", "Subject pattern", false),
+      param("predicate", "string", "Predicate pattern", false),
+      param("object", "string", "Object pattern", false),
+      param("basePath", "string", "Project base path", false, ".")
+    ], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const result = ont.sparqlQuery?.(params["query"]);
-        return ok(result ?? { bindings: [] });
+        const { store } = await loadTripleStore(params["basePath"] ?? ".");
+        const bindings = store.query({
+          subject: params["subject"],
+          predicate: params["predicate"],
+          object: params["object"]
+        });
+        return ok({ bindings, count: bindings.length });
       } catch {
-        return ok({ bindings: [] });
+        return fail("Ontology package not available");
       }
     })
   ];
@@ -14248,47 +14286,78 @@ function codeAnalysisTools() {
       param("language", "string", "Source language: typescript | javascript | python", false, "typescript")
     ], async (params) => {
       try {
-        const cg = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
-        const ast = cg.parseSource?.(params["source"], params["language"] ?? "typescript");
-        return ok(ast ?? { type: "Program", body: [] });
+        const { createASTParser: createASTParser2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
+        const nodes = createASTParser2().parse(params["source"] ?? "", params["language"] ?? "typescript");
+        return ok({ nodes, count: nodes.length });
       } catch {
-        return ok({ type: "Program", body: [] });
+        return fail("Codegraph package not available");
       }
     }),
-    tool("code.graph.build", "Build a dependency graph from source files", "code-analysis", [
-      param("entryPoint", "string", "Entry point file path"),
-      param("basePath", "string", "Project base path", false, ".")
-    ], async (params) => {
+    tool("code.graph.build", "Build a code graph (nodes) from inline sources", "code-analysis", [param("sources", "array", "Sources as {code, language, filePath} objects")], async (params) => {
       try {
-        const cg = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
-        const graph = cg.buildDependencyGraph?.(params["entryPoint"], params["basePath"] ?? ".");
-        return ok(graph ?? { nodes: [], edges: [] });
+        const { createASTParser: createASTParser2, createGraphEngine: createGraphEngine2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
+        const parser = createASTParser2();
+        const engine = createGraphEngine2();
+        const sources = params["sources"] ?? [];
+        for (const s of sources) {
+          const lang = s.language ?? "typescript";
+          for (const n of parser.parse(s.code ?? "", lang)) {
+            engine.addNode({
+              id: `${s.filePath ?? "inline"}:${n.name}`,
+              name: n.name,
+              kind: n.kind,
+              filePath: s.filePath ?? "inline",
+              language: lang,
+              startLine: n.startLine ?? 0,
+              endLine: n.endLine ?? 0
+            });
+          }
+        }
+        const stats = engine.getStats();
+        return ok({ nodeCount: stats.nodeCount, edgeCount: stats.edgeCount, languages: [...stats.languages] });
       } catch {
-        return ok({ nodes: [], edges: [] });
+        return fail("Codegraph package not available");
       }
     }),
-    tool("code.graph.search", "Search code graph using GraphRAG techniques", "code-analysis", [
+    tool("code.graph.search", "Search a code graph built from inline sources using GraphRAG", "code-analysis", [
       param("query", "string", "Search query"),
-      param("basePath", "string", "Project base path", false, ".")
+      param("sources", "array", "Sources as {code, language, filePath} objects to index")
     ], async (params) => {
       try {
-        const cg = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
-        const results = cg.graphSearch?.(params["query"], params["basePath"] ?? ".");
-        return ok(results ?? []);
+        const { createASTParser: createASTParser2, createGraphEngine: createGraphEngine2, GraphRAGSearch: GraphRAGSearch2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
+        const parser = createASTParser2();
+        const engine = createGraphEngine2();
+        const sources = params["sources"] ?? [];
+        for (const s of sources) {
+          const lang = s.language ?? "typescript";
+          for (const n of parser.parse(s.code ?? "", lang)) {
+            engine.addNode({
+              id: `${s.filePath ?? "inline"}:${n.name}`,
+              name: n.name,
+              kind: n.kind,
+              filePath: s.filePath ?? "inline",
+              language: lang,
+              startLine: n.startLine ?? 0,
+              endLine: n.endLine ?? 0
+            });
+          }
+        }
+        const results = new GraphRAGSearch2(engine).globalSearch(params["query"] ?? "");
+        return ok({ query: params["query"], results });
       } catch {
-        return ok([]);
+        return fail("Codegraph package not available");
       }
     }),
-    tool("code.dfg.analyze", "Perform data flow analysis on source code", "code-analysis", [
-      param("source", "string", "Source code to analyze"),
-      param("language", "string", "Source language", false, "typescript")
+    tool("code.dfg.analyze", "Build a data-flow graph from structured statements and report reaching definitions", "code-analysis", [
+      param("statements", "array", "SimpleStatement[] (type/line/variable/value/usedVariables)"),
+      param("scope", "string", "Scope name", false, "global")
     ], async (params) => {
       try {
-        const dfg = await Promise.resolve().then(() => (init_dist13(), dist_exports13));
-        const result = dfg.analyzeDataFlow?.(params["source"], params["language"] ?? "typescript");
-        return ok(result ?? { flows: [], variables: [] });
+        const { createDataFlowAnalyzer: createDataFlowAnalyzer2 } = await Promise.resolve().then(() => (init_dist13(), dist_exports13));
+        const dfg = createDataFlowAnalyzer2().buildDFG(params["statements"] ?? [], params["scope"] ?? "global");
+        return ok(dfg);
       } catch {
-        return ok({ flows: [], variables: [] });
+        return fail("DFG package not available");
       }
     })
   ];
@@ -14362,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");
       }
     })
   ];
@@ -14602,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

@@ -14180,63 +14180,101 @@ function policyTools() {
     })
   ];
 }
+async function loadTripleStore(basePath) {
+  const { createOntologyStore: createOntologyStore2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
+  const store = createOntologyStore2();
+  const { existsSync: existsSync12, readFileSync: readFileSync7 } = await import("node:fs");
+  const { join: join8 } = await import("node:path");
+  const file = join8(basePath, ".musubix", "ontology.json");
+  try {
+    if (existsSync12(file)) {
+      store.addTriples(JSON.parse(readFileSync7(file, "utf-8")));
+    }
+  } catch {
+  }
+  return { store, file };
+}
+async function saveTripleStore(store, 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(store.getAll(), null, 2), "utf-8");
+}
 function ontologyTools() {
   return [
-    tool("ontology.triple.add", "Add a triple (subject, predicate, object) to the ontology store", "ontology", [
-      param("subject", "string", "Subject URI"),
-      param("predicate", "string", "Predicate URI"),
-      param("object", "string", "Object URI or literal")
+    tool("ontology.triple.add", "Add a triple (subject, predicate, object) to the persisted ontology store", "ontology", [
+      param("subject", "string", "Subject"),
+      param("predicate", "string", "Predicate"),
+      param("object", "string", "Object (URI or literal)"),
+      param("basePath", "string", "Project base path", false, ".")
     ], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const store = ont.createTripleStore?.();
-        store?.add(params["subject"], params["predicate"], params["object"]);
-        return ok({ added: true, subject: params["subject"], predicate: params["predicate"], object: params["object"] });
+        const { store, file } = await loadTripleStore(params["basePath"] ?? ".");
+        store.addTriple({
+          subject: params["subject"],
+          predicate: params["predicate"],
+          object: params["object"]
+        });
+        await saveTripleStore(store, file);
+        return ok({ added: true, total: store.size() });
       } catch {
-        return ok({ added: true, subject: params["subject"], predicate: params["predicate"], object: params["object"] });
+        return fail("Ontology package not available");
       }
     }),
-    tool("ontology.triple.query", "Query triples by pattern matching", "ontology", [
-      param("subject", "string", "Subject pattern (empty for wildcard)", false),
-      param("predicate", "string", "Predicate pattern (empty for wildcard)", false),
-      param("object", "string", "Object pattern (empty for wildcard)", false)
+    tool("ontology.triple.query", "Query triples by pattern (omit a term to wildcard it)", "ontology", [
+      param("subject", "string", "Subject pattern", false),
+      param("predicate", "string", "Predicate pattern", false),
+      param("object", "string", "Object pattern", false),
+      param("basePath", "string", "Project base path", false, ".")
     ], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const store = ont.createTripleStore?.();
-        const results = store?.query(params["subject"], params["predicate"], params["object"]);
-        return ok(results ?? []);
+        const { store } = await loadTripleStore(params["basePath"] ?? ".");
+        const results = store.query({
+          subject: params["subject"],
+          predicate: params["predicate"],
+          object: params["object"]
+        });
+        return ok({ results, count: results.length });
       } catch {
-        return ok([]);
+        return fail("Ontology package not available");
       }
     }),
-    tool("ontology.rules.apply", "Apply rule engine to infer new triples", "ontology", [param("rules", "array", "Rules to apply", false)], async (params) => {
+    tool("ontology.rules.apply", "Apply the default OWL 2 RL rule engine to infer new triples", "ontology", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const engine = ont.createRuleEngine?.();
-        const result = engine?.apply(params["rules"]);
-        return ok(result ?? { inferred: 0, triples: [] });
+        const { createRuleEngine: createRuleEngine2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
+        const { store, file } = await loadTripleStore(params["basePath"] ?? ".");
+        const result = createRuleEngine2(true).applyRules(store);
+        await saveTripleStore(store, file);
+        return ok(result);
       } catch {
-        return ok({ inferred: 0, triples: [] });
+        return fail("Ontology package not available");
       }
     }),
-    tool("ontology.consistency.check", "Check ontology consistency", "ontology", [], async () => {
+    tool("ontology.consistency.check", "Check ontology consistency against the persisted store", "ontology", [param("basePath", "string", "Project base path", false, ".")], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const checker = ont.createConsistencyChecker?.();
-        const result = checker?.check();
-        return ok(result ?? { consistent: true, issues: [] });
+        const { createConsistencyValidator: createConsistencyValidator2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
+        const { store } = await loadTripleStore(params["basePath"] ?? ".");
+        return ok(createConsistencyValidator2().validate(store));
       } catch {
-        return ok({ consistent: true, issues: [] });
+        return fail("Ontology package not available");
       }
     }),
-    tool("ontology.sparql.query", "Execute a SPARQL-like query against the ontology", "ontology", [param("query", "string", "SPARQL-like query string")], async (params) => {
+    tool("ontology.sparql.query", "Pattern query over the store (basic subject/predicate/object matching)", "ontology", [
+      param("subject", "string", "Subject pattern", false),
+      param("predicate", "string", "Predicate pattern", false),
+      param("object", "string", "Object pattern", false),
+      param("basePath", "string", "Project base path", false, ".")
+    ], async (params) => {
       try {
-        const ont = await Promise.resolve().then(() => (init_dist3(), dist_exports3));
-        const result = ont.sparqlQuery?.(params["query"]);
-        return ok(result ?? { bindings: [] });
+        const { store } = await loadTripleStore(params["basePath"] ?? ".");
+        const bindings = store.query({
+          subject: params["subject"],
+          predicate: params["predicate"],
+          object: params["object"]
+        });
+        return ok({ bindings, count: bindings.length });
       } catch {
-        return ok({ bindings: [] });
+        return fail("Ontology package not available");
       }
     })
   ];
@@ -14248,47 +14286,78 @@ function codeAnalysisTools() {
       param("language", "string", "Source language: typescript | javascript | python", false, "typescript")
     ], async (params) => {
       try {
-        const cg = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
-        const ast = cg.parseSource?.(params["source"], params["language"] ?? "typescript");
-        return ok(ast ?? { type: "Program", body: [] });
+        const { createASTParser: createASTParser2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
+        const nodes = createASTParser2().parse(params["source"] ?? "", params["language"] ?? "typescript");
+        return ok({ nodes, count: nodes.length });
       } catch {
-        return ok({ type: "Program", body: [] });
+        return fail("Codegraph package not available");
       }
     }),
-    tool("code.graph.build", "Build a dependency graph from source files", "code-analysis", [
-      param("entryPoint", "string", "Entry point file path"),
-      param("basePath", "string", "Project base path", false, ".")
-    ], async (params) => {
+    tool("code.graph.build", "Build a code graph (nodes) from inline sources", "code-analysis", [param("sources", "array", "Sources as {code, language, filePath} objects")], async (params) => {
       try {
-        const cg = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
-        const graph = cg.buildDependencyGraph?.(params["entryPoint"], params["basePath"] ?? ".");
-        return ok(graph ?? { nodes: [], edges: [] });
+        const { createASTParser: createASTParser2, createGraphEngine: createGraphEngine2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
+        const parser = createASTParser2();
+        const engine = createGraphEngine2();
+        const sources = params["sources"] ?? [];
+        for (const s of sources) {
+          const lang = s.language ?? "typescript";
+          for (const n of parser.parse(s.code ?? "", lang)) {
+            engine.addNode({
+              id: `${s.filePath ?? "inline"}:${n.name}`,
+              name: n.name,
+              kind: n.kind,
+              filePath: s.filePath ?? "inline",
+              language: lang,
+              startLine: n.startLine ?? 0,
+              endLine: n.endLine ?? 0
+            });
+          }
+        }
+        const stats = engine.getStats();
+        return ok({ nodeCount: stats.nodeCount, edgeCount: stats.edgeCount, languages: [...stats.languages] });
       } catch {
-        return ok({ nodes: [], edges: [] });
+        return fail("Codegraph package not available");
       }
     }),
-    tool("code.graph.search", "Search code graph using GraphRAG techniques", "code-analysis", [
+    tool("code.graph.search", "Search a code graph built from inline sources using GraphRAG", "code-analysis", [
       param("query", "string", "Search query"),
-      param("basePath", "string", "Project base path", false, ".")
+      param("sources", "array", "Sources as {code, language, filePath} objects to index")
     ], async (params) => {
       try {
-        const cg = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
-        const results = cg.graphSearch?.(params["query"], params["basePath"] ?? ".");
-        return ok(results ?? []);
+        const { createASTParser: createASTParser2, createGraphEngine: createGraphEngine2, GraphRAGSearch: GraphRAGSearch2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports4));
+        const parser = createASTParser2();
+        const engine = createGraphEngine2();
+        const sources = params["sources"] ?? [];
+        for (const s of sources) {
+          const lang = s.language ?? "typescript";
+          for (const n of parser.parse(s.code ?? "", lang)) {
+            engine.addNode({
+              id: `${s.filePath ?? "inline"}:${n.name}`,
+              name: n.name,
+              kind: n.kind,
+              filePath: s.filePath ?? "inline",
+              language: lang,
+              startLine: n.startLine ?? 0,
+              endLine: n.endLine ?? 0
+            });
+          }
+        }
+        const results = new GraphRAGSearch2(engine).globalSearch(params["query"] ?? "");
+        return ok({ query: params["query"], results });
       } catch {
-        return ok([]);
+        return fail("Codegraph package not available");
       }
     }),
-    tool("code.dfg.analyze", "Perform data flow analysis on source code", "code-analysis", [
-      param("source", "string", "Source code to analyze"),
-      param("language", "string", "Source language", false, "typescript")
+    tool("code.dfg.analyze", "Build a data-flow graph from structured statements and report reaching definitions", "code-analysis", [
+      param("statements", "array", "SimpleStatement[] (type/line/variable/value/usedVariables)"),
+      param("scope", "string", "Scope name", false, "global")
     ], async (params) => {
       try {
-        const dfg = await Promise.resolve().then(() => (init_dist13(), dist_exports13));
-        const result = dfg.analyzeDataFlow?.(params["source"], params["language"] ?? "typescript");
-        return ok(result ?? { flows: [], variables: [] });
+        const { createDataFlowAnalyzer: createDataFlowAnalyzer2 } = await Promise.resolve().then(() => (init_dist13(), dist_exports13));
+        const dfg = createDataFlowAnalyzer2().buildDFG(params["statements"] ?? [], params["scope"] ?? "global");
+        return ok(dfg);
       } catch {
-        return ok({ flows: [], variables: [] });
+        return fail("DFG package not available");
       }
     })
   ];
@@ -14362,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");
       }
     })
   ];
@@ -14602,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.8",
+  "version": "0.5.10",
   "description": "MUSUBIX2 — Specification Driven Development System",
   "type": "module",
   "main": "./dist/index.js",