musubix2 0.5.10 → 0.5.11

package/.claude/.musubix-managed

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

package/dist/cli.js

@@ -14649,60 +14649,77 @@ 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)}`);
       }
     })
   ];
@@ -14834,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");
       }
     })
   ];
@@ -14899,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

@@ -14649,60 +14649,77 @@ 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)}`);
       }
     })
   ];
@@ -14834,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");
       }
     })
   ];
@@ -14899,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.10",
+  "version": "0.5.11",
   "description": "MUSUBIX2 — Specification Driven Development System",
   "type": "module",
   "main": "./dist/index.js",