toolfactory 0.4.4 → 0.4.6

package/src/e2e.test.ts

@@ -7,6 +7,7 @@ import { execFileSync } from "node:child_process";
 import {
   existsSync,
   lstatSync,
+  mkdirSync,
   mkdtempSync,
   readdirSync,
   readFileSync,
@@ -33,7 +34,15 @@ describe.skipIf(!existsSync(repoNodeModules))(
       const dir = mkdtempSync(join(tmpdir(), "toolfactory-e2e-"));
       symlinkSync(repoNodeModules, join(dir, "node_modules"), "dir");
 
-      const surfaces: SurfaceId[] = ["skill", "agent-plugins", "claude", "mcp", "cli", "npm"];
+      const surfaces: SurfaceId[] = [
+        "skill",
+        "agent-plugins",
+        "claude",
+        "mcp",
+        "cli",
+        "npm",
+        "openclaw-native",
+      ];
       const init = commands.init({
         root: dir,
         name: "hello",
@@ -53,8 +62,42 @@ describe.skipIf(!existsSync(repoNodeModules))(
       expect(echo.inputSchema.$schema).toBe("https://json-schema.org/draft/2020-12/schema");
       expect(echo.outputSchema?.$schema).toBe("https://json-schema.org/draft/2020-12/schema");
 
-      commands.build(dir);
+      const skillPath = join(dir, "skills/hello/SKILL.md");
+      writeFileSync(
+        skillPath,
+        readFileSync(skillPath, "utf8").replace("# hello", "# hello\n\nAuthor procedure."),
+      );
+      mkdirSync(join(dir, "skills/hello/references"));
+      writeFileSync(join(dir, "skills/hello/references/guide.md"), "Retained reference.\n");
+      const opsPath = join(dir, "src/ops.ts");
+      writeFileSync(
+        opsPath,
+        readFileSync(opsPath, "utf8").replace(
+          "Return the text you pass in.",
+          "Freshly rebuilt operation.",
+        ),
+      );
+      await commands.introspect(dir);
       await expect(commands.check(dir)).resolves.toBeDefined();
+      expect(commands.build(dir).result.written).toEqual([]);
+      const bundled = readFileSync(join(dir, "hosts/openclaw/skills/hello/SKILL.md"), "utf8");
+      expect(bundled).toBe(readFileSync(skillPath, "utf8"));
+      expect(bundled).toContain("Author procedure.");
+      expect(bundled).toContain("Freshly rebuilt operation.");
+      expect(bundled).not.toContain("Return the text you pass in.");
+      const packed = JSON.parse(
+        execFileSync("npm", ["pack", "./hosts/openclaw", "--dry-run", "--json"], {
+          cwd: dir,
+          encoding: "utf8",
+        }),
+      ) as { files: { path: string }[] }[];
+      expect(packed[0]?.files.map((file) => file.path)).toEqual(
+        expect.arrayContaining([
+          "openclaw.plugin.json",
+          "skills/hello/SKILL.md",
+          "skills/hello/references/guide.md",
+        ]),
+      );
 
       const opsOnDisk = JSON.parse(readFileSync(join(dir, "dev.toolfactory/ops.json"), "utf8"));
       expect(opsOnDisk.tools.map((t: { name: string }) => t.name)).toEqual(["echo"]);

package/src/hosts/openclaw.ts

@@ -16,7 +16,7 @@ import { fileURLToPath } from "node:url";
 import type { PlannedFile, Project } from "../model.js";
 import type { Drift } from "../project/apply.js";
 import { loadProject } from "../project/load.js";
-import { HOST_DIR, OPENCLAW_SCAFFOLD, surface } from "../surfaces/openclaw-native.js";
+import { HOST_DIR, OPENCLAW_SCAFFOLD, shipsSkills, surface } from "../surfaces/openclaw-native.js";
 
 export const DRIFT_ENTRY = fileURLToPath(import.meta.url);
 
@@ -39,7 +39,7 @@ function overridden(project: Project): Set<string> {
     paths.add(".openclaw.compat.pluginApi");
   }
   // Shipped skills append to `files`; upstream's entries must still survive (checked below).
-  if (openclaw?.skills?.length) paths.add(".files");
+  if (shipsSkills(project)) paths.add(".files");
   return paths;
 }
 
@@ -111,7 +111,7 @@ export function scaffoldDrift(project: Project): string[] {
         ? []
         : ["vitest.config.ts: upstream template changed"]),
     ];
-    if (project.tool.openclaw?.skills?.length) {
+    if (shipsSkills(project)) {
       const upstream = (JSON.parse(scaffold("package.json")) as { files?: string[] }).files ?? [];
       const ours = (JSON.parse(planned(files, "package.json")) as { files?: string[] }).files ?? [];
       const lost = upstream.filter((entry) => !ours.includes(entry));

package/src/model.ts

@@ -244,7 +244,7 @@ export const ToolConfigSchema = z
           .array(z.string())
           .optional()
           .describe(
-            "Skill directories under `.agents/skills/` that the OpenClaw plugin ships; OpenClaw loads them through the manifest's `skills` roots.",
+            "Exact skill selection for the OpenClaw plugin. Omitted: the tool's own generated skill when the skill surface is selected. []: no skills. Other names resolve under `.agents/skills/`; OpenClaw loads the packaged manifest's `skills` roots.",
           ),
         dependencies: z.record(z.string(), z.string()).optional(),
         peerDependencies: z.record(z.string(), z.string()).optional(),
@@ -387,7 +387,7 @@ export interface Project {
   toolfactoryVersion: string;
   /** From the root package.json `packageManager` field; npm when absent. */
   packageManager?: PackageManager;
-  /** Skills `openclaw.skills` declares, read once so projectors stay pure. */
+  /** Resolved OpenClaw skills, including the generated default, read once so projectors stay pure. */
   skills?: ProjectSkill[];
 }
 

package/src/project/apply.ts

@@ -501,7 +501,8 @@ export function check(root: string, plan: PlannedFile[], toolfactoryVersion: str
   return drift;
 }
 
-function render(root: string, file: PlannedFile, previous: Lock): string {
+/** Read-only preview of the exact bytes apply writes, retaining authored regions and extensions. */
+export function renderFile(root: string, file: PlannedFile, previous: Lock): string {
   const path = join(root, file.path);
   if (file.kind === "file") return file.content;
   if (file.kind === "region") {
@@ -589,7 +590,7 @@ export function apply(root: string, plan: PlannedFile[], toolfactoryVersion: str
         result.written.push(file.path);
       }
     } else {
-      const next = render(root, file, previous);
+      const next = renderFile(root, file, previous);
       if (existsSync(path) && readFileSync(path, "utf8") === next) {
         result.unchanged.push(file.path);
       } else {

package/src/project/load.test.ts

@@ -0,0 +1,229 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { build } from "../commands.js";
+import type { ToolConfig } from "../model.js";
+import { HOST_DIR } from "../surfaces/openclaw-native.js";
+import { check, setState } from "./apply.js";
+import { loadProject } from "./load.js";
+import { buildPlan } from "./plan.js";
+
+const roots: string[] = [];
+afterEach(() => {
+  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function write(root: string, path: string, content: string): void {
+  mkdirSync(dirname(join(root, path)), { recursive: true });
+  writeFileSync(join(root, path), content);
+}
+
+function fixture(overrides: Partial<ToolConfig> = {}): string {
+  const root = mkdtempSync(join(tmpdir(), "toolfactory-skills-"));
+  roots.push(root);
+  write(
+    root,
+    "plugin.json",
+    JSON.stringify({ name: "probe", version: "0.1.0", description: "Probe" }),
+  );
+  write(
+    root,
+    "dev.toolfactory/tool.json",
+    JSON.stringify({
+      schemaVersion: 1,
+      identity: "plugin.json",
+      binding: "typescript",
+      surfaces: ["skill", "cli", "openclaw-native"],
+      ...overrides,
+    }),
+  );
+  write(
+    root,
+    "dev.toolfactory/ops.json",
+    JSON.stringify({
+      tools: [
+        {
+          name: "echo",
+          description: "Current operation",
+          inputSchema: { type: "object" },
+        },
+      ],
+    }),
+  );
+  return root;
+}
+
+function hostJson(root: string, name: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(root, HOST_DIR, name), "utf8"));
+}
+
+function clean(root: string): void {
+  const project = loadProject(root);
+  expect(check(root, buildPlan(project), project.toolfactoryVersion)).toEqual([]);
+  expect(build(root).result.written).toEqual([]);
+}
+
+describe("OpenClaw skill loading and regeneration", () => {
+  it.each(["typescript", "python"] as const)(
+    "ships a fresh %s tool's own skill by default",
+    (binding) => {
+      const root = fixture({ binding });
+      expect(existsSync(join(root, "skills"))).toBe(false);
+      expect(loadProject(root).skills?.map((skill) => skill.name)).toEqual(["probe"]);
+      build(root);
+      const own = readFileSync(join(root, "skills/probe/SKILL.md"), "utf8");
+      expect(readFileSync(join(root, HOST_DIR, "skills/probe/SKILL.md"), "utf8")).toBe(own);
+      expect(own).toContain("Current operation");
+      expect(hostJson(root, "openclaw.plugin.json").skills).toEqual(["./skills"]);
+      expect(hostJson(root, "package.json").files).toContain("skills");
+      clean(root);
+    },
+  );
+
+  it.each([[], ["custom"], ["probe"], ["probe", "custom"]])(
+    "honors the exact explicit selection %j",
+    (...names) => {
+      const skills = names as string[];
+      const root = fixture({ openclaw: { skills } });
+      write(root, ".agents/skills/custom/SKILL.md", "Custom authored skill\n");
+      write(root, ".agents/skills/custom/references/guide.md", "Custom reference\n");
+      expect(loadProject(root).skills?.map((skill) => skill.name)).toEqual(skills);
+      build(root);
+      expect(existsSync(join(root, HOST_DIR, "skills/probe/SKILL.md"))).toBe(
+        skills.includes("probe"),
+      );
+      expect(existsSync(join(root, HOST_DIR, "skills/custom/SKILL.md"))).toBe(
+        skills.includes("custom"),
+      );
+      if (skills.includes("custom")) {
+        expect(
+          readFileSync(join(root, HOST_DIR, "skills/custom/references/guide.md"), "utf8"),
+        ).toBe("Custom reference\n");
+      }
+      expect(hostJson(root, "openclaw.plugin.json").skills).toEqual(
+        skills.length ? ["./skills"] : undefined,
+      );
+      expect((hostJson(root, "package.json").files as string[]).includes("skills")).toBe(
+        skills.length > 0,
+      );
+      clean(root);
+    },
+  );
+
+  it("refreshes generated regions in one build while retaining authored prose and text resources", () => {
+    const root = fixture({ openclaw: { skills: ["probe"] } });
+    build(root);
+    const path = "skills/probe/SKILL.md";
+    write(
+      root,
+      path,
+      readFileSync(join(root, path), "utf8").replace("# probe", "# probe\n\nAuthored procedure."),
+    );
+    write(root, "skills/probe/scripts/check.py", "print('retained')\n");
+    write(
+      root,
+      "plugin.json",
+      JSON.stringify({ name: "probe", version: "0.2.0", description: "Updated identity" }),
+    );
+    write(
+      root,
+      "dev.toolfactory/ops.json",
+      JSON.stringify({
+        tools: [
+          {
+            name: "new_operation",
+            description: "Updated operation",
+            inputSchema: { type: "object" },
+          },
+        ],
+      }),
+    );
+    build(root);
+    const bundled = readFileSync(join(root, HOST_DIR, path), "utf8");
+    expect(bundled).toBe(readFileSync(join(root, path), "utf8"));
+    expect(bundled).toContain("Authored procedure.");
+    expect(bundled).toContain("Updated identity");
+    expect(bundled).toContain("Updated operation");
+    expect(bundled).not.toContain("Current operation");
+    expect(readFileSync(join(root, HOST_DIR, "skills/probe/scripts/check.py"), "utf8")).toBe(
+      "print('retained')\n",
+    );
+    clean(root);
+  });
+
+  it("removes the default payload and manifest root when the author opts out", () => {
+    const root = fixture();
+    build(root);
+    const path = join(root, "dev.toolfactory/tool.json");
+    writeFileSync(
+      path,
+      JSON.stringify({ ...JSON.parse(readFileSync(path, "utf8")), openclaw: { skills: [] } }),
+    );
+    build(root);
+    expect(existsSync(join(root, HOST_DIR, "skills/probe/SKILL.md"))).toBe(false);
+    expect(existsSync(join(root, "skills/probe/SKILL.md"))).toBe(true);
+    expect(hostJson(root, "openclaw.plugin.json")).not.toHaveProperty("skills");
+    expect(hostJson(root, "package.json").files).not.toContain("skills");
+    clean(root);
+  });
+
+  it("packages an adopted own skill verbatim", () => {
+    const root = fixture();
+    build(root);
+    setState(root, "skills/probe/SKILL.md", "manual", loadProject(root).toolfactoryVersion);
+    write(root, "skills/probe/SKILL.md", "Fully authored skill without generator markers\n");
+    build(root);
+    expect(readFileSync(join(root, HOST_DIR, "skills/probe/SKILL.md"), "utf8")).toBe(
+      "Fully authored skill without generator markers\n",
+    );
+    clean(root);
+  });
+
+  it("retains an explicitly selected same-name custom canon when its alias was adopted", () => {
+    const root = fixture({ openclaw: { skills: ["probe"] } });
+    build(root);
+    setState(root, ".agents/skills/probe", "manual", loadProject(root).toolfactoryVersion);
+    rmSync(join(root, ".agents/skills/probe"));
+    write(root, ".agents/skills/probe/SKILL.md", "Custom same-name procedure\n");
+    write(root, ".agents/skills/probe/references/guide.md", "Custom same-name reference\n");
+    build(root);
+    expect(readFileSync(join(root, HOST_DIR, "skills/probe/SKILL.md"), "utf8")).toBe(
+      "Custom same-name procedure\n",
+    );
+    expect(readFileSync(join(root, HOST_DIR, "skills/probe/references/guide.md"), "utf8")).toBe(
+      "Custom same-name reference\n",
+    );
+    expect(readFileSync(join(root, "skills/probe/SKILL.md"), "utf8")).toContain(
+      "Current operation",
+    );
+    expect(readFileSync(join(root, ".agents/skills/probe/SKILL.md"), "utf8")).toBe(
+      "Custom same-name procedure\n",
+    );
+    clean(root);
+  });
+
+  it("does not infer a skill for projects without the selected pair and still validates declared custom skills", () => {
+    const hostOnly = fixture({ surfaces: ["openclaw-native"] });
+    build(hostOnly);
+    expect(loadProject(hostOnly).skills).toEqual([]);
+    expect(hostJson(hostOnly, "openclaw.plugin.json")).not.toHaveProperty("skills");
+    const instructions = fixture({ runtime: "none", surfaces: ["skill", "codex"] });
+    build(instructions);
+    expect(loadProject(instructions).skills).toEqual([]);
+    expect(existsSync(join(instructions, HOST_DIR))).toBe(false);
+    expect(readFileSync(join(instructions, "skills/probe/SKILL.md"), "utf8")).not.toContain(
+      "## Operations",
+    );
+    const custom = fixture({ surfaces: ["openclaw-native"], openclaw: { skills: ["custom"] } });
+    expect(() => loadProject(custom)).toThrow(/openclaw.skills declares "custom"/);
+    write(custom, ".agents/skills/custom/SKILL.md", "Custom only\n");
+    build(custom);
+    expect(readFileSync(join(custom, HOST_DIR, "skills/custom/SKILL.md"), "utf8")).toBe(
+      "Custom only\n",
+    );
+    clean(hostOnly);
+    clean(instructions);
+    clean(custom);
+  });
+});

package/src/project/load.ts

@@ -1,6 +1,6 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync, lstatSync, readdirSync, readFileSync, readlinkSync } from "node:fs";
 import { createRequire } from "node:module";
-import { join, relative, resolve, sep } from "node:path";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { z } from "zod";
 import { readIdentityFile } from "../identity/read.js";
 import {
@@ -14,7 +14,10 @@ import {
   type ProjectSkill,
   ToolConfigSchema,
 } from "../model.js";
-import { TOOLFACTORY_DIR } from "./lock.js";
+import { has } from "../surfaces/shared.js";
+import { skillFile } from "../surfaces/skill.js";
+import { renderFile } from "./apply.js";
+import { readLock, TOOLFACTORY_DIR } from "./lock.js";
 
 export const TOOL_PATH = `${TOOLFACTORY_DIR}/tool.json`;
 export const OPS_PATH = `${TOOLFACTORY_DIR}/ops.json`;
@@ -85,15 +88,33 @@ function readPackageManager(root: string): PackageManager | undefined {
   return name as PackageManager;
 }
 
-/** `.agents/skills/<name>/` as a shippable unit: every file, sorted, content in memory. */
-function readProjectSkill(root: string, name: string): ProjectSkill {
-  const directory = join(root, ".agents", "skills", name);
-  if (!existsSync(directory)) {
+/** The selected skill as a shippable unit: every text file, sorted, content in memory. */
+function readProjectSkill(project: Project, name: string): ProjectSkill {
+  const canonPath = `.agents/skills/${name}`;
+  const canon = join(project.root, canonPath);
+  const lock = readLock(project.root) ?? {
+    toolfactoryVersion: project.toolfactoryVersion,
+    files: {},
+  };
+  const entry = lstatSync(canon, { throwIfNoEntry: false });
+  const generatedAlias =
+    entry?.isSymbolicLink() &&
+    resolve(dirname(canon), readlinkSync(canon)) === join(project.root, "skills", name);
+  const custom =
+    project.tool.openclaw?.skills !== undefined &&
+    lock.files[canonPath]?.state === "manual" &&
+    !generatedAlias;
+  const own = has(project, "skill") && name === project.identity.name && !custom;
+  const planned = own ? skillFile(project) : undefined;
+  const directory = planned ? dirname(join(project.root, planned.path)) : canon;
+  if (!existsSync(directory) && !own) {
     throw new Error(
       `openclaw.skills declares "${name}" but ${join(".agents", "skills", name)} does not exist`,
     );
   }
-  const files = readdirSync(directory, { recursive: true, withFileTypes: true })
+  const files = (
+    existsSync(directory) ? readdirSync(directory, { recursive: true, withFileTypes: true }) : []
+  )
     .filter((entry) => entry.isFile())
     .map((entry) => join(entry.parentPath, entry.name))
     .sort()
@@ -101,6 +122,19 @@ function readProjectSkill(root: string, name: string): ProjectSkill {
       path: relative(directory, absolute).replaceAll(sep, "/"),
       content: readFileSync(absolute, "utf8"),
     }));
+  if (planned) {
+    const content =
+      lock.files[planned.path]?.state === "manual"
+        ? readFileSync(join(project.root, planned.path), "utf8")
+        : renderFile(project.root, planned, lock);
+    return {
+      name,
+      files: [
+        ...files.filter((file) => file.path !== "SKILL.md"),
+        { path: "SKILL.md", content },
+      ].sort((a, b) => a.path.localeCompare(b.path)),
+    };
+  }
   return { name, files };
 }
 
@@ -112,14 +146,18 @@ export function loadProject(rootInput = "."): Project {
   }
   const tool = ToolConfigSchema.parse(JSON.parse(readFileSync(toolPath, "utf8")));
   const identityFile = readIdentityFile(join(root, tool.identity));
-  return {
+  const project: Project = {
     root,
     tool,
     identity: identityFile.identity,
     identityExtra: identityFile.extra,
     operations: isInstructionOnly(tool) ? [] : readOps(root),
-    skills: (tool.openclaw?.skills ?? []).map((name) => readProjectSkill(root, name)),
     toolfactoryVersion: TOOLFACTORY_VERSION,
     packageManager: readPackageManager(root),
   };
+  const names =
+    tool.openclaw?.skills ??
+    (has(project, "openclaw-native") && has(project, "skill") ? [project.identity.name] : []);
+  project.skills = names.map((name) => readProjectSkill(project, name));
+  return project;
 }

package/src/project/plan.ts

@@ -91,7 +91,9 @@ export function buildPlan(
   const manual = Object.entries(lock?.files ?? {})
     .filter(([, entry]) => entry.state === "manual")
     .map(([path]) => path);
-  const total = Object.keys(lock?.files ?? {}).length || files.length;
+  // Count the plan being applied, including retained manual files, rather than the previous
+  // lock: newly bundled skill resources must not leave COVERAGE.md stale after one build.
+  const total = new Set([...files.map((file) => file.path), ...manual, "COVERAGE.md"]).size;
   files.push({
     kind: "file",
     path: "COVERAGE.md",

package/src/surfaces/openclaw-native.ts

@@ -144,9 +144,9 @@ export function registrations(project: Project): Registration[] {
   return project.tool.openclaw?.registers ?? [];
 }
 
-/** Whether the plugin ships `.agents/skills/` directories (`openclaw.skills` in tool.json). */
+/** Whether the loader resolved any skills for this plugin's payload. */
 export function shipsSkills(project: Project): boolean {
-  return (project.tool.openclaw?.skills?.length ?? 0) > 0;
+  return (project.skills?.length ?? 0) > 0;
 }
 
 /**

package/src/surfaces/skill.ts

@@ -11,6 +11,7 @@ import {
   isInstructionOnly,
   type Operation,
   type Project,
+  type RegionFile,
   type Surface,
   type Verdict,
 } from "../model.js";
@@ -86,28 +87,32 @@ export function frontmatter(project: Project): string {
   return `\n${yaml(document).trimEnd()}\n`;
 }
 
+export function skillFile(project: Project): RegionFile {
+  const path = skillPath(project);
+  const regions = [
+    { begin: "---", end: "---", content: frontmatter(project) },
+    { begin: OPERATIONS_BEGIN, end: OPERATIONS_END, content: renderOperations(project) },
+  ];
+  const template = [
+    "---",
+    "---",
+    "",
+    `# ${project.identity.name}`,
+    "",
+    "Explain here when an agent should reach for this tool and how to combine its operations.",
+    "",
+    OPERATIONS_BEGIN,
+    OPERATIONS_END,
+    "",
+  ].join("\n");
+  return { kind: "region", path, regions, template };
+}
+
 export const surface: Surface = {
   id: "skill",
   plan(project) {
-    const path = skillPath(project);
-    const regions = [
-      { begin: "---", end: "---", content: frontmatter(project) },
-      { begin: OPERATIONS_BEGIN, end: OPERATIONS_END, content: renderOperations(project) },
-    ];
-    const template = [
-      "---",
-      "---",
-      "",
-      `# ${project.identity.name}`,
-      "",
-      "Explain here when an agent should reach for this tool and how to combine its operations.",
-      "",
-      OPERATIONS_BEGIN,
-      OPERATIONS_END,
-      "",
-    ].join("\n");
     return [
-      { kind: "region", path, regions, template },
+      skillFile(project),
       {
         kind: "file",
         path: skillLinkPath(project),

package/src/surfaces/web.ts

@@ -149,12 +149,12 @@ export default defineConfig({
       preview: "vite preview",
     },
     dependencies: {
-      "@base-ui/react": "^1.8.0",
+      "@base-ui/react": "^1.9.0",
       "@fontsource-variable/geist": "^5.3.0",
       "@tailwindcss/vite": "^4.3.3",
       "class-variance-authority": "^0.7.1",
       cn: "^0.4.0",
-      "lucide-react": "^1.53.0",
+      "lucide-react": "^1.55.0",
       react: "^19.2.8",
       "react-dom": "^19.2.8",
       shadcn: "^4.21.4",

package/src/toolfactory/cli.ts

@@ -13,7 +13,7 @@ const operations = [...authored, web];
 const program = new Command()
   .name("toolfactory")
   .description("Build an agent tool once; ship it as Agent Skills, MCP servers, Agent Plugins / Claude / Codex / Cursor bundles, OpenClaw and Hermes plugins, CLIs, and packages, with the tests and releases to match.")
-  .version("0.4.4");
+  .version("0.4.6");
 
 for (const op of operations) {
   if (!serves(op, "cli")) continue;

package/src/toolfactory/mcp.ts

@@ -33,7 +33,7 @@ const introspecting = Boolean(process.env.TOOLFACTORY_INTROSPECT);
 
 /** Builds one server instance with every servable operation registered; called once for stdio, once per HTTP request. */
 function createServer(): McpServer {
-  const server = new McpServer({ name: "toolfactory", version: "0.4.4" });
+  const server = new McpServer({ name: "toolfactory", version: "0.4.6" });
   for (const op of operations) {
     if (!introspecting && !serves(op, "mcp")) continue;
     server.registerTool(