@narumitw/pi-subagents 3.0.2 → 3.1.1

package/src/runtime.ts

@@ -3,6 +3,7 @@ import { COMPLETION_MESSAGE_TYPE } from "./completion-renderer.js";
 import { type BrokerSendAcknowledgement, type MessageBroker, sanitizeTerminalText } from "./message-broker.js";
 import { modelVisibleJson, requireBoundedModelText } from "./model-output.js";
 import { runChild as defaultRunChild } from "./process.js";
+import type { ExtensionAttachment } from "./resource-attachments.js";
 import {
   type ChildControl,
   type ChildRequest,
@@ -56,6 +57,9 @@ export interface ActiveJobDisplay {
 export interface StartJobInput {
   task: string;
   tools: string[];
+  skills: string[];
+  extensions: ExtensionAttachment[];
+  toolSources: Record<string, string[]>;
   model: string;
   thinkingLevel: SubagentThinkingLevel;
   cwd: string;
@@ -93,6 +97,10 @@ export class SubagentRuntime {
     this.notifyJobsChanged();
   }
 
+  getSessionGeneration(): number {
+    return this.generation;
+  }
+
   subscribeJobs(listener: () => void): () => void {
     this.jobListeners.add(listener);
     return () => this.jobListeners.delete(listener);
@@ -139,13 +147,14 @@ export class SubagentRuntime {
     });
     void controlReady.catch(() => undefined);
     const controller = new AbortController();
+    const effectiveTools = [...new Set([...input.tools, ...input.extensions.flatMap((extension) => extension.tools)])];
     const job: InternalJob = {
       jobId,
       state: "queued",
       createdAt: this.now(),
       ...(input.timeout !== undefined ? { timeout: input.timeout } : {}),
       controller,
-      tools: [...input.tools],
+      tools: effectiveTools,
       terminal,
       resolveTerminal,
       controlReady,
@@ -172,6 +181,14 @@ export class SubagentRuntime {
         child = await this.runChild({
           task: input.task,
           tools: [...input.tools],
+          skills: [...input.skills],
+          extensions: input.extensions.map((extension) => ({
+            path: extension.path,
+            tools: [...extension.tools],
+          })),
+          toolSources: Object.fromEntries(
+            Object.entries(input.toolSources).map(([tool, sources]) => [tool, [...sources]]),
+          ),
           model: input.model,
           thinkingLevel: input.thinkingLevel,
           cwd: input.cwd,

package/src/skill-attachments.ts

@@ -0,0 +1,302 @@
+import { type Dirent, statSync } from "node:fs";
+import { opendir as opendirAsync, realpath as realpathAsync, stat as statAsync } from "node:fs/promises";
+import * as path from "node:path";
+import { loadSkills } from "@earendil-works/pi-coding-agent";
+import ignore from "ignore";
+import {
+  addAttachmentIgnoreRules,
+  type IgnoreMatcher,
+  isAbortError,
+  isWithin,
+  realpath,
+  throwIfAttachmentAborted,
+  toPosixPath,
+} from "./attachment-utils.js";
+
+export const MAX_SKILL_SCAN_DEPTH = 32;
+export const MAX_SKILL_SCAN_ENTRIES = 4_096;
+export const MAX_SKILL_SCAN_BYTES = 4 * 1024 * 1024;
+export const MAX_SKILL_IGNORE_BYTES = 1024 * 1024;
+
+export async function assertLoadableSkills(
+  skillPaths: string[],
+  cwd: string,
+  canonicalCwd: string,
+  projectTrusted: boolean,
+  signal?: AbortSignal,
+): Promise<SkillScanState> {
+  const scanState: SkillScanState = {
+    entries: 0,
+    skillBytes: 0,
+    ignoreBytes: 0,
+    ancestors: new Set<string>(),
+    signal,
+  };
+  for (const skillPath of skillPaths) {
+    throwIfAttachmentAborted(signal);
+    const candidates = await collectBoundedSkillCandidates(skillPath, scanState);
+    throwIfAttachmentAborted(signal);
+    const result = loadExplicitSkills([skillPath], cwd);
+    if (result.skills.length === 0) {
+      throw new Error("Subagent skill path must contain at least one loadable Pi skill.");
+    }
+    assertNoUntrustedProjectSkills(result, cwd, canonicalCwd, projectTrusted);
+    assertNoOmittedSkillDiagnostics(result);
+    assertNoSkillNameCollisions(result.diagnostics);
+    await assertNoSilentlyOmittedSkills(skillPath, cwd, result, canonicalCwd, projectTrusted, candidates, signal);
+  }
+  if (skillPaths.length > 1) {
+    throwIfAttachmentAborted(signal);
+    const result = loadExplicitSkills(skillPaths, cwd);
+    assertNoUntrustedProjectSkills(result, cwd, canonicalCwd, projectTrusted);
+    assertNoSkillNameCollisions(result.diagnostics);
+  }
+  return scanState;
+}
+
+function loadExplicitSkills(skillPaths: string[], cwd: string): ReturnType<typeof loadSkills> {
+  return loadSkills({ cwd, agentDir: cwd, skillPaths, includeDefaults: false });
+}
+
+function assertNoOmittedSkillDiagnostics(result: ReturnType<typeof loadSkills>): void {
+  const loadedPaths = new Set(result.skills.map((skill) => skill.filePath));
+  const omitted = result.diagnostics.some(
+    (diagnostic) =>
+      diagnostic.type === "error" ||
+      (diagnostic.type === "warning" && (!diagnostic.path || !loadedPaths.has(diagnostic.path))),
+  );
+  if (omitted) {
+    throw new Error("Subagent skill attachment must not contain an invalid or unreadable declared skill.");
+  }
+}
+
+function assertNoSkillNameCollisions(diagnostics: ReturnType<typeof loadSkills>["diagnostics"]): void {
+  if (
+    diagnostics.some((diagnostic) => diagnostic.type === "collision" && diagnostic.collision?.resourceType === "skill")
+  ) {
+    throw new Error("Subagent skill attachments must not contain duplicate skill names.");
+  }
+}
+
+function assertNoUntrustedProjectSkills(
+  result: ReturnType<typeof loadSkills>,
+  cwd: string,
+  canonicalCwd: string,
+  projectTrusted: boolean,
+): void {
+  if (projectTrusted) return;
+  for (const skill of result.skills) {
+    const lexicalPath = path.resolve(skill.filePath);
+    const canonicalPath = realpath(skill.filePath, "Loaded subagent skill");
+    if (isWithin(cwd, lexicalPath) || isWithin(canonicalCwd, canonicalPath)) {
+      throw new Error("Subagent skill cannot load a project path because the project is not trusted.");
+    }
+  }
+}
+
+async function assertNoSilentlyOmittedSkills(
+  skillPath: string,
+  cwd: string,
+  result: ReturnType<typeof loadSkills>,
+  canonicalCwd: string,
+  projectTrusted: boolean,
+  candidates: string[],
+  signal?: AbortSignal,
+): Promise<void> {
+  if (!statSync(skillPath).isDirectory()) return;
+  const loadedPaths = new Set(result.skills.map((skill) => realpath(skill.filePath, "Loaded subagent skill")));
+  for (const [index, candidate] of candidates.entries()) {
+    if (index > 0 && index % 64 === 0) await new Promise<void>((resolve) => setImmediate(resolve));
+    throwIfAttachmentAborted(signal);
+    const candidateResult = loadExplicitSkills([candidate], cwd);
+    assertNoUntrustedProjectSkills(candidateResult, cwd, canonicalCwd, projectTrusted);
+    if (candidateResult.skills.length === 0) {
+      if (path.basename(candidate) === "SKILL.md") throwInvalidDeclaredSkill();
+      continue;
+    }
+    const loaded = candidateResult.skills.some((skill) =>
+      loadedPaths.has(realpath(skill.filePath, "Loaded subagent skill")),
+    );
+    if (!loaded) throwInvalidDeclaredSkill();
+  }
+}
+
+interface SkillScanState {
+  entries: number;
+  skillBytes: number;
+  ignoreBytes: number;
+  ancestors: Set<string>;
+  signal?: AbortSignal;
+}
+
+async function collectBoundedSkillCandidates(skillPath: string, state: SkillScanState): Promise<string[]> {
+  throwIfAttachmentAborted(state.signal);
+  const stats = await statAsync(skillPath);
+  throwIfAttachmentAborted(state.signal);
+  if (!stats.isDirectory()) {
+    if (stats.isFile() && skillPath.endsWith(".md")) addSkillBytes(state, stats.size);
+    return [];
+  }
+  return collectSkillCandidates(skillPath, true, ignore(), skillPath, 0, state);
+}
+
+async function collectSkillCandidates(
+  directory: string,
+  includeRootMarkdown: boolean,
+  ignoreMatcher: IgnoreMatcher,
+  rootDirectory: string,
+  depth: number,
+  state: SkillScanState,
+): Promise<string[]> {
+  throwIfAttachmentAborted(state.signal);
+  if (depth > MAX_SKILL_SCAN_DEPTH) throwSkillScanLimit();
+  let canonicalDirectory: string;
+  try {
+    canonicalDirectory = await realpathAsync(directory);
+  } catch {
+    throwInvalidDeclaredSkill();
+  }
+  throwIfAttachmentAborted(state.signal);
+  if (state.ancestors.has(canonicalDirectory)) {
+    throw new Error("Subagent skill attachment must not contain a recursive directory link.");
+  }
+  state.ancestors.add(canonicalDirectory);
+  try {
+    await addAttachmentIgnoreRules(ignoreMatcher, directory, rootDirectory, state.signal, (_ignorePath, bytes) => {
+      state.ignoreBytes += bytes;
+      if (state.ignoreBytes > MAX_SKILL_IGNORE_BYTES) throwSkillScanLimit();
+    });
+    let directoryHandle: Awaited<ReturnType<typeof opendirAsync>>;
+    try {
+      directoryHandle = await opendirAsync(directory);
+    } catch {
+      throwInvalidDeclaredSkill();
+    }
+    const entries: Dirent[] = [];
+    try {
+      for await (const entry of directoryHandle) {
+        throwIfAttachmentAborted(state.signal);
+        state.entries++;
+        if (state.entries > MAX_SKILL_SCAN_ENTRIES) throwSkillScanLimit();
+        entries.push(entry);
+      }
+    } catch (error) {
+      if (isAbortError(error) || isSkillScanLimitError(error)) throw error;
+      throwInvalidDeclaredSkill();
+    }
+
+    const rootSkill = entries.find((entry) => entry.name === "SKILL.md");
+    if (rootSkill) {
+      const rootPath = path.join(directory, rootSkill.name);
+      const relativePath = toPosixPath(path.relative(rootDirectory, rootPath));
+      if (!ignoreMatcher.ignores(relativePath)) {
+        let rootStats: Awaited<ReturnType<typeof statAsync>>;
+        try {
+          rootStats = await statAsync(rootPath);
+        } catch (error) {
+          if (isAbortError(error)) throw error;
+          throwInvalidDeclaredSkill();
+        }
+        throwIfAttachmentAborted(state.signal);
+        if (rootStats.isFile()) {
+          addSkillBytes(state, rootStats.size);
+          return [rootPath];
+        }
+      }
+    }
+
+    const candidates: string[] = [];
+    for (const entry of entries) {
+      throwIfAttachmentAborted(state.signal);
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const candidate = path.join(directory, entry.name);
+      const relativePath = toPosixPath(path.relative(rootDirectory, candidate));
+      let candidateStats: Awaited<ReturnType<typeof statAsync>>;
+      try {
+        candidateStats = await statAsync(candidate);
+      } catch (error) {
+        if (isAbortError(error)) throw error;
+        throwIfAttachmentAborted(state.signal);
+        if (
+          !ignoreMatcher.ignores(relativePath) &&
+          (entry.name === "SKILL.md" || (includeRootMarkdown && entry.name.endsWith(".md")))
+        ) {
+          throwInvalidDeclaredSkill();
+        }
+        continue;
+      }
+      throwIfAttachmentAborted(state.signal);
+      if (ignoreMatcher.ignores(candidateStats.isDirectory() ? `${relativePath}/` : relativePath)) continue;
+      if (candidateStats.isDirectory()) {
+        candidates.push(
+          ...(await collectSkillCandidates(candidate, false, ignoreMatcher, rootDirectory, depth + 1, state)),
+        );
+      } else if (
+        candidateStats.isFile() &&
+        (entry.name === "SKILL.md" || (includeRootMarkdown && entry.name.endsWith(".md")))
+      ) {
+        addSkillBytes(state, candidateStats.size);
+        candidates.push(candidate);
+      }
+    }
+    return candidates;
+  } finally {
+    state.ancestors.delete(canonicalDirectory);
+  }
+}
+
+function addSkillBytes(state: SkillScanState, bytes: number): void {
+  state.skillBytes += bytes;
+  if (state.skillBytes > MAX_SKILL_SCAN_BYTES) throwSkillScanLimit();
+}
+
+function isSkillScanLimitError(error: unknown): boolean {
+  return error instanceof Error && error.name === "SkillScanLimitError";
+}
+
+function throwSkillScanLimit(): never {
+  const error = new Error(
+    `Subagent skill attachment exceeds traversal limits (${MAX_SKILL_SCAN_ENTRIES} entries, depth ${MAX_SKILL_SCAN_DEPTH}, ${MAX_SKILL_SCAN_BYTES} skill bytes, or ${MAX_SKILL_IGNORE_BYTES} ignore bytes).`,
+  );
+  error.name = "SkillScanLimitError";
+  throw error;
+}
+
+function throwInvalidDeclaredSkill(): never {
+  throw new Error("Subagent skill attachment must not contain an invalid or unreadable declared skill.");
+}
+
+export async function assertLoadablePackageSkills(
+  packageSkillPaths: string[],
+  explicitSkillPaths: string[],
+  cwd: string,
+  scanState: SkillScanState,
+): Promise<void> {
+  const uniquePackageSkillPaths = deduplicatePackageSkillPaths(packageSkillPaths, explicitSkillPaths);
+  for (const [index, skillPath] of uniquePackageSkillPaths.entries()) {
+    if (index > 0 && index % 64 === 0) await new Promise<void>((resolve) => setImmediate(resolve));
+    throwIfAttachmentAborted(scanState.signal);
+    await collectBoundedSkillCandidates(skillPath, scanState);
+  }
+  for (const [index, skillPath] of uniquePackageSkillPaths.entries()) {
+    if (index > 0 && index % 64 === 0) await new Promise<void>((resolve) => setImmediate(resolve));
+    throwIfAttachmentAborted(scanState.signal);
+    const result = loadExplicitSkills([skillPath], cwd);
+    if (result.skills.length === 0) throwInvalidDeclaredSkill();
+    assertNoOmittedSkillDiagnostics(result);
+  }
+  throwIfAttachmentAborted(scanState.signal);
+  assertNoSkillNameCollisions(loadExplicitSkills([...uniquePackageSkillPaths, ...explicitSkillPaths], cwd).diagnostics);
+}
+
+function deduplicatePackageSkillPaths(packageSkillPaths: string[], explicitSkillPaths: string[]): string[] {
+  const seenPaths = new Set(explicitSkillPaths.map((skillPath) => realpath(skillPath, "Loaded subagent skill")));
+  const uniquePaths: string[] = [];
+  for (const skillPath of packageSkillPaths) {
+    const canonicalPath = realpath(skillPath, "Loaded subagent package skill");
+    if (seenPaths.has(canonicalPath)) continue;
+    seenPaths.add(canonicalPath);
+    uniquePaths.push(skillPath);
+  }
+  return uniquePaths;
+}

package/src/timeout.ts

@@ -0,0 +1,24 @@
+const MAX_TIMEOUT_MS = 2_147_483_647;
+const MAX_TIMEOUT_SECONDS = MAX_TIMEOUT_MS / 1000;
+
+export function resolveTimeoutMs(timeout: number | undefined): number | undefined {
+  if (timeout === undefined) return undefined;
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    throw new Error("Invalid timeout: must be a finite number of seconds");
+  }
+  const timeoutMs = timeout * 1000;
+  if (timeoutMs > MAX_TIMEOUT_MS) {
+    throw new Error(`Invalid timeout: maximum is ${MAX_TIMEOUT_SECONDS} seconds`);
+  }
+  return timeoutMs;
+}
+
+export function prepareTimeoutArguments(args: unknown): Record<string, unknown> {
+  if (!args || typeof args !== "object") return args as Record<string, unknown>;
+  if (!Object.hasOwn(args, "timeoutMs")) return args as Record<string, unknown>;
+  const record = args as Record<string, unknown>;
+  if (typeof record.timeoutMs !== "number") return record;
+  const { timeoutMs, ...prepared } = record;
+  if (prepared.timeout === undefined) return { ...prepared, timeout: timeoutMs / 1000 };
+  return prepared;
+}

package/src/tools.ts

@@ -1,6 +1,8 @@
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
+import { assertChildBootstrapCapacity } from "./broker-credentials.js";
+import { CHILD_COMMUNICATION_TOOL_NAMES } from "./child-communication-tools.js";
 import {
   type BrokerInboundMessage,
   MAX_IDENTIFIER_LENGTH,
@@ -10,8 +12,17 @@ import {
   validateMessage,
 } from "./message-broker.js";
 import { modelVisibleJson, requireBoundedModelText } from "./model-output.js";
-import { resolveTimeoutMs } from "./process.js";
+import { assertChildCommandCapacity } from "./process.js";
+import {
+  MAX_ATTACHED_EXTENSIONS,
+  MAX_ATTACHED_SKILLS,
+  MAX_EXTENSION_TOOL_NAME_LENGTH,
+  MAX_RESOURCE_PATH_BYTES,
+  MAX_SELECTED_TOOLS,
+  resolveResourceAttachments,
+} from "./resource-attachments.js";
 import { type RuntimeDependencies, SubagentRuntime } from "./runtime.js";
+import { prepareTimeoutArguments, resolveTimeoutMs } from "./timeout.js";
 import {
   CHILD_CORE_TOOL_NAMES,
   DEFAULT_SUBAGENT_TOOLS,
@@ -20,7 +31,7 @@ import {
 } from "./types.js";
 
 const MAX_TASK_BYTES = 50 * 1024;
-const MAX_TOOLS = 64;
+const MAX_TOOLS = MAX_SELECTED_TOOLS;
 const MESSAGE_TYPE = "pi-subagents-message";
 const CHILD_CORE_TOOL_SET = new Set<string>(CHILD_CORE_TOOL_NAMES);
 const THINKING_LEVEL_SET = new Set<string>(SUBAGENT_THINKING_LEVELS);
@@ -42,6 +53,50 @@ const SpawnParameters = Type.Object(
         },
       ),
     ),
+    skills: Type.Optional(
+      Type.Array(
+        Type.String({
+          description:
+            "Local Markdown skill file or directory whose declared Pi skills all load and have names unique across attachments, resolved from the child working directory.",
+          minLength: 1,
+          maxLength: MAX_RESOURCE_PATH_BYTES,
+        }),
+        {
+          description: "Explicit local skills available to the child. Automatic skill discovery stays disabled.",
+          maxItems: MAX_ATTACHED_SKILLS,
+        },
+      ),
+    ),
+    extensions: Type.Optional(
+      Type.Array(
+        Type.Object(
+          {
+            path: Type.String({
+              description: "Local extension file or directory path, resolved from the child working directory.",
+              minLength: 1,
+              maxLength: MAX_RESOURCE_PATH_BYTES,
+            }),
+            tools: Type.Array(
+              Type.String({
+                description: "Exact extension-specific tool name to activate initially; built-in names are rejected.",
+                minLength: 1,
+                maxLength: MAX_EXTENSION_TOOL_NAME_LENGTH,
+              }),
+              {
+                description:
+                  "Extension tools to activate. Use an empty list for lifecycle or provider behavior only. All child tool names share a 16 KiB startup bootstrap.",
+                maxItems: MAX_SELECTED_TOOLS,
+              },
+            ),
+          },
+          { additionalProperties: false },
+        ),
+        {
+          description: "Explicit trusted local extensions loaded in the isolated child process.",
+          maxItems: MAX_ATTACHED_EXTENSIONS,
+        },
+      ),
+    ),
     thinkingLevel: Type.Optional(
       StringEnum(SUBAGENT_THINKING_LEVELS, {
         description: "Child thinking level. Defaults to the main agent's effective level.",
@@ -109,6 +164,7 @@ type MainSendSelection =
 
 export interface SubagentToolsDependencies extends RuntimeDependencies {
   createBroker?: (onMessage: (message: BrokerInboundMessage) => void) => MessageBroker;
+  platform?: NodeJS.Platform;
 }
 
 export interface RegisteredSubagentTools {
@@ -130,7 +186,7 @@ export function registerSubagentTools(
     name: "subagent_spawn",
     label: "Subagent · Spawn",
     description:
-      "Use subagent_spawn to start one Pi subagent job and return its jobId immediately. The task defines the child's specialization, and the selected tools define its capabilities. The job may ask the main agent questions and publishes one asynchronous completion when terminal.",
+      "Use subagent_spawn to start one Pi subagent job and return its jobId immediately. The task defines the child's specialization; selected core tools and explicit trusted local skills or extensions define its initial capabilities. The job may ask the main agent questions and publishes one asynchronous completion when terminal.",
     promptSnippet: "Use subagent_spawn to start one Pi subagent job",
     parameters: SpawnParameters,
     prepareArguments: prepareSpawnArguments,
@@ -139,18 +195,50 @@ export function registerSubagentTools(
       assertNotNested();
       const task = validateTask(params.task, "subagent_spawn");
       const tools = resolveTools(params.tools);
-      const model = resolveChildModel(ctx);
+      const cwd = ctx.cwd;
+      const projectTrusted = ctx.isProjectTrusted();
+      const sessionGeneration = runtime.getSessionGeneration();
+      const attachments = await resolveResourceAttachments(
+        { skills: params.skills, extensions: params.extensions },
+        { cwd, projectTrusted, coreTools: tools, signal },
+      );
+      throwIfAborted(signal, "Subagent spawn was cancelled");
+      if (runtime.getSessionGeneration() !== sessionGeneration) {
+        throw new Error("Subagent spawn session changed during attachment validation; retry the request.");
+      }
+      if (ctx.cwd !== cwd || ctx.isProjectTrusted() !== projectTrusted) {
+        throw new Error("Subagent spawn context changed during attachment validation; retry the request.");
+      }
+      if (attachments.extensions.length > 0) {
+        assertChildBootstrapCapacity([...new Set([...attachments.effectiveTools, ...CHILD_COMMUNICATION_TOOL_NAMES])]);
+      }
+      const model = resolveChildModel(ctx, attachments.extensions.length > 0);
       const thinkingLevel = resolveThinkingLevel(params.thinkingLevel ?? ctx.thinkingLevel ?? pi.getThinkingLevel());
       resolveTimeoutMs(params.timeout);
+      assertChildCommandCapacity(
+        {
+          tools,
+          skills: attachments.skills,
+          extensions: attachments.extensions,
+          model,
+          thinkingLevel,
+          projectTrusted,
+        },
+        dependencies.platform,
+      );
+      throwIfAborted(signal, "Subagent spawn was cancelled");
       return toolResult(
         runtime.start({
           task,
           tools,
+          skills: attachments.skills,
+          extensions: attachments.extensions,
+          toolSources: attachments.toolSources,
           model,
           thinkingLevel,
-          cwd: ctx.cwd,
+          cwd,
           timeout: params.timeout,
-          projectTrusted: ctx.isProjectTrusted(),
+          projectTrusted,
         }),
       );
     },
@@ -300,11 +388,11 @@ function resolveTools(value: unknown): string[] {
   return tools;
 }
 
-function resolveChildModel(ctx: ExtensionContext): string {
+function resolveChildModel(ctx: ExtensionContext, hasAttachedExtensions: boolean): string {
   const model = ctx.model;
   if (!model) throw new Error("Subagent model is unavailable because no main-agent model is selected.");
   const provider = sanitizeTerminalText(model.provider).slice(0, 128);
-  if (ctx.modelRegistry.getRegisteredProviderIds().includes(model.provider)) {
+  if (!hasAttachedExtensions && ctx.modelRegistry.getRegisteredProviderIds().includes(model.provider)) {
     throw new Error(`Subagent model provider ${provider} is unavailable because children disable parent extensions.`);
   }
   if (ctx.modelRegistry.getProviderAuthStatus(model.provider).source === "runtime") {
@@ -330,16 +418,6 @@ function prepareWaitArguments(args: unknown): WaitArguments {
   return prepareTimeoutArguments(args) as WaitArguments;
 }
 
-function prepareTimeoutArguments(args: unknown): Record<string, unknown> {
-  if (!args || typeof args !== "object") return args as Record<string, unknown>;
-  if (!Object.hasOwn(args, "timeoutMs")) return args as Record<string, unknown>;
-  const record = args as Record<string, unknown>;
-  if (typeof record.timeoutMs !== "number") return record;
-  const { timeoutMs, ...prepared } = record;
-  if (prepared.timeout === undefined) return { ...prepared, timeout: timeoutMs / 1000 };
-  return prepared;
-}
-
 function resolveMainSendArguments(params: SendArguments): MainSendSelection {
   validateMessage(params.message, "Subagent message");
   const recipient = optionalIdentifier(params.recipient, "recipient");

package/src/types.ts

@@ -1,4 +1,5 @@
 import type { ModelThinkingLevel } from "@earendil-works/pi-ai";
+import type { ExtensionAttachment } from "./resource-attachments.js";
 
 export const JOB_STATES = ["queued", "running", "completed", "partial", "failed", "timed_out", "cancelled"] as const;
 
@@ -46,6 +47,9 @@ export interface ChildControl {
 export interface ChildRequest {
   task: string;
   tools: string[];
+  skills: string[];
+  extensions: ExtensionAttachment[];
+  toolSources: Record<string, string[]>;
   model: string;
   thinkingLevel: SubagentThinkingLevel;
   cwd: string;