shadow-claw 1.29.0 → 1.30.0

package/src/subsystems/skills/activateSkill.test.ts

@@ -1,9 +1,11 @@
 import { jest } from "@jest/globals";
 
 const mockLoadSkill = jest.fn() as any;
+const mockDiscoverSkills = jest.fn() as any;
 
 jest.unstable_mockModule("./discoverSkills.js", () => ({
   loadSkill: mockLoadSkill,
+  discoverSkills: mockDiscoverSkills,
 }));
 
 const { executeActivateSkill } = await import("./activateSkill.js");
@@ -11,21 +13,27 @@ const { executeActivateSkill } = await import("./activateSkill.js");
 describe("executeActivateSkill", () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    mockDiscoverSkills.mockResolvedValue({
+      skills: [{ name: "existing-skill", description: "An existing skill" }],
+      diagnostics: [],
+    });
   });
 
-  it("returns error when skill name is missing or empty", async () => {
+  it("returns error when skill name is missing or empty, including available skills", async () => {
     const res1 = await executeActivateSkill({} as any, {}, "group-1");
-    expect(res1).toBe("Error: activate_skill requires a skill name.");
+    expect(res1).toContain("Error: activate_skill requires a skill name.");
+    expect(res1).toContain("Available skills: existing-skill.");
 
     const res2 = await executeActivateSkill(
       {} as any,
       { name: "   " },
       "group-1",
     );
-    expect(res2).toBe("Error: activate_skill requires a skill name.");
+    expect(res2).toContain("Error: activate_skill requires a skill name.");
+    expect(res2).toContain("Available skills: existing-skill.");
   });
 
-  it("returns error when skill is not found", async () => {
+  it("returns error when skill is not found, including available skills", async () => {
     mockLoadSkill.mockResolvedValue(null);
 
     const res = await executeActivateSkill(
@@ -33,9 +41,34 @@ describe("executeActivateSkill", () => {
       { name: "my-skill" },
       "group-1",
     );
-    expect(res).toBe(
+    expect(res).toContain(
       'Error: skill "my-skill" was not found in this conversation workspace.',
     );
+    expect(res).toContain("Available skills: existing-skill.");
+  });
+
+  it("reports matched diagnostic when a skill exists on disk but failed to parse", async () => {
+    mockLoadSkill.mockResolvedValue(null);
+    mockDiscoverSkills.mockResolvedValue({
+      skills: [{ name: "existing-skill", description: "An existing skill" }],
+      diagnostics: [
+        {
+          path: ".agents/skills/main/broken-skill/SKILL.md",
+          message: "YAML parse error on line 3",
+        },
+      ],
+    });
+
+    const res = await executeActivateSkill(
+      {} as any,
+      { name: "broken-skill" },
+      "group-1",
+    );
+    expect(res).toContain(
+      'Error: skill "broken-skill" was found at ".agents/skills/main/broken-skill/SKILL.md" but failed to load: YAML parse error on line 3.',
+    );
+    expect(res).toContain("Please fix the frontmatter in SKILL.md.");
+    expect(res).toContain("Available skills: existing-skill.");
   });
 
   it("returns error when skill disables model invocation", async () => {

package/src/subsystems/skills/activateSkill.ts

@@ -1,4 +1,4 @@
-import { loadSkill } from "./discoverSkills.js";
+import { discoverSkills, loadSkill } from "./discoverSkills.js";
 import type { ShadowClawDatabase } from "../../db/types.js";
 
 export async function executeActivateSkill(
@@ -7,13 +7,35 @@ export async function executeActivateSkill(
   groupId: string,
 ): Promise<string> {
   const name = typeof input.name === "string" ? input.name.trim() : "";
+  const discovery = await discoverSkills(db, groupId);
+  const availableSkillNames = discovery.skills.map((s) => s.name);
+  const availableList =
+    availableSkillNames.length > 0 ? availableSkillNames.join(", ") : "(none)";
+
   if (!name) {
-    return "Error: activate_skill requires a skill name.";
+    let msg = `Error: activate_skill requires a skill name. Available skills: ${availableList}.`;
+    if (discovery.diagnostics.length > 0) {
+      msg += ` (Note: ${discovery.diagnostics.length} skill file(s) had errors: ${discovery.diagnostics.map((d) => `${d.path}: ${d.message}`).join("; ")})`;
+    }
+    return msg;
   }
 
   const skill = await loadSkill(db, groupId, name);
   if (!skill) {
-    return `Error: skill "${name}" was not found in this conversation workspace.`;
+    const matchedDiag = discovery.diagnostics.find(
+      (d) =>
+        d.path.toLowerCase().includes(name.toLowerCase()) ||
+        d.message.toLowerCase().includes(name.toLowerCase()),
+    );
+    if (matchedDiag) {
+      return `Error: skill "${name}" was found at "${matchedDiag.path}" but failed to load: ${matchedDiag.message}. Please fix the frontmatter in SKILL.md. Available skills: ${availableList}.`;
+    }
+
+    let msg = `Error: skill "${name}" was not found in this conversation workspace. Available skills: ${availableList}.`;
+    if (discovery.diagnostics.length > 0) {
+      msg += ` (Note: ${discovery.diagnostics.length} skill file(s) had errors: ${discovery.diagnostics.map((d) => `${d.path}: ${d.message}`).join("; ")})`;
+    }
+    return msg;
   }
   if (skill.disableModelInvocation) {
     return `Error: skill "${name}" is not available for model-driven activation.`;

package/src/subsystems/skills/parseSkill.test.ts

@@ -83,4 +83,75 @@ describe("parseSkill", () => {
 
     expect(result.execution).toBeUndefined();
   });
+
+  it("resiliently parses frontmatter with unquoted colons, URLs, and quotes in description", () => {
+    const rawSkill = `---
+name: bible-lookup
+description: Look up Bible verses from the bible-tools/data repository (https://bible-tools.github.io/data/). Supports multiple translations in Arabic (ar), German (de), English (en: ASV, KJV, WEB), Spanish (es), and French (fr). Trigger phrases: "bible lookup", "look up a bible verse", "bible verse", "find bible verse", "bible reference", "what does the bible say about", "scripture reference", "look up verse", "bible passage".
+user-invocable: true
+metadata:
+  allowed-tools:
+    - fetch_url
+    - javascript
+---
+
+# Bible Lookup Skill
+
+Instructions here.`;
+
+    const result = parseSkill(
+      ".agents/skills/main/bible-lookup/SKILL.md",
+      rawSkill,
+    );
+
+    expect(result.name).toBe("bible-lookup");
+    expect(result.description).toContain(
+      "Look up Bible verses from the bible-tools/data repository",
+    );
+    expect(result.description).toContain("(en: ASV, KJV, WEB)");
+    expect(result.userInvocable).toBe(true);
+    expect(result.allowedTools).toBe("fetch_url javascript");
+    expect(result.metadata?.["allowed-tools"]).toBe("fetch_url javascript");
+    expect(result.body).toBe("# Bible Lookup Skill\n\nInstructions here.");
+    expect(result.path).toBe(".agents/skills/main/bible-lookup/SKILL.md");
+    expect(result.basePath).toBe(".agents/skills/main/bible-lookup");
+  });
+
+  it("normalizes array allowed-tools into a space-separated string", () => {
+    const result = parseSkill(
+      "skills/tools/SKILL.md",
+      `---\nname: tools-test\ndescription: Test tools array\nmetadata:\n  allowed-tools:\n    - read_file\n    - write_file\n    - javascript\n---\nbody`,
+    );
+
+    expect(result.allowedTools).toBe("read_file write_file javascript");
+    expect(result.metadata?.["allowed-tools"]).toBe(
+      "read_file write_file javascript",
+    );
+  });
+
+  it("recovers via fallback extraction when YAML syntax is malformed", () => {
+    const brokenYaml = `---
+name: broken-yaml-skill
+description: Resilient fallback description with : colons and [broken brackets
+user-invocable: true
+disable-model-invocation: false
+allowed-tools:
+  - tool_a
+  - tool_b
+some_random_key: {unclosed object
+---
+
+# Fallback Body`;
+
+    const result = parseSkill("skills/broken/SKILL.md", brokenYaml);
+
+    expect(result.name).toBe("broken-yaml-skill");
+    expect(result.description).toBe(
+      "Resilient fallback description with : colons and [broken brackets",
+    );
+    expect(result.userInvocable).toBe(true);
+    expect(result.disableModelInvocation).toBe(false);
+    expect(result.allowedTools).toBe("tool_a tool_b");
+    expect(result.body).toBe("# Fallback Body");
+  });
 });

package/src/subsystems/skills/parseSkill.ts

@@ -5,10 +5,145 @@ import type { SkillExecution, SkillRecord } from "./types.js";
 
 const NAME_PATTERN = /^[a-z0-9](?:[a-z0-9]|-(?!-))*[a-z0-9]$|^[a-z0-9]$/;
 
+interface FrontmatterParseResult {
+  data: Record<string, unknown>;
+  content: string;
+}
+
+function parseFrontmatterResiliently(source: string): FrontmatterParseResult {
+  try {
+    const parsed = matter(source);
+    return {
+      data: parsed.data && typeof parsed.data === "object" ? parsed.data : {},
+      content: parsed.content || "",
+    };
+  } catch {
+    // Attempt 1: Sanitize unquoted scalar lines in the frontmatter block
+    const fmMatch = source.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (fmMatch) {
+      const rawFm = fmMatch[1];
+      const rest = fmMatch[2] || "";
+      const lines = rawFm.split(/\r?\n/);
+      const sanitizedLines = lines.map((line) => {
+        const fieldMatch = line.match(/^([a-zA-Z0-9_-]+):\s*(.+)$/);
+        if (fieldMatch) {
+          const [, key, val] = fieldMatch;
+          const trimmed = val.trim();
+          // If value is not already quoted and not a YAML block indicator/collection opening or boolean/number
+          if (
+            trimmed &&
+            trimmed !== "true" &&
+            trimmed !== "false" &&
+            trimmed !== "null" &&
+            !trimmed.startsWith('"') &&
+            !trimmed.startsWith("'") &&
+            !trimmed.startsWith("[") &&
+            !trimmed.startsWith("{") &&
+            trimmed !== ">" &&
+            trimmed !== "|" &&
+            trimmed !== ">-" &&
+            trimmed !== "|-" &&
+            !/^-?\d+(?:\.\d+)?$/.test(trimmed)
+          ) {
+            return `${key}: ${JSON.stringify(trimmed)}`;
+          }
+        }
+        return line;
+      });
+
+      try {
+        const sanitizedSource = `---\n${sanitizedLines.join("\n")}\n---\n${rest}`;
+        const parsed = matter(sanitizedSource);
+        return {
+          data:
+            parsed.data && typeof parsed.data === "object" ? parsed.data : {},
+          content: parsed.content || "",
+        };
+      } catch {
+        // Continue to fallback
+      }
+
+      // Attempt 2: Line-by-line fallback extraction for essential frontmatter fields
+      const fallbackData: Record<string, unknown> = {};
+      const nameMatch = rawFm.match(/^name:\s*["']?([^"'\r\n]+)["']?/m);
+      if (nameMatch) {
+        fallbackData.name = nameMatch[1].trim();
+      }
+
+      const descMatch = rawFm.match(/^description:\s*(.+)$/m);
+      if (descMatch) {
+        let desc = descMatch[1].trim();
+        if (
+          (desc.startsWith('"') && desc.endsWith('"')) ||
+          (desc.startsWith("'") && desc.endsWith("'"))
+        ) {
+          desc = desc.slice(1, -1);
+        }
+        fallbackData.description = desc;
+      }
+
+      const userInvocableMatch = rawFm.match(
+        /^user-invocable:\s*(true|false)/im,
+      );
+      if (userInvocableMatch) {
+        fallbackData["user-invocable"] =
+          userInvocableMatch[1].toLowerCase() === "true";
+      }
+
+      const disableModelMatch = rawFm.match(
+        /^disable-model-invocation:\s*(true|false)/im,
+      );
+      if (disableModelMatch) {
+        fallbackData["disable-model-invocation"] =
+          disableModelMatch[1].toLowerCase() === "true";
+      }
+
+      const toolsMatch = rawFm.match(
+        /^allowed-tools:\s*["']?([^"'\r\n]+)["']?/m,
+      );
+      if (toolsMatch) {
+        fallbackData["allowed-tools"] = toolsMatch[1].trim();
+      }
+
+      // Check for bullet list allowed-tools
+      const toolListMatch = rawFm.match(
+        /allowed-tools:\s*\n((?:\s*-\s*[^\r\n]+\r?\n?)+)/m,
+      );
+      if (toolListMatch) {
+        const tools = toolListMatch[1]
+          .split(/\r?\n/)
+          .map((l) => l.replace(/^\s*-\s*/, "").trim())
+          .filter(Boolean);
+        if (tools.length > 0) {
+          fallbackData["allowed-tools"] = tools;
+        }
+      }
+
+      return { data: fallbackData, content: rest };
+    }
+
+    return { data: {}, content: source };
+  }
+}
+
+function extractAllowedTools(raw: unknown): string | undefined {
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+  }
+  if (Array.isArray(raw)) {
+    const tools = raw
+      .filter((item): item is string => typeof item === "string")
+      .map((item) => item.trim())
+      .filter((item) => item.length > 0);
+    return tools.length > 0 ? tools.join(" ") : undefined;
+  }
+  return undefined;
+}
+
 export function parseSkill(path: string, source: string): SkillRecord {
-  const parsed = matter(source);
-  const data =
-    parsed.data && typeof parsed.data === "object" ? parsed.data : {};
+  const parsed = parseFrontmatterResiliently(source);
+  const data = parsed.data;
   const name = typeof data.name === "string" ? data.name.trim() : "";
   const description =
     typeof data.description === "string" ? data.description.trim() : "";
@@ -36,31 +171,45 @@ export function parseSkill(path: string, source: string): SkillRecord {
       ? (data.metadata as Record<string, unknown>)
       : undefined;
 
-  const metadataEntries = rawMetadata
-    ? Object.entries(rawMetadata).filter(
-        ([key, value]) =>
-          key !== "execution" && value !== null && typeof value !== "object",
-      )
-    : [];
+  const allowedToolsRaw =
+    extractAllowedTools(rawMetadata?.["allowed-tools"]) ||
+    extractAllowedTools(rawMetadata?.["allowedTools"]) ||
+    extractAllowedTools(data["allowed-tools"]) ||
+    extractAllowedTools(data["allowedTools"]);
+
+  const metadataEntries: [string, string][] = [];
+  if (rawMetadata) {
+    for (const [key, value] of Object.entries(rawMetadata)) {
+      if (key === "execution" || value === null || value === undefined) {
+        continue;
+      }
+      if (key === "allowed-tools" || key === "allowedTools") {
+        if (allowedToolsRaw) {
+          metadataEntries.push([key, allowedToolsRaw]);
+        }
+      } else if (
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean"
+      ) {
+        metadataEntries.push([key, String(value)]);
+      } else if (Array.isArray(value)) {
+        const stringItems = value
+          .filter((item): item is string => typeof item === "string")
+          .map((item) => item.trim())
+          .filter(Boolean);
+        if (stringItems.length > 0) {
+          metadataEntries.push([key, stringItems.join(" ")]);
+        }
+      }
+    }
+  }
 
   const metadata =
     metadataEntries.length > 0
-      ? Object.fromEntries(
-          metadataEntries.map(([key, value]) => [key, String(value)]),
-        )
+      ? Object.fromEntries(metadataEntries)
       : undefined;
 
-  const allowedToolsRaw =
-    (rawMetadata &&
-      (typeof rawMetadata["allowed-tools"] === "string"
-        ? rawMetadata["allowed-tools"]
-        : typeof rawMetadata["allowedTools"] === "string"
-          ? rawMetadata["allowedTools"]
-          : undefined)) ||
-    (typeof data["allowed-tools"] === "string"
-      ? data["allowed-tools"]
-      : undefined);
-
   const execution = rawMetadata?.execution;
 
   let parsedExecution;
@@ -119,10 +268,21 @@ export function parseSkill(path: string, source: string): SkillRecord {
       : {}),
     ...(typeof data["user-invocable"] === "boolean"
       ? { userInvocable: data["user-invocable"] }
-      : {}),
+      : typeof data["user-invocable"] === "string" &&
+          (data["user-invocable"].toLowerCase() === "true" ||
+            data["user-invocable"].toLowerCase() === "false")
+        ? { userInvocable: data["user-invocable"].toLowerCase() === "true" }
+        : {}),
     ...(typeof data["disable-model-invocation"] === "boolean"
       ? { disableModelInvocation: data["disable-model-invocation"] }
-      : {}),
+      : typeof data["disable-model-invocation"] === "string" &&
+          (data["disable-model-invocation"].toLowerCase() === "true" ||
+            data["disable-model-invocation"].toLowerCase() === "false")
+        ? {
+            disableModelInvocation:
+              data["disable-model-invocation"].toLowerCase() === "true",
+          }
+        : {}),
     ...(parsedExecution ? { execution: parsedExecution } : {}),
     body: parsed.content.trim(),
     path,

package/src/subsystems/tools/files.ts

@@ -278,10 +278,10 @@ export const search_files: ToolDefinition = {
 export const send_file: ToolDefinition = {
   name: "send_file",
   description:
-    "Send a workspace file directly to the current peer over the P2P (PeerJS/WebRTC) data channel. " +
-    "Use this when the user is in a peer conversation and explicitly asks to send or transfer a file to their peer. " +
-    "Do NOT use this for local-browser or non-peer conversations — it only works when the active conversation " +
-    "is a peer: group. The file is read from the current group workspace and transferred in binary chunks " +
+    "Send a workspace file directly to connected peer(s) over the P2P (PeerJS/WebRTC) data channel. " +
+    "Use this when the user is in a peer conversation or room and asks to send or transfer a file. " +
+    "Do NOT use this for local-browser or other non-peer conversations — it only works when the active conversation " +
+    "is a peer or room session (peer: or room: group). The file is read from the current group workspace and transferred in binary chunks " +
     "so there is no size limit.",
   input_schema: {
     type: "object",

package/src/worker/tools/spawn-subagent/spawn-subagent.test.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { jest } from "@jest/globals";
 
 describe("executeSpawnSubagentTool", () => {
@@ -131,7 +130,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("calls handleInvoke with a subagent groupId starting with 'subagent:'", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       // Simulate the subagent posting a response message
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
@@ -161,7 +160,7 @@ describe("executeSpawnSubagentTool", () => {
   it("uses a unique ulid for subagent groupId", async () => {
     mockUlid.mockReturnValueOnce("ulid-aaa").mockReturnValueOnce("ulid-bbb");
 
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -186,7 +185,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("excludes spawn_subagent from the subagent's tool list to prevent recursion", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -212,7 +211,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("uses the provided tools list when specified in input", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -238,7 +237,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("in manual mode, overrides model when specified as pinned model", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -267,7 +266,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("in automatic mode, ignores LLM-emitted model and falls back to parent ctx model", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -299,7 +298,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("clamps subagent max tokens by selected model limit", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -329,7 +328,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("uses conversation subagent max tokens override but keeps model-safe clamp", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -360,7 +359,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("uses the selected subagent model limit when auto max tokens is enabled", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -391,7 +390,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("in manual mode, overrides provider to a different provider with its api key", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -421,7 +420,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("in automatic mode, ignores LLM-emitted provider and falls back to parent ctx provider", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -452,7 +451,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("in automatic mode, maps profile 'fast', 'smart', 'powerful' to their configured provider/model", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -507,7 +506,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("in automatic mode, falls back to parent model/provider if profile is not configured or current", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -552,7 +551,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("in manual mode, ignores profile selection and uses pinned model/provider", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -609,7 +608,7 @@ describe("executeSpawnSubagentTool", () => {
       return undefined;
     });
 
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -642,7 +641,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("forwards storageHandle from parent context", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -679,7 +678,7 @@ describe("executeSpawnSubagentTool", () => {
       return undefined;
     });
 
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -716,7 +715,7 @@ describe("executeSpawnSubagentTool", () => {
       return undefined;
     });
 
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -754,7 +753,7 @@ describe("executeSpawnSubagentTool", () => {
     });
 
     mockUlid.mockReturnValueOnce("iso-123");
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -779,7 +778,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("uses conversation-level manual subagent provider/model defaults when tool input omits them", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -809,7 +808,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("manual subagent defaults override per-tool provider/model inputs", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {
@@ -947,7 +946,7 @@ describe("executeSpawnSubagentTool", () => {
   });
 
   it("overrides system_prompt when specified", async () => {
-    mockHandleInvoke.mockImplementation((_db: any, payload: any) => {
+    mockHandleInvoke.mockImplementation((_db: any, _payload: any) => {
       const collectors = mockRegisterSubagentCollector.mock.calls;
       const lastCall = collectors[collectors.length - 1];
       if (lastCall) {