pi-subagents 0.80.0 → 0.82.0

package/bundle/chunk-5LFLVSTM.js

@@ -0,0 +1,260 @@
+// src/shared/types.ts
+import * as os from "node:os";
+import * as path from "node:path";
+var SUBAGENT_LIFECYCLE_ARTIFACT_VERSION = 3;
+var INTERCOM_DETACH_REQUEST_EVENT = "pi-intercom:detach-request";
+var INTERCOM_DETACH_RESPONSE_EVENT = "pi-intercom:detach-response";
+var INTERCOM_SESSION_IDENTITY_EVENT = "intercom:session-identity";
+var SUBAGENT_ASYNC_STARTED_EVENT = "subagent:async-started";
+var RUNNER_LAUNCHER_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+var RUNNER_LAUNCHER_NAME_RULE = "must start with a letter or digit and use only letters, digits, '.', '_' or '-' (at most 128 characters)";
+var SUBAGENT_ASYNC_COMPLETE_EVENT = "subagent:async-complete";
+var SUBAGENT_PROCESS_TERMINAL_EVENT = "subagent:process-terminal";
+var SUBAGENT_FOREGROUND_COMPLETE_EVENT = "subagent:foreground-complete";
+var SUBAGENT_CONTROL_EVENT = "subagent:control-event";
+var SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
+var SUBAGENT_STEERING_NOTICE_EVENT = "subagent:steering-notice";
+var SUBAGENT_CHILD_STATUS_EVENT = "subagent:child-status";
+var SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
+var SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
+var FLEET_KEYBINDING_ACTIONS = [
+  "close",
+  "scrollUp",
+  "scrollDown",
+  "selectUp",
+  "selectDown",
+  "selectFirst",
+  "selectLast",
+  "pageUp",
+  "pageDown",
+  "refresh",
+  "steer",
+  "inspect",
+  "stop",
+  "toggleTools"
+];
+var DEFAULT_MAX_OUTPUT = {
+  bytes: 200 * 1024,
+  lines: 5e3
+};
+var DEFAULT_ARTIFACT_CONFIG = {
+  enabled: true,
+  dir: "session",
+  includeInput: true,
+  includeOutput: true,
+  includeJsonl: false,
+  includeTranscript: true,
+  includeMetadata: true,
+  cleanupDays: 7
+};
+function sanitizeTempScopeSegment(value) {
+  const sanitized = value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized || "unknown";
+}
+function resolveTempScopeId(options) {
+  const env = options?.env ?? process.env;
+  const getuid = options && Object.hasOwn(options, "getuid") ? options.getuid : process.getuid?.bind(process);
+  if (typeof getuid === "function") {
+    return `uid-${getuid()}`;
+  }
+  for (const key of ["USERNAME", "USER", "LOGNAME"]) {
+    const value = env[key];
+    if (value) return `user-${sanitizeTempScopeSegment(value)}`;
+  }
+  const userInfo2 = options && Object.hasOwn(options, "userInfo") ? options.userInfo : os.userInfo;
+  try {
+    const username = userInfo2?.().username;
+    if (username) return `user-${sanitizeTempScopeSegment(username)}`;
+  } catch {
+  }
+  const homedir2 = env.USERPROFILE ?? env.HOME;
+  if (homedir2) return `home-${sanitizeTempScopeSegment(homedir2)}`;
+  const resolveHomedir = options && Object.hasOwn(options, "homedir") ? options.homedir : os.homedir;
+  try {
+    const fallbackHomedir = resolveHomedir?.();
+    if (fallbackHomedir) return `home-${sanitizeTempScopeSegment(fallbackHomedir)}`;
+  } catch {
+  }
+  return "shared";
+}
+var configuredTempRoot = process.env.PI_SUBAGENTS_TEMP_ROOT?.trim();
+var TEMP_ROOT_DIR = configuredTempRoot ? path.resolve(configuredTempRoot) : path.join(os.tmpdir(), `pi-subagents-${resolveTempScopeId()}`);
+var RESULTS_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-results");
+var ASYNC_DIR = path.join(TEMP_ROOT_DIR, "async-subagent-runs");
+var CHAIN_RUNS_DIR = path.join(TEMP_ROOT_DIR, "chain-runs");
+var TEMP_ARTIFACTS_DIR = path.join(TEMP_ROOT_DIR, "artifacts");
+var DIRS = {
+  results: RESULTS_DIR,
+  async: ASYNC_DIR,
+  chain: CHAIN_RUNS_DIR,
+  artifacts: TEMP_ARTIFACTS_DIR
+};
+var WIDGET_KEY = "subagent-async";
+var SLASH_RESULT_TYPE = "subagent-slash-result";
+var SLASH_TEXT_RESULT_TYPE = "subagent-slash-text-result";
+var SLASH_TEXT_VIEW_ONLY_DETAILS = { viewOnly: true };
+var SLASH_SUBAGENT_REQUEST_EVENT = "subagent:slash:request";
+var SLASH_SUBAGENT_STARTED_EVENT = "subagent:slash:started";
+var SLASH_SUBAGENT_RESPONSE_EVENT = "subagent:slash:response";
+var SLASH_SUBAGENT_UPDATE_EVENT = "subagent:slash:update";
+var SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel";
+var POLL_INTERVAL_MS = 250;
+var WIDGET_ANIMATION_INTERVAL_MS = 1e3;
+var MAX_WIDGET_JOBS = 4;
+var DEFAULT_SUBAGENT_MAX_DEPTH = 2;
+var SUBAGENT_ACTIONS = ["list", "get", "models", "children.list", "guide", "validate", "create", "update", "delete", "eject", "disable", "enable", "reset", "mission.create", "mission.list", "mission.show", "mission.update", "mission.resolve-decision", "mission.attach-run", "mission.close", "worktree.discard", "worktree.cleanup", "lane.status", "lane.recordMerge", "lane.recordSupersession", "refine", "refine.show", "refine.rollback", "inspector.open", "inspector.command", "inspector.status", "inspector.close", "project.open", "project.status", "project.close", "status", "debug.run", "grant-spawn-budget", "interrupt", "resume", "steer", "stop", "command.status", "command.yield", "command.cancel", "dismiss", "doctor", "watchdog.status", "watchdog.check", "watchdog.configure", "watchdog.recommend-model", "schedule.create", "schedule.list", "schedule.show", "schedule.history", "schedule.pause", "schedule.resume", "schedule.run", "schedule.run-due", "schedule.delete"];
+var DEFAULT_FORK_PREAMBLE = "You are a delegated subagent running from a fork of the parent session. Treat the inherited conversation as reference-only context, not a live thread to continue. Do not continue or answer prior messages as if they are waiting for a reply. Your sole job is to execute the task below and return a focused result for that task using your tools.";
+function getAsyncConfigPath(suffix) {
+  return path.join(TEMP_ROOT_DIR, `async-cfg-${suffix}.json`);
+}
+function wrapForkTask(task, preamble) {
+  if (preamble === false) return task;
+  const effectivePreamble = preamble ?? DEFAULT_FORK_PREAMBLE;
+  const wrappedPrefix = `${effectivePreamble}
+
+Task:
+`;
+  if (task.startsWith(wrappedPrefix)) return task;
+  return `${wrappedPrefix}${task}`;
+}
+function normalizeNonNegativeInteger(value) {
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+  if (!Number.isInteger(parsed) || parsed < 0) return void 0;
+  return parsed;
+}
+function normalizeMaxSubagentDepth(value) {
+  return normalizeNonNegativeInteger(value);
+}
+var SUBAGENT_MAX_DEPTH_ENV = "PI_SUBAGENT_MAX_DEPTH";
+function resolveCurrentMaxSubagentDepth(configMaxDepth, runtime) {
+  return normalizeMaxSubagentDepth(runtime ? runtime.maxDepth : process.env[SUBAGENT_MAX_DEPTH_ENV]) ?? normalizeMaxSubagentDepth(configMaxDepth) ?? DEFAULT_SUBAGENT_MAX_DEPTH;
+}
+function resolveChildMaxSubagentDepth(parentMaxDepth, agentMaxDepth) {
+  const normalizedParent = normalizeMaxSubagentDepth(parentMaxDepth) ?? DEFAULT_SUBAGENT_MAX_DEPTH;
+  const normalizedAgent = normalizeMaxSubagentDepth(agentMaxDepth);
+  return normalizedAgent === void 0 ? normalizedParent : Math.min(normalizedParent, normalizedAgent);
+}
+function resolveCurrentSubagentDepth(runtime) {
+  const depth = runtime ? runtime.depth : 0;
+  return Number.isFinite(depth) ? depth : 0;
+}
+function checkSubagentDepth(configMaxDepth, runtime) {
+  const depth = resolveCurrentSubagentDepth(runtime);
+  const maxDepth = resolveCurrentMaxSubagentDepth(configMaxDepth, runtime);
+  const blocked = depth >= maxDepth;
+  return { blocked, depth, maxDepth };
+}
+function resolveChildDepth(maxDepth, runtime) {
+  return {
+    depth: resolveCurrentSubagentDepth(runtime) + 1,
+    maxDepth: normalizeMaxSubagentDepth(maxDepth) ?? resolveCurrentMaxSubagentDepth(void 0, runtime)
+  };
+}
+function normalizeMaxSubagentSpawnsPerSession(value) {
+  return normalizeNonNegativeInteger(value);
+}
+function resolveMaxSubagentSpawnsPerSession(configMaxSpawns) {
+  const envMaxSpawns = normalizeMaxSubagentSpawnsPerSession(process.env.PI_SUBAGENT_MAX_SPAWNS_PER_SESSION);
+  if (envMaxSpawns !== void 0) return envMaxSpawns === 0 ? void 0 : envMaxSpawns;
+  const configuredMaxSpawns = normalizeMaxSubagentSpawnsPerSession(configMaxSpawns);
+  return configuredMaxSpawns === 0 ? void 0 : configuredMaxSpawns;
+}
+var DEFAULT_MAX_SUBAGENT_SPAWNS_PER_RUN = 64;
+function normalizeMaxSubagentSpawnsPerRun(value) {
+  const normalized = normalizeNonNegativeInteger(value);
+  return normalized !== void 0 && normalized > 0 ? normalized : void 0;
+}
+function resolveMaxSubagentSpawnsPerRun(configMaxSpawns) {
+  return normalizeMaxSubagentSpawnsPerRun(process.env.PI_SUBAGENT_MAX_SPAWNS_PER_RUN) ?? normalizeMaxSubagentSpawnsPerRun(configMaxSpawns) ?? DEFAULT_MAX_SUBAGENT_SPAWNS_PER_RUN;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+function truncateOutput(output, config, artifactPath) {
+  const lines = output.split("\n");
+  const bytes = Buffer.byteLength(output, "utf-8");
+  if (bytes <= config.bytes && lines.length <= config.lines) {
+    return { text: output, truncated: false };
+  }
+  let truncatedLines = lines;
+  if (lines.length > config.lines) {
+    truncatedLines = lines.slice(0, config.lines);
+  }
+  let result = truncatedLines.join("\n");
+  if (Buffer.byteLength(result, "utf-8") > config.bytes) {
+    let low = 0;
+    let high = result.length;
+    while (low < high) {
+      const mid = Math.floor((low + high + 1) / 2);
+      if (Buffer.byteLength(result.slice(0, mid), "utf-8") <= config.bytes) {
+        low = mid;
+      } else {
+        high = mid - 1;
+      }
+    }
+    result = result.slice(0, low);
+  }
+  const keptLines = result.split("\n").length;
+  const marker = `[TRUNCATED: showing first ${keptLines} of ${lines.length} lines, ${formatBytes(Buffer.byteLength(result))} of ${formatBytes(bytes)}${artifactPath ? ` - full output at ${artifactPath}` : ""}]
+`;
+  return {
+    text: marker + result,
+    truncated: true,
+    originalBytes: bytes,
+    originalLines: lines.length,
+    artifactPath
+  };
+}
+
+export {
+  SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
+  INTERCOM_DETACH_REQUEST_EVENT,
+  INTERCOM_DETACH_RESPONSE_EVENT,
+  INTERCOM_SESSION_IDENTITY_EVENT,
+  SUBAGENT_ASYNC_STARTED_EVENT,
+  RUNNER_LAUNCHER_NAME_PATTERN,
+  RUNNER_LAUNCHER_NAME_RULE,
+  SUBAGENT_ASYNC_COMPLETE_EVENT,
+  SUBAGENT_PROCESS_TERMINAL_EVENT,
+  SUBAGENT_FOREGROUND_COMPLETE_EVENT,
+  SUBAGENT_CONTROL_EVENT,
+  SUBAGENT_CONTROL_INTERCOM_EVENT,
+  SUBAGENT_STEERING_NOTICE_EVENT,
+  SUBAGENT_CHILD_STATUS_EVENT,
+  SUBAGENT_RESULT_INTERCOM_EVENT,
+  SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
+  FLEET_KEYBINDING_ACTIONS,
+  DEFAULT_MAX_OUTPUT,
+  DEFAULT_ARTIFACT_CONFIG,
+  TEMP_ROOT_DIR,
+  ASYNC_DIR,
+  CHAIN_RUNS_DIR,
+  TEMP_ARTIFACTS_DIR,
+  DIRS,
+  WIDGET_KEY,
+  SLASH_RESULT_TYPE,
+  SLASH_TEXT_RESULT_TYPE,
+  SLASH_TEXT_VIEW_ONLY_DETAILS,
+  SLASH_SUBAGENT_REQUEST_EVENT,
+  SLASH_SUBAGENT_STARTED_EVENT,
+  SLASH_SUBAGENT_RESPONSE_EVENT,
+  SLASH_SUBAGENT_UPDATE_EVENT,
+  SLASH_SUBAGENT_CANCEL_EVENT,
+  POLL_INTERVAL_MS,
+  WIDGET_ANIMATION_INTERVAL_MS,
+  MAX_WIDGET_JOBS,
+  SUBAGENT_ACTIONS,
+  DEFAULT_FORK_PREAMBLE,
+  getAsyncConfigPath,
+  wrapForkTask,
+  resolveCurrentMaxSubagentDepth,
+  resolveChildMaxSubagentDepth,
+  checkSubagentDepth,
+  resolveChildDepth,
+  resolveMaxSubagentSpawnsPerSession,
+  normalizeMaxSubagentSpawnsPerRun,
+  resolveMaxSubagentSpawnsPerRun,
+  truncateOutput
+};

package/bundle/chunk-5TYMSZX3.js

@@ -0,0 +1,235 @@
+import {
+  getAgentDir
+} from "./chunk-CIZQXJ5Q.js";
+import {
+  TEMP_ARTIFACTS_DIR
+} from "./chunk-5LFLVSTM.js";
+
+// src/shared/artifacts.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+var CLEANUP_MARKER_FILE = ".last-cleanup";
+var PROJECT_SUBAGENTS_RELATIVE_DIR = ".pi/subagents";
+var PROJECT_ARTIFACT_PATHS = [
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/output.md`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_input.md`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_output.md`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker.jsonl`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_transcript.jsonl`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/run_worker_meta.json`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/progress/run/progress.md`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/outputs/output.md`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/artifacts/outputs/run/output.md`,
+  `${PROJECT_SUBAGENTS_RELATIVE_DIR}/chain-runs/run.json`
+];
+function globMatchesPath(pattern, filePath) {
+  let expression = "^";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const character = pattern[index];
+    if (character === void 0) break;
+    if (character === "*" && pattern[index + 1] === "*") {
+      index += 1;
+      if (pattern[index + 1] === "/") {
+        index += 1;
+        expression += "(?:.*/)?";
+      } else {
+        expression += ".*";
+      }
+    } else if (character === "*") {
+      expression += "[^/]*";
+    } else if (character === "?") {
+      expression += "[^/]";
+    } else if (character === "[") {
+      const end = pattern.indexOf("]", index + 1);
+      if (end === -1) expression += "\\[";
+      else {
+        expression += pattern.slice(index, end + 1);
+        index = end;
+      }
+    } else {
+      expression += character.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    }
+  }
+  try {
+    return new RegExp(`${expression}$`).test(filePath);
+  } catch {
+    return false;
+  }
+}
+function normalizePattern(pattern) {
+  return pattern.replace(/^\.\//, "").replace(/^\//, "").replace(/\/+$/, "");
+}
+function patternMatchesArtifactPath(pattern, artifactPath) {
+  const normalized = normalizePattern(pattern);
+  return normalized === PROJECT_SUBAGENTS_RELATIVE_DIR || normalized === "*" || artifactPath.startsWith(`${normalized}/`) || globMatchesPath(normalized, artifactPath);
+}
+function ignoreFileExcludesProjectArtifacts(filePath) {
+  if (!fs.existsSync(filePath)) return false;
+  try {
+    const excluded = /* @__PURE__ */ new Set();
+    for (const rawLine of fs.readFileSync(filePath, "utf-8").split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+      const negated = line.startsWith("!");
+      const pattern = negated ? line.slice(1) : line;
+      for (const artifactPath of PROJECT_ARTIFACT_PATHS) {
+        if (!patternMatchesArtifactPath(pattern, artifactPath)) continue;
+        if (negated) excluded.delete(artifactPath);
+        else excluded.add(artifactPath);
+      }
+    }
+    return excluded.size === PROJECT_ARTIFACT_PATHS.length;
+  } catch {
+    return false;
+  }
+}
+function filesIncludeProjectArtifacts(files) {
+  if (!Array.isArray(files)) return void 0;
+  const included = /* @__PURE__ */ new Set();
+  for (const entry of files) {
+    if (typeof entry !== "string") continue;
+    const negated = entry.startsWith("!");
+    const pattern = negated ? entry.slice(1) : entry;
+    for (const artifactPath of PROJECT_ARTIFACT_PATHS) {
+      if (!patternMatchesArtifactPath(pattern, artifactPath)) continue;
+      if (negated) included.delete(artifactPath);
+      else included.add(artifactPath);
+    }
+  }
+  return included.size > 0;
+}
+function getProjectArtifactPackagingWarning(cwd) {
+  const packagePath = path.join(cwd, "package.json");
+  if (!fs.existsSync(packagePath)) return void 0;
+  let packageJson;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    packageJson = parsed;
+  } catch {
+    return void 0;
+  }
+  const filesIncludeArtifacts = filesIncludeProjectArtifacts(packageJson.files);
+  if (filesIncludeArtifacts === false) return void 0;
+  const npmIgnorePath = path.join(cwd, ".npmignore");
+  const ignorePath = fs.existsSync(npmIgnorePath) ? npmIgnorePath : path.join(cwd, ".gitignore");
+  if (filesIncludeArtifacts === void 0 && ignoreFileExcludesProjectArtifacts(ignorePath)) return void 0;
+  return "Project-scoped subagent artifacts can be included when this package is published. Add '.pi/subagents/' to .npmignore, restrict package.json files, or set artifactDir to 'session' or 'temp'.";
+}
+function getProjectSubagentsDir(cwd) {
+  return path.join(cwd, PROJECT_SUBAGENTS_RELATIVE_DIR);
+}
+function getProjectArtifactsDir(cwd) {
+  return path.join(getProjectSubagentsDir(cwd), "artifacts");
+}
+function getArtifactsDir(sessionFile, projectCwd, dirPreference = "session") {
+  switch (dirPreference) {
+    case "session":
+      if (sessionFile) {
+        const sessionDir = path.dirname(sessionFile);
+        return path.join(sessionDir, "subagent-artifacts");
+      }
+      return TEMP_ARTIFACTS_DIR;
+    case "temp":
+      return TEMP_ARTIFACTS_DIR;
+    case "project":
+      if (projectCwd) return getProjectArtifactsDir(projectCwd);
+      if (sessionFile) {
+        const sessionDir = path.dirname(sessionFile);
+        return path.join(sessionDir, "subagent-artifacts");
+      }
+      return TEMP_ARTIFACTS_DIR;
+    default:
+      throw new Error(`Unsupported artifactDir ${JSON.stringify(dirPreference)}; expected "project", "session", or "temp".`);
+  }
+}
+function getArtifactPaths(artifactsDir, runId, agent, index) {
+  const suffix = index !== void 0 ? `_${index}` : "";
+  const safeAgent = agent.replace(/[^\w.-]/g, "_");
+  const base = `${runId}_${safeAgent}${suffix}`;
+  return {
+    inputPath: path.join(artifactsDir, `${base}_input.md`),
+    outputPath: path.join(artifactsDir, `${base}_output.md`),
+    jsonlPath: path.join(artifactsDir, `${base}.jsonl`),
+    transcriptPath: path.join(artifactsDir, `${base}_transcript.jsonl`),
+    metadataPath: path.join(artifactsDir, `${base}_meta.json`)
+  };
+}
+function ensureArtifactsDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+function writeArtifact(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+function formatOutputArtifactContent(input) {
+  if (input.output.trim() || !input.error) return input.output;
+  const lines = ["Subagent run failed before producing output.", "", "Error:", input.error];
+  if (input.transcriptPath) lines.push("", `Transcript: ${input.transcriptPath}`);
+  if (input.metadataPath) lines.push(`Metadata: ${input.metadataPath}`);
+  return lines.join("\n");
+}
+function writeMetadata(filePath, metadata) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(metadata, null, 2), "utf-8");
+}
+function appendJsonl(filePath, line) {
+  fs.appendFileSync(filePath, `${line}
+`);
+}
+function cleanupOldArtifacts(dir, maxAgeDays) {
+  if (maxAgeDays <= 0 || !fs.existsSync(dir)) return;
+  const markerPath = path.join(dir, CLEANUP_MARKER_FILE);
+  const now = Date.now();
+  if (fs.existsSync(markerPath)) {
+    const stat = fs.statSync(markerPath);
+    if (now - stat.mtimeMs < 24 * 60 * 60 * 1e3) return;
+  }
+  const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1e3;
+  const cutoff = now - maxAgeMs;
+  for (const file of fs.readdirSync(dir)) {
+    if (file === CLEANUP_MARKER_FILE) continue;
+    const filePath = path.join(dir, file);
+    try {
+      const stat = fs.statSync(filePath);
+      if (stat.mtimeMs < cutoff) {
+        fs.unlinkSync(filePath);
+      }
+    } catch {
+    }
+  }
+  fs.writeFileSync(markerPath, String(now));
+}
+function cleanupAllArtifactDirs(maxAgeDays) {
+  cleanupOldArtifacts(TEMP_ARTIFACTS_DIR, maxAgeDays);
+  const sessionsBase = path.join(getAgentDir(), "sessions");
+  if (!fs.existsSync(sessionsBase)) return;
+  let dirs;
+  try {
+    dirs = fs.readdirSync(sessionsBase);
+  } catch {
+    return;
+  }
+  for (const dir of dirs) {
+    const artifactsDir = path.join(sessionsBase, dir, "subagent-artifacts");
+    try {
+      cleanupOldArtifacts(artifactsDir, maxAgeDays);
+    } catch {
+    }
+  }
+}
+
+export {
+  PROJECT_SUBAGENTS_RELATIVE_DIR,
+  getProjectArtifactPackagingWarning,
+  getProjectSubagentsDir,
+  getArtifactsDir,
+  getArtifactPaths,
+  ensureArtifactsDir,
+  writeArtifact,
+  formatOutputArtifactContent,
+  writeMetadata,
+  appendJsonl,
+  cleanupOldArtifacts,
+  cleanupAllArtifactDirs
+};

package/bundle/chunk-62OCY2S4.js

@@ -0,0 +1,14 @@
+// src/api/inspectors.ts
+var INSPECTOR_REGISTER_EVENT = "pi-subagents:inspector-register:v1";
+function registerInspector(pi, plugin) {
+  const request = { version: 1, plugin };
+  pi.events.emit(INSPECTOR_REGISTER_EVENT, request);
+  if (!request.result) throw new Error("pi-subagents is not installed, not ready, or does not support inspector registration.");
+  if (!request.result.ok) throw request.result.error;
+  return request.result.registration;
+}
+
+export {
+  INSPECTOR_REGISTER_EVENT,
+  registerInspector
+};

package/bundle/chunk-7F6RKT6W.js

@@ -0,0 +1,132 @@
+// src/shared/launch-contract.ts
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+var AGENT_DEFINITION_PROJECTION_VERSION = 2;
+var LAUNCH_BINDING_PROJECTION_VERSION = 2;
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function stableJsonDigest(value) {
+  return createHash("sha256").update(stableJson(value)).digest("hex");
+}
+function fileDigest(filePath) {
+  try {
+    return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+  } catch {
+    return void 0;
+  }
+}
+function projectAgentDefinition(agent) {
+  return {
+    version: AGENT_DEFINITION_PROJECTION_VERSION,
+    name: agent.name,
+    localName: agent.localName,
+    packageName: agent.packageName,
+    filePath: agent.filePath,
+    fileContentDigest: fileDigest(agent.filePath),
+    runner: agent.runner,
+    systemPrompt: agent.systemPrompt,
+    systemPromptMode: agent.systemPromptMode,
+    inheritProjectContext: agent.inheritProjectContext,
+    inheritGlobalContext: agent.inheritGlobalContext,
+    inheritSkills: agent.inheritSkills,
+    model: agent.model,
+    modelProvider: agent.modelProvider,
+    fast: agent.fast,
+    thinking: agent.thinking,
+    tools: agent.tools,
+    excludeTools: agent.excludeTools,
+    allowNestedSubagents: agent.allowNestedSubagents,
+    allowedAgents: agent.allowedAgents,
+    mcpDirectTools: agent.mcpDirectTools,
+    extensions: agent.extensions,
+    subagentOnlyExtensions: agent.subagentOnlyExtensions,
+    mutationTools: agent.mutationTools,
+    skills: agent.skills,
+    skillPath: agent.skillPath,
+    output: agent.output,
+    outputSchema: agent.outputSchema,
+    defaultReads: agent.defaultReads,
+    defaultProgress: agent.defaultProgress,
+    defaultContext: agent.defaultContext,
+    defaultAsync: agent.defaultAsync,
+    defaultTimeoutMs: agent.defaultTimeoutMs,
+    defaultAcceptance: agent.defaultAcceptance,
+    acceptanceRole: agent.acceptanceRole,
+    interactive: agent.interactive,
+    maxSubagentDepth: agent.maxSubagentDepth,
+    toolBudget: agent.toolBudget,
+    memory: agent.memory
+  };
+}
+function agentDefinitionDigest(agent) {
+  return agent.definitionDigest ?? stableJsonDigest(projectAgentDefinition(agent));
+}
+function projectLaunchBinding(input) {
+  return {
+    version: LAUNCH_BINDING_PROJECTION_VERSION,
+    definitionDigest: input.definitionDigest,
+    taskDigest: input.task === void 0 ? void 0 : stableJsonDigest(input.task),
+    model: input.model,
+    fast: input.fast,
+    thinking: input.thinking,
+    systemPromptDigest: input.systemPrompt === void 0 || input.systemPrompt === null ? void 0 : stableJsonDigest(input.systemPrompt),
+    systemPromptMode: input.systemPromptMode,
+    inheritProjectContext: input.inheritProjectContext,
+    inheritGlobalContext: input.inheritGlobalContext,
+    inheritSkills: input.inheritSkills,
+    skills: input.skills,
+    tools: input.tools,
+    excludeTools: input.excludeTools,
+    extensions: input.extensions,
+    subagentOnlyExtensions: input.subagentOnlyExtensions,
+    mcpDirectTools: input.mcpDirectTools,
+    outputPath: input.outputPath,
+    outputMode: input.outputMode,
+    structuredOutputSchema: input.structuredOutputSchema,
+    extensionBindings: input.extensionBindings
+  };
+}
+function launchBindingDigest(input) {
+  return stableJsonDigest(projectLaunchBinding(input));
+}
+function resolveLaunchBinding(source) {
+  const identity = "agent" in source ? {
+    definitionDigest: agentDefinitionDigest(source.agent),
+    systemPromptMode: source.agent.systemPromptMode,
+    inheritProjectContext: source.agent.inheritProjectContext,
+    inheritGlobalContext: source.agent.inheritGlobalContext,
+    inheritSkills: source.agent.inheritSkills
+  } : source;
+  return {
+    definitionDigest: identity.definitionDigest,
+    launchContractDigest: launchBindingDigest({
+      ...identity,
+      task: source.task,
+      model: source.model,
+      fast: source.fast,
+      thinking: source.thinking || void 0,
+      systemPrompt: source.systemPrompt,
+      skills: source.skills,
+      tools: source.toolPlan.effectiveToolAllowlist,
+      excludeTools: source.toolPlan.excludeTools.length > 0 ? source.toolPlan.excludeTools : void 0,
+      extensions: source.toolPlan.extensionArgs,
+      mcpDirectTools: source.toolPlan.effectiveMcpTools,
+      outputPath: source.outputPath || void 0,
+      outputMode: source.outputMode,
+      structuredOutputSchema: source.structuredOutputSchema,
+      extensionBindings: source.extensionBindings || void 0
+    })
+  };
+}
+
+export {
+  AGENT_DEFINITION_PROJECTION_VERSION,
+  stableJsonDigest,
+  agentDefinitionDigest,
+  resolveLaunchBinding
+};