pi-subagents 0.80.0 → 0.81.0

package/bundle/chunk-3DC5KBVP.js

@@ -0,0 +1,235 @@
+import {
+  getAgentDir
+} from "./chunk-ZBC44JJ3.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-3IF2PGW7.js

@@ -0,0 +1,380 @@
+import {
+  BUILTIN_AGENT_NAMES,
+  CODE_OWNED_EXTERNAL_CLI_ADAPTER_LABEL,
+  applyRuntimeAgentSettings,
+  isCodeOwnedExternalCliAdapterId,
+  parseExternalCliCapabilityNarrowing,
+  validateAcceptanceInput,
+  validateCodeOwnedProfileRunner,
+  validatePermissionRules,
+  validateToolBudgetConfig
+} from "./chunk-ZBC44JJ3.js";
+
+// src/agents/runtime-agent-registry.ts
+var RUNTIME_AGENT_REGISTRY_KEY = "pi-subagents.runtime-agents.v1";
+var MAX_RUNTIME_AGENTS_PER_PI = 200;
+var MAX_AGENT_NAME_LENGTH = 128;
+var MAX_DESCRIPTION_LENGTH = 4096;
+var MAX_SYSTEM_PROMPT_LENGTH = 1024 * 1024;
+var MAX_FIELD_STRING_LENGTH = 8192;
+function defaultSystemPromptMode(name) {
+  return name === "delegate" ? "append" : "replace";
+}
+function defaultInheritProjectContext(name) {
+  return name === "delegate";
+}
+function defaultInheritSkills() {
+  return false;
+}
+function registry() {
+  const key = Symbol.for(RUNTIME_AGENT_REGISTRY_KEY);
+  const globalObject = globalThis;
+  const existing = globalObject[key];
+  if (existing === void 0) {
+    const created = { version: 1, byPi: /* @__PURE__ */ new WeakMap() };
+    globalObject[key] = created;
+    return created;
+  }
+  if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+    throw new Error(`Malformed runtime agent registry at Symbol.for("${RUNTIME_AGENT_REGISTRY_KEY}").`);
+  }
+  const candidate = existing;
+  if (candidate.version !== 1 || !(candidate.byPi instanceof WeakMap)) {
+    throw new Error(`Unsupported runtime agent registry at Symbol.for("${RUNTIME_AGENT_REGISTRY_KEY}").`);
+  }
+  return candidate;
+}
+function validatePi(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Runtime agent pi must be an ExtensionAPI object.");
+  const pi = value;
+  if (typeof pi.on !== "function" || typeof pi.registerTool !== "function") throw new Error("Runtime agent pi must be an ExtensionAPI object.");
+  return value;
+}
+function validateString(value, field, maxLength) {
+  if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
+    throw new Error(`${field} must be a non-empty string without leading or trailing whitespace.`);
+  }
+  if (value.length > maxLength) throw new Error(`${field} must be at most ${maxLength} characters.`);
+  if (value.includes("\0")) throw new Error(`${field} must not contain NUL characters.`);
+  return value;
+}
+function validateOptionalString(value, field, maxLength = MAX_FIELD_STRING_LENGTH) {
+  if (value === void 0) return void 0;
+  return validateString(value, field, maxLength);
+}
+function validateStringList(value, field) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) throw new Error(`${field} must be an array of strings when provided.`);
+  return [...new Set(value.map((entry, index) => validateString(entry, `${field}[${index}]`, MAX_FIELD_STRING_LENGTH)))];
+}
+function validatePositiveInteger(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) throw new Error(`${field} must be a positive integer when provided.`);
+  return value;
+}
+function validateBoolean(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") throw new Error(`${field} must be a boolean when provided.`);
+  return value;
+}
+function isJsonSerializable(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(isJsonSerializable);
+  if (value && typeof value === "object") return Object.values(value).every(isJsonSerializable);
+  return false;
+}
+function validateRunner(value) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Runtime agent definition runner must be an object when provided.");
+  const runner = value;
+  if (runner.type === "pi") {
+    if (Object.keys(runner).some((key) => key !== "type")) throw new Error("Runtime agent definition Pi runner supports only 'type'.");
+    return { type: "pi" };
+  }
+  if (runner.type === "external-job") {
+    if (typeof runner.provider !== "string" || !runner.provider.trim() || runner.provider.trim() !== runner.provider) throw new Error("Runtime agent definition external-job runner requires a non-empty trimmed provider string.");
+    if (runner.options !== void 0 && (!runner.options || typeof runner.options !== "object" || Array.isArray(runner.options) || !isJsonSerializable(runner.options))) throw new Error("Runtime agent definition external-job runner options must be a JSON-serializable object.");
+    const supported2 = /* @__PURE__ */ new Set(["type", "provider", "options"]);
+    const unknown2 = Object.keys(runner).filter((key) => !supported2.has(key));
+    if (unknown2.length > 0) throw new Error(`Runtime agent definition external-job runner has unsupported fields: ${unknown2.join(", ")}.`);
+    return { type: "external-job", provider: runner.provider, ...runner.options ? { options: runner.options } : {} };
+  }
+  if (runner.type !== "external-cli") throw new Error("Runtime agent definition runner.type must be 'pi', 'external-cli', or 'external-job'.");
+  if (typeof runner.command !== "string" || !runner.command.trim()) throw new Error("Runtime agent definition external-cli runner requires a non-empty command string.");
+  if (runner.args !== void 0 && (!Array.isArray(runner.args) || runner.args.some((arg) => typeof arg !== "string"))) throw new Error("Runtime agent definition external-cli runner args must be an array of strings.");
+  if (runner.adapter !== void 0 && !isCodeOwnedExternalCliAdapterId(runner.adapter)) throw new Error(`Runtime agent definition external-cli runner adapter must be ${CODE_OWNED_EXTERNAL_CLI_ADAPTER_LABEL}.`);
+  if (runner.adapter !== void 0 && Array.isArray(runner.args) && runner.args.length > 0) throw new Error(`Runtime agent definition ${runner.adapter} adapter owns its argv; runner args are not supported.`);
+  if (runner.promptDelivery !== void 0 && runner.promptDelivery !== "stdin") throw new Error("Runtime agent definition external-cli runner promptDelivery must be 'stdin'.");
+  const capabilities = parseExternalCliCapabilityNarrowing(runner.capabilities, "Runtime agent definition external-cli runner capabilities");
+  const supported = /* @__PURE__ */ new Set(["type", "adapter", "command", "args", "promptDelivery", "capabilities"]);
+  const unknown = Object.keys(runner).filter((key) => !supported.has(key));
+  if (unknown.length > 0) throw new Error(`Runtime agent definition external-cli runner has unsupported fields: ${unknown.join(", ")}.`);
+  const args = runner.args;
+  return { type: "external-cli", ...isCodeOwnedExternalCliAdapterId(runner.adapter) ? { adapter: runner.adapter } : {}, command: runner.command.trim(), ...args?.length ? { args } : {}, ...runner.promptDelivery ? { promptDelivery: "stdin" } : {}, ...capabilities ? { capabilities } : {} };
+}
+function validateAcceptance(value) {
+  const errors = validateAcceptanceInput(value, "Runtime agent definition defaultAcceptance");
+  if (errors.length > 0) throw new Error(errors.join(" "));
+  return value;
+}
+function validateToolBudget(value) {
+  const result = validateToolBudgetConfig(value, "Runtime agent definition toolBudget");
+  if (result.error) throw new Error(result.error);
+  return result.budget;
+}
+function validateDefinition(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Runtime agent definition must be an object.");
+  const definition = value;
+  const supported = /* @__PURE__ */ new Set([
+    "description",
+    "systemPrompt",
+    "aliases",
+    "tools",
+    "excludeTools",
+    "allowNestedSubagents",
+    "mcpDirectTools",
+    "model",
+    "thinking",
+    "systemPromptMode",
+    "inheritProjectContext",
+    "inheritGlobalContext",
+    "inheritSkills",
+    "defaultContext",
+    "defaultAsync",
+    "defaultTimeoutMs",
+    "defaultToolTimeoutMs",
+    "defaultAcceptance",
+    "acceptanceRole",
+    "runner",
+    "machine",
+    "skills",
+    "skillPath",
+    "extensions",
+    "subagentOnlyExtensions",
+    "mutationTools",
+    "output",
+    "outputMode",
+    "defaultReads",
+    "defaultProgress",
+    "interactive",
+    "maxSubagentDepth",
+    "toolBudget",
+    "permissions"
+  ]);
+  const unknown = Object.keys(definition).filter((key) => !supported.has(key));
+  if (unknown.length > 0) throw new Error(`Runtime agent definition has unknown fields: ${unknown.join(", ")}.`);
+  const systemPromptMode = definition.systemPromptMode;
+  if (systemPromptMode !== void 0 && systemPromptMode !== "append" && systemPromptMode !== "replace") throw new Error("Runtime agent definition systemPromptMode must be 'append' or 'replace'.");
+  const defaultContext = definition.defaultContext;
+  if (defaultContext !== void 0 && defaultContext !== "fresh" && defaultContext !== "fork") throw new Error("Runtime agent definition defaultContext must be 'fresh' or 'fork'.");
+  const thinking = definition.thinking;
+  if (thinking !== void 0 && thinking !== false && typeof thinking !== "string") throw new Error("Runtime agent definition thinking must be a string or false when provided.");
+  const acceptanceRole = definition.acceptanceRole;
+  if (acceptanceRole !== void 0 && acceptanceRole !== "read-only" && acceptanceRole !== "writer") throw new Error("Runtime agent definition acceptanceRole must be 'read-only' or 'writer'.");
+  const outputMode = definition.outputMode;
+  if (outputMode !== void 0 && outputMode !== "inline" && outputMode !== "file-only") throw new Error("Runtime agent definition outputMode must be 'inline' or 'file-only'.");
+  const aliases = validateStringList(definition.aliases, "Runtime agent definition aliases");
+  const tools = validateStringList(definition.tools, "Runtime agent definition tools");
+  const excludeTools = validateStringList(definition.excludeTools, "Runtime agent definition excludeTools");
+  const allowNestedSubagents = validateBoolean(definition.allowNestedSubagents, "Runtime agent definition allowNestedSubagents");
+  const mcpDirectTools = validateStringList(definition.mcpDirectTools, "Runtime agent definition mcpDirectTools");
+  const model = validateOptionalString(definition.model, "Runtime agent definition model");
+  if (definition.fallbackModels !== void 0) throw new Error("Runtime agent definition fallbackModels was removed; configure one model instead.");
+  const inheritProjectContext = validateBoolean(definition.inheritProjectContext, "Runtime agent definition inheritProjectContext");
+  const inheritGlobalContext = validateBoolean(definition.inheritGlobalContext, "Runtime agent definition inheritGlobalContext");
+  const inheritSkills = validateBoolean(definition.inheritSkills, "Runtime agent definition inheritSkills");
+  const defaultAsync = validateBoolean(definition.defaultAsync, "Runtime agent definition defaultAsync");
+  const defaultTimeoutMs = validatePositiveInteger(definition.defaultTimeoutMs, "Runtime agent definition defaultTimeoutMs");
+  const defaultToolTimeoutMs = validatePositiveInteger(definition.defaultToolTimeoutMs, "Runtime agent definition defaultToolTimeoutMs");
+  const defaultAcceptance = validateAcceptance(definition.defaultAcceptance);
+  const runner = validateRunner(definition.runner);
+  const skills = validateStringList(definition.skills, "Runtime agent definition skills");
+  const skillPath = validateStringList(definition.skillPath, "Runtime agent definition skillPath");
+  const extensions = validateStringList(definition.extensions, "Runtime agent definition extensions");
+  const subagentOnlyExtensions = validateStringList(definition.subagentOnlyExtensions, "Runtime agent definition subagentOnlyExtensions");
+  const mutationTools = validateStringList(definition.mutationTools, "Runtime agent definition mutationTools");
+  const machine = validateOptionalString(definition.machine, "Runtime agent definition machine");
+  const output = validateOptionalString(definition.output, "Runtime agent definition output");
+  const defaultReads = validateStringList(definition.defaultReads, "Runtime agent definition defaultReads");
+  const defaultProgress = validateBoolean(definition.defaultProgress, "Runtime agent definition defaultProgress");
+  const interactive = validateBoolean(definition.interactive, "Runtime agent definition interactive");
+  const maxSubagentDepth = validatePositiveInteger(definition.maxSubagentDepth, "Runtime agent definition maxSubagentDepth");
+  const toolBudget = validateToolBudget(definition.toolBudget);
+  const permissions = validatePermissionRules(definition.permissions, "Runtime agent definition permissions");
+  return {
+    description: validateString(definition.description, "Runtime agent definition description", MAX_DESCRIPTION_LENGTH),
+    systemPrompt: validateString(definition.systemPrompt, "Runtime agent definition systemPrompt", MAX_SYSTEM_PROMPT_LENGTH),
+    ...aliases ? { aliases } : {},
+    ...tools ? { tools } : {},
+    ...excludeTools ? { excludeTools } : {},
+    ...allowNestedSubagents !== void 0 ? { allowNestedSubagents } : {},
+    ...mcpDirectTools ? { mcpDirectTools } : {},
+    ...model ? { model } : {},
+    ...thinking !== void 0 ? { thinking } : {},
+    ...systemPromptMode !== void 0 ? { systemPromptMode } : {},
+    ...inheritProjectContext !== void 0 ? { inheritProjectContext } : {},
+    ...inheritGlobalContext !== void 0 ? { inheritGlobalContext } : {},
+    ...inheritSkills !== void 0 ? { inheritSkills } : {},
+    ...defaultContext !== void 0 ? { defaultContext } : {},
+    ...defaultAsync !== void 0 ? { defaultAsync } : {},
+    ...defaultTimeoutMs !== void 0 ? { defaultTimeoutMs } : {},
+    ...defaultToolTimeoutMs !== void 0 ? { defaultToolTimeoutMs } : {},
+    ...defaultAcceptance !== void 0 ? { defaultAcceptance } : {},
+    ...acceptanceRole !== void 0 ? { acceptanceRole } : {},
+    ...runner !== void 0 ? { runner } : {},
+    ...skills ? { skills } : {},
+    ...skillPath ? { skillPath } : {},
+    ...extensions ? { extensions } : {},
+    ...subagentOnlyExtensions ? { subagentOnlyExtensions } : {},
+    ...mutationTools ? { mutationTools } : {},
+    ...machine ? { machine } : {},
+    ...output ? { output } : {},
+    ...outputMode !== void 0 ? { outputMode } : {},
+    ...defaultReads ? { defaultReads } : {},
+    ...defaultProgress !== void 0 ? { defaultProgress } : {},
+    ...interactive !== void 0 ? { interactive } : {},
+    ...maxSubagentDepth !== void 0 ? { maxSubagentDepth } : {},
+    ...toolBudget !== void 0 ? { toolBudget } : {},
+    ...permissions !== void 0 ? { permissions } : {}
+  };
+}
+function normalizeAliases(rawAliases, agentName) {
+  const aliases = [...new Set((rawAliases ?? []).map((alias) => alias.trim()).filter(Boolean))].filter((alias) => alias !== agentName);
+  return aliases.length > 0 ? aliases : void 0;
+}
+function identityKeys(agent) {
+  return [agent.name, ...agent.localName ? [agent.localName] : [], ...agent.aliases ?? []];
+}
+function assertNoIdentityCollisions(agents, context) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    for (const key of identityKeys(agent)) {
+      const previous = seen.get(key);
+      if (previous !== void 0) throw new Error(`${context} collision for '${key}' between '${previous}' and '${agent.name}'.`);
+      seen.set(key, agent.name);
+    }
+  }
+}
+function assertNoRuntimeCollision(agent, existing) {
+  const existingKeys = /* @__PURE__ */ new Map();
+  for (const registered of existing) {
+    for (const key of identityKeys(registered)) existingKeys.set(key, registered.name);
+  }
+  for (const key of identityKeys(agent)) {
+    const previous = existingKeys.get(key);
+    if (previous !== void 0) throw new Error(`Runtime agent '${agent.name}' collides with runtime agent '${previous}' on name or alias '${key}'.`);
+  }
+}
+function assertNoBuiltinCollision(agent) {
+  for (const key of identityKeys(agent)) {
+    if (BUILTIN_AGENT_NAMES.includes(key)) throw new Error(`Runtime agent '${agent.name}' collides with builtin agent '${key}'.`);
+  }
+}
+function toAgentConfig(name, definition) {
+  const aliases = normalizeAliases(definition.aliases, name);
+  const agent = {
+    name,
+    description: definition.description,
+    ...aliases ? { aliases } : {},
+    ...definition.runner !== void 0 ? { runner: definition.runner } : {},
+    ...definition.tools !== void 0 ? { tools: [...definition.tools] } : {},
+    ...definition.excludeTools !== void 0 ? { excludeTools: [...definition.excludeTools] } : {},
+    ...definition.allowNestedSubagents !== void 0 ? { allowNestedSubagents: definition.allowNestedSubagents } : {},
+    ...definition.mcpDirectTools !== void 0 ? { mcpDirectTools: [...definition.mcpDirectTools] } : {},
+    ...definition.model !== void 0 ? { model: definition.model } : {},
+    ...definition.thinking !== void 0 ? { thinking: definition.thinking } : {},
+    systemPromptMode: definition.systemPromptMode ?? defaultSystemPromptMode(name),
+    inheritProjectContext: definition.inheritProjectContext ?? defaultInheritProjectContext(name),
+    inheritGlobalContext: definition.inheritGlobalContext ?? false,
+    inheritSkills: definition.inheritSkills ?? defaultInheritSkills(),
+    ...definition.defaultContext !== void 0 ? { defaultContext: definition.defaultContext } : {},
+    ...definition.defaultAsync !== void 0 ? { defaultAsync: definition.defaultAsync } : {},
+    ...definition.defaultTimeoutMs !== void 0 ? { defaultTimeoutMs: definition.defaultTimeoutMs } : {},
+    ...definition.defaultToolTimeoutMs !== void 0 ? { defaultToolTimeoutMs: definition.defaultToolTimeoutMs } : {},
+    ...definition.defaultAcceptance !== void 0 ? { defaultAcceptance: definition.defaultAcceptance } : {},
+    ...definition.acceptanceRole !== void 0 ? { acceptanceRole: definition.acceptanceRole } : {},
+    systemPrompt: definition.systemPrompt,
+    source: "runtime",
+    filePath: `runtime:${name}`,
+    ...definition.skills !== void 0 ? { skills: [...definition.skills] } : {},
+    ...definition.skillPath !== void 0 ? { skillPath: [...definition.skillPath] } : {},
+    ...definition.extensions !== void 0 ? { extensions: [...definition.extensions] } : {},
+    ...definition.subagentOnlyExtensions !== void 0 ? { subagentOnlyExtensions: [...definition.subagentOnlyExtensions] } : {},
+    ...definition.mutationTools !== void 0 ? { mutationTools: [...definition.mutationTools] } : {},
+    ...definition.machine !== void 0 ? { machine: definition.machine } : {},
+    ...definition.output !== void 0 ? { output: definition.output } : {},
+    ...definition.outputMode !== void 0 ? { outputMode: definition.outputMode } : {},
+    ...definition.defaultReads !== void 0 ? { defaultReads: [...definition.defaultReads] } : {},
+    ...definition.defaultProgress !== void 0 ? { defaultProgress: definition.defaultProgress } : {},
+    ...definition.interactive !== void 0 ? { interactive: definition.interactive } : {},
+    ...definition.maxSubagentDepth !== void 0 ? { maxSubagentDepth: definition.maxSubagentDepth } : {},
+    ...definition.toolBudget !== void 0 ? { toolBudget: definition.toolBudget } : {},
+    ...definition.permissions !== void 0 ? { permissions: definition.permissions } : {}
+  };
+  assertNoIdentityCollisions([agent], `Runtime agent '${name}'`);
+  return agent;
+}
+function registerRuntimeAgent(input) {
+  const pi = validatePi(input.pi);
+  const name = validateString(input.name, "Runtime agent name", MAX_AGENT_NAME_LENGTH);
+  const definition = validateDefinition(input.definition);
+  const agent = toAgentConfig(name, definition);
+  const profileError = validateCodeOwnedProfileRunner(agent);
+  if (profileError) throw new Error(profileError);
+  assertNoBuiltinCollision(agent);
+  const current = registry();
+  const records = current.byPi.get(pi) ?? [];
+  if (records.length >= MAX_RUNTIME_AGENTS_PER_PI) throw new Error(`Runtime agent registry supports at most ${MAX_RUNTIME_AGENTS_PER_PI} agents per Pi runtime.`);
+  assertNoRuntimeCollision(agent, records.map((record2) => record2.agent));
+  const record = { pi, agent };
+  records.push(record);
+  current.byPi.set(pi, records);
+  let disposed = false;
+  return {
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      const latest = current.byPi.get(pi);
+      if (!latest) return;
+      const next = latest.filter((entry) => entry !== record);
+      if (next.length > 0) current.byPi.set(pi, next);
+      else current.byPi.delete(pi);
+    }
+  };
+}
+function clearRuntimeAgentsForPi(pi) {
+  registry().byPi.delete(pi);
+}
+function listRuntimeAgentConfigs(pi) {
+  return (registry().byPi.get(pi) ?? []).map((record) => ({ ...record.agent, aliases: record.agent.aliases ? [...record.agent.aliases] : void 0 }));
+}
+function assertNoConfiguredCollision(configuredAgents, runtimeAgents) {
+  const configured = /* @__PURE__ */ new Map();
+  for (const agent of configuredAgents) {
+    for (const key of identityKeys(agent)) configured.set(key, agent.name);
+  }
+  for (const agent of runtimeAgents) {
+    for (const key of identityKeys(agent)) {
+      const previous = configured.get(key);
+      if (previous !== void 0) {
+        throw new Error(`Runtime agent '${agent.name}' collides with configured agent '${previous}' on name or alias '${key}'.`);
+      }
+    }
+  }
+}
+function mergeRuntimeAgents(pi, discovered, configuredAgents = discovered.agents, settings) {
+  const registered = listRuntimeAgentConfigs(pi).filter((agent) => agent.disabled !== true);
+  if (registered.length === 0) return discovered;
+  assertNoIdentityCollisions(registered, "Runtime agent registration");
+  assertNoConfiguredCollision(configuredAgents, registered);
+  const runtimeAgents = settings ? applyRuntimeAgentSettings(registered, settings) : registered;
+  return { ...discovered, agents: [...discovered.agents, ...runtimeAgents] };
+}
+
+export {
+  registerRuntimeAgent,
+  clearRuntimeAgentsForPi,
+  listRuntimeAgentConfigs,
+  mergeRuntimeAgents
+};

