toolfactory 0.2.4 → 0.4.2

package/src/commands.test.ts

@@ -251,3 +251,37 @@ describe("unpublish", () => {
     expect(result.steps.some((step) => step.run.includes("npm deprecate probe@'*'"))).toBe(true);
   });
 });
+
+describe("registerOpenClawProject", () => {
+  it("reports the exact register call for a tool scaffolded under the shared registry (dry-run)", () => {
+    const registry = join(mkdtempSync(join(tmpdir(), "tf-home-")), ".openclaw", "projects");
+    process.env.TOOLFACTORY_OPENCLAW_PROJECTS_ROOT = registry;
+    const root = join(registry, "probe");
+    const result = commands.init({
+      root,
+      name: "probe",
+      binding: "typescript",
+      setup: false,
+      git: false,
+      dryRun: true,
+    });
+    const line = result.nextSteps.find((step) => step.startsWith("OpenClaw:"));
+    expect(line).toBe(
+      "OpenClaw: run `openclaw gateway call projects.register --params " +
+        JSON.stringify({ path: root }) +
+        "` to add it to the shared project registry.",
+    );
+  });
+
+  it("says nothing outside the shared registry", () => {
+    const result = commands.init({
+      root: join(tmpdir(), "tf-plain"),
+      name: "probe",
+      binding: "typescript",
+      setup: false,
+      git: false,
+      dryRun: true,
+    });
+    expect(result.nextSteps.some((step) => step.startsWith("OpenClaw:"))).toBe(false);
+  });
+});

package/src/commands.ts

@@ -5,7 +5,8 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { dirname, join, relative, resolve } from "node:path";
 import { parseEnv } from "node:util";
 import { getBinding } from "./bindings/index.js";
 import { LIVE_TEST_COMMAND } from "./bindings/python.js";
@@ -163,6 +164,29 @@ function agentSetup(root: string): InitResult["agentConfig"] {
   return { setup: result.status === 0, harnesses };
 }
 
+/**
+ * The shared OpenClaw project registry (owner decision 2026-09-19, `docs/adoption.md`): a tool
+ * scaffolded under `~/.openclaw/projects/<id>` gets its project row at `init` time, best-effort
+ * the way `.agents/setup` is — no reachable gateway (or CLI) still leaves a scaffolded project,
+ * and the next step carries the exact call to run. Session creation stays with the calling agent.
+ * TOOLFACTORY_OPENCLAW_PROJECTS_ROOT overrides the registry root (deployments, tests).
+ */
+function registerOpenClawProject(root: string, dryRun: boolean): string | undefined {
+  const registryRoot =
+    process.env.TOOLFACTORY_OPENCLAW_PROJECTS_ROOT ?? join(homedir(), ".openclaw", "projects");
+  const beneath = relative(registryRoot, root);
+  if (!beneath || beneath.startsWith("..") || resolve(beneath) === beneath) return undefined;
+  const args = ["gateway", "call", "projects.register", "--params", JSON.stringify({ path: root })];
+  if (dryRun)
+    return (
+      "OpenClaw: run `openclaw " + args.join(" ") + "` to add it to the shared project registry."
+    );
+  const registered = spawnSync("openclaw", args, { timeout: 60_000 });
+  return registered.status === 0
+    ? "OpenClaw: registered in the shared project registry; bind one visible dashboard session to it for ongoing work."
+    : "OpenClaw: registration did not succeed — run the `openclaw gateway call projects.register` step once the gateway is reachable.";
+}
+
 function nextSteps(project: Project, agentConfig: InitResult["agentConfig"]): string[] {
   const cli = toolfactoryCli(project);
   const ops =
@@ -290,10 +314,13 @@ export function init(options: InitOptions): InitResult {
       git(root, [...commitIdentity(root), "commit", "-q", "--no-verify", "-m", "toolfactory init"]);
     }
   }
