@bluewombat/slots 0.4.0 → 0.6.0

package/README.md

@@ -92,8 +92,12 @@ or `--report`. A role slot after `--` is what names one:
 - ./.mason/transcripts
 ```
 
-`cursor.mjs` needs `cursor-agent` on PATH (`cursor-agent login`); `claude.mjs`
-needs `claude`, signed in once.
+`cursor.mjs` needs `cursor-agent` on PATH. Without `--agent-home` it uses the
+CLI's own login (`cursor-agent login`). With `--agent-home DIR` and
+`--api-key-env NAME` the vendor process gets that directory as `HOME` and
+`CURSOR_API_KEY` from `NAME`; the value never appears on the argv. `claude.mjs`
+needs `claude`, signed in once, and refuses those two flags: Claude is not
+isolated yet, and starting it would keep the operator's own config.
 
 | Option                             | Meaning                                                                          |
 | ---------------------------------- | -------------------------------------------------------------------------------- |
@@ -106,25 +110,34 @@ needs `claude`, signed in once.
 | `--transcript-dir PATH`            | Write one file per turn under here. Off unless given                             |
 | `--transcript-part NAME`           | `prompt`, `stdout`, `stderr`, `timing`. Repeatable. Default: all                 |
 | `--agent-arg VALUE`                | Appended to the CLI argv, before the prompt. Repeatable                          |
+| `--agent-home DIR`                 | Isolate the vendor process: its `HOME` is this directory. Cursor only; Claude refuses |
+| `--api-key-env NAME`               | With `--agent-home`, read `process.env[NAME]` for the vendor key. Never the value itself |
 | `--id` / `--attempt` / `--context` | How a transcript is filed. Forwarded by the role                                 |
 
 The agent CLI prints **one JSON line** — a `SerializedRun` from
-`@bluewombat/slot-kit` — with the vendor's raw streams plus two extras the
+`@bluewombat/slot-kit` — with the vendor's raw streams plus three extras the
 wrapper fills when it can:
 
 | Field    | Meaning                                                                                                                                              |
 | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `skills` | `null` = unknown (not stream-json, or unparseable). `[]` = looked, none used. Otherwise skill names in order                                         |
 | `usage`  | `null` = unknown. Otherwise token counts (`input`, `output`, `cacheRead`, `cacheWrite`) and `costUsd` (`null` when the vendor did not report a cost) |
+| `tools`  | `null` = unknown (not stream-json, or unparseable). Otherwise what the agent did with its tools: `calls` per tool name, `busyMs` (time with a tool running; `null` when the stream has no times, as Claude's), and the lists `web` (pages fetched, searches, URLs a shell command named), `mcp` (`server/tool`, plus `getMcpTools` when the agent only listed a server's tools), `subagents` (by description), `outside` (paths named outside the working directory, skill files excepted) |
 
 Cursor extracts skills from `stream-json` `readToolCall` paths ending in
 `/skills/<name>/SKILL.md`. Claude extracts them from `tool_use` blocks named
 `Skill` (`input.skill`), and adds `--verbose` whenever the format is
-`stream-json`. A future vendor agent (`codex.mjs`, …) uses the same fields:
-leave them `null` when it cannot tell.
-
-When `--transcript-dir` is set, the transcript header repeats `skills` and
-`usage` (`unknown`, `(none)`, or the values).
+`stream-json`. Tools come from Cursor's `<name>ToolCall` events (`webFetch`,
+`mcp`, `task`, `shell`, … — names seen on cursor-agent 2026.10.01) and from
+Claude's `tool_use` blocks (`WebFetch`, `WebSearch`, `Bash`, `Task`,
+`mcp__<server>__<tool>`); the vendor-free part is `agents/tool-facts.mjs`. A
+future vendor agent (`codex.mjs`, …) uses the same fields: leave them `null`
+when it cannot tell.
+
+When `--transcript-dir` is set, the transcript header repeats `skills`,
+`usage` and the tools — `tools`, `web`, `mcp`, `subagents`, `outside the
+workspace` — each `unknown`, `(none)`, or the values. "Did it read the page I
+linked?" is answered there, without reading the stream.
 
 A global npm install belongs to one Node version: after `nvm use`, a `claude`
 installed under another version is off PATH. Give `--bin` the absolute path, or
@@ -250,7 +263,8 @@ loop that misbehaves cannot be read back, only guessed at.
 
 `--transcript-dir` writes one Markdown file per turn: the invocation, the prompt
 as sent, stdout, stderr, how long it took, and — when the agent wrapper passed
-them — `skills` and `usage` (`unknown`, `(none)`, or the values). Files are
+them — `skills`, `usage` and what the tools did (`unknown`, `(none)`, or the
+values). Files are
 filed under the Feature the Task belongs to, named for the Subtask and the
 Attempt. It belongs on the **agent** command, after `--`.
 

package/agents/claude-extras.mjs

@@ -9,24 +9,96 @@
  * Usage: terminal `result` documents `usage` (`input_tokens`, …) and
  * `total_cost_usd`.
  *
- * `skills` is `null` when stdout is not NDJSON we can parse; `[]` when parsed
- * with no Skill tool_use.
+ * Tools: every `tool_use` block of an assistant message, counted under its
+ * `name`, as Claude Code's tools reference names them: `WebFetch` (`input.url`),
+ * `WebSearch` (`input.query`), `Bash` (`input.command`), `Task` / `Agent`
+ * (`input.description`), an MCP tool as `mcp__<server>__<tool>`, and
+ * `file_path` / `path` on the file tools. The stream carries no times:
+ * `busyMs` stays null.
+ *
+ * `skills` and `tools` are `null` when stdout is not NDJSON we can parse;
+ * `skills` is `[]` when parsed with no Skill tool_use.
  */
 
 import { readResult } from "@bluewombat/slot-kit";
+import { count, emptyTools, isOutside, urlsIn } from "./tool-facts.mjs";
 
 /**
  * @param {string} stdout
  * @param {string} outputFormat
- * @returns {{ skills: string[] | null, usage: import("@bluewombat/slot-kit").AgentUsage | null }}
+ * @param {string} cwd the directory the agent worked in
+ * @returns {import("@bluewombat/slot-kit").AgentExtras}
  */
-export function extrasFromClaude(stdout, outputFormat) {
+export function extrasFromClaude(stdout, outputFormat, cwd) {
+  const streamed = outputFormat === "stream-json";
   return {
-    skills: outputFormat === "stream-json" ? skillsFromClaude(stdout) : null,
+    skills: streamed ? skillsFromClaude(stdout) : null,
     usage: usageFromClaude(stdout),
+    tools: streamed ? toolsFromClaude(stdout, cwd) : null,
   };
 }
 
+/**
+ * @param {string} stdout
+ * @param {string} cwd the directory the agent worked in
+ * @returns {import("@bluewombat/slot-kit").AgentTools | null}
+ */
+export function toolsFromClaude(stdout, cwd) {
+  const tools = emptyTools();
+  /** @type {Set<string>} */
+  const seen = new Set();
+  let parsedAny = false;
+  for (const line of stdout.split("\n")) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (event === null || typeof event !== "object" || Array.isArray(event)) {
+      continue;
+    }
+    parsedAny = true;
+    const content = event.type === "assistant" ? event.message?.content : undefined;
+    if (!Array.isArray(content)) {
+      continue;
+    }
+    for (const block of content) {
+      if (block?.type !== "tool_use" || typeof block.name !== "string") {
+        continue;
+      }
+      // A partial-message stream repeats a block; its id says it once.
+      if (typeof block.id === "string") {
+        if (seen.has(block.id)) {
+          continue;
+        }
+        seen.add(block.id);
+      }
+      const name = block.name;
+      const input = block.input ?? {};
+      count(tools, name);
+      const mcp = /^mcp__(.+?)__(.+)$/.exec(name);
+      if (mcp !== null) {
+        tools.mcp.push(`${mcp[1]}/${mcp[2]}`);
+      } else if (name === "WebFetch" && typeof input.url === "string") {
+        tools.web.push(input.url);
+      } else if (name === "WebSearch" && typeof input.query === "string") {
+        tools.web.push(`search: ${input.query}`);
+      } else if (name === "Bash") {
+        tools.web.push(...urlsIn(input.command).map((url) => `${url} (shell)`));
+      } else if ((name === "Task" || name === "Agent") && typeof input.description === "string") {
+        tools.subagents.push(input.description);
+      }
+      for (const path of [input.file_path, input.path, input.notebook_path]) {
+        if (isOutside(path, cwd)) {
+          tools.outside.push(path);
+        }
+      }
+    }
+  }
+  return parsedAny ? tools : null;
+}
+
 /**
  * @param {string} stdout
  * @returns {string[] | null}

package/agents/claude.mjs

@@ -26,6 +26,8 @@ import { extrasFromClaude } from "./claude-extras.mjs";
 //   --transcript-dir PATH  write one file per turn. Off by default
 //   --transcript-part NAME prompt, stdout, stderr, timing. Repeatable
 //   --agent-arg VALUE      appended before the prompt. Repeatable
+//   --agent-home / --api-key-env   recognised, then refused. Claude is not
+//                         isolated yet; starting would keep the operator's config
 //   --id / --attempt / --context   how a transcript is filed
 
 const NAME = "Claude Code";
@@ -47,6 +49,15 @@ if (!parsed.ok) {
 }
 const options = parsed.values;
 
+if (
+  textOption(options, "agentHome") !== undefined ||
+  textOption(options, "apiKeyEnv") !== undefined
+) {
+  refuse(
+    "Claude Code does not isolate the operator home yet. Remove --agent-home and --api-key-env; the vendor was not started.",
+  );
+}
+
 const loaded = readAgentPrompt(options);
 if (!loaded.ok) {
   refuse(loaded.reason);
@@ -83,7 +94,7 @@ const transcript = transcriptFor(process.argv, options, {
   prompt,
 });
 const run = await runAgent({ file: bin, args, cwd });
-const extras = extrasFromClaude(run.stdout, outputFormat);
+const extras = extrasFromClaude(run.stdout, outputFormat, cwd);
 transcript.write(run, extras);
 answer(run, bin, extras);
 
@@ -102,7 +113,13 @@ function refuse(reason) {
 function answer(run, binPath, extras) {
   writeContract(
     `${JSON.stringify(
-      serializeRun(run, { name: NAME, bin: binPath, skills: extras.skills, usage: extras.usage }),
+      serializeRun(run, {
+        name: NAME,
+        bin: binPath,
+        skills: extras.skills,
+        usage: extras.usage,
+        tools: extras.tools,
+      }),
     )}\n`,
   );
   process.exit(0);

package/agents/cursor-extras.mjs

@@ -9,24 +9,122 @@
  * with camelCase token fields (observed; not in the published json schema).
  * No cost field is documented for Cursor — `costUsd` stays null.
  *
- * `skills` is `null` when the stdout is not NDJSON we can parse (unknown),
- * `[]` when we parsed and found no skill reads.
+ * Tools: every `tool_call` (`<name>ToolCall`, args under it) counted once, on
+ * `started`; its `completed` closes the interval for the busy time
+ * (`timestamp_ms`). Observed on cursor-agent 2026.10.01: `webFetchToolCall`
+ * (`args.url`), `mcpToolCall` (`args.providerIdentifier` / `args.toolName`),
+ * `getMcpToolsToolCall` (a catalogue read, counted in `mcp` so a server that
+ * was only listed still shows up), `taskToolCall` (`args.description`),
+ * `shellToolCall` (`args.command`), and `path` / `targetDirectory` on the
+ * file tools.
+ *
+ * `skills` and `tools` are `null` when the stdout is not NDJSON we can parse
+ * (unknown); `skills` is `[]` when we parsed and found no skill reads.
  */
 
 import { readResult } from "@bluewombat/slot-kit";
+import { busyMs, count, emptyTools, isOutside, urlsIn } from "./tool-facts.mjs";
 
 /**
  * @param {string} stdout
  * @param {string} outputFormat
- * @returns {{ skills: string[] | null, usage: import("@bluewombat/slot-kit").AgentUsage | null }}
+ * @param {string} cwd the directory the agent worked in
+ * @returns {import("@bluewombat/slot-kit").AgentExtras}
  */
-export function extrasFromCursor(stdout, outputFormat) {
+export function extrasFromCursor(stdout, outputFormat, cwd) {
+  const streamed = outputFormat === "stream-json";
   return {
-    skills: outputFormat === "stream-json" ? skillsFromCursor(stdout) : null,
+    skills: streamed ? skillsFromCursor(stdout) : null,
     usage: usageFromCursor(stdout),
+    tools: streamed ? toolsFromCursor(stdout, cwd) : null,
   };
 }
 
+/**
+ * @param {string} stdout
+ * @param {string} cwd the directory the agent worked in
+ * @returns {import("@bluewombat/slot-kit").AgentTools | null}
+ */
+export function toolsFromCursor(stdout, cwd) {
+  const tools = emptyTools();
+  /** @type {Map<string, number>} */
+  const open = new Map();
+  /** @type {[number, number][]} */
+  const intervals = [];
+  let parsedAny = false;
+  for (const line of stdout.split("\n")) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (event === null || typeof event !== "object" || Array.isArray(event)) {
+      continue;
+    }
+    parsedAny = true;
+    if (
+      event.type !== "tool_call" ||
+      event.tool_call === null ||
+      typeof event.tool_call !== "object"
+    ) {
+      continue;
+    }
+    const callId = typeof event.call_id === "string" ? event.call_id : "";
+    const at = Number(event.timestamp_ms);
+    if (event.subtype === "completed") {
+      const started = open.get(callId);
+      if (started !== undefined && Number.isFinite(at)) {
+        intervals.push([started, at]);
+      }
+      open.delete(callId);
+      continue;
+    }
+    if (event.subtype !== "started" || open.has(callId)) {
+      continue;
+    }
+    if (Number.isFinite(at)) {
+      open.set(callId, at);
+    }
+    const key = Object.keys(event.tool_call).find((name) => name.endsWith("ToolCall"));
+    if (key === undefined) {
+      continue;
+    }
+    const name = key.slice(0, -"ToolCall".length);
+    const args = event.tool_call[key]?.args ?? {};
+    count(tools, name);
+    if (name === "webFetch" && typeof args.url === "string") {
+      tools.web.push(args.url);
+    } else if (name === "webSearch") {
+      const term = args.searchTerm ?? args.query;
+      if (typeof term === "string") {
+        tools.web.push(`search: ${term}`);
+      }
+    } else if (name === "shell") {
+      tools.web.push(...urlsIn(args.command).map((url) => `${url} (shell)`));
+    } else if (name === "mcp") {
+      tools.mcp.push(`${args.providerIdentifier ?? args.server ?? "?"}/${args.toolName ?? "?"}`);
+    } else if (name === "getMcpTools") {
+      const server = args.server ?? args.providerIdentifier ?? args.provider;
+      tools.mcp.push(
+        typeof server === "string" && server.length > 0 ? `${server}/getMcpTools` : "getMcpTools",
+      );
+    } else if (name === "task" && typeof args.description === "string") {
+      tools.subagents.push(args.description);
+    }
+    for (const path of [args.path, args.targetDirectory]) {
+      if (isOutside(path, cwd)) {
+        tools.outside.push(path);
+      }
+    }
+  }
+  if (!parsedAny) {
+    return null;
+  }
+  tools.busyMs = intervals.length === 0 ? null : busyMs(intervals);
+  return tools;
+}
+
 /**
  * @param {string} stdout
  * @returns {string[] | null}

package/agents/cursor.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
+import { existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import {
   AGENT_OPTIONS,
   findExecutable,
@@ -25,6 +26,9 @@ import { extrasFromCursor } from "./cursor-extras.mjs";
 //   --transcript-dir PATH write one file per turn. Off by default
 //   --transcript-part NAME prompt, stdout, stderr, timing. Repeatable
 //   --agent-arg VALUE     appended before the prompt. Repeatable
+//   --agent-home DIR      isolate this process: HOME is DIR, not the operator's
+//   --api-key-env NAME    required with --agent-home. Read process.env[NAME];
+//                         the value is never put on the argv
 //   --id / --attempt / --context   how a transcript is filed
 
 const NAME = "Cursor CLI";
@@ -70,17 +74,135 @@ const args = [
   prompt,
 ];
 
+const isolation = cursorIsolation(options, cwd);
+if (!isolation.ok) {
+  refuse(isolation.reason);
+}
+
 const transcript = transcriptFor(process.argv, options, {
   slot: NAME,
   bin,
   args,
   prompt,
 });
-const run = await runAgent({ file: bin, args, cwd });
-const extras = extrasFromCursor(run.stdout, outputFormat);
+const run = await runAgent({
+  file: bin,
+  args,
+  cwd,
+  ...(isolation.env === undefined ? {} : { env: isolation.env }),
+});
+const extras = extrasFromCursor(run.stdout, outputFormat, cwd);
 transcript.write(run, extras);
 answer(run, bin, extras);
 
+/**
+ * `--agent-home` isolates the vendor process. The wrapper keeps the parent's
+ * HOME, so `findExecutable` still sees the operator's install directories.
+ * No link to the login keychain: auth is the named variable, held in memory.
+ *
+ * @param {import("@bluewombat/slot-kit").OptionValues} options
+ * @param {string} dir
+ * @returns {{ ok: true, env: NodeJS.ProcessEnv | undefined } | { ok: false, reason: string }}
+ */
+function cursorIsolation(options, dir) {
+  const home = textOption(options, "agentHome");
+  const keyEnv = textOption(options, "apiKeyEnv");
+  if (home === undefined && keyEnv === undefined) {
+    return { ok: true, env: undefined };
+  }
+  if (home === undefined || keyEnv === undefined) {
+    return {
+      ok: false,
+      reason: "An isolated Cursor agent needs both --agent-home and --api-key-env.",
+    };
+  }
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(keyEnv)) {
+    return {
+      ok: false,
+      reason: `--api-key-env must name an environment variable, not "${keyEnv}".`,
+    };
+  }
+  const apiKey = process.env[keyEnv];
+  if (apiKey === undefined || apiKey.length === 0) {
+    return {
+      ok: false,
+      reason: `The environment variable ${keyEnv} is empty. An isolated Cursor agent needs it, or the CLI tries to store credentials in the login keychain.`,
+    };
+  }
+  return { ok: true, env: isolatedVendorEnv(resolve(dir, home), apiKey) };
+}
+
+/**
+ * @param {string} agentHome
+ * @param {string} apiKey
+ * @returns {NodeJS.ProcessEnv}
+ */
+function isolatedVendorEnv(agentHome, apiKey) {
+  mkdirSync(agentHome, { recursive: true });
+  const parentHome = homedir();
+  /** @type {NodeJS.ProcessEnv} */
+  const env = { ...process.env, HOME: agentHome };
+  if (process.env.PATH !== undefined) {
+    env.PATH = process.env.PATH;
+  }
+  env.CURSOR_API_KEY = apiKey;
+  env.AGENT_CLI_CREDENTIAL_STORE = "memory";
+  const gitConfig = parentGitConfig(parentHome);
+  if (gitConfig === undefined) {
+    delete env.GIT_CONFIG_GLOBAL;
+  } else {
+    env.GIT_CONFIG_GLOBAL = gitConfig;
+  }
+  const npmCache = process.env.npm_config_cache;
+  env.npm_config_cache =
+    npmCache !== undefined && npmCache.length > 0 ? npmCache : join(parentHome, ".npm");
+  const corepack = parentCorepack(parentHome);
+  if (corepack === undefined) {
+    delete env.COREPACK_HOME;
+  } else {
+    env.COREPACK_HOME = corepack;
+  }
+  return env;
+}
+
+/**
+ * The global git file the parent already resolves. `~/.gitconfig` wins over
+ * the XDG file, which is git's own order when both exist.
+ *
+ * @param {string} parentHome
+ * @returns {string | undefined}
+ */
+function parentGitConfig(parentHome) {
+  const fromEnv = process.env.GIT_CONFIG_GLOBAL;
+  if (fromEnv !== undefined && fromEnv.length > 0 && existsSync(fromEnv)) {
+    return fromEnv;
+  }
+  const dot = join(parentHome, ".gitconfig");
+  if (existsSync(dot)) {
+    return dot;
+  }
+  const xdgRoot = process.env.XDG_CONFIG_HOME;
+  const xdg = join(
+    xdgRoot !== undefined && xdgRoot.length > 0 ? xdgRoot : join(parentHome, ".config"),
+    "git",
+    "config",
+  );
+  return existsSync(xdg) ? xdg : undefined;
+}
+
+/**
+ * @param {string} parentHome
+ * @returns {string | undefined}
+ */
+function parentCorepack(parentHome) {
+  const fromEnv = process.env.COREPACK_HOME;
+  if (fromEnv !== undefined && fromEnv.length > 0 && existsSync(fromEnv)) {
+    return fromEnv;
+  }
+  const fallback = join(parentHome, ".cache", "node", "corepack");
+  return existsSync(fallback) ? fallback : undefined;
+}
+
 /** @param {string} reason @returns {never} */
 function refuse(reason) {
   writeContract(`${JSON.stringify({ error: reason })}\n`);
@@ -96,7 +218,13 @@ function refuse(reason) {
 function answer(run, binPath, extras) {
   writeContract(
     `${JSON.stringify(
-      serializeRun(run, { name: NAME, bin: binPath, skills: extras.skills, usage: extras.usage }),
+      serializeRun(run, {
+        name: NAME,
+        bin: binPath,
+        skills: extras.skills,
+        usage: extras.usage,
+        tools: extras.tools,
+      }),
     )}\n`,
   );
   process.exit(0);

package/agents/tool-facts.mjs

@@ -0,0 +1,77 @@
+/**
+ * What both vendors' tool summaries share: the facts a stream yields once each
+ * tool call has been read in that vendor's own shape. Vendor-free.
+ */
+
+import { isAbsolute, relative, resolve } from "node:path";
+
+const URL_IN_TEXT = /https?:\/\/[^\s'"`<>|)\]]+/g;
+
+/**
+ * URLs a shell command names: `curl`, `wget` or a script reaching the web.
+ * @param {unknown} command
+ * @returns {string[]}
+ */
+export function urlsIn(command) {
+  return typeof command === "string"
+    ? [...command.matchAll(URL_IN_TEXT)].map((match) => match[0])
+    : [];
+}
+
+/**
+ * Whether a path a tool named is outside `cwd`. A skill file is not reported:
+ * it is read from the plugin directories Mason itself points the agent at.
+ * @param {unknown} path
+ * @param {unknown} cwd
+ * @returns {path is string}
+ */
+export function isOutside(path, cwd) {
+  if (typeof path !== "string" || path.length === 0 || typeof cwd !== "string") {
+    return false;
+  }
+  if (/(?:^|[/\\])skills[/\\][^/\\]+[/\\]SKILL\.md$/i.test(path)) {
+    return false;
+  }
+  const absolute = isAbsolute(path) ? path : resolve(cwd, path);
+  const fromCwd = relative(cwd, absolute);
+  return fromCwd === ".." || fromCwd.startsWith(`..${"/"}`) || isAbsolute(fromCwd);
+}
+
+/**
+ * Wall time covered by at least one `[start, end]` interval, in ms.
+ * @param {[number, number][]} intervals
+ * @returns {number}
+ */
+export function busyMs(intervals) {
+  let total = 0;
+  /** @type {[number, number] | undefined} */
+  let current;
+  for (const [start, end] of [...intervals].sort((a, b) => a[0] - b[0])) {
+    if (current === undefined || start > current[1]) {
+      if (current !== undefined) {
+        total += current[1] - current[0];
+      }
+      current = [start, end];
+    } else {
+      current[1] = Math.max(current[1], end);
+    }
+  }
+  return current === undefined ? total : total + current[1] - current[0];
+}
+
+/**
+ * An empty summary, filled by a vendor's reader.
+ * @returns {import("@bluewombat/slot-kit").AgentTools}
+ */
+export function emptyTools() {
+  return { calls: {}, busyMs: null, web: [], mcp: [], subagents: [], outside: [] };
+}
+
+/**
+ * One call more under `name`.
+ * @param {import("@bluewombat/slot-kit").AgentTools} tools
+ * @param {string} name
+ */
+export function count(tools, name) {
+  tools.calls[name] = (tools.calls[name] ?? 0) + 1;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bluewombat/slots",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "description": "Shipped mason slots: Planners, Builders, Gates, publishers, and refreshers a Project names in its config.",
   "keywords": [
@@ -53,6 +53,6 @@
     "test": "tsx --test $(find test -name '*.test.ts')"
   },
   "dependencies": {
-    "@bluewombat/slot-kit": "^0.4.0"
+    "@bluewombat/slot-kit": "^0.6.0"
   }
 }