musubix2 0.5.9 → 0.5.11

package/.claude/.musubix-managed

@@ -1 +1 @@
-{"generator":"musubix2","version":"0.5.9","timestamp":"2026-07-09T10:34:18.313Z"}
+{"generator":"musubix2","version":"0.5.11","timestamp":"2026-07-09T10:51:51.652Z"}

package/dist/assets/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0",
-  "generatedAt": "2026-07-09T10:34:18.341Z",
+  "generatedAt": "2026-07-09T10:51:51.684Z",
   "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");
       }
     })
   ];
@@ -14613,110 +14649,156 @@ function synthesisTools() {
     })
   ];
 }
+async function buildSpecFromParams(params) {
+  const text = params["text"] ?? params["requirement"] ?? params["spec"] ?? "";
+  let pattern = params["pattern"];
+  if (!pattern) {
+    try {
+      const { createEARSValidator: createEARSValidator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+      pattern = createEARSValidator2().analyze(text).pattern;
+    } catch {
+      pattern = "ubiquitous";
+    }
+  }
+  return {
+    id: params["id"] ?? "REQ-XXX-001",
+    title: params["name"] ?? params["title"] ?? "requirement",
+    text,
+    pattern,
+    trigger: params["trigger"],
+    condition: params["condition"],
+    action: params["action"] ?? text
+  };
+}
 function formalVerifyTools() {
   return [
-    tool("verify.ears-to-smt", "Convert EARS requirements to SMT-LIB2 format", "formal-verify", [param("requirement", "string", "EARS requirement text")], async (params) => {
+    tool("verify.ears-to-smt", "Convert an EARS requirement to SMT-LIB2", "formal-verify", [
+      param("text", "string", "EARS requirement text"),
+      param("action", "string", "Requirement action clause", false)
+    ], async (params) => {
       try {
-        const fv = await Promise.resolve().then(() => (init_dist16(), dist_exports16));
-        const smt = fv.earsToSmt?.(params["requirement"]);
-        return ok(smt ?? { smtlib2: "", requirement: params["requirement"] });
+        const { createEarsToSmtConverter: createEarsToSmtConverter2 } = await Promise.resolve().then(() => (init_dist16(), dist_exports16));
+        return ok(createEarsToSmtConverter2().convert(await buildSpecFromParams(params)));
       } catch {
-        return ok({ smtlib2: "", requirement: params["requirement"] });
+        return fail("Formal-verify package not available");
       }
     }),
-    tool("verify.z3.solve", "Solve an SMT formula using Z3", "formal-verify", [
-      param("formula", "string", "SMT-LIB2 formula"),
-      param("timeout", "number", "Timeout in milliseconds", false, 5e3)
-    ], async (params) => {
+    tool("verify.z3.solve", "Solve an SMT-LIB2 script with the Z3 adapter", "formal-verify", [param("formula", "string", "SMT-LIB2 script")], async (params) => {
       try {
-        const fv = await Promise.resolve().then(() => (init_dist16(), dist_exports16));
-        const result = fv.z3Solve?.(params["formula"], params["timeout"] ?? 5e3);
-        return ok(result ?? { satisfiable: false, model: null });
-      } catch {
-        return ok({ satisfiable: false, model: null });
+        const { createZ3Adapter: createZ3Adapter2 } = await Promise.resolve().then(() => (init_dist16(), dist_exports16));
+        return ok(await createZ3Adapter2().solve(params["formula"] ?? ""));
+      } catch (err) {
+        return fail(`Z3 solve failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }),
-    tool("verify.lean.convert", "Convert a specification to a Lean 4 theorem", "formal-verify", [
-      param("spec", "string", "Specification to convert"),
+    tool("verify.lean.convert", "Convert a requirement specification to a Lean 4 theorem", "formal-verify", [
+      param("text", "string", "Requirement text"),
+      param("action", "string", "Requirement action clause", false),
       param("name", "string", "Theorem name", false, "spec_theorem")
     ], async (params) => {
       try {
-        const lean = await Promise.resolve().then(() => (init_dist17(), dist_exports17));
-        const result = lean.convertToLean?.(params["spec"], params["name"] ?? "spec_theorem");
-        return ok(result ?? { lean4: "", name: params["name"] ?? "spec_theorem" });
+        const { createEarsToLeanConverter: createEarsToLeanConverter2 } = await Promise.resolve().then(() => (init_dist17(), dist_exports17));
+        return ok(createEarsToLeanConverter2().convert(await buildSpecFromParams(params)));
       } catch {
-        return ok({ lean4: "", name: params["name"] ?? "spec_theorem" });
+        return fail("Lean package not available");
       }
     }),
-    tool("verify.lean.run", "Run a Lean 4 proof", "formal-verify", [param("proof", "string", "Lean 4 proof code")], async (params) => {
+    tool("verify.lean.run", "Run a Lean 4 proof (requires a Lean toolchain; reports availability otherwise)", "formal-verify", [param("proof", "string", "Lean 4 proof code")], async (params) => {
       try {
-        const lean = await Promise.resolve().then(() => (init_dist17(), dist_exports17));
-        const result = lean.runProof?.(params["proof"]);
-        return ok(result ?? { verified: false, output: "" });
-      } catch {
-        return ok({ verified: false, output: "" });
+        const { createLeanProofRunner: createLeanProofRunner2 } = await Promise.resolve().then(() => (init_dist17(), dist_exports17));
+        return ok(await createLeanProofRunner2().runProof(params["proof"] ?? ""));
+      } catch (err) {
+        return fail(`Lean proof run failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }),
-    tool("verify.hybrid", "Run hybrid verification combining Z3 and Lean", "formal-verify", [
-      param("spec", "string", "Specification to verify"),
-      param("strategy", "string", "Verification strategy: z3-first | lean-first | parallel", false, "z3-first")
+    tool("verify.hybrid", "Run hybrid (Z3 + Lean) verification on a requirement specification", "formal-verify", [
+      param("text", "string", "Requirement text"),
+      param("action", "string", "Requirement action clause", false)
     ], async (params) => {
       try {
-        const fv = await Promise.resolve().then(() => (init_dist16(), dist_exports16));
-        const result = fv.hybridVerify?.(params["spec"], params["strategy"] ?? "z3-first");
-        return ok(result ?? { verified: false, strategy: params["strategy"] ?? "z3-first" });
-      } catch {
-        return ok({ verified: false, strategy: params["strategy"] ?? "z3-first" });
+        const { createHybridVerifier: createHybridVerifier2 } = await Promise.resolve().then(() => (init_dist17(), dist_exports17));
+        return ok(await createHybridVerifier2().verify(await buildSpecFromParams(params)));
+      } catch (err) {
+        return fail(`Hybrid verification failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     })
   ];
 }
+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");
       }
     })
   ];
@@ -14769,44 +14851,56 @@ function decisionsTools() {
     })
   ];
 }
+async function getSkillManager() {
+  if (!_skillManager) {
+    const { createSkillManager: createSkillManager2 } = await Promise.resolve().then(() => (init_dist7(), dist_exports7));
+    _skillManager = createSkillManager2();
+  }
+  return _skillManager;
+}
 function skillsTools() {
   return [
-    tool("skills.list", "List all registered skills", "skills", [], async () => {
+    tool("skills.list", "List skills registered in the current server session", "skills", [], async () => {
       try {
-        const sm = await Promise.resolve().then(() => (init_dist7(), dist_exports7));
-        const skills = sm.listSkills?.();
-        return ok(skills ?? []);
+        const mgr = await getSkillManager();
+        return ok(mgr.getAvailableSkills().map((s) => ({ id: s.id, name: s.metadata.name, status: s.status })));
       } catch {
-        return ok([]);
+        return fail("Skill-manager package not available");
       }
     }),
-    tool("skills.register", "Register a new skill", "skills", [
+    tool("skills.register", "Register a skill (echo-executor) for this server session", "skills", [
       param("name", "string", "Skill name"),
-      param("description", "string", "Skill description"),
-      param("handler", "string", "Handler module path")
+      param("description", "string", "Skill description", false, ""),
+      param("triggers", "array", "Trigger keywords", false)
     ], async (params) => {
       try {
-        const sm = await Promise.resolve().then(() => (init_dist7(), dist_exports7));
-        const result = sm.registerSkill?.({
-          name: params["name"],
-          description: params["description"],
-          handler: params["handler"]
-        });
-        return ok(result ?? { name: params["name"], registered: true });
+        const mgr = await getSkillManager();
+        const name = params["name"] ?? "skill";
+        const skill = mgr.loadFromMetadata({
+          name,
+          version: "1.0.0",
+          description: params["description"] ?? "",
+          triggers: params["triggers"] ?? []
+        }, async (input) => ({ skill: name, output: input }));
+        return ok({ id: skill.id, name, registered: true });
       } catch {
-        return ok({ name: params["name"], registered: true });
+        return fail("Skill-manager package not available");
       }
     }),
-    tool("skills.execute", "Execute a registered skill by name", "skills", [
+    tool("skills.execute", "Execute a session skill by name (must be registered in this session first)", "skills", [
       param("name", "string", "Skill name to execute"),
       param("input", "object", "Skill input parameters", false, {})
     ], async (params) => {
       try {
-        const sm = await Promise.resolve().then(() => (init_dist7(), dist_exports7));
-        const result = sm.executeSkill?.(params["name"], params["input"]);
-        return ok(result ?? { executed: false, name: params["name"] });
+        const mgr = await getSkillManager();
+        const name = params["name"] ?? "";
+        const match = mgr.getAvailableSkills().find((s) => s.metadata.name === name);
+        if (!match)
+          return fail(`Skill not registered in this session: ${name}`);
+        const output = await match.execute(params["input"] ?? {});
+        return ok({ executed: true, name, output });
       } catch {
-        return ok({ executed: false, name: params["name"] });
+        return fail("Skill-manager package not available");
       }
     })
   ];
@@ -14834,9 +14928,11 @@ function registerDefaultTools(server) {
     server.registerBatch(category.tools);
   }
 }
+var _skillManager;
 var init_catalog = __esm({
   "../mcp-server/dist/catalog.js"() {
     "use strict";
+    _skillManager = null;
   }
 });
 

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");
       }
     })
   ];
@@ -14613,110 +14649,156 @@ function synthesisTools() {
     })
   ];
 }
+async function buildSpecFromParams(params) {
+  const text = params["text"] ?? params["requirement"] ?? params["spec"] ?? "";
+  let pattern = params["pattern"];
+  if (!pattern) {
+    try {
+      const { createEARSValidator: createEARSValidator2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+      pattern = createEARSValidator2().analyze(text).pattern;
+    } catch {
+      pattern = "ubiquitous";
+    }
+  }
+  return {
+    id: params["id"] ?? "REQ-XXX-001",
+    title: params["name"] ?? params["title"] ?? "requirement",
+    text,
+    pattern,
+    trigger: params["trigger"],
+    condition: params["condition"],
+    action: params["action"] ?? text
+  };
+}
 function formalVerifyTools() {
   return [
-    tool("verify.ears-to-smt", "Convert EARS requirements to SMT-LIB2 format", "formal-verify", [param("requirement", "string", "EARS requirement text")], async (params) => {
+    tool("verify.ears-to-smt", "Convert an EARS requirement to SMT-LIB2", "formal-verify", [
+      param("text", "string", "EARS requirement text"),
+      param("action", "string", "Requirement action clause", false)
+    ], async (params) => {
       try {
-        const fv = await Promise.resolve().then(() => (init_dist16(), dist_exports16));
-        const smt = fv.earsToSmt?.(params["requirement"]);
-        return ok(smt ?? { smtlib2: "", requirement: params["requirement"] });
+        const { createEarsToSmtConverter: createEarsToSmtConverter2 } = await Promise.resolve().then(() => (init_dist16(), dist_exports16));
+        return ok(createEarsToSmtConverter2().convert(await buildSpecFromParams(params)));
       } catch {
-        return ok({ smtlib2: "", requirement: params["requirement"] });
+        return fail("Formal-verify package not available");
       }
     }),
-    tool("verify.z3.solve", "Solve an SMT formula using Z3", "formal-verify", [
-      param("formula", "string", "SMT-LIB2 formula"),
-      param("timeout", "number", "Timeout in milliseconds", false, 5e3)
-    ], async (params) => {
+    tool("verify.z3.solve", "Solve an SMT-LIB2 script with the Z3 adapter", "formal-verify", [param("formula", "string", "SMT-LIB2 script")], async (params) => {
       try {
-        const fv = await Promise.resolve().then(() => (init_dist16(), dist_exports16));
-        const result = fv.z3Solve?.(params["formula"], params["timeout"] ?? 5e3);
-        return ok(result ?? { satisfiable: false, model: null });
-      } catch {
-        return ok({ satisfiable: false, model: null });
+        const { createZ3Adapter: createZ3Adapter2 } = await Promise.resolve().then(() => (init_dist16(), dist_exports16));
+        return ok(await createZ3Adapter2().solve(params["formula"] ?? ""));
+      } catch (err) {
+        return fail(`Z3 solve failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }),
-    tool("verify.lean.convert", "Convert a specification to a Lean 4 theorem", "formal-verify", [
-      param("spec", "string", "Specification to convert"),
+    tool("verify.lean.convert", "Convert a requirement specification to a Lean 4 theorem", "formal-verify", [
+      param("text", "string", "Requirement text"),
+      param("action", "string", "Requirement action clause", false),
       param("name", "string", "Theorem name", false, "spec_theorem")
     ], async (params) => {
       try {
-        const lean = await Promise.resolve().then(() => (init_dist17(), dist_exports17));
-        const result = lean.convertToLean?.(params["spec"], params["name"] ?? "spec_theorem");
-        return ok(result ?? { lean4: "", name: params["name"] ?? "spec_theorem" });
+        const { createEarsToLeanConverter: createEarsToLeanConverter2 } = await Promise.resolve().then(() => (init_dist17(), dist_exports17));
+        return ok(createEarsToLeanConverter2().convert(await buildSpecFromParams(params)));
       } catch {
-        return ok({ lean4: "", name: params["name"] ?? "spec_theorem" });
+        return fail("Lean package not available");
       }
     }),
-    tool("verify.lean.run", "Run a Lean 4 proof", "formal-verify", [param("proof", "string", "Lean 4 proof code")], async (params) => {
+    tool("verify.lean.run", "Run a Lean 4 proof (requires a Lean toolchain; reports availability otherwise)", "formal-verify", [param("proof", "string", "Lean 4 proof code")], async (params) => {
       try {
-        const lean = await Promise.resolve().then(() => (init_dist17(), dist_exports17));
-        const result = lean.runProof?.(params["proof"]);
-        return ok(result ?? { verified: false, output: "" });
-      } catch {
-        return ok({ verified: false, output: "" });
+        const { createLeanProofRunner: createLeanProofRunner2 } = await Promise.resolve().then(() => (init_dist17(), dist_exports17));
+        return ok(await createLeanProofRunner2().runProof(params["proof"] ?? ""));
+      } catch (err) {
+        return fail(`Lean proof run failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }),
-    tool("verify.hybrid", "Run hybrid verification combining Z3 and Lean", "formal-verify", [
-      param("spec", "string", "Specification to verify"),
-      param("strategy", "string", "Verification strategy: z3-first | lean-first | parallel", false, "z3-first")
+    tool("verify.hybrid", "Run hybrid (Z3 + Lean) verification on a requirement specification", "formal-verify", [
+      param("text", "string", "Requirement text"),
+      param("action", "string", "Requirement action clause", false)
     ], async (params) => {
       try {
-        const fv = await Promise.resolve().then(() => (init_dist16(), dist_exports16));
-        const result = fv.hybridVerify?.(params["spec"], params["strategy"] ?? "z3-first");
-        return ok(result ?? { verified: false, strategy: params["strategy"] ?? "z3-first" });
-      } catch {
-        return ok({ verified: false, strategy: params["strategy"] ?? "z3-first" });
+        const { createHybridVerifier: createHybridVerifier2 } = await Promise.resolve().then(() => (init_dist17(), dist_exports17));
+        return ok(await createHybridVerifier2().verify(await buildSpecFromParams(params)));
+      } catch (err) {
+        return fail(`Hybrid verification failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     })
   ];
 }
+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");
       }
     })
   ];
@@ -14769,44 +14851,56 @@ function decisionsTools() {
     })
   ];
 }
+async function getSkillManager() {
+  if (!_skillManager) {
+    const { createSkillManager: createSkillManager2 } = await Promise.resolve().then(() => (init_dist7(), dist_exports7));
+    _skillManager = createSkillManager2();
+  }
+  return _skillManager;
+}
 function skillsTools() {
   return [
-    tool("skills.list", "List all registered skills", "skills", [], async () => {
+    tool("skills.list", "List skills registered in the current server session", "skills", [], async () => {
       try {
-        const sm = await Promise.resolve().then(() => (init_dist7(), dist_exports7));
-        const skills = sm.listSkills?.();
-        return ok(skills ?? []);
+        const mgr = await getSkillManager();
+        return ok(mgr.getAvailableSkills().map((s) => ({ id: s.id, name: s.metadata.name, status: s.status })));
       } catch {
-        return ok([]);
+        return fail("Skill-manager package not available");
       }
     }),
-    tool("skills.register", "Register a new skill", "skills", [
+    tool("skills.register", "Register a skill (echo-executor) for this server session", "skills", [
       param("name", "string", "Skill name"),
-      param("description", "string", "Skill description"),
-      param("handler", "string", "Handler module path")
+      param("description", "string", "Skill description", false, ""),
+      param("triggers", "array", "Trigger keywords", false)
     ], async (params) => {
       try {
-        const sm = await Promise.resolve().then(() => (init_dist7(), dist_exports7));
-        const result = sm.registerSkill?.({
-          name: params["name"],
-          description: params["description"],
-          handler: params["handler"]
-        });
-        return ok(result ?? { name: params["name"], registered: true });
+        const mgr = await getSkillManager();
+        const name = params["name"] ?? "skill";
+        const skill = mgr.loadFromMetadata({
+          name,
+          version: "1.0.0",
+          description: params["description"] ?? "",
+          triggers: params["triggers"] ?? []
+        }, async (input) => ({ skill: name, output: input }));
+        return ok({ id: skill.id, name, registered: true });
       } catch {
-        return ok({ name: params["name"], registered: true });
+        return fail("Skill-manager package not available");
       }
     }),
-    tool("skills.execute", "Execute a registered skill by name", "skills", [
+    tool("skills.execute", "Execute a session skill by name (must be registered in this session first)", "skills", [
       param("name", "string", "Skill name to execute"),
       param("input", "object", "Skill input parameters", false, {})
     ], async (params) => {
       try {
-        const sm = await Promise.resolve().then(() => (init_dist7(), dist_exports7));
-        const result = sm.executeSkill?.(params["name"], params["input"]);
-        return ok(result ?? { executed: false, name: params["name"] });
+        const mgr = await getSkillManager();
+        const name = params["name"] ?? "";
+        const match = mgr.getAvailableSkills().find((s) => s.metadata.name === name);
+        if (!match)
+          return fail(`Skill not registered in this session: ${name}`);
+        const output = await match.execute(params["input"] ?? {});
+        return ok({ executed: true, name, output });
       } catch {
-        return ok({ executed: false, name: params["name"] });
+        return fail("Skill-manager package not available");
       }
     })
   ];
@@ -14834,9 +14928,11 @@ function registerDefaultTools(server) {
     server.registerBatch(category.tools);
   }
 }
+var _skillManager;
 var init_catalog = __esm({
   "../mcp-server/dist/catalog.js"() {
     "use strict";
+    _skillManager = null;
   }
 });
 

package/package.json

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