+  const steps = nextSteps(built.project, agentConfig);
+  // Last, because registration wants the committed repository on record, not a bare scaffold.
+  const openclaw = registerOpenClawProject(root, options.dryRun === true);
   const result: InitResult = {
     written,
     agentConfig,
-    nextSteps: nextSteps(built.project, agentConfig),
+    nextSteps: openclaw ? [...steps, openclaw] : steps,
   };
   if (options.repo) {
     const project = loadProject(root);

package/src/hosts/github.ts

@@ -87,13 +87,12 @@ export function bootstrapRepo(project: Project, options: BootstrapOptions = {}):
   const manual = (options.manual ?? []).filter((step) => !step.startsWith("npm:"));
   const envFile = options.envFile ?? join(project.root, ".env");
   const values = existsSync(envFile) ? parseEnv(readFileSync(envFile, "utf8")) : {};
-  const keys = liveCredentials(project);
+  const keys = project.tool.tests.live?.ci === false ? [] : liveCredentials(project);
   const commands: string[] = [];
   const written: string[] = [];
   const missing: string[] = [];
 
-  // The live tier's own environment, and only when the project has a live tier: a `tool.json`
-  // config key that is both required and sensitive is the whole trigger (§6 T4).
+  // A local-vault-only live tier does not need a GitHub environment or copied account secrets.
   if (keys.length) {
     const ids = reviewers.map((login) => {
       const args = ["api", `users/${login}`, "--jq", ".id"];

package/src/hosts/openclaw.ts

@@ -29,7 +29,8 @@ const PER_TOOL_KEYS = new Set(["name", "version", "description"]);
  */
 function overridden(project: Project): Set<string> {
   const openclaw = project.tool.openclaw;
-  const paths = new Set<string>();
+  // The host development dependency is deliberately pinned to the recorded scaffold release.
+  const paths = new Set<string>([".devDependencies.openclaw"]);
   for (const section of ["dependencies", "peerDependencies", "devDependencies"] as const) {
     for (const key of Object.keys(openclaw?.[section] ?? {})) paths.add(`.${section}.${key}`);
   }
@@ -78,8 +79,7 @@ export function scaffoldDrift(project: Project): string[] {
   // The probe must run the exact openclaw this project pins (author override or the
   // scaffold default) - never whatever happens to be on PATH, which made the drift verdict
   // environment-dependent: the scaffold openclawVersion is the running CLI own version.
-  const pin =
-    project.tool.openclaw?.devDependencies?.openclaw ?? OPENCLAW_SCAFFOLD.devDependencies.openclaw;
+  const pin = project.tool.openclaw?.devDependencies?.openclaw ?? OPENCLAW_SCAFFOLD.openclawVersion;
   const pinned = join(project.root, HOST_DIR, "node_modules/.bin/openclaw");
   try {
     const probe = existsSync(pinned)

package/src/model.ts

@@ -131,7 +131,26 @@ export const ToolConfigSchema = z
         "JSON Schema 2020-12 object for the tool's configuration; mark secrets with x-toolfactory.sensitive.",
       ),
     tests: z
-      .object({ examples: z.record(z.string(), jsonObject).default({}) })
+      .object({
+        examples: z.record(z.string(), jsonObject).default({}),
+        live: z
+          .object({
+            credentials: z
+              .array(z.string().regex(/^[A-Z_][A-Z0-9_]*$/))
+              .min(1)
+              .optional()
+              .describe(
+                "Environment gates for live tests when auth is supplied outside tool config, such as a host vault. Names only, never values.",
+              ),
+            ci: z
+              .boolean()
+              .optional()
+              .describe(
+                "Set false for live tests that require a local vault or browser unavailable on hosted CI. The native local live-test tier is still generated.",
+              ),
+          })
+          .optional(),
+      })
       .default({ examples: {} })
       .describe("Example arguments per operation, used by the generated surface-smoke tests."),
     npm: z.object({ scope: z.string().optional() }).optional(),

package/src/project/gate.ts

@@ -307,11 +307,10 @@ export function packageSteps(project: Project, options: { system?: boolean } = {
       run: [
         `npm --prefix ${OPENCLAW_HOST_DIR} install`,
         `npm --prefix ${OPENCLAW_HOST_DIR} run build`,
-        `v=$(node -p "require('./package.json').version")`,
         `cp ${OPENCLAW_HOST_DIR}/package.json ${OPENCLAW_HOST_DIR}/package.json.prepack`,
-        `(cd ${OPENCLAW_HOST_DIR} && npm pkg set dependencies.toolfactory=$v)`,
-        `npm pack ./${OPENCLAW_HOST_DIR} --pack-destination ${RELEASE_DIR}`,
-        `mv ${OPENCLAW_HOST_DIR}/package.json.prepack ${OPENCLAW_HOST_DIR}/package.json`,
+        `(trap 'mv ${OPENCLAW_HOST_DIR}/package.json.prepack ${OPENCLAW_HOST_DIR}/package.json' EXIT; ` +
+          `(cd ${OPENCLAW_HOST_DIR} && npm pkg set 'dependencies.${npmName(project)}=${project.identity.version}') && ` +
+          `npm pack ./${OPENCLAW_HOST_DIR} --pack-destination ${RELEASE_DIR})`,
       ].join(" && "),
     });
   }

package/src/surfaces/agents.test.ts

@@ -126,6 +126,7 @@ describe("agents", () => {
     expect(setup).not.toContain("# Project setup goes here");
     // Owner ask #11: a commit cannot leave a generated file stale, with or without CI.
     expect(setup).toContain("npx toolfactory check >/dev/null");
+    expect(setup).toContain("if [ -f package-lock.json ]; then\n    npm ci --no-audit --no-fund");
     expect(setup).toContain("npm install --no-audit --no-fund");
   });
 

package/src/surfaces/agents.ts

@@ -637,7 +637,13 @@ function setupTail(project: Project): string {
             "    exit 1",
             "fi",
           ]
-        : ["npm install --no-audit --no-fund"];
+        : [
+            "if [ -f package-lock.json ]; then",
+            "    npm ci --no-audit --no-fund",
+            "else",
+            "    npm install --no-audit --no-fund",
+            "fi",
+          ];
   return [
     "",
     "# The pre-commit hook installed above converges agent config; toolfactory's drift gate goes in",

package/src/surfaces/openclaw-native.test.ts

@@ -122,7 +122,7 @@ describe("openclaw-native", () => {
   it("projects only the operations OpenClaw can run and pins the scaffold in one place", () => {
     const files = emitted(project());
     const manifest = JSON.parse(files[`${HOST_DIR}/openclaw.plugin.json`] ?? "{}");
-    expect(manifest.contracts).toEqual({ tools: ["echo"] });
+    expect(manifest.contracts).toEqual({ tools: ["hello_echo"] });
     expect(manifest.activation).toEqual({ onStartup: true });
     expect(surface.verdict?.(shoot, project())).toEqual({
       kind: "excluded",
@@ -133,7 +133,10 @@ describe("openclaw-native", () => {
     expect(files[`${HOST_DIR}/README.md`]).toContain("`shoot` — requires browser");
 
     const pkg = JSON.parse(files[`${HOST_DIR}/package.json`] ?? "{}");
-    expect(pkg.devDependencies).toMatchObject(OPENCLAW_SCAFFOLD.devDependencies);
+    expect(pkg.devDependencies).toMatchObject({
+      ...OPENCLAW_SCAFFOLD.devDependencies,
+      openclaw: OPENCLAW_SCAFFOLD.openclawVersion,
+    });
     expect(pkg.openclaw).toEqual({
       extensions: ["./dist/index.js"],
       compat: { pluginApi: OPENCLAW_SCAFFOLD.pluginApi },
@@ -169,7 +172,7 @@ describe("openclaw-native", () => {
     expect(index).toContain("api.registerControlUiDescriptor(descriptor)");
     // Neither registrar is a manifest contract key; both are what the inspector expects to see.
     expect(JSON.parse(files[`${HOST_DIR}/openclaw.plugin.json`] ?? "{}").contracts).toEqual({
-      tools: ["echo"],
+      tools: ["hello_echo"],
     });
     expect(
       JSON.parse(files[`${HOST_DIR}/package.json`] ?? "{}").pluginInspector.plugin.expect
@@ -259,8 +262,8 @@ describe("openclaw-native", () => {
     // when the tool's own result carries a name its output schema promises; leg 3 catches the rest.
     expect(fixtures.fixtures).toEqual([
       {
-        match: { toolName: "echo", hasToolResult: false },
-        response: { toolCalls: [{ name: "echo", arguments: { text: "hello" } }] },
+        match: { toolName: "hello_echo", hasToolResult: false },
+        response: { toolCalls: [{ name: "hello_echo", arguments: { text: "hello" } }] },
       },
       {
         match: { hasToolResult: true, toolResultContains: "echoed" },

package/src/surfaces/openclaw-native.ts

@@ -97,6 +97,16 @@ export function openclawVersion(project: Project): string {
   return project.tool.openclaw?.devDependencies?.openclaw ?? OPENCLAW_SCAFFOLD.openclawVersion;
 }
 
+/**
+ * The gateway has one flat tool namespace, so the plugin's tool names are the tool id prefix
+ * plus the operation name with dots flattened: unprefixed names collide across plugins (two
+ * `web`s) and dotted ones fold onto core tools (`sessions.list` → `sessions_list`). The
+ * kernel, CLI and MCP server keep the bare operation names; only this host renames.
+ */
+export function toolName(project: Project, operation: Operation): string {
+  return `${project.identity.name}_${operation.name.replace(/\./g, "_")}`;
+}
+
 export const OPENCLAW_ADDITIONS = {
   /** Without it `tsc` emits a `dist/` from source that failed type-checking. */
   compilerOptions: { noEmitOnError: true },
@@ -278,6 +288,7 @@ function packageJson(
     dependencies: { ...OPENCLAW_SCAFFOLD.dependencies, ...core, ...extra?.dependencies },
     devDependencies: {
       ...OPENCLAW_SCAFFOLD.devDependencies,
+      openclaw: openclawVersion(project),
       ...(kase ? { "@copilotkit/aimock": OPENCLAW_ADDITIONS.aimock } : {}),
       ...extra?.devDependencies,
     },
@@ -317,7 +328,7 @@ function pluginManifest(project: Project, operations: Operation[]): Record<strin
     activation: activation(project),
     skills: shipsSkills(project) ? ["./skills"] : undefined,
     contracts: {
-      tools: operations.map((operation) => operation.name),
+      tools: operations.map((operation) => toolName(project, operation)),
       ...Object.fromEntries(declared),
     },
   }) as Record<string, unknown>;
@@ -421,7 +432,7 @@ const execFileAsync = promisify(execFile);
 ${pythonKernel(project)}`;
   const tools = operations.map(
     (operation) => `    tool({
-      name: ${JSON.stringify(operation.name)},
+      name: ${JSON.stringify(toolName(project, operation))},
       description: ${JSON.stringify(operation.description ?? operation.name)},
       parameters: Type.Unsafe(${literal(normalizeSchema(operation.inputSchema), 6)}),
       ${executeBody(project, operation)}
@@ -582,7 +593,7 @@ import entry from "./index.js";
 
 describe(${JSON.stringify(project.identity.name)}, () => {
   it("declares tool metadata", () => {
-    expect(getToolPluginMetadata(entry)?.tools.map((tool) => tool.name)).toEqual(${JSON.stringify(operations.map((operation) => operation.name))});
+    expect(getToolPluginMetadata(entry)?.tools.map((tool) => tool.name)).toEqual(${JSON.stringify(operations.map((operation) => toolName(project, operation)))});
   });
 ${registrationTest}${web}});
 `;
@@ -628,8 +639,8 @@ function e2eCase(project: Project, operations: Operation[]): E2eCase | undefined
  * would answer OK even for a tool that threw, because the host reports that in a tool message too.
  * An operation that promises no output names has nothing to gate on, so it gets no failure leg.
  */
-function e2eFixtures(kase: E2eCase): string {
-  const name = kase.operation.name;
+function e2eFixtures(project: Project, kase: E2eCase): string {
+  const name = toolName(project, kase.operation);
   return json({
     fixtures: [
       {
@@ -775,19 +786,19 @@ describe(${JSON.stringify(`${id} in a real OpenClaw agent turn`)}, () => {
   it("registers its tools at runtime", async () => {
     const inspected = JSON.parse(await oc(["plugins", "inspect", ${JSON.stringify(id)}, "--runtime", "--json"]));
     expect(inspected.plugin.status).toBe("loaded");
-    expect(inspected.plugin.toolNames).toEqual(${JSON.stringify(operations.map((operation) => operation.name))});
+    expect(inspected.plugin.toolNames).toEqual(${JSON.stringify(operations.map((operation) => toolName(project, operation)))});
   });
 
-  it(${JSON.stringify(`the model calls ${kase.operation.name} and the tool's result reaches the reply`)}, async () => {
+  it(${JSON.stringify(`the model calls ${toolName(project, kase.operation)} and the tool's result reaches the reply`)}, async () => {
     const turn = JSON.parse(
       await oc([
         "agent", "--local", "--agent", "main", "--session-id", \`e2e-\${Date.now()}\`,
         "--model", MODEL, "--thinking", "off", "--timeout", "120", "--json",
         "--message",
-        ${JSON.stringify(`Call the tool named ${kase.operation.name}. Reply with only the exact text returned by that tool.`)},
+        ${JSON.stringify(`Call the tool named ${toolName(project, kase.operation)}. Reply with only the exact text returned by that tool.`)},
       ]),
     );
-    expect(turn.meta.agentMeta.terminalReceipt.successfulToolNames).toContain(${JSON.stringify(kase.operation.name)});
+    expect(turn.meta.agentMeta.terminalReceipt.successfulToolNames).toContain(${JSON.stringify(toolName(project, kase.operation))});
     expect(turn.payloads[0].text).toBe(${JSON.stringify(kase.ok)});
   }, 180_000);
 });
@@ -877,7 +888,7 @@ function readme(project: Project, operations: Operation[], kase?: E2eCase): stri
       "`npm run test:e2e` runs one real OpenClaw agent turn against a scripted OpenAI-compatible",
       "model (`@copilotkit/aimock`, the same package OpenClaw's own QA lane uses). `e2e/fixtures.json`",
       "is projected from `dev.toolfactory/ops.json` and `tool.json`'s `tests.examples`: the model asks",
-      `for \`${kase.operation.name}\` with those arguments, and answers \`${kase.ok}\` only when the tool's own`,
+      `for \`${toolName(project, kase.operation)}\` with those arguments, and answers \`${kase.ok}\` only when the tool's own`,
       "result comes back carrying what its output schema promises.",
       "",
     );
@@ -1008,7 +1019,7 @@ export const surface: Surface = {
             {
               kind: "file" as const,
               path: `${HOST_DIR}/e2e/fixtures.json`,
-              content: e2eFixtures(kase),
+              content: e2eFixtures(project, kase),
             },
             {
               kind: "file" as const,

package/src/surfaces/shared.ts

@@ -118,6 +118,7 @@ export function dataDirEnvName(project: Project): string {
  * A tool with none has nothing to gate a live tier on, so no live test and no `live` CI job.
  */
 export function liveCredentials(project: Project): string[] {
+  if (project.tool.tests.live?.credentials) return project.tool.tests.live.credentials;
   const properties = configProperties(project);
   const required = new Set(requiredConfig(project));
   return Object.keys(properties).filter(

package/src/surfaces/vscode-extension.ts

@@ -272,7 +272,7 @@ export const surface: Surface = {
         format: "json",
         patch: {
           compilerOptions: {
-            module: "Node16",
+            module: "NodeNext",
             target: "ES2022",
             lib: ["ES2022"],
             types: ["node", "mocha"],

package/src/surfaces/web.ts

@@ -153,8 +153,8 @@ export default defineConfig({
       "@fontsource-variable/geist": "^5.3.0",
       "@tailwindcss/vite": "^4.3.3",
       "class-variance-authority": "^0.7.1",
-      cn: "^0.3.0",
-      "lucide-react": "^1.46.0",
+      cn: "^0.4.0",
+      "lucide-react": "^1.48.0",
       react: "^19.2.8",
       "react-dom": "^19.2.8",
       shadcn: "^4.21.0",

package/src/surfaces/workflows.test.ts

@@ -1,5 +1,5 @@
 import { execFileSync, spawnSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { describe, expect, it } from "vitest";
@@ -457,6 +457,20 @@ describe("workflows", () => {
     expect(composeHermes.services.openclaw).toBeUndefined();
   });
 
+  it("supports explicit live credentials without making runtime configuration mandatory", () => {
+    const target = project(["cli"]);
+    target.tool.config = undefined;
+    target.tool.tests.live = { credentials: ["LIVE_ACCOUNT_READY"] };
+    const ci = yamlParse(emitted(target)[".github/workflows/ci.yml"]);
+    expect(ci.jobs.live.env).toEqual({ LIVE_ACCOUNT_READY: "${{ secrets.LIVE_ACCOUNT_READY }}" });
+    expect(ci.jobs.live.environment).toBe("live-tests");
+
+    target.tool.tests.live.ci = false;
+    const localOnly = yamlParse(emitted(target)[".github/workflows/ci.yml"]);
+    expect(localOnly.jobs.live).toBeUndefined();
+    expect(localOnly.on.workflow_dispatch).toBeUndefined();
+  });
+
   it("adds the T4 live job, and workflow_dispatch, iff a config key is required and sensitive", () => {
     const ci = yamlParse(emitted(project(["cli"]))[".github/workflows/ci.yml"]);
     expect(ci.on.workflow_dispatch).toEqual({});
@@ -626,6 +640,11 @@ describe("bootstrap-repo", () => {
     );
     expect(release.manual.join(" ")).toContain("NPM_TRUSTED_PUBLISHER");
     expect(release.manual.filter((step) => step.startsWith("npm:"))).toHaveLength(1);
+
+    noCredential.tool.tests.live = { credentials: ["LOCAL_VAULT_READY"], ci: false };
+    const localOnly = bootstrapRepo(noCredential, { dryRun: true });
+    expect(localOnly.secrets).toEqual([]);
+    expect(localOnly.commands.some((command) => command.includes("live-tests"))).toBe(false);
   });
 });
 
@@ -662,6 +681,61 @@ describe("gate", () => {
     ]);
   });
 
+  it("packs the actual core dependency and restores the host manifest after success or failure", () => {
+    const root = mkdtempSync(join(tmpdir(), "toolfactory-plugin-pack-"));
+    mkdirSync(join(root, "hosts/openclaw"), { recursive: true });
+    mkdirSync(join(root, "bin"));
+    const manifest = {
+      name: "openclaw-plugin-example",
+      dependencies: { "@example/core": "file:../.." },
+    };
+    writeFileSync(join(root, "hosts/openclaw/package.json"), JSON.stringify(manifest));
+    writeFileSync(
+      join(root, "bin/npm"),
+      `#!/usr/bin/env node
+const fs = require('node:fs');
+const path = require('node:path');
+const args = process.argv.slice(2);
+if (args[0] === 'pkg') {
+  const value = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  const [key, version] = args[2].slice('dependencies.'.length).split('=');
+  value.dependencies[key] = version;
+  fs.writeFileSync('package.json', JSON.stringify(value));
+} else if (args[0] === 'pack') {
+  fs.copyFileSync('hosts/openclaw/package.json', 'packed.json');
+  process.exit(Number(process.env.PACK_EXIT || 0));
+}
+`,
+      { mode: 0o755 },
+    );
+    const target = project(["npm", "openclaw-native"], {
+      identity: { name: "core", version: "1.2.3", description: "Example" },
+    });
+    // npmName is the publication mapping, not the Tool Factory package's name.
+    target.tool.npm = { scope: "@example" };
+    const command = packageSteps(target).find(
+      (step) => step.name === "OpenClaw plugin tarball",
+    )?.run;
+    if (!command) throw new Error("OpenClaw packaging step is missing");
+    for (const code of [0, 7]) {
+      const result = spawnSync("sh", ["-c", command], {
+        cwd: root,
+        env: {
+          ...process.env,
+          PATH: `${join(root, "bin")}:${process.env.PATH}`,
+          PACK_EXIT: String(code),
+        },
+      });
+      expect(result.status, result.stderr.toString()).toBe(code);
+      expect(JSON.parse(readFileSync(join(root, "packed.json"), "utf8")).dependencies).toEqual({
+        "@example/core": "1.2.3",
+      });
+      expect(JSON.parse(readFileSync(join(root, "hosts/openclaw/package.json"), "utf8"))).toEqual(
+        manifest,
+      );
+    }
+  });
+
   it("packages one asset per selected distribution surface into dist/release", () => {
     const target = project([
       "npm",

package/src/surfaces/workflows.ts

@@ -199,11 +199,17 @@ function actionStep(step: GateStep, matrix: boolean): Step {
  * (an environment gates deployments, not the checkout an untrusted PR ships).
  */
 function liveJob(project: Project): Record<string, unknown> | undefined {
+  if (project.tool.tests.live?.ci === false) return undefined;
   if (liveCredentials(project).length === 0) return undefined;
   const properties = configProperties(project);
-  const secrets = Object.keys(properties).filter((key) =>
-    isSensitive(properties[key] as Record<string, unknown>),
-  );
+  const secrets = [
+    ...new Set([
+      ...Object.keys(properties).filter((key) =>
+        isSensitive(properties[key] as Record<string, unknown>),
+      ),
+      ...liveCredentials(project),
+    ]),
+  ];
   const pmName = project.packageManager ?? "npm";
   const pm = PACKAGE_MANAGER_COMMANDS[pmName];
   const steps: Step[] =

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.2.4");
+  .version("0.4.2");
 
 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.2.4" });
+  const server = new McpServer({ name: "toolfactory", version: "0.4.2" });
   for (const op of operations) {
     if (!introspecting && !serves(op, "mcp")) continue;
     server.registerTool(