package/bundle/chunk-4QFZZV3O.js

@@ -0,0 +1,57 @@
+// src/runs/shared/herdr-pi-protocol.ts
+var HERDR_PI_PROTOCOL = 1;
+var HERDR_PI_MAX_FRAME_BYTES = 1024 * 1024;
+var HERDR_PI_MODE_ENV = "PI_SUBAGENTS_HERDR_BRIDGE";
+var HERDR_PI_RUN_ENV = "PI_SUBAGENTS_HERDR_RUN_ID";
+var HERDR_PI_RUNTIME_DIR_ENV = "PI_SUBAGENTS_HERDR_RUNTIME_DIR";
+var SAFE_ID = /^[A-Za-z0-9_-]{8,96}$/u;
+function validateHerdrPiRunId(value) {
+  if (typeof value !== "string" || !SAFE_ID.test(value)) throw new Error("Herdr Pi bridge run identity is invalid.");
+  return value;
+}
+function encodeHerdrPiFrame(frame) {
+  const data = Buffer.from(`${JSON.stringify(frame)}
+`, "utf8");
+  if (data.byteLength > HERDR_PI_MAX_FRAME_BYTES) throw new Error(`Herdr Pi frame exceeds ${HERDR_PI_MAX_FRAME_BYTES} bytes.`);
+  return data;
+}
+var HerdrPiFrameDecoder = class {
+  #buffer = Buffer.alloc(0);
+  push(chunk) {
+    this.#buffer = Buffer.concat([this.#buffer, chunk]);
+    if (this.#buffer.byteLength > HERDR_PI_MAX_FRAME_BYTES) throw new Error(`Herdr Pi frame exceeds ${HERDR_PI_MAX_FRAME_BYTES} bytes.`);
+    const frames = [];
+    for (; ; ) {
+      const newline = this.#buffer.indexOf(10);
+      if (newline < 0) break;
+      const line = this.#buffer.subarray(0, newline);
+      this.#buffer = this.#buffer.subarray(newline + 1);
+      let value;
+      try {
+        value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(line));
+      } catch {
+        throw new Error("Herdr Pi bridge emitted malformed JSON or UTF-8.");
+      }
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Herdr Pi bridge frame must be an object.");
+      const frame = value;
+      if (frame.protocol !== HERDR_PI_PROTOCOL || typeof frame.type !== "string") throw new Error("Herdr Pi bridge protocol mismatch.");
+      validateHerdrPiRunId(frame.runId);
+      frames.push(frame);
+    }
+    return frames;
+  }
+  end() {
+    if (this.#buffer.byteLength) throw new Error("Herdr Pi bridge ended with a partial frame.");
+  }
+};
+
+export {
+  HERDR_PI_PROTOCOL,
+  HERDR_PI_MAX_FRAME_BYTES,
+  HERDR_PI_MODE_ENV,
+  HERDR_PI_RUN_ENV,
+  HERDR_PI_RUNTIME_DIR_ENV,
+  validateHerdrPiRunId,
+  encodeHerdrPiFrame,
+  HerdrPiFrameDecoder
+};