@marcoscale98/pi-extensible-workflows 5.14.1-fork.1

package/dist/trajectory/index.js

@@ -0,0 +1,3459 @@
+// trajectory/src/index.ts
+import { spawn } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { mkdir as mkdir3, open as open3, readFile as readFile6, rm as rm5 } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname as dirname5, join as join8 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { getAgentDir as getAgentDir3 } from "@earendil-works/pi-coding-agent";
+
+// src/trajectory-host-handle.ts
+var TRAJECTORY_HOST_KEY = /* @__PURE__ */ Symbol.for("pi-extensible-workflows.trajectory-host");
+var globalTrajectoryHosts = globalThis;
+function setTrajectoryHost(host) {
+  globalTrajectoryHosts[TRAJECTORY_HOST_KEY] = host;
+}
+function clearTrajectoryHost(host) {
+  if (globalTrajectoryHosts[TRAJECTORY_HOST_KEY] === host) globalTrajectoryHosts[TRAJECTORY_HOST_KEY] = void 0;
+}
+
+// src/session-lease.ts
+import { link, mkdir, open, readFile as readFile2, readdir, rename as rename2, rm as rm2, stat } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/types.ts
+var RUN_STATES = ["queued", "running", "pausing", "paused", "awaiting_input", "completed", "failed", "stopped", "interrupted", "budget_exhausted"];
+var AGENT_STATES = ["queued", "running", "waiting_for_child", "paused", "retrying", "completed", "failed", "cancelled"];
+var HARD_TERMINAL_RUN_STATES = /* @__PURE__ */ new Set(["completed", "failed", "stopped"]);
+var ERROR_CODES = [
+  "CONFIG_ERROR",
+  "INVALID_SETTINGS",
+  "INVALID_SYNTAX",
+  "INVALID_METADATA",
+  "DUPLICATE_NAME",
+  "INVALID_SCHEMA",
+  "UNKNOWN_MODEL",
+  "UNKNOWN_TOOL",
+  "UNKNOWN_AGENT_TYPE",
+  "RUN_OWNED",
+  "RUN_NOT_FOUND",
+  "REGISTRY_FROZEN",
+  "GLOBAL_COLLISION",
+  "MISSING_WORKFLOW",
+  "RPC_LIMIT_EXCEEDED",
+  "SHELL_FAILED",
+  "AGENT_TIMEOUT",
+  "AGENT_FAILED",
+  "AGENT_RESULT_COLLECTED",
+  "RESULT_INVALID",
+  "CANCELLED",
+  "WORKER_UNRESPONSIVE",
+  "WORKTREE_FAILED",
+  "RESUME_INCOMPATIBLE",
+  "BUDGET_EXHAUSTED",
+  "INTERNAL_ERROR"
+];
+var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+var BUDGET_DIMENSIONS = ["tokens", "costUsd", "durationMs", "agentLaunches"];
+var BUDGET_EVENT_TYPES = ["soft_crossed", "hard_overrun", "hard_exhausted", "adjustment_requested", "adjustment_approved", "adjustment_rejected"];
+var CONTEXT_FILE_SCOPES = ["global", "project", "cwd"];
+function isContextFileScope(value) {
+  return CONTEXT_FILE_SCOPES.some((scope) => scope === value);
+}
+var WORKFLOW_AGENT_STALL_THRESHOLD_MS = 10 * 60 * 1e3;
+var WORKFLOW_ERROR_BRAND = /* @__PURE__ */ Symbol.for("pi-extensible-workflows.workflow-error");
+var WorkflowError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "WorkflowError";
+    this[WORKFLOW_ERROR_BRAND] = true;
+  }
+  code;
+  static [Symbol.hasInstance](value) {
+    if (Function.prototype[Symbol.hasInstance].call(this, value)) return true;
+    return Object.hasOwn(this, WORKFLOW_ERROR_BRAND) && typeof value === "object" && value !== null && WORKFLOW_ERROR_BRAND in value;
+  }
+};
+Object.defineProperty(WorkflowError, WORKFLOW_ERROR_BRAND, { value: true });
+
+// src/utils.ts
+import { Minimatch } from "minimatch";
+var SerialLane = class {
+  #tail = Promise.resolve();
+  run(task) {
+    const next = this.#tail.then(task, task);
+    this.#tail = next.then(() => void 0, () => void 0);
+    return next;
+  }
+};
+function object(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var ESCAPE_CHARACTER = String.fromCharCode(27);
+var BELL_CHARACTER = String.fromCharCode(7);
+var ANSI_ESCAPE_SEQUENCE = new RegExp(`${ESCAPE_CHARACTER}(?:\\[[0-?]*[ -/]*[@-~]|\\][^${BELL_CHARACTER}]*(?:${BELL_CHARACTER}|${ESCAPE_CHARACTER}\\\\))`, "g");
+var TERMINAL_CONTROL_CHARACTER = new RegExp(`[${String.fromCharCode(0)}-${String.fromCharCode(31)}${String.fromCharCode(127)}-${String.fromCharCode(159)}]`, "g");
+function isStringKey(key) {
+  return typeof key === "string";
+}
+function stringKeyValue(value, key) {
+  return object(value) ? value[key] : void 0;
+}
+function jsonValue(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || seen.has(value)) return false;
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return false;
+  const ownKeys = Reflect.ownKeys(value);
+  const keys = ownKeys.filter(isStringKey);
+  if (keys.length !== ownKeys.length) return false;
+  seen.add(value);
+  const valid = (Array.isArray(value) ? Array.from(value) : keys.map((key) => stringKeyValue(value, key))).every((item) => jsonValue(item, seen));
+  seen.delete(value);
+  return valid;
+}
+function positiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function deepFreeze(value) {
+  if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value)) deepFreeze(child);
+  }
+  return value;
+}
+function isNodeError(error, code) {
+  return object(error) && error.code === code;
+}
+function isWorkflowErrorCode(value) {
+  return ERROR_CODES.some((candidate) => candidate === value);
+}
+function errorText(error) {
+  return object(error) && typeof error.message === "string" ? error.message : error instanceof Error ? error.message : String(error);
+}
+function coerceWorkflowError(code, error) {
+  return error instanceof WorkflowError && error.code === code ? error : new WorkflowError(code, errorText(error));
+}
+function errorCode(error) {
+  if (error instanceof WorkflowError) return isWorkflowErrorCode(error.code) ? error.code : void 0;
+  if (!object(error)) return void 0;
+  return isWorkflowErrorCode(error.code) ? error.code : void 0;
+}
+function fail(code, message) {
+  throw new WorkflowError(code, message);
+}
+function byPriorityThenName(left, right) {
+  return left.priority - right.priority || (left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+}
+function isThinkingLevel(value) {
+  return THINKING_LEVELS.some((level) => level === value);
+}
+var MODEL_ALIAS_NAME = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var WORKFLOW_EXTENSION_NAMESPACE = /^[A-Za-z][A-Za-z0-9_-]*$/;
+function validWorkflowExtensionNamespace(value) {
+  return WORKFLOW_EXTENSION_NAMESPACE.test(value) && value !== "__proto__" && value !== "constructor" && value !== "prototype";
+}
+function parseModelReference(value) {
+  const match = /^([^/:\s]+)\/([^:\s]+)(?::([^:\s]+))?$/.exec(value);
+  if (!match?.[1] || !match[2]) fail("UNKNOWN_MODEL", `Invalid model spec: ${value}`);
+  const thinking = match[3];
+  if (thinking !== void 0 && !isThinkingLevel(thinking)) fail("UNKNOWN_MODEL", `Invalid thinking level: ${thinking}`);
+  return { provider: match[1], model: match[2], ...thinking !== void 0 ? { thinking } : {} };
+}
+var MODEL_ALIAS_ERROR_NAME = /* @__PURE__ */ Symbol("modelAliasErrorName");
+function aliasError(message, settingsPath, name) {
+  const error = new WorkflowError("CONFIG_ERROR", `${message} (settings: ${settingsPath})`);
+  if (name) Object.defineProperty(error, MODEL_ALIAS_ERROR_NAME, { value: name, configurable: true });
+  throw error;
+}
+function modelAliasName(value, aliases) {
+  const name = /^([^/:\s]+)(?::[^:\s]+)?$/.exec(value)?.[1];
+  return name && Object.prototype.hasOwnProperty.call(aliases, name) ? name : void 0;
+}
+function validateModelAliases(value, settingsPath = "workflow settings") {
+  if (!object(value)) aliasError("modelAliases must be an object", settingsPath);
+  const aliases = {};
+  for (const [name, target] of Object.entries(value)) {
+    if (!MODEL_ALIAS_NAME.test(name)) aliasError(`Invalid model alias name: ${name}`, settingsPath, name);
+    if (typeof target !== "string" || !target.trim()) aliasError(`Invalid model alias target for ${name}`, settingsPath, name);
+    aliases[name] = target;
+  }
+  for (const name of Object.keys(aliases)) {
+    try {
+      resolveModelReference(name, aliases);
+    } catch (error) {
+      aliasError(`Invalid model alias target for ${name}: ${errorText(error)}`, settingsPath, name);
+    }
+  }
+  return Object.freeze(aliases);
+}
+function unknownModel(value, target, settingsPath) {
+  const resolved = target ? ` resolved to ${target}` : "";
+  const path = settingsPath ? ` (settings: ${settingsPath})` : "";
+  fail("UNKNOWN_MODEL", `Unknown model${target ? " alias" : ""} ${value}${resolved}${path}`);
+}
+function resolveModelReference(value, aliases = {}, knownModels, settingsPath) {
+  const resolveReference = (reference, chain) => {
+    if (reference.includes("/")) return parseModelReference(reference);
+    const match = /^([^:\s]+)(?::([^:\s]+))?$/.exec(reference);
+    const thinking = match?.[2];
+    if (!match?.[1] || thinking !== void 0 && !isThinkingLevel(thinking)) unknownModel(reference, void 0, settingsPath);
+    const alias = modelAliasName(reference, aliases);
+    if (alias) {
+      if (chain.includes(alias)) fail("UNKNOWN_MODEL", `Circular model alias: ${[...chain, alias].join(" -> ")}${settingsPath ? ` (settings: ${settingsPath})` : ""}`);
+      const { [alias]: target } = aliases;
+      if (typeof target !== "string") unknownModel(reference, void 0, settingsPath);
+      const parsed = resolveReference(target, [...chain, alias]);
+      return thinking !== void 0 ? { ...parsed, thinking } : parsed;
+    }
+    const candidates = [...knownModels ?? []].filter((model) => model.slice(model.indexOf("/") + 1) === match[1]);
+    if (candidates.length === 1) {
+      const [candidate] = candidates;
+      if (candidate !== void 0) {
+        const parsed = parseModelReference(candidate);
+        return thinking !== void 0 ? { ...parsed, thinking } : parsed;
+      }
+    }
+    unknownModel(reference, void 0, settingsPath);
+  };
+  return resolveReference(value, []);
+}
+var RESOURCE_PATTERN_OPTIONS = { dot: true, nonegate: true, nocomment: true };
+function resourcePatternBody(pattern) {
+  return pattern.startsWith("!") ? pattern.slice(1) : pattern;
+}
+function resourcePatternPath(value) {
+  return value.replaceAll("\\", "/");
+}
+function validateResourcePattern(pattern) {
+  const body = resourcePatternBody(pattern);
+  if (!body) throw new Error(`Empty minimatch pattern ${JSON.stringify(pattern)}`);
+  const matcher = new Minimatch(resourcePatternPath(body), RESOURCE_PATTERN_OPTIONS);
+  if (matcher.makeRe() === false) throw new Error(`Invalid minimatch pattern ${JSON.stringify(pattern)}`);
+}
+function resourcePatternMatches(resource, pattern) {
+  const body = resourcePatternBody(pattern);
+  if (body === "*") return true;
+  return new Minimatch(resourcePatternPath(body), RESOURCE_PATTERN_OPTIONS).match(resourcePatternPath(resource));
+}
+function selectResourcesByLayers(layers, resources) {
+  const enabled = new Set(resources);
+  for (const layer of layers) {
+    if (layer === void 0) continue;
+    for (const resource of resources) {
+      for (const pattern of layer) if (resourcePatternMatches(resource, pattern)) {
+        if (pattern.startsWith("!")) enabled.delete(resource);
+        else enabled.add(resource);
+      }
+    }
+  }
+  return resources.filter((resource) => enabled.has(resource));
+}
+function resourcePatternHasMagic(pattern) {
+  return /[*?\x5b\x5d{}()]/.test(resourcePatternBody(pattern));
+}
+function loadLaunchSnapshot(input) {
+  return deepFreeze(structuredClone(input));
+}
+
+// src/decoders.ts
+var INVALID_PERSISTED_VALUE = /* @__PURE__ */ Symbol("invalid persisted value");
+function integer(value) {
+  return finiteNumber(value) && Number.isInteger(value);
+}
+function safePositiveInteger(value) {
+  return integer(value) && Number.isSafeInteger(value) && value > 0;
+}
+function isLaunchMode(value) {
+  return value === "foreground" || value === "background";
+}
+function isRunState(value) {
+  return RUN_STATES.some((candidate) => candidate === value);
+}
+function isAgentState(value) {
+  return AGENT_STATES.some((candidate) => candidate === value);
+}
+function isAgentContinuity(value) {
+  return value === "fresh" || value === "continued";
+}
+function isBudgetDimension(value) {
+  return BUDGET_DIMENSIONS.some((candidate) => candidate === value);
+}
+function isBudgetEventType(value) {
+  return BUDGET_EVENT_TYPES.some((candidate) => candidate === value);
+}
+function optionalString(value) {
+  return value === void 0 || typeof value === "string" ? value : INVALID_PERSISTED_VALUE;
+}
+function optionalNumber(value) {
+  return value === void 0 || finiteNumber(value) ? value : INVALID_PERSISTED_VALUE;
+}
+function optionalBoolean(value) {
+  return value === void 0 || typeof value === "boolean" ? value : INVALID_PERSISTED_VALUE;
+}
+function decodeArray(value, decoder) {
+  if (!Array.isArray(value)) return void 0;
+  const decoded = [];
+  for (const entry of value) {
+    const result = decoder(entry);
+    if (result === void 0) return void 0;
+    decoded.push(result);
+  }
+  return decoded;
+}
+function decodeStringArray(value) {
+  return decodeArray(value, (entry) => typeof entry === "string" ? entry : void 0);
+}
+function decodeWorktreePostCreateCommand(value) {
+  const command = decodeStringArray(value);
+  return command && command.length > 0 && command.every((entry) => Boolean(entry.trim())) ? command : void 0;
+}
+function decodeJsonValue(value) {
+  return jsonValue(value) ? value : void 0;
+}
+function decodeJsonObject(value) {
+  return object(value) && jsonValue(value) ? { ...value } : void 0;
+}
+function decodeStringMap(value) {
+  return decodeRecord(value, (entry) => typeof entry === "string" ? entry : void 0);
+}
+function decodeRecord(value, decoder) {
+  if (!object(value)) return void 0;
+  const entries = [];
+  for (const [key, entry] of Object.entries(value)) {
+    const decoded = decoder(entry);
+    if (decoded === void 0) return void 0;
+    entries.push([key, decoded]);
+  }
+  return Object.fromEntries(entries);
+}
+function decodeModelSpec(value) {
+  if (!object(value) || typeof value.provider !== "string" || typeof value.model !== "string") return void 0;
+  const thinking = value.thinking;
+  if (thinking !== void 0 && !isThinkingLevel(thinking)) return void 0;
+  return { provider: value.provider, model: value.model, ...isThinkingLevel(thinking) ? { thinking } : {} };
+}
+function decodeAgentResourceSelectors(value) {
+  if (!object(value)) return void 0;
+  const skills = value.skills === void 0 ? void 0 : decodeStringArray(value.skills);
+  const extensions = value.extensions === void 0 ? void 0 : decodeStringArray(value.extensions);
+  const tools = value.tools === void 0 ? void 0 : decodeStringArray(value.tools);
+  if (value.skills !== void 0 && !skills || value.extensions !== void 0 && !extensions || value.tools !== void 0 && !tools) return void 0;
+  return { ...skills === void 0 ? {} : { skills }, ...extensions === void 0 ? {} : { extensions }, ...tools === void 0 ? {} : { tools } };
+}
+function decodeContextFileScopes(value) {
+  return decodeArray(value, (scope) => isContextFileScope(scope) ? scope : void 0);
+}
+function decodeAgentDefinition(value) {
+  if (!object(value)) return void 0;
+  const prompt = optionalString(value.prompt);
+  const description = optionalString(value.description);
+  const model = optionalString(value.model);
+  const thinking = value.thinking;
+  const tools = value.tools === void 0 ? void 0 : decodeStringArray(value.tools);
+  const skills = value.skills === void 0 ? void 0 : decodeStringArray(value.skills);
+  const extensions = value.extensions === void 0 ? void 0 : decodeStringArray(value.extensions);
+  const overrideSystemPrompt = optionalBoolean(value.overrideSystemPrompt);
+  const contextFiles = value.contextFiles === void 0 ? void 0 : decodeContextFileScopes(value.contextFiles);
+  const extensionSettings = value.extensionSettings === void 0 ? void 0 : decodeWorkflowExtensions(value.extensionSettings);
+  if (prompt === INVALID_PERSISTED_VALUE || description === INVALID_PERSISTED_VALUE || model === INVALID_PERSISTED_VALUE || overrideSystemPrompt === INVALID_PERSISTED_VALUE) return void 0;
+  if (thinking !== void 0 && !isThinkingLevel(thinking) || value.tools !== void 0 && !tools || value.skills !== void 0 && !skills || value.extensions !== void 0 && !extensions || value.contextFiles !== void 0 && !contextFiles || value.extensionSettings !== void 0 && !extensionSettings) return void 0;
+  const foldedModel = typeof model === "string" && thinking !== void 0 && !model.includes(":") ? `${model}:${thinking}` : model;
+  return {
+    ...prompt === void 0 ? {} : { prompt },
+    ...description === void 0 ? {} : { description },
+    ...foldedModel === void 0 ? {} : { model: foldedModel },
+    ...tools === void 0 ? {} : { tools },
+    ...skills === void 0 ? {} : { skills },
+    ...extensions === void 0 ? {} : { extensions },
+    ...overrideSystemPrompt === void 0 ? {} : { overrideSystemPrompt },
+    ...contextFiles === void 0 ? {} : { contextFiles },
+    ...extensionSettings === void 0 ? {} : { extensionSettings }
+  };
+}
+function decodeWorkflowMetadata(value) {
+  if (!object(value) || typeof value.name !== "string") return void 0;
+  const description = optionalString(value.description);
+  if (description === INVALID_PERSISTED_VALUE) return void 0;
+  return { name: value.name, ...description === void 0 ? {} : { description } };
+}
+function decodeWorkflowExtensions(value) {
+  if (!object(value) || !jsonValue(value)) return void 0;
+  const normalized = {};
+  for (const [namespace, raw] of Object.entries(value)) {
+    if (!validWorkflowExtensionNamespace(namespace)) return void 0;
+    if (namespace === "herdr") {
+      if (!object(raw) || Object.keys(raw).some((key) => key !== "enableFullyInspectableMode") || raw.enableFullyInspectableMode !== void 0 && typeof raw.enableFullyInspectableMode !== "boolean") return void 0;
+      normalized.herdr = { ...raw.enableFullyInspectableMode === void 0 ? {} : { enableFullyInspectableMode: raw.enableFullyInspectableMode } };
+      continue;
+    }
+    if (namespace === "trajectory") {
+      if (!object(raw) || Object.keys(raw).some((key) => key !== "port" && key !== "themes") || raw.port !== void 0 && (typeof raw.port !== "number" || !Number.isSafeInteger(raw.port) || raw.port < 1 || raw.port > 65535) || raw.themes !== void 0 && typeof raw.themes !== "boolean") return void 0;
+      normalized.trajectory = { ...raw.port === void 0 ? {} : { port: raw.port }, ...raw.themes === void 0 ? {} : { themes: raw.themes } };
+      continue;
+    }
+    if (!jsonValue(raw)) return void 0;
+    normalized[namespace] = structuredClone(raw);
+  }
+  return normalized;
+}
+function decodeBudgetLimits(value) {
+  if (!object(value)) return void 0;
+  const soft = optionalNumber(value.soft);
+  const hard = optionalNumber(value.hard);
+  if (soft === INVALID_PERSISTED_VALUE || hard === INVALID_PERSISTED_VALUE) return void 0;
+  return { ...soft === void 0 ? {} : { soft }, ...hard === void 0 ? {} : { hard } };
+}
+function decodeBudget(value) {
+  if (!object(value)) return void 0;
+  const budget = {};
+  for (const dimension of BUDGET_DIMENSIONS) {
+    const raw = value[dimension];
+    if (raw === void 0) continue;
+    const limits = decodeBudgetLimits(raw);
+    if (limits === void 0) return void 0;
+    budget[dimension] = limits;
+  }
+  return budget;
+}
+function decodeRetention(value) {
+  if (!object(value) || Object.keys(value).some((key) => key !== "olderThanDays" && key !== "maxTerminalRuns")) return INVALID_PERSISTED_VALUE;
+  const olderThanDays = value.olderThanDays;
+  const maxTerminalRuns = value.maxTerminalRuns;
+  if (olderThanDays !== void 0 && !safePositiveInteger(olderThanDays) || maxTerminalRuns !== void 0 && !safePositiveInteger(maxTerminalRuns)) return INVALID_PERSISTED_VALUE;
+  return Object.freeze({ ...olderThanDays === void 0 ? {} : { olderThanDays }, ...maxTerminalRuns === void 0 ? {} : { maxTerminalRuns } });
+}
+function decodeWorkflowSettings(value) {
+  if (!object(value) || !positiveInteger(value.concurrency)) return void 0;
+  const backgroundWidget = optionalBoolean(value.backgroundWidget);
+  const modelAliases = value.modelAliases === void 0 ? void 0 : decodeStringMap(value.modelAliases);
+  const skills = value.skills === void 0 ? void 0 : decodeStringArray(value.skills);
+  const tools = value.tools === void 0 ? void 0 : decodeStringArray(value.tools);
+  const legacyExtensionSettings = value.extensions !== void 0 && object(value.extensions) ? decodeWorkflowExtensions(value.extensions) : void 0;
+  const extensions = value.extensions === void 0 || object(value.extensions) ? void 0 : decodeStringArray(value.extensions);
+  const extensionSettings = value.extensionSettings === void 0 ? void 0 : decodeWorkflowExtensions(value.extensionSettings);
+  const effectiveExtensionSettings = extensionSettings ?? legacyExtensionSettings;
+  const retention = value.retention === void 0 ? void 0 : decodeRetention(value.retention);
+  const worktreePostCreateCommand = value.worktreePostCreateCommand === void 0 ? void 0 : decodeWorktreePostCreateCommand(value.worktreePostCreateCommand);
+  if (backgroundWidget === INVALID_PERSISTED_VALUE || value.modelAliases !== void 0 && !modelAliases || value.skills !== void 0 && !skills || value.tools !== void 0 && !tools || value.extensions !== void 0 && !extensions && !legacyExtensionSettings || value.extensionSettings !== void 0 && !extensionSettings || retention === INVALID_PERSISTED_VALUE || value.worktreePostCreateCommand !== void 0 && !worktreePostCreateCommand) return void 0;
+  return {
+    concurrency: value.concurrency,
+    ...backgroundWidget === void 0 ? {} : { backgroundWidget },
+    ...modelAliases === void 0 ? {} : { modelAliases },
+    ...skills === void 0 ? {} : { skills },
+    ...tools === void 0 ? {} : { tools },
+    ...extensions === void 0 ? {} : { extensions },
+    ...effectiveExtensionSettings === void 0 ? {} : { extensionSettings: effectiveExtensionSettings },
+    ...retention === void 0 ? {} : { retention },
+    ...worktreePostCreateCommand === void 0 ? {} : { worktreePostCreateCommand }
+  };
+}
+function decodeWorkflowSettingsSources(value) {
+  if (!object(value) || typeof value.concurrency !== "string" || typeof value.modelAliases !== "string") return void 0;
+  const skills = value.skills === void 0 ? void 0 : typeof value.skills === "string" ? value.skills : void 0;
+  const extensions = value.extensions === void 0 ? void 0 : typeof value.extensions === "string" ? value.extensions : void 0;
+  const tools = value.tools === void 0 ? void 0 : typeof value.tools === "string" ? value.tools : void 0;
+  const extensionSettings = value.extensionSettings === void 0 ? void 0 : typeof value.extensionSettings === "string" ? value.extensionSettings : void 0;
+  const retention = value.retention === void 0 ? void 0 : typeof value.retention === "string" ? value.retention : void 0;
+  const worktreePostCreateCommand = value.worktreePostCreateCommand === void 0 ? void 0 : typeof value.worktreePostCreateCommand === "string" ? value.worktreePostCreateCommand : void 0;
+  if (value.skills !== void 0 && skills === void 0 || value.extensions !== void 0 && extensions === void 0 || value.tools !== void 0 && tools === void 0 || value.extensionSettings !== void 0 && extensionSettings === void 0 || value.retention !== void 0 && retention === void 0 || value.worktreePostCreateCommand !== void 0 && worktreePostCreateCommand === void 0) return void 0;
+  return { concurrency: value.concurrency, modelAliases: value.modelAliases, ...skills === void 0 ? {} : { skills }, ...extensions === void 0 ? {} : { extensions }, ...tools === void 0 ? {} : { tools }, ...extensionSettings === void 0 ? {} : { extensionSettings }, ...retention === void 0 ? {} : { retention }, ...worktreePostCreateCommand === void 0 ? {} : { worktreePostCreateCommand } };
+}
+function decodeIdentity(value) {
+  if (!object(value) || typeof value.callSite !== "string" || !positiveInteger(value.occurrence)) return void 0;
+  const structuralPath2 = decodeStringArray(value.structuralPath);
+  const parentBreadcrumb = optionalString(value.parentBreadcrumb);
+  const worktreeOwner = optionalString(value.worktreeOwner);
+  const handle = optionalString(value.handle);
+  if (!structuralPath2 || parentBreadcrumb === INVALID_PERSISTED_VALUE || worktreeOwner === INVALID_PERSISTED_VALUE || handle === INVALID_PERSISTED_VALUE || handle !== void 0 && !positiveInteger(value.turn)) return void 0;
+  return { structuralPath: structuralPath2, callSite: value.callSite, occurrence: value.occurrence, ...parentBreadcrumb === void 0 ? {} : { parentBreadcrumb }, ...worktreeOwner === void 0 ? {} : { worktreeOwner }, ...handle === void 0 ? {} : { handle, turn: value.turn } };
+}
+function decodeScheduledAgentOptions(value) {
+  if (!object(value) || typeof value.label !== "string" || typeof value.cwd !== "string") return void 0;
+  const tools = decodeStringArray(value.tools);
+  const skills = value.skills === void 0 ? void 0 : decodeStringArray(value.skills);
+  const extensions = value.extensions === void 0 ? void 0 : decodeStringArray(value.extensions);
+  if (!tools) return void 0;
+  const requestedLabel = optionalString(value.requestedLabel);
+  const parentBreadcrumb = optionalString(value.parentBreadcrumb);
+  const worktreeOwner = optionalString(value.worktreeOwner);
+  const model = optionalString(value.model);
+  const role = typeof value.role === "string" ? value.role : void 0;
+  const contextFiles = value.contextFiles === void 0 ? void 0 : decodeContextFileScopes(value.contextFiles);
+  const schema = value.schema === void 0 ? void 0 : decodeJsonObject(value.schema);
+  const retries = optionalNumber(value.retries);
+  const timeoutMs = value.timeoutMs;
+  const agentOptions = value.agentOptions === void 0 ? void 0 : decodeJsonObject(value.agentOptions);
+  const agentIdentity = value.agentIdentity === void 0 ? void 0 : decodeIdentity(value.agentIdentity);
+  const sessionPath = optionalString(value.sessionPath);
+  const continuity = value.continuity === void 0 ? void 0 : isAgentContinuity(value.continuity) ? value.continuity : INVALID_PERSISTED_VALUE;
+  const extensionSettings = value.extensionSettings === void 0 ? void 0 : decodeWorkflowExtensions(value.extensionSettings);
+  if (sessionPath === INVALID_PERSISTED_VALUE || continuity === INVALID_PERSISTED_VALUE || requestedLabel === INVALID_PERSISTED_VALUE || parentBreadcrumb === INVALID_PERSISTED_VALUE || worktreeOwner === INVALID_PERSISTED_VALUE || model === INVALID_PERSISTED_VALUE || value.skills !== void 0 && !skills || value.extensions !== void 0 && !extensions || value.role !== void 0 && typeof value.role !== "string" || value.contextFiles !== void 0 && !contextFiles || value.schema !== void 0 && !schema || retries === INVALID_PERSISTED_VALUE || retries !== void 0 && !integer(retries) || timeoutMs !== void 0 && timeoutMs !== null && !finiteNumber(timeoutMs) || value.agentOptions !== void 0 && !agentOptions || value.agentIdentity !== void 0 && !agentIdentity || value.extensionSettings !== void 0 && !extensionSettings) return void 0;
+  return {
+    label: value.label,
+    ...requestedLabel === void 0 ? {} : { requestedLabel },
+    ...parentBreadcrumb === void 0 ? {} : { parentBreadcrumb },
+    cwd: value.cwd,
+    tools,
+    ...skills === void 0 ? {} : { skills },
+    ...extensions === void 0 ? {} : { extensions },
+    ...worktreeOwner === void 0 ? {} : { worktreeOwner },
+    ...model === void 0 ? {} : { model },
+    ...role === void 0 ? {} : { role },
+    ...contextFiles === void 0 ? {} : { contextFiles },
+    ...schema === void 0 ? {} : { schema },
+    ...retries === void 0 ? {} : { retries },
+    ...timeoutMs === void 0 ? {} : { timeoutMs },
+    ...sessionPath === void 0 ? {} : { sessionPath },
+    ...continuity === void 0 ? {} : { continuity },
+    ...agentOptions === void 0 ? {} : { agentOptions },
+    ...agentIdentity === void 0 ? {} : { agentIdentity },
+    ...extensionSettings === void 0 ? {} : { extensionSettings }
+  };
+}
+function decodeAgentSession(value) {
+  if (!object(value) || typeof value.transport !== "string" || typeof value.sessionId !== "string") return void 0;
+  const locator = value.locator === void 0 ? void 0 : decodeJsonValue(value.locator);
+  if (value.locator !== void 0 && locator === void 0) return void 0;
+  return { transport: value.transport, sessionId: value.sessionId, ...locator === void 0 ? {} : { locator } };
+}
+function decodeAgentAccounting(value) {
+  if (!object(value) || !finiteNumber(value.input) || !finiteNumber(value.output) || !finiteNumber(value.cacheRead) || !finiteNumber(value.cacheWrite) || !finiteNumber(value.cost)) return void 0;
+  return { input: value.input, output: value.output, cacheRead: value.cacheRead, cacheWrite: value.cacheWrite, cost: value.cost };
+}
+function decodeAgentActivity(value) {
+  if (!object(value) || typeof value.text !== "string") return void 0;
+  const kind = value.kind;
+  if (kind !== "reasoning" && kind !== "tool" && kind !== "text") return void 0;
+  return { kind, text: value.text };
+}
+function decodeAgentToolCall(value) {
+  if (!object(value) || typeof value.id !== "string" || typeof value.name !== "string") return void 0;
+  const state = value.state;
+  if (state !== "running" && state !== "completed" && state !== "failed") return void 0;
+  return { id: value.id, name: value.name, state };
+}
+function decodeAgentResourceInspection(value) {
+  if (!object(value)) return void 0;
+  const selectors = decodeAgentResourceSelectors(value.selectors);
+  const skills = decodeStringArray(value.skills);
+  const extensions = decodeStringArray(value.extensions);
+  const tools = decodeStringArray(value.tools);
+  const unmatchedSkills = decodeStringArray(value.unmatchedSkills);
+  const unmatchedExtensions = decodeStringArray(value.unmatchedExtensions);
+  const unmatchedTools = decodeStringArray(value.unmatchedTools);
+  const rawSources = value.selectorSources;
+  const sourceRecord = object(rawSources) ? rawSources : void 0;
+  const sources = sourceRecord === void 0 ? void 0 : {
+    global: decodeAgentResourceSelectors(sourceRecord.global),
+    project: decodeAgentResourceSelectors(sourceRecord.project),
+    ...sourceRecord.role === void 0 ? {} : { role: decodeAgentResourceSelectors(sourceRecord.role) },
+    ...sourceRecord.call === void 0 ? {} : { call: decodeAgentResourceSelectors(sourceRecord.call) }
+  };
+  if (!selectors || !skills || !extensions || !tools || !unmatchedSkills || !unmatchedExtensions || !unmatchedTools || rawSources !== void 0 && (!sources || !sources.global || !sources.project || sources.role === void 0 && sourceRecord?.role !== void 0 || sources.call === void 0 && sourceRecord?.call !== void 0)) return void 0;
+  return { selectors: { skills: [...selectors.skills ?? []], extensions: [...selectors.extensions ?? []], tools: [...selectors.tools ?? []] }, skills, extensions, tools, unmatchedSkills, unmatchedExtensions, unmatchedTools, ...sources === void 0 ? {} : { selectorSources: { global: sources.global ?? {}, project: sources.project ?? {}, ...sources.role === void 0 ? {} : { role: sources.role }, ...sources.call === void 0 ? {} : { call: sources.call } } } };
+}
+function decodeAgentSetupSummary(value) {
+  if (!object(value) || typeof value.cwd !== "string") return void 0;
+  const hookNames = decodeStringArray(value.hookNames);
+  const tools = decodeStringArray(value.tools);
+  const model = decodeModelSpec(value.model);
+  const resourceSelectors = value.resourceSelectors === void 0 ? void 0 : decodeAgentResourceInspection(value.resourceSelectors);
+  if (!hookNames || !tools || !model || value.resourceSelectors !== void 0 && !resourceSelectors) return void 0;
+  return { hookNames, model, tools, cwd: value.cwd, ...resourceSelectors === void 0 ? {} : { resourceSelectors } };
+}
+function decodeAttemptError(value) {
+  if (!object(value) || typeof value.code !== "string" || typeof value.message !== "string") return void 0;
+  return { code: value.code, message: value.message };
+}
+function decodeAgentAttempt(value) {
+  if (!object(value) || !positiveInteger(value.attempt) || typeof value.transport !== "string") return void 0;
+  const session = value.session === void 0 ? void 0 : decodeAgentSession(value.session);
+  const setup = decodeAgentSetupSummary(value.setup);
+  const error = value.error === void 0 ? void 0 : decodeAttemptError(value.error);
+  const accounting = decodeAgentAccounting(value.accounting);
+  if (!setup || !accounting || value.session !== void 0 && !session || value.error !== void 0 && !error) return void 0;
+  return { attempt: value.attempt, transport: value.transport, setup, accounting, ...session === void 0 ? {} : { session }, ...error === void 0 ? {} : { error } };
+}
+function decodeAgent(value) {
+  if (!object(value) || typeof value.id !== "string" || typeof value.name !== "string" || typeof value.path !== "string" || !isAgentState(value.state) || !integer(value.attempts)) return void 0;
+  const model = decodeModelSpec(value.model);
+  const tools = decodeStringArray(value.tools);
+  const systemPrompt = optionalString(value.systemPrompt);
+  const prompt = optionalString(value.prompt);
+  const label = optionalString(value.label);
+  const parentId = optionalString(value.parentId);
+  const structuralPath2 = value.structuralPath === void 0 ? void 0 : decodeStringArray(value.structuralPath);
+  const resultPath = optionalString(value.resultPath);
+  const parentBreadcrumb = optionalString(value.parentBreadcrumb);
+  const worktreeOwner = optionalString(value.worktreeOwner);
+  const handle = optionalString(value.handle);
+  const continuity = value.continuity === void 0 ? void 0 : isAgentContinuity(value.continuity) ? value.continuity : INVALID_PERSISTED_VALUE;
+  const role = optionalString(value.role);
+  const requestedModel = optionalString(value.requestedModel);
+  const startedAt = optionalNumber(value.startedAt);
+  const durationMs = optionalNumber(value.durationMs);
+  const attemptDetails = value.attemptDetails === void 0 ? void 0 : decodeArray(value.attemptDetails, decodeAgentAttempt);
+  const accounting = value.accounting === void 0 ? void 0 : decodeAgentAccounting(value.accounting);
+  const toolCalls = value.toolCalls === void 0 ? void 0 : decodeArray(value.toolCalls, decodeAgentToolCall);
+  const activity = value.activity === void 0 ? void 0 : decodeAgentActivity(value.activity);
+  const lastEventAt = optionalNumber(value.lastEventAt);
+  if (systemPrompt === INVALID_PERSISTED_VALUE || prompt === INVALID_PERSISTED_VALUE || label === INVALID_PERSISTED_VALUE || parentId === INVALID_PERSISTED_VALUE || resultPath === INVALID_PERSISTED_VALUE || parentBreadcrumb === INVALID_PERSISTED_VALUE || worktreeOwner === INVALID_PERSISTED_VALUE || role === INVALID_PERSISTED_VALUE || requestedModel === INVALID_PERSISTED_VALUE || startedAt === INVALID_PERSISTED_VALUE || durationMs === INVALID_PERSISTED_VALUE || lastEventAt === INVALID_PERSISTED_VALUE || handle === INVALID_PERSISTED_VALUE || continuity === INVALID_PERSISTED_VALUE || handle !== void 0 && !positiveInteger(value.turn)) return void 0;
+  if (!model || !tools || value.structuralPath !== void 0 && !structuralPath2 || value.attemptDetails !== void 0 && !attemptDetails || value.accounting !== void 0 && !accounting || value.toolCalls !== void 0 && !toolCalls || value.activity !== void 0 && !activity) return void 0;
+  return {
+    ...systemPrompt === void 0 ? {} : { systemPrompt },
+    ...prompt === void 0 ? {} : { prompt },
+    id: value.id,
+    name: value.name,
+    ...label === void 0 ? {} : { label },
+    path: value.path,
+    state: value.state,
+    ...parentId === void 0 ? {} : { parentId },
+    ...structuralPath2 === void 0 ? {} : { structuralPath: structuralPath2 },
+    ...resultPath === void 0 ? {} : { resultPath },
+    ...parentBreadcrumb === void 0 ? {} : { parentBreadcrumb },
+    ...worktreeOwner === void 0 ? {} : { worktreeOwner },
+    ...handle === void 0 ? {} : { handle, turn: value.turn },
+    ...continuity === void 0 ? {} : { continuity },
+    ...role === void 0 ? {} : { role },
+    ...requestedModel === void 0 ? {} : { requestedModel },
+    model,
+    tools,
+    attempts: value.attempts,
+    ...startedAt === void 0 ? {} : { startedAt },
+    ...durationMs === void 0 ? {} : { durationMs },
+    ...attemptDetails === void 0 ? {} : { attemptDetails },
+    ...accounting === void 0 ? {} : { accounting },
+    ...toolCalls === void 0 ? {} : { toolCalls },
+    ...activity === void 0 ? {} : { activity },
+    ...lastEventAt === void 0 ? {} : { lastEventAt }
+  };
+}
+function decodeRetry(value) {
+  if (!object(value) || typeof value.sourceRunId !== "string" || typeof value.lineageRootRunId !== "string") return void 0;
+  const completedPaths = decodeStringArray(value.completedPaths);
+  const incompletePaths = decodeStringArray(value.incompletePaths);
+  const namedWorktrees = decodeStringArray(value.namedWorktrees);
+  if (!completedPaths || !incompletePaths || !namedWorktrees) return void 0;
+  return { sourceRunId: value.sourceRunId, lineageRootRunId: value.lineageRootRunId, completedPaths, incompletePaths, namedWorktrees };
+}
+function decodeWorkflowError(value) {
+  if (!object(value) || typeof value.code !== "string" || typeof value.message !== "string") return void 0;
+  const code = isWorkflowErrorCode(value.code) ? value.code : "INTERNAL_ERROR";
+  const failedAt = optionalString(value.failedAt);
+  if (failedAt === INVALID_PERSISTED_VALUE) return void 0;
+  return { code, message: value.message, ...failedAt === void 0 ? {} : { failedAt } };
+}
+function decodeUsage(value) {
+  if (!object(value) || !finiteNumber(value.tokens) || !finiteNumber(value.costUsd) || !finiteNumber(value.durationMs) || !finiteNumber(value.agentLaunches)) return void 0;
+  return { tokens: value.tokens, costUsd: value.costUsd, durationMs: value.durationMs, agentLaunches: value.agentLaunches };
+}
+function decodeBudgetEvent(value) {
+  if (!object(value) || !isBudgetEventType(value.type) || !integer(value.budgetVersion) || !finiteNumber(value.at)) return void 0;
+  const dimensions = decodeArray(value.dimensions, (entry) => isBudgetDimension(entry) ? entry : void 0);
+  const usage = decodeUsage(value.usage);
+  const limits = decodeBudget(value.limits);
+  const proposalId = optionalString(value.proposalId);
+  const previous = value.previous === void 0 ? void 0 : decodeBudget(value.previous);
+  const proposed = value.proposed === void 0 ? void 0 : decodeBudget(value.proposed);
+  if (!dimensions || !usage || !limits || proposalId === INVALID_PERSISTED_VALUE || value.previous !== void 0 && !previous || value.proposed !== void 0 && !proposed) return void 0;
+  return { type: value.type, budgetVersion: value.budgetVersion, dimensions, usage, limits, at: value.at, ...proposalId === void 0 ? {} : { proposalId }, ...previous === void 0 ? {} : { previous }, ...proposed === void 0 ? {} : { proposed } };
+}
+function decodePhaseRecord(value) {
+  if (!object(value) || typeof value.phase !== "string" || !integer(value.afterAgent)) return void 0;
+  return { phase: value.phase, afterAgent: value.afterAgent };
+}
+function decodeShellActivity(value) {
+  if (!object(value) || !integer(value.phaseIndex) || !integer(value.active) || !finiteNumber(value.startedAt)) return void 0;
+  return { phaseIndex: value.phaseIndex, active: value.active, startedAt: value.startedAt };
+}
+function decodeRunEvent(value) {
+  if (!object(value) || typeof value.type !== "string" || typeof value.message !== "string") return void 0;
+  const timestamp = optionalNumber(value.timestamp);
+  if (timestamp === INVALID_PERSISTED_VALUE) return void 0;
+  return { type: value.type, message: value.message, ...timestamp === void 0 ? {} : { timestamp } };
+}
+function decodeDelivery(value) {
+  if (!object(value)) return void 0;
+  const mode = value.mode;
+  const state = value.state;
+  if (mode !== "foreground" && mode !== "background" || state !== "attached" && state !== "pending" && state !== "delivered") return void 0;
+  const toolCallId = optionalString(value.toolCallId);
+  if (toolCallId === INVALID_PERSISTED_VALUE) return void 0;
+  return { mode, state, ...toolCallId === void 0 ? {} : { toolCallId } };
+}
+function decodePersistedRun(value, allowLegacyAgentSessions = false) {
+  if (!object(value) || typeof value.id !== "string" || typeof value.workflowName !== "string" || typeof value.cwd !== "string" || typeof value.sessionId !== "string" || !isRunState(value.state)) return void 0;
+  const agentSessions = value.agentSessions === void 0 && allowLegacyAgentSessions ? [] : decodeArray(value.agentSessions, decodeAgentSession);
+  const agents = decodeArray(value.agents, decodeAgent);
+  const parentRunId = optionalString(value.parentRunId);
+  const retry = value.retry === void 0 ? void 0 : decodeRetry(value.retry);
+  const phase = optionalString(value.phase);
+  const phaseHistory = value.phaseHistory === void 0 ? void 0 : decodeArray(value.phaseHistory, decodePhaseRecord);
+  const phaseHistoryIndex = optionalNumber(value.phaseHistoryIndex);
+  const activeShells = optionalNumber(value.activeShells);
+  const activeShellStartedAt = optionalNumber(value.activeShellStartedAt);
+  const activeShellsByPhase = value.activeShellsByPhase === void 0 ? void 0 : decodeArray(value.activeShellsByPhase, decodeShellActivity);
+  const error = value.error === void 0 ? void 0 : decodeWorkflowError(value.error);
+  const failedAt = optionalString(value.failedAt);
+  const budget = value.budget === void 0 ? void 0 : decodeBudget(value.budget);
+  const budgetVersion = optionalNumber(value.budgetVersion);
+  const usage = value.usage === void 0 ? void 0 : decodeUsage(value.usage);
+  const budgetEvents = value.budgetEvents === void 0 ? void 0 : decodeArray(value.budgetEvents, decodeBudgetEvent);
+  const events = value.events === void 0 ? void 0 : decodeArray(value.events, decodeRunEvent);
+  const delivery = value.delivery === void 0 ? void 0 : decodeDelivery(value.delivery);
+  if (!agentSessions || !agents || parentRunId === INVALID_PERSISTED_VALUE || value.retry !== void 0 && !retry || phase === INVALID_PERSISTED_VALUE || value.phaseHistory !== void 0 && !phaseHistory || phaseHistoryIndex === INVALID_PERSISTED_VALUE || activeShells === INVALID_PERSISTED_VALUE || activeShellStartedAt === INVALID_PERSISTED_VALUE || value.activeShellsByPhase !== void 0 && !activeShellsByPhase || value.error !== void 0 && !error || failedAt === INVALID_PERSISTED_VALUE || value.budget !== void 0 && !budget || budgetVersion === INVALID_PERSISTED_VALUE || value.budgetVersion !== void 0 && !integer(budgetVersion) || value.usage !== void 0 && !usage || value.budgetEvents !== void 0 && !budgetEvents || value.events !== void 0 && !events || value.delivery !== void 0 && !delivery) return void 0;
+  if (value.agentSessions === void 0 && !allowLegacyAgentSessions) return void 0;
+  return {
+    id: value.id,
+    workflowName: value.workflowName,
+    cwd: value.cwd,
+    sessionId: value.sessionId,
+    state: value.state,
+    agentSessions,
+    ...parentRunId === void 0 ? {} : { parentRunId },
+    ...retry === void 0 ? {} : { retry },
+    ...phase === void 0 ? {} : { phase },
+    ...phaseHistory === void 0 ? {} : { phaseHistory },
+    ...phaseHistoryIndex === void 0 ? {} : { phaseHistoryIndex },
+    agents,
+    ...activeShells === void 0 ? {} : { activeShells },
+    ...activeShellStartedAt === void 0 ? {} : { activeShellStartedAt },
+    ...activeShellsByPhase === void 0 ? {} : { activeShellsByPhase },
+    ...error === void 0 ? {} : { error },
+    ...failedAt === void 0 ? {} : { failedAt },
+    ...budget === void 0 ? {} : { budget },
+    ...budgetVersion === void 0 ? {} : { budgetVersion },
+    ...usage === void 0 ? {} : { usage },
+    ...budgetEvents === void 0 ? {} : { budgetEvents },
+    ...events === void 0 ? {} : { events },
+    ...delivery === void 0 ? {} : { delivery }
+  };
+}
+function decodeLaunchSnapshot(value) {
+  if (!object(value) || typeof value.script !== "string") return void 0;
+  const identityVersion = optionalNumber(value.identityVersion);
+  const launchMode = value.launchMode;
+  const args = decodeJsonValue(value.args);
+  const metadata = decodeWorkflowMetadata(value.metadata);
+  const settings = decodeWorkflowSettings(value.settings);
+  const settingsSources = value.settingsSources === void 0 ? void 0 : decodeWorkflowSettingsSources(value.settingsSources);
+  const budget = value.budget === void 0 ? void 0 : decodeBudget(value.budget);
+  const settingsPath = optionalString(value.settingsPath);
+  const modelAliases = value.modelAliases === void 0 ? void 0 : decodeStringMap(value.modelAliases);
+  const phases = value.phases === void 0 ? void 0 : decodeStringArray(value.phases);
+  const models = decodeStringArray(value.models);
+  const tools = decodeStringArray(value.tools);
+  const agentTypes = decodeStringArray(value.agentTypes);
+  const roles = value.roles === void 0 ? void 0 : decodeRecord(value.roles, decodeAgentDefinition);
+  const projectRoles = value.projectRoles === void 0 ? void 0 : decodeStringArray(value.projectRoles);
+  const schemas = decodeArray(value.schemas, decodeJsonObject);
+  if (identityVersion === INVALID_PERSISTED_VALUE || value.identityVersion !== void 0 && !integer(identityVersion) || launchMode !== void 0 && !isLaunchMode(launchMode) || args === void 0 || !metadata || !settings || value.settingsSources !== void 0 && !settingsSources || value.budget !== void 0 && !budget || settingsPath === INVALID_PERSISTED_VALUE || value.modelAliases !== void 0 && !modelAliases || value.phases !== void 0 && !phases || !models || !tools || !agentTypes || value.roles !== void 0 && !roles || value.projectRoles !== void 0 && !projectRoles || !schemas) return void 0;
+  return {
+    ...identityVersion === void 0 ? {} : { identityVersion },
+    ...launchMode === void 0 ? {} : { launchMode },
+    script: value.script,
+    args,
+    metadata,
+    settings,
+    ...settingsSources === void 0 ? {} : { settingsSources },
+    ...budget === void 0 ? {} : { budget },
+    ...settingsPath === void 0 ? {} : { settingsPath },
+    ...modelAliases === void 0 ? {} : { modelAliases },
+    ...phases === void 0 ? {} : { phases },
+    models,
+    tools,
+    agentTypes,
+    ...roles === void 0 ? {} : { roles },
+    ...projectRoles === void 0 ? {} : { projectRoles },
+    schemas
+  };
+}
+function decodeOwnershipRecord(value) {
+  if (!object(value) || typeof value.id !== "string" || typeof value.label !== "string" || !isAgentState(value.state)) return void 0;
+  const parentId = optionalString(value.parentId);
+  const prompt = optionalString(value.prompt);
+  const options = decodeScheduledAgentOptions(value.options);
+  if (parentId === INVALID_PERSISTED_VALUE || prompt === INVALID_PERSISTED_VALUE || !options) return void 0;
+  return { id: value.id, label: value.label, state: value.state, options, ...parentId === void 0 ? {} : { parentId }, ...prompt === void 0 ? {} : { prompt } };
+}
+function decodeOwnershipRecords(value) {
+  return decodeArray(value, decodeOwnershipRecord);
+}
+function decodeWorktreeReference(value) {
+  if (!object(value) || typeof value.owner !== "string" || typeof value.path !== "string" || typeof value.branch !== "string" || typeof value.cwd !== "string" || typeof value.base !== "string") return void 0;
+  return { owner: value.owner, path: value.path, branch: value.branch, cwd: value.cwd, base: value.base };
+}
+function decodeWorktreeReferences(value) {
+  return decodeArray(value, decodeWorktreeReference);
+}
+function decodeBorrowedWorktreeBinding(value) {
+  if (!object(value) || typeof value.name !== "string" || typeof value.sourceRunId !== "string" || typeof value.owner !== "string") return void 0;
+  return { name: value.name, sourceRunId: value.sourceRunId, owner: value.owner };
+}
+function decodeBorrowedWorktreeBindings(value) {
+  return decodeArray(value, decodeBorrowedWorktreeBinding);
+}
+function decodeCompletedOperation(value) {
+  if (!object(value) || typeof value.path !== "string") return void 0;
+  const decodedValue = decodeJsonValue(value.value);
+  if (decodedValue === void 0) return void 0;
+  return { path: value.path, value: decodedValue };
+}
+function decodeAwaitingCheckpoint(value) {
+  if (!object(value) || typeof value.path !== "string" || typeof value.name !== "string" || typeof value.prompt !== "string") return void 0;
+  const context = decodeJsonValue(value.context);
+  if (context === void 0) return void 0;
+  return { path: value.path, name: value.name, prompt: value.prompt, context };
+}
+function decodePendingWorkflowDecision(value) {
+  if (!object(value) || value.kind !== "budget" || typeof value.proposalId !== "string" || typeof value.runId !== "string" || !integer(value.budgetVersion)) return void 0;
+  const consumed = decodeUsage(value.consumed);
+  const previous = decodeBudget(value.previous);
+  const proposed = decodeBudget(value.proposed);
+  const foreground = optionalBoolean(value.foreground);
+  if (!consumed || !previous || !proposed || foreground === INVALID_PERSISTED_VALUE) return void 0;
+  return { kind: "budget", proposalId: value.proposalId, runId: value.runId, consumed, previous, proposed, budgetVersion: value.budgetVersion, ...foreground === void 0 ? {} : { foreground } };
+}
+function decodeJournal(value) {
+  if (!object(value)) return void 0;
+  const completed = decodeRecord(value.completed, decodeCompletedOperation);
+  const awaiting = value.awaiting === void 0 ? void 0 : decodeRecord(value.awaiting, decodeAwaitingCheckpoint);
+  const decisions = value.decisions === void 0 ? void 0 : decodeRecord(value.decisions, decodePendingWorkflowDecision);
+  if (!completed || value.awaiting !== void 0 && !awaiting || value.decisions !== void 0 && !decisions) return void 0;
+  return { completed, ...awaiting === void 0 ? {} : { awaiting }, ...decisions === void 0 ? {} : { decisions } };
+}
+function decodeBooleanCheckpointResult(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function decodeSummaryProjection(value) {
+  if (!object(value)) return void 0;
+  const createdAt = optionalString(value.createdAt);
+  const updatedAt = optionalString(value.updatedAt);
+  const terminalAt = optionalString(value.terminalAt);
+  if (createdAt === INVALID_PERSISTED_VALUE || updatedAt === INVALID_PERSISTED_VALUE || terminalAt === INVALID_PERSISTED_VALUE) return void 0;
+  return { ...createdAt === void 0 ? {} : { createdAt }, ...updatedAt === void 0 ? {} : { updatedAt }, ...terminalAt === void 0 ? {} : { terminalAt } };
+}
+function decodeEffectiveSystemPrompt(value) {
+  if (!object(value) || typeof value.sessionId !== "string" || !positiveInteger(value.attempt) || !positiveInteger(value.turn) || typeof value.sha256 !== "string" || !/^[0-9a-f]{64}$/.test(value.sha256) || typeof value.prompt !== "string") return void 0;
+  return { sessionId: value.sessionId, attempt: value.attempt, turn: value.turn, sha256: value.sha256, prompt: value.prompt };
+}
+function decodeSystemPromptArtifact(value) {
+  if (!object(value) || !finiteNumber(value.version)) return void 0;
+  const entries = value.entries === void 0 ? void 0 : decodeArray(value.entries, decodeEffectiveSystemPrompt);
+  if (value.entries !== void 0 && !entries) return void 0;
+  return { version: value.version, ...value.format === void 0 ? {} : { format: value.format }, ...value.storage === void 0 ? {} : { storage: value.storage }, ...entries === void 0 ? {} : { entries } };
+}
+
+// src/io.ts
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { renameSync, rmSync, writeFileSync } from "node:fs";
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+import { promisify } from "node:util";
+var execute = promisify(execFile);
+var RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 400, 800];
+var syncSleepBuffer = new Int32Array(new SharedArrayBuffer(4));
+function retryableRenameError(error) {
+  return isNodeError(error, "EPERM") || isNodeError(error, "EBUSY") || isNodeError(error, "EACCES");
+}
+async function renameWithRetry(from, to) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      await rename(from, to);
+      return;
+    } catch (error) {
+      const delayMs = RENAME_RETRY_DELAYS_MS[attempt];
+      if (!retryableRenameError(error) || delayMs === void 0) throw error;
+      await new Promise((resolve5) => setTimeout(resolve5, delayMs));
+    }
+  }
+}
+function renameSyncWithRetry(from, to) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      renameSync(from, to);
+      return;
+    } catch (error) {
+      const delayMs = RENAME_RETRY_DELAYS_MS[attempt];
+      if (!retryableRenameError(error) || delayMs === void 0) throw error;
+      Atomics.wait(syncSleepBuffer, 0, 0, delayMs);
+    }
+  }
+}
+var gitIdentity = {
+  GIT_AUTHOR_NAME: "pi-extensible-workflows",
+  GIT_AUTHOR_EMAIL: "pi-extensible-workflows@localhost",
+  GIT_COMMITTER_NAME: "pi-extensible-workflows",
+  GIT_COMMITTER_EMAIL: "pi-extensible-workflows@localhost",
+  GIT_AUTHOR_DATE: "2000-01-01T00:00:00Z",
+  GIT_COMMITTER_DATE: "2000-01-01T00:00:00Z"
+};
+function atomicWriteFile(path, content, sync = false) {
+  const temporary = `${path}.${String(process.pid)}.${randomUUID()}.tmp`;
+  if (sync) {
+    try {
+      writeFileSync(temporary, content, { encoding: "utf8", mode: 384 });
+      renameSyncWithRetry(temporary, path);
+    } catch (error) {
+      try {
+        rmSync(temporary, { force: true });
+      } catch {
+      }
+      throw error;
+    }
+    return;
+  }
+  return writeFile(temporary, content, { encoding: "utf8", mode: 384 }).then(() => renameWithRetry(temporary, path)).catch(async (error) => {
+    try {
+      await rm(temporary, { force: true });
+    } catch {
+    }
+    throw error;
+  });
+}
+async function atomicJson(path, value) {
+  const serialized = JSON.stringify(value);
+  if (typeof serialized !== "string") throw new WorkflowError("INTERNAL_ERROR", `Cannot serialize JSON for ${path}`);
+  await atomicWriteFile(path, `${serialized}
+`);
+}
+async function atomicPrettyJson(path, value) {
+  await atomicWriteFile(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function json(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+async function git(cwd, args, extraEnv = {}) {
+  const { stdout } = await execute("git", ["-c", "core.hooksPath=/dev/null", "-c", "commit.gpgSign=false", ...args], { cwd, env: { ...process.env, ...extraEnv }, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
+  return stdout;
+}
+
+// src/paths.ts
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+function safePart(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function canonicalPath(path) {
+  const absolute = resolve(path);
+  try {
+    return realpathSync(absolute);
+  } catch {
+    return absolute;
+  }
+}
+function sameFilesystemPath(left, right) {
+  return canonicalPath(left) === canonicalPath(right);
+}
+function workflowProjectSettingsPath(cwd) {
+  return join(cwd, ".pi", "pi-extensible-workflows", "settings.json");
+}
+function projectStorageKey(cwd) {
+  const exact = resolve(cwd);
+  const slug = safePart(basename(exact)) || "root";
+  return `${slug}-${createHash("sha256").update(exact).digest("hex").slice(0, 12)}`;
+}
+function projectSessionsDirectory(cwd, home = homedir()) {
+  return join(home, ".pi", "workflows", "projects", projectStorageKey(cwd), "sessions");
+}
+function runsDirectory(cwd, sessionId, home = homedir()) {
+  return join(projectSessionsDirectory(cwd, home), safePart(sessionId), "runs");
+}
+function structuralPath(...names) {
+  if (names.length === 0 || names.some((name) => name.trim() === "")) throw new WorkflowError("INVALID_METADATA", "Structural paths require non-empty explicit names");
+  return names.map((name) => encodeURIComponent(name)).join("/");
+}
+
+// src/session-lease.ts
+var RUN_CREATE_TEMP = /^\.([a-zA-Z0-9._-]+)\.(\d+)\.[0-9a-f-]+\.tmp$/;
+async function processAlive(pid, startedAt) {
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    return !isNodeError(error, "ESRCH");
+  }
+  if (startedAt !== void 0 && process.platform === "linux") {
+    try {
+      if ((await stat(`/proc/${String(pid)}`)).ctimeMs > startedAt) return false;
+    } catch (error) {
+      if (isNodeError(error, "ENOENT")) return false;
+    }
+  }
+  return true;
+}
+async function cleanupRunTemps(directory, entries) {
+  await Promise.all(entries.map(async (entry) => {
+    const match = entry.isDirectory() ? RUN_CREATE_TEMP.exec(entry.name) : void 0;
+    const pid = match?.[2] ? Number(match[2]) : void 0;
+    if (pid && !await processAlive(pid)) await rm2(join2(directory, entry.name), { recursive: true, force: true });
+  }));
+}
+async function listRunIds(cwd, sessionId, home = homedir2(), cleanTemps = true) {
+  const directory = runsDirectory(cwd, sessionId, home);
+  try {
+    const entries = await readdir(directory, { withFileTypes: true });
+    if (cleanTemps) await cleanupRunTemps(directory, entries);
+    return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map(({ name }) => name);
+  } catch (error) {
+    if (isNodeError(error, "ENOENT")) return [];
+    throw error;
+  }
+}
+
+// src/trajectory.ts
+import { open as open2, readFile as readFile4, readdir as readdir3, stat as stat3 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { basename as basename4, dirname as dirname4, join as join6, resolve as resolve4 } from "node:path";
+import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, DefaultPackageManager, getAgentDir as getAgentDir2, SettingsManager, DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
+
+// src/store.ts
+import { execFile as execFile2 } from "node:child_process";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { access, mkdir as mkdir2, readdir as readdir2, readFile as readFile3, realpath, rename as rename3, rm as rm3, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { dirname, join as join3, relative, resolve as resolve2, sep } from "node:path";
+import { promisify as promisify2 } from "node:util";
+
+// src/budget.ts
+function budgetUsage(value) {
+  return { tokens: value?.tokens ?? 0, costUsd: value?.costUsd ?? 0, durationMs: value?.durationMs ?? 0, agentLaunches: value?.agentLaunches ?? 0 };
+}
+
+// src/store.ts
+var executeFile = promisify2(execFile2);
+var WORKTREE_POST_CREATE_TIMEOUT_MS = 6e4;
+var WORKTREE_POST_CREATE_OUTPUT_LIMIT = 4096;
+var SYSTEM_PROMPT_STORAGE = ".system-prompts";
+var SYSTEM_PROMPT_RECORDS = "records";
+var SYSTEM_PROMPT_BODIES = "bodies";
+var SYSTEM_PROMPT_SEQUENCE = "sequence";
+var SYSTEM_PROMPT_ARTIFACT = { version: 2, format: "append-only", storage: SYSTEM_PROMPT_STORAGE };
+function summaryArtifacts(directory) {
+  return { runDirectory: directory, statePath: join3(directory, "state.json"), journalPath: join3(directory, "journal.json"), snapshotPath: join3(directory, "snapshot.json"), workflowPath: join3(directory, "workflow.js"), resultPath: join3(directory, "result.json"), summaryPath: join3(directory, "summary.json") };
+}
+function summaryFromRun(run, directory, journal, previous, fallbackCreatedAt, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const createdAt = typeof previous?.createdAt === "string" ? previous.createdAt : fallbackCreatedAt;
+  const failedAt = run.failedAt ?? run.error?.failedAt;
+  const replayablePaths = [.../* @__PURE__ */ new Set([...run.retry?.completedPaths ?? [], ...Object.keys(journal.completed)])];
+  const incompletePaths = [.../* @__PURE__ */ new Set([...run.retry?.incompletePaths ?? [], ...failedAt ? [failedAt] : []])];
+  return { schemaVersion: 1, runId: run.id, sessionId: run.sessionId, workflowName: run.workflowName, state: run.state, createdAt, updatedAt: now, ...previous?.terminalAt || HARD_TERMINAL_RUN_STATES.has(run.state) ? { terminalAt: previous?.terminalAt ?? now } : {}, usage: budgetUsage(run.usage), agents: run.agents.map(({ id, name, label, state, role, attempts }) => ({ id, name, ...label ? { label } : {}, state, ...role ? { role } : {}, attempts })), ...run.error ? { error: run.error } : {}, ...failedAt ? { failedAt } : {}, replayablePaths, incompletePaths, artifacts: summaryArtifacts(directory) };
+}
+function systemPromptStoragePath(directory) {
+  return join3(directory, SYSTEM_PROMPT_STORAGE);
+}
+function systemPromptRecordsPath(directory) {
+  return join3(systemPromptStoragePath(directory), SYSTEM_PROMPT_RECORDS);
+}
+function systemPromptBodiesPath(directory) {
+  return join3(systemPromptStoragePath(directory), SYSTEM_PROMPT_BODIES);
+}
+function systemPromptSequencePath(directory) {
+  return join3(systemPromptStoragePath(directory), SYSTEM_PROMPT_SEQUENCE);
+}
+function systemPromptRecordName(sequence) {
+  return `${String(sequence).padStart(20, "0")}.json`;
+}
+async function createSystemPromptStorage(directory, writeArtifact) {
+  const storage = systemPromptStoragePath(directory);
+  await mkdir2(join3(storage, SYSTEM_PROMPT_RECORDS), { recursive: true, mode: 448 });
+  await mkdir2(join3(storage, SYSTEM_PROMPT_BODIES), { recursive: true, mode: 448 });
+  await atomicWriteFile(systemPromptSequencePath(directory), "0\n");
+  if (writeArtifact) await atomicJson(join3(directory, "system-prompts.json"), SYSTEM_PROMPT_ARTIFACT);
+}
+var RunStore = class _RunStore {
+  constructor(cwd, sessionId, runId, home = homedir3()) {
+    this.cwd = cwd;
+    this.sessionId = sessionId;
+    this.runId = runId;
+    this.home = home;
+    this.cwd = resolve2(cwd);
+    this.directory = join3(runsDirectory(this.cwd, sessionId, home), safePart(runId));
+  }
+  cwd;
+  sessionId;
+  runId;
+  home;
+  directory;
+  journalLane = new SerialLane();
+  // ponytail: serializes one RunStore instance; cross-process run sharing remains unsupported.
+  stateLane = new SerialLane();
+  summaryLane = new SerialLane();
+  worktreeLane = new SerialLane();
+  borrowedWorktreeLane = new SerialLane();
+  snapshotLane = new SerialLane();
+  launchSnapshotLane = new SerialLane();
+  // ponytail: the session lease prevents concurrent RunStore writers for one run.
+  systemPromptLane = new SerialLane();
+  #assertRunIdentity(run, code, message) {
+    if (resolve2(run.cwd) !== this.cwd || run.sessionId !== this.sessionId || run.id !== this.runId) throw new WorkflowError(code, message);
+  }
+  async create(run, snapshot) {
+    this.#assertRunIdentity(run, "INTERNAL_ERROR", "Run identity does not match its session-scoped store");
+    const temporary = join3(dirname(this.directory), `.${safePart(this.runId)}.${String(process.pid)}.${randomUUID2()}.tmp`);
+    await mkdir2(dirname(this.directory), { recursive: true, mode: 448 });
+    await mkdir2(temporary, { mode: 448 });
+    try {
+      await writeFile2(join3(temporary, "workflow.js"), snapshot.script, { encoding: "utf8", mode: 384 });
+      await atomicJson(join3(temporary, "snapshot.json"), snapshot);
+      await atomicJson(join3(temporary, "journal.json"), { completed: {}, awaiting: {}, decisions: {} });
+      await atomicJson(join3(temporary, "ownership.json"), []);
+      await atomicJson(join3(temporary, "worktrees.json"), []);
+      await atomicJson(join3(temporary, "borrowed-worktrees.json"), []);
+      await atomicJson(join3(temporary, "state.json"), run);
+      await createSystemPromptStorage(temporary, true);
+      await atomicJson(join3(temporary, "summary.json"), summaryFromRun(run, this.directory, { completed: {} }, void 0, (/* @__PURE__ */ new Date()).toISOString()));
+      await rename3(temporary, this.directory);
+    } catch (error) {
+      await rm3(temporary, { recursive: true, force: true });
+      throw error;
+    }
+  }
+  async refreshSummary() {
+    const write = this.summaryLane.run(async () => {
+      const run = decodePersistedRun(await json(join3(this.directory, "state.json")), true);
+      const journal = decodeJournal(await json(join3(this.directory, "journal.json")));
+      const previous = await json(join3(this.directory, "summary.json")).then(decodeSummaryProjection).catch(() => void 0);
+      if (!run || !journal) throw new Error("Persisted run or journal is invalid");
+      const fallbackCreatedAt = await stat2(join3(this.directory, "state.json")).then((value) => new Date(value.mtimeMs).toISOString());
+      await atomicJson(join3(this.directory, "summary.json"), summaryFromRun(run, this.directory, journal, previous, fallbackCreatedAt));
+    });
+    await write;
+  }
+  //NOTE: summary.json is an optional derived cache (see OPTIONAL_RUN_FILES); a missed refresh self-heals because every reader (loadSummary, CLI inspector) recomputes from state/journal. Keep this best-effort so a cache hiccup never fails the primary write.
+  refreshSummaryBestEffort() {
+    void this.refreshSummary().catch(() => void 0);
+  }
+  async isComplete() {
+    try {
+      await Promise.all([access(join3(this.directory, "snapshot.json")), access(join3(this.directory, "journal.json")), access(join3(this.directory, "ownership.json")), access(join3(this.directory, "state.json"))]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async load() {
+    await this.stateLane.run(async () => void 0);
+    const rawRun = await json(join3(this.directory, "state.json"));
+    const run = decodePersistedRun(rawRun, true);
+    if (!run) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted run is invalid");
+    this.#assertRunIdentity(run, "RESUME_INCOMPATIBLE", "Persisted run belongs to another cwd or Pi session");
+    if (!object(rawRun) || !Array.isArray(rawRun.agentSessions) || Object.hasOwn(rawRun, "nativeSessions")) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted run uses an unsupported agent session format");
+    const snapshot = decodeLaunchSnapshot(await json(join3(this.directory, "snapshot.json")));
+    if (!snapshot) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted launch snapshot is invalid");
+    return { run, snapshot: loadLaunchSnapshot(snapshot) };
+  }
+  async loadStatus() {
+    await this.stateLane.run(async () => void 0);
+    const run = decodePersistedRun(await json(join3(this.directory, "state.json")), true);
+    if (!run) throw new WorkflowError("RUN_NOT_FOUND", "Persisted run is invalid");
+    this.#assertRunIdentity(run, "RUN_NOT_FOUND", "Persisted run does not belong to this project");
+    return run;
+  }
+  async loadSummary() {
+    await this.stateLane.run(async () => void 0);
+    await this.journalLane.run(async () => void 0);
+    await this.summaryLane.run(async () => void 0);
+    const run = decodePersistedRun(await json(join3(this.directory, "state.json")), true);
+    const journal = decodeJournal(await json(join3(this.directory, "journal.json")));
+    const previous = await json(join3(this.directory, "summary.json")).then(decodeSummaryProjection).catch(() => void 0);
+    if (!run || !journal) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted run or journal is invalid");
+    const [stateStat, journalStat] = await Promise.all([stat2(join3(this.directory, "state.json")), stat2(join3(this.directory, "journal.json"))]);
+    const fallbackCreatedAt = new Date(stateStat.mtimeMs).toISOString();
+    const previousUpdatedAt = previous?.updatedAt === void 0 ? Number.NaN : Date.parse(previous.updatedAt);
+    const updatedAt = new Date(Math.max(stateStat.mtimeMs, journalStat.mtimeMs, Number.isNaN(previousUpdatedAt) ? 0 : previousUpdatedAt)).toISOString();
+    return summaryFromRun(run, this.directory, journal, previous, fallbackCreatedAt, updatedAt);
+  }
+  async saveState(run) {
+    const write = this.stateLane.run(async () => {
+      this.#assertRunIdentity(run, "INTERNAL_ERROR", "Run identity does not match its session-scoped store");
+      await atomicJson(join3(this.directory, "state.json"), run);
+      this.refreshSummaryBestEffort();
+    });
+    await write;
+  }
+  async updateState(update) {
+    const write = this.stateLane.run(async () => {
+      const current = decodePersistedRun(await json(join3(this.directory, "state.json")));
+      if (!current) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted run is invalid");
+      this.#assertRunIdentity(current, "RESUME_INCOMPATIBLE", "Persisted run belongs to another cwd or Pi session");
+      const result = await update(current);
+      this.#assertRunIdentity(result, "INTERNAL_ERROR", "Run identity does not match its session-scoped store");
+      await atomicJson(join3(this.directory, "state.json"), result);
+      this.refreshSummaryBestEffort();
+      return result;
+    });
+    return write;
+  }
+  async saveSnapshot(snapshot) {
+    const write = this.launchSnapshotLane.run(() => atomicJson(join3(this.directory, "snapshot.json"), snapshot));
+    await write;
+  }
+  async appendEvent(event) {
+    await this.updateState((run) => ({ ...run, events: [...run.events ?? [], ...event.type !== "log" && run.events?.some((current) => current.type === event.type && current.message === event.message) ? [] : [event]] }));
+  }
+  async saveOwnership(nodes) {
+    await atomicJson(join3(this.directory, "ownership.json"), nodes);
+  }
+  async loadOwnership() {
+    const nodes = decodeOwnershipRecords(await json(join3(this.directory, "ownership.json")));
+    if (!nodes) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted ownership records are invalid");
+    return nodes;
+  }
+  systemPromptPath() {
+    return join3(this.directory, "system-prompts.json");
+  }
+  async readSystemPromptArtifact() {
+    try {
+      const artifact = decodeSystemPromptArtifact(await json(this.systemPromptPath()));
+      if (!artifact) throw new Error("Persisted system prompts are invalid");
+      return artifact;
+    } catch (error) {
+      if (isNodeError(error, "ENOENT")) return void 0;
+      throw error;
+    }
+  }
+  async appendSystemPromptV2(entry) {
+    const sha256 = createHash2("sha256").update(entry.prompt).digest("hex");
+    const bodyPath = join3(systemPromptBodiesPath(this.directory), sha256);
+    try {
+      await access(bodyPath);
+    } catch (error) {
+      if (!isNodeError(error, "ENOENT")) throw error;
+      await atomicWriteFile(bodyPath, entry.prompt);
+    }
+    const previous = Number(await readFile3(systemPromptSequencePath(this.directory), "utf8"));
+    if (!Number.isSafeInteger(previous) || previous < 0 || previous >= Number.MAX_SAFE_INTEGER) throw new Error("Persisted system-prompt sequence is invalid");
+    const sequence = previous + 1;
+    await atomicWriteFile(systemPromptSequencePath(this.directory), `${String(sequence)}
+`);
+    await atomicJson(join3(systemPromptRecordsPath(this.directory), systemPromptRecordName(sequence)), { sessionId: entry.sessionId, attempt: entry.attempt, turn: entry.turn, sha256 });
+  }
+  async migrateSystemPrompts(legacy) {
+    await rm3(systemPromptStoragePath(this.directory), { recursive: true, force: true });
+    await createSystemPromptStorage(this.directory, false);
+    for (const entry of legacy.entries ?? []) await this.appendSystemPromptV2(entry);
+    await atomicJson(this.systemPromptPath(), SYSTEM_PROMPT_ARTIFACT);
+  }
+  async prepareSystemPromptStorage() {
+    const artifact = await this.readSystemPromptArtifact();
+    if (artifact === void 0) {
+      await rm3(systemPromptStoragePath(this.directory), { recursive: true, force: true });
+      await createSystemPromptStorage(this.directory, true);
+    } else if (artifact.version === 1) {
+      if (!Array.isArray(artifact.entries)) throw new Error("Persisted system prompts are invalid");
+      await this.migrateSystemPrompts(artifact);
+    } else if (artifact.version !== SYSTEM_PROMPT_ARTIFACT.version || artifact.format !== SYSTEM_PROMPT_ARTIFACT.format || artifact.storage !== SYSTEM_PROMPT_ARTIFACT.storage) throw new Error("Persisted system prompts are invalid");
+  }
+  async readSystemPromptsV2() {
+    const artifact = await this.readSystemPromptArtifact();
+    if (!artifact || artifact.version !== SYSTEM_PROMPT_ARTIFACT.version || artifact.format !== SYSTEM_PROMPT_ARTIFACT.format || artifact.storage !== SYSTEM_PROMPT_ARTIFACT.storage) throw new Error("Persisted system prompts are invalid");
+    const sequence = Number(await readFile3(systemPromptSequencePath(this.directory), "utf8"));
+    if (!Number.isSafeInteger(sequence) || sequence < 0) throw new Error("Persisted system-prompt sequence is invalid");
+    const names = (await readdir2(systemPromptRecordsPath(this.directory))).filter((name) => !name.endsWith(".tmp")).sort();
+    const entries = [];
+    let highest = 0;
+    for (const name of names) {
+      const match = /^(\d{20})\.json$/.exec(name);
+      if (!match) throw new Error("Persisted system-prompt records are invalid");
+      const recordSequence = Number(match[1]);
+      if (!Number.isSafeInteger(recordSequence) || recordSequence < 1) throw new Error("Persisted system-prompt records are invalid");
+      highest = Math.max(highest, recordSequence);
+      const record = await json(join3(systemPromptRecordsPath(this.directory), name));
+      if (!object(record)) throw new Error("Persisted system-prompt record is invalid");
+      const sessionId = record.sessionId;
+      const attempt = record.attempt;
+      const turn = record.turn;
+      const sha256 = record.sha256;
+      if (typeof sessionId !== "string" || !sessionId || !positiveInteger(attempt) || !positiveInteger(turn) || typeof sha256 !== "string" || !/^[0-9a-f]{64}$/.test(sha256)) throw new Error("Persisted system-prompt record is invalid");
+      const prompt = await readFile3(join3(systemPromptBodiesPath(this.directory), sha256), "utf8");
+      if (createHash2("sha256").update(prompt).digest("hex") !== sha256) throw new Error("Persisted system-prompt body is invalid");
+      entries.push({ sessionId, attempt, turn, sha256, prompt });
+    }
+    if (sequence < highest) throw new Error("Persisted system-prompt sequence is invalid");
+    return entries;
+  }
+  async recordSystemPrompt(entry) {
+    const write = this.systemPromptLane.run(async () => {
+      await this.prepareSystemPromptStorage();
+      await this.appendSystemPromptV2(entry);
+    });
+    await write;
+  }
+  async systemPrompts() {
+    await this.systemPromptLane.run(async () => void 0);
+    const artifact = await this.readSystemPromptArtifact();
+    if (artifact === void 0) return [];
+    if (artifact.version === 1) return artifact.entries ?? [];
+    if (artifact.version === SYSTEM_PROMPT_ARTIFACT.version) return this.readSystemPromptsV2();
+    throw new Error("Persisted system prompts are invalid");
+  }
+  async #decodeJournal() {
+    const journal = decodeJournal(await json(join3(this.directory, "journal.json")));
+    if (!journal) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted journal is invalid");
+    return journal;
+  }
+  /** Reads the journal after every queued journal write has settled. */
+  async #readJournal() {
+    await this.journalLane.run(async () => void 0);
+    return this.#decodeJournal();
+  }
+  async updateJournal(update) {
+    const write = this.journalLane.run(async () => {
+      const journal = await this.#decodeJournal();
+      journal.awaiting ??= {};
+      const result = await update(journal);
+      await atomicJson(join3(this.directory, "journal.json"), journal);
+      this.refreshSummaryBestEffort();
+      return result;
+    });
+    return write;
+  }
+  async complete(path, value) {
+    await this.updateJournal((journal) => {
+      if (journal.completed[path]) throw new WorkflowError("DUPLICATE_NAME", `Completed structural path already exists: ${path}`);
+      journal.completed[path] = { path, value };
+    });
+  }
+  async replay(path) {
+    const [operation] = await this.replayableOperationsFrom(/* @__PURE__ */ new Set(), path);
+    return operation;
+  }
+  async replayableOperations() {
+    return this.replayableOperationsFrom(/* @__PURE__ */ new Set());
+  }
+  /** Every journaled agent operation of the retry lineage, mapped to its session file when one was recorded. */
+  async agentSessionFiles() {
+    return this.agentSessionFilesFrom(/* @__PURE__ */ new Set());
+  }
+  async agentSessionFilesFrom(seen) {
+    if (seen.has(this.runId)) throw new WorkflowError("RESUME_INCOMPATIBLE", "Retry provenance contains a cycle");
+    const nextSeen = new Set(seen);
+    nextSeen.add(this.runId);
+    const loaded = await this.load();
+    const files = /* @__PURE__ */ new Map();
+    if (loaded.run.retry?.sourceRunId) {
+      const source = await this.sourceRun(loaded.run.retry.sourceRunId);
+      for (const [path, file] of await source.agentSessionFilesFrom(nextSeen)) files.set(path, file);
+    }
+    const journal = await this.#readJournal();
+    for (const agent of loaded.run.agents) {
+      if (!agent.resultPath || !journal.completed[agent.resultPath]) continue;
+      const locator = agent.attemptDetails?.filter((detail) => !detail.error).at(-1)?.session?.locator;
+      files.set(agent.resultPath, object(locator) && typeof locator.sessionFile === "string" ? locator.sessionFile : void 0);
+    }
+    return files;
+  }
+  /** Source lineage first, own journal last (it overrides); `path` narrows to one operation without cloning the rest. */
+  async replayableOperationsFrom(seen, path) {
+    if (seen.has(this.runId)) throw new WorkflowError("RESUME_INCOMPATIBLE", "Retry provenance contains a cycle");
+    const nextSeen = new Set(seen);
+    nextSeen.add(this.runId);
+    const loaded = await this.load();
+    const operations = /* @__PURE__ */ new Map();
+    if (loaded.run.retry?.sourceRunId) {
+      const source = await this.sourceRun(loaded.run.retry.sourceRunId);
+      for (const operation of await source.replayableOperationsFrom(nextSeen, path)) operations.set(operation.path, operation);
+    }
+    const journal = await this.#readJournal();
+    for (const operation of Object.values(journal.completed)) if (path === void 0 || operation.path === path) operations.set(operation.path, operation);
+    return [...operations.values()].map((operation) => structuredClone(operation));
+  }
+  async awaitCheckpoint(checkpoint) {
+    const replayed = await this.replay(checkpoint.path);
+    if (replayed) {
+      const result = decodeBooleanCheckpointResult(replayed.value);
+      if (result === void 0) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted checkpoint result is invalid");
+      return result;
+    }
+    return this.updateJournal((journal) => {
+      const completed = journal.completed[checkpoint.path];
+      if (completed) {
+        const result = decodeBooleanCheckpointResult(completed.value);
+        if (result === void 0) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted checkpoint result is invalid");
+        return result;
+      }
+      const awaiting = journal.awaiting ?? (journal.awaiting = {});
+      awaiting[checkpoint.path] = checkpoint;
+      return void 0;
+    });
+  }
+  async awaitingCheckpoints() {
+    return Object.values((await this.#readJournal()).awaiting ?? {});
+  }
+  async requestWorkflowDecision(request) {
+    await this.updateJournal((journal) => {
+      journal.decisions ??= {};
+      journal.decisions[request.proposalId] = request;
+    });
+  }
+  async pendingWorkflowDecisions() {
+    return Object.values((await this.#readJournal()).decisions ?? {});
+  }
+  async answerWorkflowDecision(proposalId, approved) {
+    return this.updateJournal((journal) => {
+      const request = journal.decisions?.[proposalId];
+      if (!request) return void 0;
+      journal.completed[`decision/${proposalId}`] = { path: `decision/${proposalId}`, value: approved };
+      delete journal.decisions?.[proposalId];
+      return request;
+    });
+  }
+  async answerCheckpoint(name, approved) {
+    return this.updateJournal((journal) => {
+      const checkpoint = Object.values(journal.awaiting ?? {}).find((item) => item.name === name);
+      if (!checkpoint || journal.completed[checkpoint.path]) return void 0;
+      journal.completed[checkpoint.path] = { path: checkpoint.path, value: approved };
+      journal.awaiting = Object.fromEntries(Object.entries(journal.awaiting ?? {}).filter(([path]) => path !== checkpoint.path));
+      return checkpoint;
+    });
+  }
+  #worktreeKey(owner) {
+    return createHash2("sha256").update(`${this.sessionId}\0${this.runId}\0${owner}`).digest("hex").slice(0, 16);
+  }
+  expectedWorktree(owner) {
+    const key = this.#worktreeKey(owner);
+    return { path: join3(this.directory, "worktrees", key), branch: `pi-extensible-workflows/${safePart(this.runId)}/${key}` };
+  }
+  markerPath(owner) {
+    return join3(this.directory, `worktree-${this.#worktreeKey(owner)}.creating`);
+  }
+  namedWorktreeOwner(name) {
+    if (!name.trim()) throw new WorkflowError("WORKTREE_FAILED", "Named worktree names must be non-empty");
+    return structuralPath("worktree", "named", name.trim());
+  }
+  worktreeName(owner) {
+    const prefix = `${structuralPath("worktree", "named")}/`;
+    if (!owner.startsWith(prefix)) return void 0;
+    const encoded = owner.slice(prefix.length);
+    if (!encoded || encoded.includes("/")) return void 0;
+    try {
+      const name = decodeURIComponent(encoded);
+      return name.trim() ? name : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async runWorktreePostCreateCommand(command, cwd, source) {
+    const executable = command[0];
+    if (!executable) return;
+    const display = command.map((argument) => JSON.stringify(argument)).join(" ");
+    try {
+      await executeFile(executable, [...command.slice(1)], { cwd, env: process.env, encoding: "utf8", timeout: WORKTREE_POST_CREATE_TIMEOUT_MS, maxBuffer: 1024 * 1024 });
+    } catch (error) {
+      const record = typeof error === "object" && error !== null ? error : {};
+      const code = record.code;
+      const signal = typeof record.signal === "string" ? record.signal : void 0;
+      const stderr = typeof record.stderr === "string" ? record.stderr.trim() : "";
+      const stdout = typeof record.stdout === "string" ? record.stdout.trim() : "";
+      const output = [stderr, stdout].filter(Boolean).join("\n").slice(0, WORKTREE_POST_CREATE_OUTPUT_LIMIT);
+      const provenance = source !== void 0 && sameFilesystemPath(source, workflowProjectSettingsPath(this.cwd)) ? "trusted project settings" : "global settings";
+      let category;
+      if (code === "ENOENT") category = `executable ${JSON.stringify(executable)} was not found`;
+      else if (code === "ETIMEDOUT" || record.killed === true && signal === "SIGTERM") category = `timed out after ${String(WORKTREE_POST_CREATE_TIMEOUT_MS / 1e3)} seconds`;
+      else if (typeof code === "number") category = `exited with status ${String(code)}`;
+      else if (signal) category = `was terminated by ${signal}`;
+      else category = `could not be started${typeof code === "string" ? ` (${code})` : ""}`;
+      throw new Error(`worktree post-create command ${display} from ${provenance} failed in ${cwd}: ${category}${output ? `; output: ${output}` : ""}`, { cause: error });
+    }
+  }
+  structuralWorktree(owner, record) {
+    const expected = this.expectedWorktree(owner);
+    const relativePath = relative(this.directory, record.path);
+    const relativeCwd = relative(record.path, record.cwd);
+    if (record.owner !== owner || resolve2(record.path) !== expected.path || record.branch !== expected.branch || relativePath === ".." || relativePath.startsWith(`..${sep}`) || relativeCwd === ".." || relativeCwd.startsWith(`..${sep}`)) throw new Error(`Invalid worktree record for ${owner}`);
+    return record;
+  }
+  async #loadWorktreeRecords(missingOk = true) {
+    const rawRecords = await json(join3(this.directory, "worktrees.json")).catch((error) => {
+      if (missingOk && isNodeError(error, "ENOENT")) return [];
+      throw error;
+    });
+    const records = decodeWorktreeReferences(rawRecords);
+    if (!records) throw new WorkflowError("WORKTREE_FAILED", "Worktree records are invalid");
+    return records;
+  }
+  async borrowedWorktreeRecords(wait = true) {
+    if (wait) await this.borrowedWorktreeLane.run(async () => void 0);
+    const rawRecords = await json(join3(this.directory, "borrowed-worktrees.json")).catch((error) => {
+      if (isNodeError(error, "ENOENT")) return [];
+      throw error;
+    });
+    const records = decodeBorrowedWorktreeBindings(rawRecords);
+    if (!records) throw new WorkflowError("WORKTREE_FAILED", "Borrowed worktree bindings are invalid");
+    const seen = /* @__PURE__ */ new Set();
+    return records.map((candidate) => {
+      if (!candidate.name.trim() || candidate.name !== candidate.name.trim() || !candidate.sourceRunId || candidate.owner !== this.namedWorktreeOwner(candidate.name)) throw new WorkflowError("WORKTREE_FAILED", "Borrowed worktree binding is invalid");
+      if (seen.has(candidate.name)) throw new WorkflowError("WORKTREE_FAILED", `Duplicate borrowed worktree binding for ${candidate.name}`);
+      seen.add(candidate.name);
+      return candidate;
+    });
+  }
+  async borrowedWorktrees() {
+    return this.borrowedWorktreeRecords();
+  }
+  async borrowedWorktree(name) {
+    return (await this.borrowedWorktreeRecords()).find((binding) => binding.name === name);
+  }
+  async sourceRun(sourceRunId) {
+    if (!sourceRunId || sourceRunId === this.runId) throw new WorkflowError("WORKTREE_FAILED", "Borrowed worktree source run is invalid");
+    const source = new _RunStore(this.cwd, this.sessionId, sourceRunId, this.home);
+    try {
+      const loaded = await source.load();
+      if (!HARD_TERMINAL_RUN_STATES.has(loaded.run.state)) throw new Error(`Source run ${sourceRunId} is not terminal`);
+      return source;
+    } catch (error) {
+      throw coerceWorkflowError("WORKTREE_FAILED", error);
+    }
+  }
+  async validateParentRun(parentRunId) {
+    await this.sourceRun(parentRunId);
+  }
+  async validateRetrySource() {
+    const validate = async (current, seen) => {
+      if (seen.has(current.runId)) throw new WorkflowError("RESUME_INCOMPATIBLE", "Retry provenance contains a cycle");
+      const nextSeen = new Set(seen);
+      nextSeen.add(current.runId);
+      const loaded = await current.load();
+      const retry = loaded.run.retry;
+      if (!retry) return;
+      if (!retry.sourceRunId || retry.sourceRunId === current.runId || !retry.lineageRootRunId) throw new WorkflowError("RESUME_INCOMPATIBLE", "Retry provenance is incomplete");
+      const source = await current.sourceRun(retry.sourceRunId);
+      const sourceRun = (await source.load()).run;
+      if (loaded.run.parentRunId !== retry.sourceRunId) throw new WorkflowError("RESUME_INCOMPATIBLE", "Retry parent run does not match its source run");
+      if (sourceRun.state !== "failed") throw new WorkflowError("RESUME_INCOMPATIBLE", `Retry source run ${retry.sourceRunId} is not failed`);
+      const expectedLineageRoot = sourceRun.retry?.lineageRootRunId ?? sourceRun.id;
+      if (retry.lineageRootRunId !== expectedLineageRoot) throw new WorkflowError("RESUME_INCOMPATIBLE", "Retry lineage root does not match its source run");
+      await validate(source, nextSeen);
+    };
+    try {
+      await validate(this, /* @__PURE__ */ new Set());
+    } catch (error) {
+      throw coerceWorkflowError("RESUME_INCOMPATIBLE", error);
+    }
+  }
+  async ownedWorktree(owner, cwd) {
+    const records = await this.#loadWorktreeRecords(false);
+    const matches = records.filter((candidate) => candidate.owner === owner);
+    if (matches.length !== 1) throw new Error(`Missing or duplicate worktree record for ${owner}`);
+    const record = matches[0];
+    if (!record) throw new Error(`Missing or duplicate worktree record for ${owner}`);
+    const validated = this.structuralWorktree(owner, record);
+    if (cwd !== void 0 && resolve2(cwd) !== resolve2(validated.cwd)) throw new Error(`Invalid worktree record for ${owner}`);
+    await access(validated.cwd);
+    return validated;
+  }
+  async resolveBorrowedWorktree(binding, seen) {
+    try {
+      const source = await this.sourceRun(binding.sourceRunId);
+      const resolved = await source.findNamedWorktree(binding.name, seen);
+      if (!resolved) throw new Error(`Missing named worktree ${binding.name} in source run ${binding.sourceRunId}`);
+      if (resolved.owner !== binding.owner) throw new Error(`Borrowed worktree binding does not match source owner for ${binding.name}`);
+      return resolved;
+    } catch (error) {
+      throw coerceWorkflowError("WORKTREE_FAILED", error);
+    }
+  }
+  async findNamedWorktree(name, seen = /* @__PURE__ */ new Set()) {
+    const owner = this.namedWorktreeOwner(name);
+    if (seen.has(this.runId)) throw new WorkflowError("WORKTREE_FAILED", "Borrowed worktree bindings contain a cycle");
+    const nextSeen = new Set(seen);
+    nextSeen.add(this.runId);
+    const binding = await this.borrowedWorktree(name);
+    if (binding) {
+      const loaded = await this.load();
+      if (loaded.run.parentRunId === void 0) throw new WorkflowError("WORKTREE_FAILED", `Borrowed worktree ${name} has no parent run`);
+      const parent = await this.sourceRun(loaded.run.parentRunId);
+      const resolved = await parent.findNamedWorktree(name, nextSeen);
+      if (!resolved || resolved.sourceRunId !== binding.sourceRunId || resolved.owner !== binding.owner) throw new WorkflowError("WORKTREE_FAILED", `Borrowed worktree binding for ${name} is not inherited from its parent run`);
+      return resolved;
+    }
+    const records = await this.#loadWorktreeRecords(false);
+    const matches = records.filter((candidate) => candidate.owner === owner);
+    if (matches.length === 0) {
+      const loaded = await this.load();
+      if (loaded.run.parentRunId === void 0) return void 0;
+      const parent = await this.sourceRun(loaded.run.parentRunId);
+      return parent.findNamedWorktree(name, nextSeen);
+    }
+    try {
+      const reference = await this.ownedWorktree(owner);
+      return { reference, sourceRunId: this.runId, owner };
+    } catch (error) {
+      throw coerceWorkflowError("WORKTREE_FAILED", error);
+    }
+  }
+  async resolveNamedWorktree(name, seen = /* @__PURE__ */ new Set()) {
+    const resolved = await this.findNamedWorktree(name, seen);
+    if (!resolved) throw new WorkflowError("WORKTREE_FAILED", `Missing named worktree ${name}`);
+    return resolved;
+  }
+  async validateDeletionWorktrees() {
+    try {
+      const records = await this.#loadWorktreeRecords(false);
+      const owners = /* @__PURE__ */ new Set();
+      const paths = /* @__PURE__ */ new Set();
+      for (const record of records) {
+        const owner = record.owner;
+        if (owners.has(owner)) throw new Error(`Duplicate worktree record for ${owner}`);
+        owners.add(owner);
+        const reference = this.structuralWorktree(owner, record);
+        paths.add(resolve2(reference.path));
+      }
+      const entries = await readdir2(join3(this.directory, "worktrees"), { withFileTypes: true }).catch((error) => {
+        if (isNodeError(error, "ENOENT")) return [];
+        throw error;
+      });
+      for (const entry of entries) if (!entry.isDirectory() || entry.isSymbolicLink() || !paths.has(resolve2(join3(this.directory, "worktrees", entry.name)))) throw new Error(`Unrecorded worktree artifact: ${join3(this.directory, "worktrees", entry.name)}`);
+    } catch (error) {
+      throw coerceWorkflowError("WORKTREE_FAILED", error);
+    }
+  }
+  async validateBorrowedWorktrees() {
+    try {
+      const loaded = await this.load();
+      if (loaded.run.parentRunId !== void 0) await this.validateParentRun(loaded.run.parentRunId);
+      for (const binding of await this.borrowedWorktreeRecords()) await this.resolveBorrowedWorktree(binding, /* @__PURE__ */ new Set([this.runId]));
+    } catch (error) {
+      throw coerceWorkflowError("WORKTREE_FAILED", error);
+    }
+  }
+  async validateNamedWorktrees() {
+    try {
+      const records = await this.#loadWorktreeRecords(false);
+      for (const record of records) {
+        const owner = record.owner;
+        if (this.worktreeName(owner)) await this.validateWorktree(owner);
+      }
+    } catch (error) {
+      throw coerceWorkflowError("WORKTREE_FAILED", error);
+    }
+  }
+  async ownsWorktree(owner) {
+    const records = await this.#loadWorktreeRecords(false);
+    return records.filter((candidate) => candidate.owner === owner).length === 1;
+  }
+  async cleanupMarker(markerPath) {
+    let marker;
+    try {
+      const parsed = await json(markerPath);
+      if (!object(parsed)) return;
+      marker = parsed;
+    } catch {
+      return;
+    }
+    if (typeof marker.owner !== "string" || typeof marker.base !== "string") return;
+    const expected = this.expectedWorktree(marker.owner);
+    if (marker.path !== expected.path || marker.branch !== expected.branch) return;
+    const root = await git(this.cwd, ["rev-parse", "--show-toplevel"]).then((value) => value.trim()).catch(() => "");
+    if (!root) return;
+    const branchBase = await git(root, ["rev-parse", "--verify", `${expected.branch}^{commit}`]).then((value) => value.trim()).catch(() => "");
+    if (branchBase !== marker.base) return;
+    await git(root, ["worktree", "remove", "--force", expected.path]).catch(() => void 0);
+    await git(root, ["branch", "-D", expected.branch]).catch(() => void 0);
+    await rm3(expected.path, { recursive: true, force: true });
+    await rm3(markerPath, { force: true });
+  }
+  async cleanupOrphanWorktrees() {
+    const entries = await readdir2(this.directory).catch(() => []);
+    for (const entry of entries.filter((name) => name.endsWith(".creating"))) await this.cleanupMarker(join3(this.directory, entry));
+  }
+  async validateWorktree(owner, cwd) {
+    try {
+      await this.load();
+      const name = this.worktreeName(owner);
+      const binding = name ? await this.borrowedWorktree(name) : void 0;
+      if (binding) {
+        const resolved = await this.resolveBorrowedWorktree(binding, /* @__PURE__ */ new Set([this.runId]));
+        if (cwd !== void 0 && resolve2(cwd) !== resolve2(resolved.reference.cwd)) throw new Error(`Invalid worktree record for ${owner}`);
+        return resolved.reference;
+      }
+      return await this.ownedWorktree(owner, cwd);
+    } catch (error) {
+      throw coerceWorkflowError("WORKTREE_FAILED", error);
+    }
+  }
+  async worktree(owner) {
+    const write = this.worktreeLane.run(async () => {
+      const loaded = await this.load();
+      const recordsPath = resolve2(this.directory, "worktrees.json");
+      let records = await this.#loadWorktreeRecords();
+      const name = this.worktreeName(owner);
+      const binding = name ? await this.borrowedWorktree(name) : void 0;
+      if (binding) return (await this.resolveBorrowedWorktree(binding, /* @__PURE__ */ new Set([this.runId]))).reference;
+      if (name && loaded.run.parentRunId !== void 0) {
+        const resolved = await this.resolveNamedWorktreeFromParent(name, loaded.run.parentRunId);
+        if (resolved) {
+          await this.bindBorrowedWorktree({ name, sourceRunId: resolved.sourceRunId, owner: resolved.owner });
+          return resolved.reference;
+        }
+      }
+      if (name && Array.isArray(loaded.run.retry?.namedWorktrees) && loaded.run.retry.namedWorktrees.includes(name)) throw new WorkflowError("WORKTREE_FAILED", `Missing inherited named worktree ${name}`);
+      const existing = records.find((record) => record.owner === owner);
+      if (existing) return this.validateWorktree(owner);
+      const { path, branch } = this.expectedWorktree(owner);
+      const markerPath = this.markerPath(owner);
+      let branchCreated = false;
+      let worktreeCreated = false;
+      let markerWritten = false;
+      try {
+        const root = (await git(this.cwd, ["rev-parse", "--show-toplevel"])).trim();
+        const [canonicalRoot, canonicalCwd] = await Promise.all([realpath(root), realpath(this.cwd)]);
+        const launchRelative = relative(canonicalRoot, canonicalCwd);
+        if (launchRelative === ".." || launchRelative.startsWith(`..${sep}`)) throw new Error("launch cwd is outside the repository");
+        await this.cleanupMarker(markerPath);
+        const dirty = (await git(root, ["status", "--porcelain", "--untracked-files=normal"])).trim();
+        if (dirty) {
+          const dirtyPaths = dirty.split("\n").filter(Boolean).map((entry) => entry.slice(3));
+          const shownPaths = dirtyPaths.slice(0, 10);
+          const more = dirtyPaths.length > shownPaths.length ? `, and ${String(dirtyPaths.length - shownPaths.length)} more` : "";
+          throw new Error(`repository ${root} has uncommitted changes at worktree creation; commit or stash them first: ${shownPaths.join(", ")}${more}`);
+        }
+        let commit;
+        try {
+          commit = (await git(root, ["rev-parse", "--verify", "HEAD^{commit}"])).trim();
+        } catch {
+          throw new Error("repository has no commits");
+        }
+        await mkdir2(dirname(path), { recursive: true, mode: 448 });
+        const record = { owner, path, branch, cwd: join3(path, launchRelative), base: commit };
+        await atomicJson(markerPath, { owner, path, branch, base: commit });
+        markerWritten = true;
+        await git(root, ["branch", branch, commit]);
+        branchCreated = true;
+        await git(root, ["worktree", "add", "--no-checkout", path, branch]);
+        worktreeCreated = true;
+        await git(path, ["checkout", "--force", branch]);
+        if (loaded.snapshot.settings.worktreePostCreateCommand) await this.runWorktreePostCreateCommand(loaded.snapshot.settings.worktreePostCreateCommand, record.cwd, loaded.snapshot.settingsSources?.worktreePostCreateCommand);
+        await atomicJson(recordsPath, [...records, record]);
+        await rm3(markerPath, { force: true });
+        return record;
+      } catch (error) {
+        if (worktreeCreated) await git(this.cwd, ["worktree", "remove", "--force", path]).catch(() => void 0);
+        if (branchCreated) await git(this.cwd, ["branch", "-D", branch]).catch(() => void 0);
+        if (markerWritten) await rm3(markerPath, { force: true });
+        try {
+          const persisted = await this.#loadWorktreeRecords();
+          const match = persisted.filter((candidate2) => candidate2.owner === owner);
+          const candidate = match.length === 1 ? match[0] : void 0;
+          if (candidate) {
+            this.structuralWorktree(owner, candidate);
+            records = persisted.filter((current) => current !== candidate);
+            await atomicJson(recordsPath, records);
+          }
+        } catch {
+        }
+        throw new WorkflowError("WORKTREE_FAILED", errorText(error));
+      }
+    });
+    return write;
+  }
+  async resolveNamedWorktreeFromParent(name, parentRunId) {
+    const source = await this.sourceRun(parentRunId);
+    return source.findNamedWorktree(name, /* @__PURE__ */ new Set([this.runId]));
+  }
+  async bindBorrowedWorktree(binding) {
+    const write = this.borrowedWorktreeLane.run(async () => {
+      const records = [...await this.borrowedWorktreeRecords(false)];
+      const existing = records.find((candidate) => candidate.name === binding.name);
+      if (existing) {
+        if (JSON.stringify(existing) !== JSON.stringify(binding)) throw new WorkflowError("WORKTREE_FAILED", `Borrowed worktree binding for ${binding.name} changed`);
+        return;
+      }
+      records.push(binding);
+      await atomicJson(join3(this.directory, "borrowed-worktrees.json"), records);
+    });
+    await write;
+  }
+  async snapshotWorktree(owner) {
+    try {
+      const write = this.snapshotLane.run(async () => {
+        const record = await this.worktree(owner);
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+          await git(record.path, ["add", "-A"]);
+          if (!(await git(record.path, ["status", "--porcelain"])).trim()) break;
+          try {
+            await git(record.path, ["commit", "-m", "pi-extensible-workflows runtime snapshot"], gitIdentity);
+            break;
+          } catch (error) {
+            if (attempt === 2) throw error;
+          }
+        }
+        return (await git(record.path, ["rev-parse", "HEAD"])).trim();
+      });
+      return await write;
+    } catch (error) {
+      throw coerceWorkflowError("WORKTREE_FAILED", error);
+    }
+  }
+  async worktrees() {
+    const records = await this.#loadWorktreeRecords();
+    const bindings = await this.borrowedWorktreeRecords();
+    const boundOwners = new Set(bindings.map((binding) => binding.owner));
+    const owned = await Promise.all(records.filter((record) => !boundOwners.has(record.owner)).map(async (record) => {
+      try {
+        return await this.validateWorktree(record.owner);
+      } catch {
+        return void 0;
+      }
+    }));
+    const borrowed = await Promise.all(bindings.map(async (binding) => (await this.resolveBorrowedWorktree(binding, /* @__PURE__ */ new Set([this.runId]))).reference));
+    return [...owned.filter((record) => record !== void 0), ...borrowed];
+  }
+  async validNamedWorktrees() {
+    const names = /* @__PURE__ */ new Set();
+    const records = await this.#loadWorktreeRecords();
+    let bindings;
+    try {
+      bindings = await this.borrowedWorktreeRecords();
+    } catch (error) {
+      if (error instanceof WorkflowError && error.code === "WORKTREE_FAILED") return [];
+      throw error;
+    }
+    const boundOwners = new Set(bindings.map((binding) => binding.owner));
+    for (const record of records) {
+      const owner = record.owner;
+      const name = this.worktreeName(owner);
+      if (!name || owner !== this.namedWorktreeOwner(name) || boundOwners.has(owner)) continue;
+      try {
+        await this.ownedWorktree(owner);
+        names.add(name);
+      } catch {
+      }
+    }
+    for (const binding of bindings) {
+      try {
+        await this.resolveBorrowedWorktree(binding, /* @__PURE__ */ new Set([this.runId]));
+        names.add(binding.name);
+      } catch {
+      }
+    }
+    return [...names];
+  }
+  async changedWorktrees() {
+    const changed = [];
+    for (const valid of await this.worktrees()) {
+      try {
+        await git(valid.path, ["diff", "--quiet", valid.base, "HEAD"]);
+      } catch {
+        changed.push(valid);
+      }
+    }
+    return changed;
+  }
+  async saveResult(value) {
+    const path = join3(this.directory, "result.json");
+    await atomicPrettyJson(path, value);
+    return path;
+  }
+  async resultBytes() {
+    return (await stat2(join3(this.directory, "result.json"))).size;
+  }
+  async delete(confirmed) {
+    if (!confirmed) throw new WorkflowError("CANCELLED", "Run deletion requires confirmation");
+    const records = await this.#loadWorktreeRecords();
+    const validated = records.map((record) => {
+      try {
+        return this.structuralWorktree(record.owner, record);
+      } catch (error) {
+        throw new WorkflowError("WORKTREE_FAILED", errorText(error));
+      }
+    });
+    await this.cleanupOrphanWorktrees();
+    for (const record of validated) {
+      await git(this.cwd, ["worktree", "remove", "--force", record.path]).catch(() => void 0);
+      await git(this.cwd, ["branch", "-D", record.branch]).catch(() => void 0);
+    }
+    await rm3(this.directory, { recursive: true, force: true });
+  }
+};
+
+// src/host-view.ts
+import { keyHint, truncateToVisualLines } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth as truncateToWidth2 } from "@earendil-works/pi-tui";
+
+// src/background-widget.ts
+import { isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+var QUIET_MS = 3 * 60 * 1e3;
+
+// src/host-view.ts
+var ANSI_SGR_SOURCE = `${String.fromCharCode(27)}\\[[0-9;]*m`;
+var ANSI_SGR = new RegExp(ANSI_SGR_SOURCE);
+
+// subagents/src/contracts.ts
+import { Type } from "@earendil-works/pi-ai";
+
+// src/validation.ts
+import { mkdirSync, readFileSync as readFileSync2, readdirSync, statSync } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { basename as basename3, dirname as dirname3, extname, join as join5, resolve as resolve3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import * as acorn from "acorn";
+import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
+
+// src/registry.ts
+import { readFileSync } from "node:fs";
+import { basename as basename2, dirname as dirname2, isAbsolute, join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Value } from "typebox/value";
+
+// src/package-identity.ts
+var CORE_PACKAGE_NAME = "@marcoscale98/pi-extensible-workflows";
+var CORE_PACKAGE_COMPATIBILITY_NAME = "pi-extensible-workflows";
+var CORE_PACKAGE_NAMES = [CORE_PACKAGE_NAME, CORE_PACKAGE_COMPATIBILITY_NAME];
+function isCorePackageName(value) {
+  return typeof value === "string" && CORE_PACKAGE_NAMES.includes(value);
+}
+
+// src/registry.ts
+var RESERVED_GLOBALS = /* @__PURE__ */ new Set(["agent", "shell", "prompt", "checkpoint", "parallel", "pipeline", "phase", "withWorktree", "log", "args", "Promise", "JSON", "Math", "Date", "eval", "Function", "WebAssembly", "process", "require", "module", "exports", "console", "fetch", "XMLHttpRequest", "WebSocket", "performance", "crypto", "setTimeout", "setInterval", "setImmediate", "queueMicrotask", "Intl", "SharedArrayBuffer", "Atomics", "globalThis", "global", "undefined", "NaN", "Infinity", "extensions", "workflow_catalog"]);
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+var SEMVER = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var PACKAGE_NAME = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+function normalizeRoleDirectory(value) {
+  try {
+    if (value instanceof URL) {
+      if (value.protocol !== "file:") fail("INVALID_METADATA", "Workflow role directories require file URLs or absolute filesystem paths");
+      return fileURLToPath(value);
+    }
+    if (typeof value === "string") {
+      if (value.startsWith("file:")) return fileURLToPath(value);
+      if (isAbsolute(value)) return value;
+    }
+  } catch (error) {
+    fail("INVALID_METADATA", `Invalid workflow role directory: ${errorText(error)}`);
+  }
+  fail("INVALID_METADATA", "Workflow role directories require file URLs or absolute filesystem paths");
+}
+function isBuiltinRoleDirectory(path) {
+  const canonical = canonicalPath(path);
+  const starterDirectory = dirname2(canonical);
+  if (basename2(canonical) !== "roles" || basename2(starterDirectory) !== "starter") return false;
+  const distributionDirectory = dirname2(starterDirectory);
+  const packageRoot = basename2(distributionDirectory) === "dist" ? dirname2(distributionDirectory) : distributionDirectory;
+  try {
+    const metadata = JSON.parse(readFileSync(join4(packageRoot, "package.json"), "utf8"));
+    return object(metadata) && isCorePackageName(metadata.name);
+  } catch {
+    return false;
+  }
+}
+function catalogSchema(schema, at) {
+  validateSchema(schema, at);
+  return structuredClone(schema);
+}
+var WorkflowRegistry = class {
+  #extensions = /* @__PURE__ */ new Set();
+  #functionSources = /* @__PURE__ */ new Map();
+  #globals = /* @__PURE__ */ new Map();
+  #hooks = /* @__PURE__ */ new Map();
+  #agentAttemptActions = /* @__PURE__ */ new Map();
+  #roleDirectories = /* @__PURE__ */ new Map();
+  #modelAliases = /* @__PURE__ */ new Map();
+  #settingsValidators = /* @__PURE__ */ new Set();
+  #frozen = false;
+  #subagentStatusObserver;
+  get frozen() {
+    return this.#frozen;
+  }
+  freeze() {
+    this.#frozen = true;
+  }
+  setSubagentStatusObserver(observer) {
+    this.#subagentStatusObserver = observer;
+  }
+  observeSubagentStatus(status, request) {
+    this.#subagentStatusObserver?.(status, request);
+  }
+  register(extension2) {
+    if (this.#frozen) fail("REGISTRY_FROZEN", "Workflow extension registration is closed after session_start");
+    if (object(extension2) && Object.prototype.hasOwnProperty.call(extension2, "workflows")) fail("INVALID_METADATA", "Separate registered workflow definitions were removed; register a function with input and output schemas instead");
+    if (!object(extension2) || Object.keys(extension2).some((key) => !["version", "headline", "description", "source", "dependencies", "validateSettings", "functions", "modelAliases", "agentSetupHooks", "agentAttemptActions", "roleDirectories"].includes(key)) || typeof extension2.version !== "string" || !SEMVER.test(extension2.version) || typeof extension2.headline !== "string" || !extension2.headline.trim()) fail("INVALID_METADATA", "Workflow extensions require a semantic version and non-empty headline");
+    const functions = extension2.functions ?? {};
+    const modelAliases = extension2.modelAliases ?? {};
+    const agentSetupHooks = extension2.agentSetupHooks ?? {};
+    const agentAttemptActions = extension2.agentAttemptActions ?? {};
+    const source = extension2.source;
+    const dependencyValues = extension2.dependencies;
+    const dependencies = dependencyValues ?? [];
+    const validateSettings = extension2.validateSettings;
+    if (validateSettings !== void 0 && typeof validateSettings !== "function") fail("INVALID_METADATA", "Workflow extension validateSettings must be a function");
+    if (source !== void 0 && (typeof source !== "string" || !source.trim())) fail("INVALID_METADATA", "Workflow extension source must be a non-empty module URL");
+    if (dependencyValues !== void 0 && (!Array.isArray(dependencyValues) || dependencyValues.some((dependency) => typeof dependency !== "string" || dependency.trim() !== dependency || !PACKAGE_NAME.test(dependency)) || new Set(dependencyValues).size !== dependencyValues.length)) fail("INVALID_METADATA", "Workflow extension dependencies must be unique, non-empty package names");
+    const roleDirectoryValues = extension2.roleDirectories === void 0 ? [] : extension2.roleDirectories;
+    if (!Array.isArray(roleDirectoryValues)) fail("INVALID_METADATA", "Workflow extension roleDirectories must be an array");
+    const roleDirectories = [...new Set(Array.from(roleDirectoryValues, (value) => normalizeRoleDirectory(value)))];
+    if (!object(functions) || !object(modelAliases) || !object(agentSetupHooks) || !object(agentAttemptActions) || Object.keys(functions).length === 0 && Object.keys(modelAliases).length === 0 && Object.keys(agentSetupHooks).length === 0 && Object.keys(agentAttemptActions).length === 0 && roleDirectories.length === 0 && validateSettings === void 0) fail("INVALID_METADATA", "Workflow extensions require functions, model aliases, agent setup hooks, agent attempt actions, role directories, or a settings validator");
+    const names = Object.keys(functions);
+    if (new Set(names).size !== names.length) fail("GLOBAL_COLLISION", "Global name collision inside extension");
+    for (const name of names) {
+      if (!IDENTIFIER.test(name) || name.startsWith("__pi_extensible_workflows_")) fail("INVALID_METADATA", `Invalid global name: ${name}`);
+      if (RESERVED_GLOBALS.has(name)) fail("GLOBAL_COLLISION", `Global name is reserved: ${name}`);
+      if (this.#globals.has(name)) fail("GLOBAL_COLLISION", `Global name is already registered: ${name}`);
+    }
+    for (const [name, fn] of Object.entries(functions)) {
+      if (!object(fn) || Object.keys(fn).some((key) => !["description", "input", "output", "run"].includes(key)) || typeof fn.description !== "string" || !fn.description.trim() || typeof fn.run !== "function") fail("INVALID_METADATA", `Invalid workflow function: ${name}`);
+      validateSchema(fn.input, `${name} input`);
+      validateSchema(fn.output, `${name} output`);
+      if (fn.input.type !== "object") fail("INVALID_SCHEMA", `${name} input must describe one object`);
+    }
+    for (const [name, alias] of Object.entries(modelAliases)) {
+      if (!MODEL_ALIAS_NAME.test(name)) fail("INVALID_METADATA", `Invalid model alias name: ${name}`);
+      if (!object(alias) || Object.keys(alias).some((key) => key !== "resolve") || typeof alias.resolve !== "function") fail("INVALID_METADATA", `Invalid model alias resolver: ${name}`);
+      if (this.#modelAliases.has(name)) fail("DUPLICATE_NAME", `Model alias already registered: ${name}`);
+    }
+    for (const [name, hook] of Object.entries(agentSetupHooks)) {
+      if (!IDENTIFIER.test(name) || !object(hook) || Object.keys(hook).some((key) => !["priority", "setup"].includes(key)) || typeof hook.setup !== "function" || hook.priority !== void 0 && (typeof hook.priority !== "number" || !Number.isFinite(hook.priority))) fail("INVALID_METADATA", `Invalid agent setup hook: ${name}`);
+      if (this.#hooks.has(name)) fail("DUPLICATE_NAME", `Agent setup hook already registered: ${name}`);
+    }
+    for (const [name, action] of Object.entries(agentAttemptActions)) {
+      if (!IDENTIFIER.test(name) || !object(action) || Object.keys(action).some((key) => !["label", "visible", "run", "visibleStandalone", "runStandalone"].includes(key)) || typeof action.label !== "string" || !action.label.trim() || typeof action.visible !== "function" || typeof action.run !== "function" || action.visibleStandalone !== void 0 && typeof action.visibleStandalone !== "function" || action.runStandalone !== void 0 && typeof action.runStandalone !== "function") fail("INVALID_METADATA", `Invalid agent attempt action: ${name}`);
+      if (action.visibleStandalone !== void 0 !== (action.runStandalone !== void 0)) fail("INVALID_METADATA", `Standalone agent attempt actions require visibleStandalone and runStandalone: ${name}`);
+      if (this.#agentAttemptActions.has(name)) fail("DUPLICATE_NAME", `Agent attempt action already registered: ${name}`);
+    }
+    const stored = deepFreeze({ ...extension2, functions, modelAliases, agentSetupHooks, agentAttemptActions, ...roleDirectories.length ? { roleDirectories } : {} });
+    if (source !== void 0) for (const name of names) this.#functionSources.set(name, Object.freeze({ module: source, export: "default", dependencies: Object.freeze([...dependencies]) }));
+    this.#extensions.add(stored);
+    for (const directory of roleDirectories) if (!this.#roleDirectories.has(directory)) this.#roleDirectories.set(directory, deepFreeze({ path: directory, extension: { version: extension2.version, headline: extension2.headline }, ...isBuiltinRoleDirectory(directory) ? { builtin: true } : {} }));
+    for (const name of names) this.#globals.set(name, name);
+    for (const [name, alias] of Object.entries(modelAliases)) this.#modelAliases.set(name, { name, version: extension2.version, headline: extension2.headline, resolve: alias.resolve });
+    for (const [name, hook] of Object.entries(agentSetupHooks)) this.#hooks.set(name, { name, priority: hook.priority ?? 10, setup: hook.setup });
+    for (const [name, action] of Object.entries(agentAttemptActions)) this.#agentAttemptActions.set(name, action);
+    if (validateSettings !== void 0) this.#settingsValidators.add({ headline: extension2.headline, validate: validateSettings });
+  }
+  function(name) {
+    if (!IDENTIFIER.test(name)) fail("MISSING_WORKFLOW", `Registered functions require an unqualified name: ${name}`);
+    const fn = [...this.#extensions].find((extension2) => extension2.functions?.[name])?.functions?.[name];
+    if (!fn) fail("MISSING_WORKFLOW", `Registered function is unavailable: ${name}; the separate registered-workflow format was removed`);
+    return fn;
+  }
+  functions() {
+    return Object.freeze(Object.fromEntries([...this.#extensions].flatMap((extension2) => Object.entries(extension2.functions ?? {}))));
+  }
+  functionSources() {
+    return Object.freeze(Object.fromEntries(this.#functionSources));
+  }
+  catalog(context) {
+    const functions = [];
+    for (const extension2 of this.#extensions) {
+      for (const [name, fn] of Object.entries(extension2.functions ?? {})) functions.push({ name, version: extension2.version, headline: extension2.headline, description: fn.description, input: catalogSchema(fn.input, `${name} input`), output: catalogSchema(fn.output, `${name} output`) });
+    }
+    let aliases;
+    let settings;
+    let source = "global settings";
+    try {
+      const resolved = context ? resolveWorkflowSettings(context.cwd, context.projectTrusted, context.globalSettingsPath) : void 0;
+      aliases = resolved?.effective.modelAliases ?? loadSettings().modelAliases;
+      if (resolved) {
+        source = resolved.projectTrusted && [resolved.sources.modelAliases, resolved.sources.skills, resolved.sources.extensions, resolved.sources.tools].some((path) => path === resolved.projectSettingsPath) ? "trusted project settings" : "global settings";
+        settings = { concurrency: resolved.effective.concurrency, backgroundWidget: resolved.effective.backgroundWidget ?? true, modelAliases: resolved.effective.modelAliases ?? {}, skills: resolved.effective.skills ?? [], extensions: Array.isArray(resolved.effective.extensions) ? resolved.effective.extensions : [], tools: resolved.effective.tools ?? [], ...resolved.effective.extensionSettings === void 0 ? {} : { extensionSettings: resolved.effective.extensionSettings }, ...resolved.effective.worktreePostCreateCommand === void 0 ? {} : { worktreePostCreateCommand: resolved.effective.worktreePostCreateCommand }, globalSettingsPath: resolved.globalSettingsPath, projectSettingsPath: resolved.projectSettingsPath, projectTrusted: resolved.projectTrusted, sources: resolved.sources };
+      }
+    } catch {
+      aliases = void 0;
+    }
+    const staticEntries = Object.keys(aliases ?? {}).map((name) => ({ name, kind: "static", provenance: source }));
+    const dynamicEntries = [...this.#modelAliases.values()].map(({ name, version, headline }) => ({ name, kind: "dynamic", provenance: `extension: ${headline}`, version, headline }));
+    const modelAliasEntries = [...staticEntries, ...dynamicEntries].sort((left, right) => left.name.localeCompare(right.name) || left.kind.localeCompare(right.kind) || left.provenance.localeCompare(right.provenance));
+    const sort = (left, right) => left.name.localeCompare(right.name);
+    const catalog = { functions: functions.sort(sort), ...modelAliasEntries.length ? { modelAliasEntries } : {} };
+    if (aliases && Object.keys(aliases).length) Object.defineProperty(catalog, "modelAliases", { value: Object.freeze(structuredClone(aliases)), enumerable: false });
+    if (settings) {
+      const publicSettings = { ...settings, modelAliases: Object.keys(aliases ?? {}).length ? {} : settings.modelAliases };
+      Object.defineProperty(catalog, "settings", { value: deepFreeze(publicSettings), enumerable: true });
+    }
+    return deepFreeze(catalog);
+  }
+  catalogIndex(context) {
+    const catalog = this.catalog(context);
+    let modelAliasEntries;
+    if (catalog.modelAliasEntries !== void 0) {
+      const winningEntries = /* @__PURE__ */ new Map();
+      for (const entry of catalog.modelAliasEntries) {
+        if (!winningEntries.has(entry.name) || entry.kind === "static") winningEntries.set(entry.name, entry);
+      }
+      modelAliasEntries = [...winningEntries.values()];
+    }
+    const index = {
+      functions: catalog.functions.map(({ name, description, input }) => ({ name, description, input: structuredClone(input) })),
+      ...modelAliasEntries ? { modelAliasEntries: structuredClone(modelAliasEntries) } : {}
+    };
+    if (catalog.modelAliases) Object.defineProperty(index, "modelAliases", { value: Object.freeze(structuredClone(catalog.modelAliases)), enumerable: false });
+    if (catalog.settings) Object.defineProperty(index, "settings", { value: deepFreeze(structuredClone(catalog.settings)), enumerable: true });
+    return deepFreeze(index);
+  }
+  catalogDetail(name, context) {
+    const catalog = this.catalog(context);
+    const entry = catalog.functions.find((candidate) => candidate.name === name);
+    if (entry) return entry;
+    const alias = catalog.modelAliasEntries?.find((candidate) => candidate.name === name && candidate.kind === "static") ?? catalog.modelAliasEntries?.find((candidate) => candidate.name === name);
+    if (alias) return alias;
+    return deepFreeze({ error: { code: "NOT_FOUND", name, message: `No registered workflow function is available: ${name}` } });
+  }
+  globals() {
+    return Object.freeze(Object.fromEntries([...this.#extensions].flatMap((extension2) => Object.keys(extension2.functions ?? {}).map((name) => [name, { name }]))));
+  }
+  validateExtensionSettings(settings, context) {
+    const effectiveSettings = settings ?? Object.freeze({});
+    if (!jsonValue(effectiveSettings) || !object(effectiveSettings)) fail("INVALID_SETTINGS", "Workflow extension settings must be a JSON object");
+    const unsafeNamespace = Object.keys(effectiveSettings).find((namespace) => !validWorkflowExtensionNamespace(namespace));
+    if (unsafeNamespace !== void 0) fail("INVALID_SETTINGS", `Workflow extension settings contains an invalid namespace: ${unsafeNamespace}`);
+    const frozenSettings = deepFreeze(structuredClone(effectiveSettings));
+    for (const { headline, validate } of this.#settingsValidators) {
+      try {
+        validate(frozenSettings, Object.freeze({ ...context }));
+      } catch (error) {
+        const location = context.source === "role" && context.role ? `role ${context.role}` : context.source;
+        fail("INVALID_SETTINGS", `Invalid extension settings (${headline}; ${location}): ${errorText(error)}`);
+      }
+    }
+  }
+  async invokeFunction(name, input, context, path, journal) {
+    const fn = this.function(name);
+    if (!object(input) || !jsonValue(input) || !Value.Check(fn.input, input)) fail("RESULT_INVALID", `Invalid input for ${name}`);
+    const replayed = journal.get(path);
+    if (replayed !== void 0) {
+      if (!jsonValue(replayed) || !Value.Check(fn.output, replayed)) fail("RESULT_INVALID", `Invalid replay for ${name}`);
+      return structuredClone(replayed);
+    }
+    const result = await fn.run(deepFreeze(structuredClone(input)), Object.freeze({ run: context.run, settings: deepFreeze(structuredClone(context.settings)), invoke: context.invoke, agent: context.agent, shell: context.shell, prompt: context.prompt, parallel: context.parallel, pipeline: context.pipeline, withWorktree: context.withWorktree, checkpoint: context.checkpoint, phase: context.phase, log: context.log }));
+    if (!jsonValue(result) || !Value.Check(fn.output, result)) fail("RESULT_INVALID", `Invalid output from ${name}`);
+    const stored = structuredClone(result);
+    journal.put(path, stored);
+    return structuredClone(stored);
+  }
+  agentSetupHooks() {
+    return [...this.#hooks.values()].sort(byPriorityThenName);
+  }
+  agentAttemptActions() {
+    return Object.freeze(Object.fromEntries(this.#agentAttemptActions.entries()));
+  }
+  roleDirectories() {
+    return [...this.#roleDirectories.keys()];
+  }
+  roleDirectoryRegistrations() {
+    return [...this.#roleDirectories.values()];
+  }
+  modelAliases() {
+    return [...this.#modelAliases.values()].sort((left, right) => left.name.localeCompare(right.name));
+  }
+  async resolveModelAliases(context, shadowed = /* @__PURE__ */ new Set()) {
+    const resolved = {};
+    const isAborted = () => context.signal.aborted;
+    for (const alias of this.modelAliases()) {
+      if (shadowed.has(alias.name)) continue;
+      if (isAborted()) fail("CANCELLED", `Model alias resolver cancelled: ${alias.name} (${alias.headline})`);
+      let target;
+      try {
+        target = await alias.resolve(Object.freeze({ cwd: context.cwd, projectTrusted: context.projectTrusted, rootModel: Object.freeze({ ...context.rootModel }), knownModels: new Set(context.knownModels), availableModels: new Set(context.availableModels), signal: context.signal }));
+      } catch (error) {
+        if (isAborted() || error instanceof Error && error.name === "AbortError" || errorCode(error) === "CANCELLED") fail("CANCELLED", `Model alias resolver cancelled: ${alias.name} (${alias.headline})`);
+        fail("CONFIG_ERROR", `Model alias resolver failed for ${alias.name} (${alias.headline}): ${errorText(error)}`);
+      }
+      if (isAborted()) fail("CANCELLED", `Model alias resolver cancelled: ${alias.name} (${alias.headline})`);
+      if (typeof target !== "string" || !target.trim()) fail("CONFIG_ERROR", `Model alias resolver returned an invalid target for ${alias.name} (${alias.headline})`);
+      resolved[alias.name] = target.trim();
+    }
+    return Object.freeze(resolved);
+  }
+};
+var WORKFLOW_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("pi-extensible-workflows.workflow-registry");
+var globalRegistry = globalThis;
+function createWorkflowRegistryApi(registry) {
+  return {
+    get frozen() {
+      return registry.frozen;
+    },
+    freeze: () => {
+      registry.freeze();
+    },
+    setSubagentStatusObserver: (observer) => {
+      registry.setSubagentStatusObserver(observer);
+    },
+    observeSubagentStatus: (status, request) => {
+      registry.observeSubagentStatus(status, request);
+    },
+    register: (extension2) => {
+      registry.register(extension2);
+    },
+    function: (name) => registry.function(name),
+    functions: () => registry.functions(),
+    functionSources: () => registry.functionSources(),
+    catalog: (context) => registry.catalog(context),
+    catalogIndex: (context) => registry.catalogIndex(context),
+    catalogDetail: (name, context) => registry.catalogDetail(name, context),
+    globals: () => registry.globals(),
+    invokeFunction: (...args) => registry.invokeFunction(...args),
+    validateExtensionSettings: (...args) => {
+      registry.validateExtensionSettings(...args);
+    },
+    modelAliases: () => registry.modelAliases(),
+    resolveModelAliases: (...args) => registry.resolveModelAliases(...args),
+    roleDirectories: () => registry.roleDirectories(),
+    roleDirectoryRegistrations: () => registry.roleDirectoryRegistrations(),
+    agentSetupHooks: () => registry.agentSetupHooks(),
+    agentAttemptActions: () => registry.agentAttemptActions()
+  };
+}
+function workflowRegistryHost() {
+  return globalRegistry[WORKFLOW_REGISTRY_KEY] ??= { api: createWorkflowRegistryApi(new WorkflowRegistry()), activeHosts: 0 };
+}
+function resetWorkflowRegistry() {
+  workflowRegistryHost().api = createWorkflowRegistryApi(new WorkflowRegistry());
+}
+function beginWorkflowExtensionLoading() {
+  const host = workflowRegistryHost();
+  if (host.api.frozen && host.activeHosts === 0) resetWorkflowRegistry();
+}
+beginWorkflowExtensionLoading();
+
+// src/validation.ts
+var DEFAULT_SETTINGS = Object.freeze({ concurrency: 8, backgroundWidget: true });
+function workflowSettingsPath(agentDir = getAgentDir()) {
+  return join5(agentDir, ROLE_DIRECTORY, "settings.json");
+}
+function normalizedResourcePath(value, settingsPath) {
+  if (value === "*") return value;
+  let expanded = value === "~" ? homedir4() : value.startsWith("~/") || value.startsWith("~\\") ? join5(homedir4(), value.slice(2)) : value;
+  if (expanded.startsWith("file://")) expanded = fileURLToPath2(expanded);
+  const resolved = resolve3(dirname3(settingsPath), expanded);
+  if (expanded === "**" || expanded.startsWith("**/") || expanded.startsWith("**\\")) return expanded;
+  if (resourcePatternHasMagic(expanded)) {
+    const magicIndex = resolved.search(/[*?\x5b\x5d{}()]/);
+    const separatorIndex = Math.max(resolved.lastIndexOf("/", magicIndex), resolved.lastIndexOf("\\", magicIndex));
+    const rootBoundary = separatorIndex === 0 || separatorIndex === 2 && /^[A-Za-z]:[\\/]/.test(resolved);
+    const prefix = rootBoundary ? resolved.slice(0, separatorIndex + 1) : separatorIndex >= 0 ? resolved.slice(0, separatorIndex) : resolved;
+    const suffix = rootBoundary ? resolved.slice(separatorIndex + 1) : separatorIndex >= 0 ? resolved.slice(separatorIndex) : "";
+    return `${canonicalPath(prefix)}${suffix}`;
+  }
+  return canonicalPath(resolved);
+}
+function validateSelectorList(value, path, kind, errorCode2 = "INVALID_SETTINGS", normalizeExtensions = true) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) fail(errorCode2, `${path}.${kind} must be an array`);
+  const normalized = [];
+  for (const [index, entry] of value.entries()) {
+    if (typeof entry !== "string" || !entry.trim()) fail(errorCode2, `${path}.${kind}[${String(index)}] must be a non-empty string`);
+    let selector = entry.trim();
+    if (kind === "extensions" && normalizeExtensions) {
+      const negated = selector.startsWith("!");
+      const body = negated ? selector.slice(1) : selector;
+      if (!body) fail(errorCode2, `${path}.${kind}[${String(index)}] must be a valid minimatch pattern: Empty minimatch pattern ${JSON.stringify(selector)}`);
+      try {
+        selector = `${negated ? "!" : ""}${normalizedResourcePath(body, path)}`;
+      } catch (error) {
+        fail(errorCode2, `${path}.${kind}[${String(index)}] must be a valid path: ${errorText(error)}`);
+      }
+    }
+    try {
+      validateResourcePattern(selector);
+    } catch (error) {
+      fail(errorCode2, `${path}.${kind}[${String(index)}] must be a valid minimatch pattern: ${errorText(error)}`);
+    }
+    normalized.push(selector);
+  }
+  return Object.freeze(normalized);
+}
+function validateWorktreePostCreateCommand(value, settingsPath) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.length === 0) fail("INVALID_SETTINGS", `${settingsPath}.worktreePostCreateCommand must be a non-empty array`);
+  return Object.freeze(value.map((entry, index) => {
+    if (typeof entry !== "string" || !entry.trim()) fail("INVALID_SETTINGS", `${settingsPath}.worktreePostCreateCommand[${String(index)}] must be a non-empty string`);
+    return entry;
+  }));
+}
+function selectorsFromSettings(settings) {
+  return {
+    ...settings.skills === void 0 ? {} : { skills: settings.skills },
+    ...settings.extensions === void 0 ? {} : { extensions: settings.extensions },
+    ...settings.tools === void 0 ? {} : { tools: settings.tools }
+  };
+}
+function selectorSet(value) {
+  return { skills: [...value?.skills ?? []], extensions: [...value?.extensions ?? []], ...value?.tools === void 0 ? {} : { tools: [...value.tools] } };
+}
+function validateWorkflowExtensionSettings(value, settingsPath, errorCode2 = "INVALID_SETTINGS", applyDefaults = true) {
+  if (value === void 0) return void 0;
+  const base = `${settingsPath}.extensionSettings`;
+  if (!object(value)) fail(errorCode2, `${base} must be an object`);
+  const normalized = {};
+  for (const [namespace, raw] of Object.entries(value)) {
+    if (!validWorkflowExtensionNamespace(namespace)) fail(errorCode2, `${base} contains an invalid namespace: ${namespace}`);
+    if (namespace === "herdr") {
+      if (!object(raw)) fail(errorCode2, `${base}.herdr must be an object`);
+      if (Object.keys(raw).some((key) => key !== "enableFullyInspectableMode")) fail(errorCode2, `${base}.herdr contains an unsupported setting`);
+      if (raw.enableFullyInspectableMode !== void 0 && typeof raw.enableFullyInspectableMode !== "boolean") fail(errorCode2, `${base}.herdr.enableFullyInspectableMode must be a boolean`);
+      normalized.herdr = Object.freeze({ ...raw.enableFullyInspectableMode === void 0 ? {} : { enableFullyInspectableMode: raw.enableFullyInspectableMode } });
+      continue;
+    }
+    if (namespace === "trajectory") {
+      if (!object(raw)) fail(errorCode2, `${base}.trajectory must be an object`);
+      if (Object.keys(raw).some((key) => key !== "port" && key !== "themes")) fail(errorCode2, `${base}.trajectory contains an unsupported setting`);
+      if (raw.port !== void 0 && (!positiveInteger(raw.port) || raw.port > 65535)) fail(errorCode2, `${base}.trajectory.port must be an integer from 1 to 65535`);
+      if (raw.themes !== void 0 && typeof raw.themes !== "boolean") fail(errorCode2, `${base}.trajectory.themes must be a boolean`);
+      normalized.trajectory = Object.freeze({ ...raw.port === void 0 ? {} : { port: raw.port }, ...raw.themes === void 0 ? applyDefaults ? { themes: false } : {} : { themes: raw.themes } });
+      continue;
+    }
+    if (!jsonValue(raw)) fail(errorCode2, `${base}.${namespace} must be JSON-compatible`);
+    normalized[namespace] = structuredClone(raw);
+  }
+  return deepFreeze(normalized);
+}
+function positiveRetentionInteger(value) {
+  return positiveInteger(value) && Number.isSafeInteger(value);
+}
+function validateRetention(value, settingsPath) {
+  if (value === void 0) return void 0;
+  const base = `${settingsPath}.retention`;
+  if (!object(value)) fail("INVALID_SETTINGS", `${base} must be an object`);
+  const unknown = Object.keys(value).find((key) => key !== "olderThanDays" && key !== "maxTerminalRuns");
+  if (unknown) fail("INVALID_SETTINGS", `Unknown retention setting at ${base}: ${unknown}`);
+  if (value.olderThanDays !== void 0 && !positiveRetentionInteger(value.olderThanDays)) fail("INVALID_SETTINGS", `${base}.olderThanDays must be a positive integer`);
+  if (value.maxTerminalRuns !== void 0 && !positiveRetentionInteger(value.maxTerminalRuns)) fail("INVALID_SETTINGS", `${base}.maxTerminalRuns must be a positive integer`);
+  return Object.freeze({ ...value.olderThanDays === void 0 ? {} : { olderThanDays: value.olderThanDays }, ...value.maxTerminalRuns === void 0 ? {} : { maxTerminalRuns: value.maxTerminalRuns } });
+}
+function parseSettings(path, partial) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch (error) {
+    if (isNodeError(error, "ENOENT")) return partial ? Object.freeze({}) : DEFAULT_SETTINGS;
+    fail("CONFIG_ERROR", `Invalid workflow settings JSON at ${path}: ${errorText(error)}`);
+  }
+  if (!object(parsed)) fail("INVALID_SETTINGS", `Workflow settings at ${path} must be an object`);
+  const allowed = /* @__PURE__ */ new Set(["concurrency", "modelAliases", "skills", "extensions", "extensionSettings", "tools", "retention", "worktreePostCreateCommand", ...partial ? [] : ["backgroundWidget"]]);
+  const unknown = Object.keys(parsed).find((key) => !allowed.has(key));
+  if (Object.prototype.hasOwnProperty.call(parsed, "disabledAgentResources")) fail("INVALID_SETTINGS", `disabledAgentResources is no longer supported; use skills, extensions, and tools selectors (settings: ${path})`);
+  if (unknown) fail("INVALID_SETTINGS", `Unknown workflow setting at ${path}: ${unknown}`);
+  const concurrency = parsed.concurrency === void 0 ? partial ? void 0 : DEFAULT_SETTINGS.concurrency : parsed.concurrency;
+  if (concurrency !== void 0 && (!positiveInteger(concurrency) || concurrency > 16)) fail("INVALID_SETTINGS", `${path}.concurrency must be an integer from 1 to 16`);
+  const backgroundWidget = parsed.backgroundWidget === void 0 ? partial ? void 0 : DEFAULT_SETTINGS.backgroundWidget : parsed.backgroundWidget;
+  if (backgroundWidget !== void 0 && typeof backgroundWidget !== "boolean") fail("INVALID_SETTINGS", `${path}.backgroundWidget must be a boolean`);
+  const modelAliases = parsed.modelAliases === void 0 ? void 0 : validateModelAliases(parsed.modelAliases, path);
+  const skills = validateSelectorList(parsed.skills, path, "skills");
+  const tools = validateSelectorList(parsed.tools, path, "tools");
+  const extensions = validateSelectorList(parsed.extensions, path, "extensions");
+  const extensionSettings = parsed.extensionSettings === void 0 ? void 0 : validateWorkflowExtensionSettings(parsed.extensionSettings, path, "INVALID_SETTINGS", !partial);
+  const retention = validateRetention(parsed.retention, path);
+  const worktreePostCreateCommand = validateWorktreePostCreateCommand(parsed.worktreePostCreateCommand, path);
+  return Object.freeze({
+    ...concurrency === void 0 ? {} : { concurrency },
+    ...backgroundWidget === void 0 ? {} : { backgroundWidget },
+    ...modelAliases === void 0 ? {} : { modelAliases },
+    ...skills === void 0 ? {} : { skills },
+    ...extensions === void 0 ? {} : { extensions },
+    ...extensionSettings === void 0 ? {} : { extensionSettings },
+    ...tools === void 0 ? {} : { tools },
+    ...retention === void 0 ? {} : { retention },
+    ...worktreePostCreateCommand === void 0 ? {} : { worktreePostCreateCommand }
+  });
+}
+function loadSettings(path = workflowSettingsPath()) {
+  return parseSettings(path, false);
+}
+function loadSettingsOverrides(path) {
+  return parseSettings(path, true);
+}
+function resolveWorkflowSettings(cwd, projectTrusted, globalSettingsPath = workflowSettingsPath()) {
+  const projectSettingsPath = workflowProjectSettingsPath(cwd);
+  const global = loadSettings(globalSettingsPath);
+  const project = projectTrusted ? loadSettingsOverrides(projectSettingsPath) : Object.freeze({});
+  const projectHas = (key) => Object.prototype.hasOwnProperty.call(project, key);
+  const sourceFor = (key) => projectHas(key) ? projectSettingsPath : globalSettingsPath;
+  const globalSelectors = selectorsFromSettings(global);
+  const projectSelectors = selectorsFromSettings(project);
+  const effectiveSelectors = selectorSet({
+    skills: [...globalSelectors.skills ?? [], ...projectSelectors.skills ?? []],
+    extensions: [...globalSelectors.extensions ?? [], ...projectSelectors.extensions ?? []],
+    ...globalSelectors.tools === void 0 && projectSelectors.tools === void 0 ? {} : { tools: [...globalSelectors.tools ?? [], ...projectSelectors.tools ?? []] }
+  });
+  const hasExtensionSelectors = global.extensions !== void 0 || project.extensions !== void 0;
+  const extensionSettings = projectHas("extensionSettings") ? project.extensionSettings : global.extensionSettings;
+  const sources = {
+    concurrency: projectHas("concurrency") ? projectSettingsPath : globalSettingsPath,
+    modelAliases: projectHas("modelAliases") ? projectSettingsPath : globalSettingsPath,
+    skills: sourceFor("skills"),
+    extensions: sourceFor("extensions"),
+    tools: sourceFor("tools"),
+    ...extensionSettings === void 0 ? {} : { extensionSettings: projectHas("extensionSettings") ? projectSettingsPath : globalSettingsPath },
+    ...project.retention === void 0 && global.retention === void 0 ? {} : { retention: project.retention === void 0 ? globalSettingsPath : projectSettingsPath },
+    ...projectHas("worktreePostCreateCommand") || global.worktreePostCreateCommand !== void 0 ? { worktreePostCreateCommand: projectHas("worktreePostCreateCommand") ? projectSettingsPath : globalSettingsPath } : {}
+  };
+  const effective = Object.freeze({
+    concurrency: project.concurrency ?? global.concurrency,
+    backgroundWidget: global.backgroundWidget ?? true,
+    ...projectHas("modelAliases") ? { modelAliases: project.modelAliases } : global.modelAliases === void 0 ? {} : { modelAliases: global.modelAliases },
+    ...effectiveSelectors.skills.length ? { skills: effectiveSelectors.skills } : global.skills !== void 0 || project.skills !== void 0 ? { skills: effectiveSelectors.skills } : {},
+    ...hasExtensionSelectors ? { extensions: effectiveSelectors.extensions } : {},
+    ...extensionSettings === void 0 ? {} : { extensionSettings },
+    ...effectiveSelectors.tools?.length ? { tools: effectiveSelectors.tools } : global.tools !== void 0 || project.tools !== void 0 ? { tools: effectiveSelectors.tools } : {},
+    ...(project.retention ?? global.retention) === void 0 ? {} : { retention: project.retention ?? global.retention },
+    ...projectHas("worktreePostCreateCommand") ? { worktreePostCreateCommand: project.worktreePostCreateCommand } : global.worktreePostCreateCommand === void 0 ? {} : { worktreePostCreateCommand: global.worktreePostCreateCommand }
+  });
+  return { globalSettingsPath, projectSettingsPath, projectTrusted, global, project, effective, sources };
+}
+var ROLE_DIRECTORY = "pi-extensible-workflows";
+function validateSchema(schema, at = "schema") {
+  if (!object(schema) || Object.getPrototypeOf(schema) !== Object.prototype || !jsonValue(schema)) fail("INVALID_SCHEMA", `${at} must be a plain JSON-compatible Schema object`);
+  if (typeof schema.type !== "string" && !Array.isArray(schema.type) && schema.$ref === void 0 && schema.anyOf === void 0 && schema.oneOf === void 0 && schema.allOf === void 0 && schema.const === void 0 && schema.enum === void 0) fail("INVALID_SCHEMA", `${at} has no JSON Schema shape`);
+  if (schema.required !== void 0 && (!Array.isArray(schema.required) || schema.required.some((key) => typeof key !== "string"))) fail("INVALID_SCHEMA", `${at}.required must be an array of strings`);
+  if (schema.properties !== void 0 && !object(schema.properties)) fail("INVALID_SCHEMA", `${at}.properties must be an object`);
+}
+
+// subagents/src/contracts.ts
+import { Value as Value2 } from "typebox/value";
+var SUBAGENT_MAX_RETRIES = 255;
+var SUBAGENT_SYSTEM_PROMPT_LIMIT = 64 * 1024;
+var SUBAGENTS_MODE = Type.Union([
+  Type.Literal("background"),
+  Type.Literal("foreground")
+], { description: "Launch mode; background is the default and foreground waits for the terminal envelope" });
+var SUBAGENTS_RUN_PARAMETERS = Type.Object({
+  prompt: Type.String({ description: "Task for the subagent" }),
+  mode: Type.Optional(SUBAGENTS_MODE),
+  label: Type.Optional(Type.String({ description: "Optional display label for the subagent" })),
+  model: Type.Optional(Type.String({ description: "Optional model as provider/model:thinking or alias[:thinking]" })),
+  tools: Type.Optional(Type.Array(Type.String(), { description: "Optional ordered tool selectors; candidates start enabled and !* restricts the set" })),
+  skills: Type.Optional(Type.Array(Type.String(), { description: "Optional ordered skill selectors; candidates start enabled and !* restricts the set" })),
+  extensions: Type.Optional(Type.Array(Type.String(), { description: "Optional ordered extension selectors; candidates start enabled and !* restricts the set" })),
+  contextFiles: Type.Optional(Type.Array(Type.String(), { description: "Optional context-file scopes: global, project, cwd" })),
+  role: Type.Optional(Type.String({ description: "Workflow role name" })),
+  worktree: Type.Optional(Type.String({ description: "Optional named worktree; requires a clean working tree" })),
+  outputSchema: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Optional JSON schema for the result" })),
+  retries: Type.Optional(Type.Integer({ minimum: 0, maximum: SUBAGENT_MAX_RETRIES, description: "Optional retry count; at most 255 retries" })),
+  timeoutMs: Type.Optional(Type.Union([Type.Integer({ minimum: 1, description: "Optional execution timeout in milliseconds" }), Type.Null()]))
+}, { additionalProperties: false });
+var SUBAGENTS_INSPECT_PARAMETERS = Type.Object({
+  id: Type.Optional(Type.String({ description: "Subagent ID; omit to list ordered run summaries" }))
+}, { additionalProperties: false });
+var SUBAGENTS_ID_PARAMETERS = Type.Object({
+  id: Type.String({ description: "Subagent ID" })
+}, { additionalProperties: false });
+var SUBAGENTS_STEER_PARAMETERS = Type.Object({
+  id: Type.String({ description: "Subagent ID" }),
+  message: Type.String({ description: "Message to send to the running subagent" })
+}, { additionalProperties: false });
+var SUBAGENTS_STOP_PARAMETERS = Type.Object({
+  id: Type.String({ description: "Subagent ID" })
+}, { additionalProperties: false });
+var SUBAGENTS_RETRY_PARAMETERS = Type.Object({
+  id: Type.String({ description: "Failed or stopped subagent ID to retry" })
+}, { additionalProperties: false });
+
+// src/trajectory-contracts.ts
+var TRAJECTORY_ACTIONS = ["checkpoint-approve", "checkpoint-reject", "pause", "resume", "steer", "stop", "retry", "share"];
+function isTrajectoryAction(value) {
+  return typeof value === "string" && TRAJECTORY_ACTIONS.includes(value);
+}
+function isTrajectoryTarget(value) {
+  const target = value;
+  return typeof value === "object" && value !== null && !Array.isArray(value) && (target.kind === "run" || target.kind === "subagent") && typeof target.id === "string" && target.id.length >= 1 && target.id.length <= 200;
+}
+function trajectoryActionError(action, target) {
+  return target.kind === "subagent" && (action === "checkpoint-approve" || action === "checkpoint-reject" || action === "pause" || action === "resume" || action === "share") ? `Trajectory action ${action} is not supported for subagent targets` : target.kind === "run" && action === "steer" ? "Trajectory action steer is not supported for run targets" : void 0;
+}
+
+// src/trajectory.ts
+var TRAJECTORY_MAX_TRANSCRIPT_BYTES = 2 * 1024 * 1024;
+var TRAJECTORY_MAX_NON_TIMING_ENTRIES = 400;
+function sessionFile(reference) {
+  const locator = reference?.locator;
+  if (!object(locator) || typeof locator.sessionFile !== "string" || !locator.sessionFile) return void 0;
+  return locator.sessionFile;
+}
+function transcriptToolCallId(value) {
+  if (!object(value)) return void 0;
+  if (typeof value.toolCallId === "string") return value.toolCallId;
+  const message = object(value.message) ? value.message : void 0;
+  if (message && typeof message.toolCallId === "string") return message.toolCallId;
+  if (!message || !Array.isArray(message.content)) return void 0;
+  for (const part of message.content) if (object(part) && typeof part.id === "string") return part.id;
+  return void 0;
+}
+function isTimingTranscriptEntry(value) {
+  return object(value) && value.type === "custom" && value.customType === "pi-workflows:tool-timing";
+}
+function timingToolCallId(value) {
+  if (!object(value) || !isTimingTranscriptEntry(value) || !object(value.data)) return void 0;
+  return typeof value.data.toolCallId === "string" ? value.data.toolCallId : void 0;
+}
+var OversizedTranscriptError = class extends Error {
+};
+async function readTranscript(path, throwOnError = false) {
+  let handle;
+  try {
+    const info = await stat3(path);
+    if (!info.isFile()) return [];
+    const startOffset = Math.max(0, info.size - TRAJECTORY_MAX_TRANSCRIPT_BYTES);
+    const length = info.size - startOffset;
+    handle = await open2(path, "r");
+    const buffer = Buffer.alloc(length);
+    let bytesRead = 0;
+    while (bytesRead < length) {
+      const result = await handle.read(buffer, bytesRead, length - bytesRead, startOffset + bytesRead);
+      if (result.bytesRead === 0) break;
+      bytesRead += result.bytesRead;
+    }
+    let content = buffer.subarray(0, bytesRead).toString("utf8");
+    if (startOffset > 0) {
+      const boundary = Buffer.alloc(1);
+      const boundaryRead = await handle.read(boundary, 0, 1, startOffset - 1);
+      const startsAtRecordBoundary = boundaryRead.bytesRead === 1 && boundary[0] === 10;
+      const firstLine = content.indexOf("\n");
+      if (firstLine < 0) {
+        if (!startsAtRecordBoundary && throwOnError) throw new OversizedTranscriptError("Transcript is too large");
+        if (!startsAtRecordBoundary) return [];
+      } else if (firstLine === content.length - 1 && content.slice(0, firstLine).trim() && !startsAtRecordBoundary) {
+        if (throwOnError) throw new OversizedTranscriptError("Transcript is too large");
+        return [];
+      } else content = content.slice(firstLine + 1);
+    }
+    const entries = [];
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const value = JSON.parse(line);
+        if (object(value)) entries.push(value);
+      } catch {
+      }
+    }
+    const retainedEntries = entries.filter((entry) => !isTimingTranscriptEntry(entry)).slice(-TRAJECTORY_MAX_NON_TIMING_ENTRIES);
+    const retainedIds = new Set(retainedEntries.map(transcriptToolCallId).filter((id) => id !== void 0));
+    const retainedTiming = entries.filter((entry) => {
+      const id = timingToolCallId(entry);
+      return id !== void 0 && retainedIds.has(id);
+    });
+    const retained = /* @__PURE__ */ new Set([...retainedEntries, ...retainedTiming]);
+    return entries.filter((entry) => retained.has(entry));
+  } catch (error) {
+    if (throwOnError) throw error;
+    return [];
+  } finally {
+    await handle?.close();
+  }
+}
+function transcriptPaths(run) {
+  const paths = /* @__PURE__ */ new Map();
+  for (const agent of run.agents) {
+    const path = sessionFile(agent.attemptDetails?.at(-1)?.session);
+    if (path) paths.set(agent.id, path);
+  }
+  return paths;
+}
+async function runTranscripts(run) {
+  const result = {};
+  for (const [agentId, path] of transcriptPaths(run)) result[agentId] = await readTranscript(path);
+  return result;
+}
+function applySystemPrompts(run, prompts) {
+  if (!prompts.length) return run;
+  const bySession = /* @__PURE__ */ new Map();
+  for (const entry of prompts) bySession.set(entry.sessionId, entry.prompt);
+  const agents = run.agents.map((agent) => {
+    if (agent.systemPrompt) return agent;
+    const sessionId = agent.attemptDetails?.at(-1)?.session?.sessionId;
+    const prompt = typeof sessionId === "string" ? bySession.get(sessionId) : void 0;
+    if (prompt === void 0) return agent;
+    return { ...agent, systemPrompt: prompt };
+  });
+  if (agents.every((agent, index) => agent === run.agents[index])) return run;
+  return { ...run, agents };
+}
+function toolDefinitionsFor(tools, catalog) {
+  return tools.flatMap((name) => {
+    const description = catalog.get(name);
+    return description ? [{ name, description }] : [];
+  });
+}
+function applyToolDescriptions(run, catalog) {
+  const agents = run.agents.map((agent) => {
+    if (agent.toolDefinitions?.length) return agent;
+    const toolDefinitions = toolDefinitionsFor(agent.tools, catalog);
+    if (!toolDefinitions.length) return agent;
+    return { ...agent, toolDefinitions };
+  });
+  if (agents.every((agent, index) => agent === run.agents[index])) return run;
+  return { ...run, agents };
+}
+function piToolCatalog(cwd = process.cwd()) {
+  return new Map([
+    createReadToolDefinition(cwd),
+    createBashToolDefinition(cwd),
+    createGrepToolDefinition(cwd),
+    createFindToolDefinition(cwd),
+    createLsToolDefinition(cwd),
+    createEditToolDefinition(cwd),
+    createWriteToolDefinition(cwd)
+  ].map((tool) => [tool.name, tool.description]));
+}
+function withPiToolDescriptions(run) {
+  return applyToolDescriptions(run, piToolCatalog());
+}
+function canonicalExtensionSelector(selector, base) {
+  const negated = selector.startsWith("!");
+  const body = negated ? selector.slice(1) : selector;
+  if (body === "*" || body === "**" || body.startsWith("**/")) return selector;
+  const resolved = resolve4(base, body);
+  if (resourcePatternHasMagic(body)) return `${negated ? "!" : ""}${resolved}`;
+  return `${negated ? "!" : ""}${canonicalPath(resolved)}`;
+}
+function skillNameFromPath(path) {
+  const file = basename4(path);
+  return file.toLowerCase() === "skill.md" ? basename4(dirname4(path)) : file;
+}
+var discoveredResourcesByCwd = /* @__PURE__ */ new Map();
+async function discoveredResources(cwd) {
+  const cached = discoveredResourcesByCwd.get(cwd);
+  if (cached) return cached;
+  const pending = (async () => {
+    const agentDir = getAgentDir2();
+    const settingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: false });
+    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
+    const resolved = await packageManager.resolve();
+    return {
+      extensions: [...new Set(resolved.extensions.filter((entry) => entry.enabled).map((entry) => canonicalPath(entry.path)))],
+      skills: [...new Set(resolved.skills.filter((entry) => entry.enabled).map((entry) => skillNameFromPath(entry.path)))]
+    };
+  })();
+  discoveredResourcesByCwd.set(cwd, pending);
+  pending.catch(() => discoveredResourcesByCwd.delete(cwd));
+  return pending;
+}
+async function resolveResourceInspection(inspection, cwd, selectorCwd = cwd) {
+  if (!inspection || inspection.skills.length && inspection.extensions.length) return inspection;
+  let discovered;
+  try {
+    discovered = await discoveredResources(cwd);
+  } catch {
+    return inspection;
+  }
+  const sources = inspection.selectorSources ?? { global: inspection.selectors, project: {} };
+  const skills = inspection.skills.length ? inspection.skills : selectResourcesByLayers([sources.global.skills, sources.project.skills, sources.role?.skills, sources.call?.skills], discovered.skills);
+  const extensions = inspection.extensions.length ? inspection.extensions : selectResourcesByLayers([sources.global.extensions, sources.project.extensions, sources.role?.extensions, sources.call?.extensions].map((layer) => layer?.map((selector) => canonicalExtensionSelector(selector, selectorCwd))), discovered.extensions);
+  return skills === inspection.skills && extensions === inspection.extensions ? inspection : { ...inspection, skills, extensions };
+}
+async function withResolvedResources(run, cwd) {
+  const agents = await Promise.all(run.agents.map(async (agent) => {
+    const details = agent.attemptDetails;
+    const last = details?.at(-1);
+    if (!details || !last) return agent;
+    const resourceSelectors = await resolveResourceInspection(last.setup.resourceSelectors, cwd, last.setup.cwd || cwd);
+    if (resourceSelectors === last.setup.resourceSelectors) return agent;
+    return { ...agent, attemptDetails: [...details.slice(0, -1), { ...last, setup: { ...last.setup, ...resourceSelectors === void 0 ? {} : { resourceSelectors } } }] };
+  }));
+  if (agents.every((agent, index) => agent === run.agents[index])) return run;
+  return { ...run, agents };
+}
+function withoutAgentActivities(run) {
+  const agents = run.agents.map((agent) => {
+    if (agent.activity === void 0) return agent;
+    const next = { ...agent };
+    delete next.activity;
+    return next;
+  });
+  return agents.every((agent, index) => agent === run.agents[index]) ? run : { ...run, agents };
+}
+async function loadTrajectoryRun(store, includeTranscripts = true) {
+  const value = await store.load();
+  const summary = await store.loadSummary().catch(() => void 0);
+  const prompts = await store.systemPrompts().catch(() => []);
+  const run = withoutAgentActivities(await withResolvedResources(withPiToolDescriptions(applySystemPrompts(value.run, prompts)), store.cwd));
+  return { run, snapshot: value.snapshot, awaiting: await store.awaitingCheckpoints(), ...summary?.createdAt === void 0 ? {} : { createdAt: summary.createdAt }, transcripts: includeTranscripts ? await runTranscripts(run) : {} };
+}
+async function loadTrajectoryRuns(cwd, sessionId, home = homedir5(), overlay) {
+  const loaded = [];
+  for (const runId of await listRunIds(cwd, sessionId, home, false)) {
+    try {
+      const value = await loadTrajectoryRun(new RunStore(cwd, sessionId, runId, home));
+      loaded.push(overlay ? { ...value, run: overlay(value.run) } : value);
+    } catch {
+    }
+  }
+  return loaded;
+}
+
+// trajectory/src/export.ts
+import { execFile as execFile3 } from "node:child_process";
+import { mkdtemp, readFile as readFile5, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir6, tmpdir } from "node:os";
+import { join as join7 } from "node:path";
+var DEFAULT_SHARE_VIEWER_URL = "https://vekexasia.github.io/pi-extensible-workflows/run.html";
+function inlineAsset(html, tag, replacement) {
+  if (!html.includes(tag)) throw new Error(`Trajectory UI is missing the expected ${tag} reference`);
+  return html.replace(tag, () => replacement);
+}
+async function exportTrajectoryRunHtml(options) {
+  const home = options.home ?? homedir6();
+  const runs = await loadTrajectoryRuns(options.cwd, options.sessionId, home);
+  const run = runs.find((candidate) => candidate.run.id === options.runId);
+  if (!run) throw new Error(`Workflow run ${options.runId} was not found for session ${options.sessionId}`);
+  const assets = new URL("./assets/", import.meta.url);
+  const [html, marked, morphdom, favicon] = await Promise.all([
+    readFile5(new URL("index.html", assets), "utf8"),
+    readFile5(new URL("marked.min.js", assets)),
+    readFile5(new URL("morphdom.min.js", assets)),
+    readFile5(new URL("favicon.png", assets))
+  ]);
+  const state = {
+    type: "state",
+    publishers: [{ id: `export-${options.runId}`, title: `run ${options.runId.slice(0, 8)}`, cwd: options.cwd, sessionId: options.sessionId, themes: true, connected: true, runs: [run], subagents: [] }],
+    updatedAt: Date.now()
+  };
+  const script = (source) => `<script src="data:text/javascript;base64,${source.toString("base64")}"></script>`;
+  let output = html;
+  output = inlineAsset(output, '<link rel="icon" type="image/png" href="./favicon.png" />', `<link rel="icon" type="image/png" href="data:image/png;base64,${favicon.toString("base64")}" />`);
+  output = inlineAsset(output, '<script src="./marked.min.js"></script>', script(marked));
+  output = inlineAsset(output, '<script src="./morphdom.min.js"></script>', script(morphdom));
+  output = inlineAsset(output, '<body data-view="run">', `<body data-view="run">
+  <script>window.__PIEWF_STATIC__ = ${JSON.stringify(state).replace(/</g, "\\u003c")};</script>`);
+  return output;
+}
+function runGh(ghPath, args) {
+  return new Promise((resolve5, reject) => {
+    execFile3(ghPath, [...args], { encoding: "utf8", maxBuffer: 1024 * 1024 }, (error, stdout, stderr) => {
+      if (error) {
+        const notFound = error.code === "ENOENT";
+        reject(new Error(notFound ? "GitHub CLI (gh) is not installed. Install it from https://cli.github.com/ and run `gh auth login`." : stderr.trim() || error.message));
+        return;
+      }
+      resolve5(stdout);
+    });
+  });
+}
+async function shareTrajectoryRun(options) {
+  const html = await exportTrajectoryRunHtml(options);
+  const directory = await mkdtemp(join7(tmpdir(), "piewf-share-"));
+  try {
+    const file = join7(directory, "trajectory.html");
+    await writeFile3(file, html);
+    const stdout = await runGh(options.ghPath ?? "gh", ["gist", "create", "--public=false", file]);
+    const gistUrl = stdout.trim().split("\n").pop() ?? "";
+    const gistId = gistUrl.split("/").pop() ?? "";
+    if (!/^[0-9a-f]+$/i.test(gistId)) throw new Error(`Could not parse the gist ID from gh output: ${stdout.trim()}`);
+    const base = process.env.PIEWF_SHARE_VIEWER_URL || DEFAULT_SHARE_VIEWER_URL;
+    return { gistUrl, shareUrl: `${base}#${gistId}` };
+  } finally {
+    await rm4(directory, { recursive: true, force: true });
+  }
+}
+
+// trajectory/src/index.ts
+var DEFAULT_TRAJECTORY_PORT = 7432;
+var TRAJECTORY_IDLE_EXIT_MS = 5 * 60 * 1e3;
+var TRAJECTORY_LOCK_NAME = "trajectory.lock";
+function trajectoryLockPath(agentDir) {
+  return join8(agentDir, "pi-extensible-workflows", TRAJECTORY_LOCK_NAME);
+}
+function trajectoryServerPath(moduleDirectory = dirname5(fileURLToPath3(import.meta.url))) {
+  const candidates = [join8(moduleDirectory, "server.js"), join8(moduleDirectory, "../../dist/trajectory/src/server.js")];
+  const path = candidates.find((candidate) => existsSync(candidate));
+  if (!path) throw new Error("Trajectory server implementation is unavailable");
+  return path;
+}
+async function trajectoryFingerprint(serverPath) {
+  const [serverBytes, htmlBytes] = await Promise.all([readFile6(serverPath), readFile6(join8(dirname5(serverPath), "assets/index.html"))]);
+  return `${createHash3("sha256").update(serverBytes).digest("hex")}:${createHash3("sha256").update(htmlBytes).digest("hex")}`;
+}
+function publisherId(cwd, sessionId) {
+  return createHash3("sha256").update(`${cwd}
+${sessionId}`).digest("hex").slice(0, 16);
+}
+function trajectoryPort(value) {
+  return positiveInteger(value) && value <= 65535 ? value : DEFAULT_TRAJECTORY_PORT;
+}
+function delay(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+async function serverHealthy(port) {
+  try {
+    const response = await fetch(`http://127.0.0.1:${String(port)}/health`, { signal: AbortSignal.timeout(300) });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function signalProcess(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch (error) {
+    if (!isNodeError(error, "ESRCH")) throw error;
+  }
+}
+async function stopStaleServer(lock) {
+  if (lock.pid === process.pid) return;
+  if (!await processAlive(lock.pid, lock.startedAt)) return;
+  signalProcess(lock.pid, "SIGTERM");
+  const deadline = Date.now() + 3e3;
+  while (Date.now() < deadline) {
+    if (!await serverHealthy(lock.port)) break;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    await delay(Math.min(50, remaining));
+  }
+  if (await processAlive(lock.pid, lock.startedAt)) signalProcess(lock.pid, "SIGKILL");
+}
+async function readLock(path) {
+  try {
+    const parsed = JSON.parse(await readFile6(path, "utf8"));
+    if (!object(parsed) || !positiveInteger(parsed.pid) || !positiveInteger(parsed.port) || parsed.port > 65535) return void 0;
+    const fingerprint = typeof parsed.fingerprint === "string" ? parsed.fingerprint : void 0;
+    const startedAt = positiveInteger(parsed.startedAt) ? parsed.startedAt : void 0;
+    return { pid: parsed.pid, port: parsed.port, ...fingerprint === void 0 ? {} : { fingerprint }, ...startedAt === void 0 ? {} : { startedAt } };
+  } catch (error) {
+    if (isNodeError(error, "ENOENT")) return void 0;
+    return void 0;
+  }
+}
+async function waitForServer(port) {
+  for (let attempt = 0; attempt < 60; attempt += 1) {
+    if (await serverHealthy(port)) return;
+    await delay(50);
+  }
+  throw new Error(`Trajectory server did not start on port ${String(port)}`);
+}
+async function resolveExistingServer(lockPath, existing, fingerprint) {
+  if (await serverHealthy(existing.port)) {
+    if (existing.fingerprint === fingerprint) return existing;
+    await stopStaleServer(existing);
+    await rm5(lockPath, { force: true });
+    return void 0;
+  }
+  if (await processAlive(existing.pid, existing.startedAt)) {
+    try {
+      await waitForServer(existing.port);
+      return existing;
+    } catch {
+      await stopStaleServer(existing);
+      await rm5(lockPath, { force: true });
+      return void 0;
+    }
+  }
+  await rm5(lockPath, { force: true });
+  return void 0;
+}
+async function ensureTrajectoryServer(agentDir, configuredPort) {
+  const lockPath = trajectoryLockPath(agentDir);
+  const serverPath = trajectoryServerPath();
+  const fingerprint = await trajectoryFingerprint(serverPath);
+  await mkdir3(dirname5(lockPath), { recursive: true, mode: 448 });
+  const existing = await readLock(lockPath);
+  if (existing) {
+    const reused = await resolveExistingServer(lockPath, existing, fingerprint);
+    if (reused) return reused;
+  }
+  let lockHandle;
+  try {
+    lockHandle = await open3(lockPath, "wx", 384);
+    await lockHandle.writeFile(`${JSON.stringify({ pid: process.pid, port: configuredPort, fingerprint, startedAt: Date.now() })}
+`, "utf8");
+  } catch (error) {
+    if (isNodeError(error, "EEXIST")) {
+      const raced = await readLock(lockPath);
+      if (raced) {
+        const reused = await resolveExistingServer(lockPath, raced, fingerprint);
+        if (reused) return reused;
+      }
+      await rm5(lockPath, { force: true });
+      lockHandle = await open3(lockPath, "wx", 384);
+      await lockHandle.writeFile(`${JSON.stringify({ pid: process.pid, port: configuredPort, fingerprint, startedAt: Date.now() })}
+`, "utf8");
+    } else {
+      throw error;
+    }
+  } finally {
+    await lockHandle?.close();
+  }
+  try {
+    const child = spawn(process.versions.bun ? "node" : process.execPath, [serverPath, "--port", String(configuredPort), "--lock", lockPath, "--fingerprint", fingerprint], { detached: true, stdio: "ignore" });
+    const startupError = new Promise((_resolve, reject) => {
+      child.once("error", reject);
+    });
+    child.unref();
+    await Promise.race([waitForServer(configuredPort), startupError]);
+    return { port: configuredPort };
+  } catch (error) {
+    await rm5(lockPath, { force: true });
+    throw error;
+  }
+}
+function trajectoryWebSocket() {
+  const candidate = globalThis.WebSocket;
+  return typeof candidate === "function" ? candidate : void 0;
+}
+function openBrowser(url) {
+  const command = process.platform === "win32" ? "rundll32" : process.platform === "darwin" ? "open" : "xdg-open";
+  const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+  try {
+    const child = spawn(command, args, { detached: true, stdio: "ignore", windowsHide: true });
+    child.once("error", () => void 0);
+    child.unref();
+  } catch {
+  }
+}
+function trajectoryUrl(port) {
+  return `http://127.0.0.1:${String(port)}/`;
+}
+function openTrajectoryUrl(url) {
+  openBrowser(url);
+}
+var MAX_FRAME_BYTES = 32 * 1024 * 1024;
+var MAX_LIVE_STATE_BYTES = MAX_FRAME_BYTES - 1024;
+var MAX_TRANSCRIPT_REQUESTS = 64;
+var TRANSCRIPT_REQUEST_TIMEOUT_MS = 1e4;
+var RECONNECT_INITIAL_DELAY_MS = 100;
+var RECONNECT_MAX_DELAY_MS = 5e3;
+function isTimingEntry(value) {
+  return object(value) && value.type === "custom" && value.customType === "pi-workflows:tool-timing";
+}
+function boundedString(value, maxLength = 1024) {
+  if (typeof value !== "string") return value;
+  const bytes = Buffer.from(value);
+  return bytes.length > maxLength ? bytes.subarray(0, maxLength).toString("utf8") : value;
+}
+var MAX_LIVE_STRING_BYTES = 64 * 1024;
+var MAX_LIVE_ARRAY_ENTRIES = 256;
+var MAX_LIVE_OBJECT_KEYS = 64;
+var LIVE_METADATA_ARRAY_KEYS = /* @__PURE__ */ new Set(["agents", "runs", "subagents"]);
+var LIVE_TRUNCATABLE_ARRAY_KEYS = /* @__PURE__ */ new Set(["events", "phaseHistory"]);
+var LIVE_METADATA_OBJECT_KEYS = /* @__PURE__ */ new Set(["transcripts"]);
+function boundedTiming(value) {
+  const entries = Array.isArray(value) ? value.filter(isTimingEntry) : [];
+  const retained = [];
+  let bytes = 2;
+  for (const entry of entries) {
+    let serialized;
+    try {
+      serialized = JSON.stringify(entry);
+    } catch {
+      continue;
+    }
+    const nextBytes = bytes + (retained.length ? 1 : 0) + Buffer.byteLength(serialized);
+    if (nextBytes >= 64 * 1024) break;
+    retained.push(entry);
+    bytes = nextBytes;
+  }
+  return retained;
+}
+function boundedLiveValue(value, key = "", depth = 0) {
+  if (typeof value === "string") return boundedString(value, MAX_LIVE_STRING_BYTES);
+  if (typeof value === "number" || typeof value === "boolean" || value === null) return value;
+  if (depth >= 12) return void 0;
+  if (key === "timing") return boundedTiming(value);
+  if (Array.isArray(value)) {
+    const array = value;
+    const maxEntries = LIVE_TRUNCATABLE_ARRAY_KEYS.has(key) ? MAX_LIVE_ARRAY_ENTRIES - 1 : MAX_LIVE_ARRAY_ENTRIES;
+    const entries = key === "attemptDetails" ? array.slice(-8) : LIVE_METADATA_ARRAY_KEYS.has(key) ? array : array.length <= maxEntries ? array : [...array.slice(0, 32), ...array.slice(-maxEntries + 32)];
+    const bounded = entries.map((entry) => boundedLiveValue(entry, "", depth + 1));
+    if (entries.length !== array.length && LIVE_TRUNCATABLE_ARRAY_KEYS.has(key)) bounded.push({ type: "trajectory:truncated", field: key, omitted: array.length - entries.length });
+    return bounded;
+  }
+  if (object(value)) {
+    const result = {};
+    const properties = LIVE_METADATA_OBJECT_KEYS.has(key) ? Object.keys(value).sort() : Object.keys(value).sort().slice(0, MAX_LIVE_OBJECT_KEYS);
+    for (const property of properties) result[property] = boundedLiveValue(value[property], property, depth + 1);
+    return result;
+  }
+  return void 0;
+}
+function transcriptRevisionProjection(value, depth = 0) {
+  if (depth >= 8) return typeof value === "string" ? boundedString(value, 1024) : typeof value === "number" || typeof value === "boolean" || value === null ? value : void 0;
+  if (Array.isArray(value)) {
+    const entries = value;
+    const sample = entries.length <= 16 ? entries : [...entries.slice(0, 8), ...entries.slice(-8)];
+    return { length: entries.length, values: sample.map((entry) => transcriptRevisionProjection(entry, depth + 1)) };
+  }
+  if (object(value)) {
+    const result = {};
+    for (const key of Object.keys(value).sort().slice(0, 32)) result[key] = transcriptRevisionProjection(value[key], depth + 1);
+    return result;
+  }
+  return value;
+}
+function sourceMetadata(value, key, revisions) {
+  if (object(value) && !Array.isArray(value) && typeof value.revision === "number" && typeof value.status === "string") return { ...value, timing: boundedTiming(value.timing) };
+  const entries = Array.isArray(value) ? value : [];
+  const signature = createHash3("sha256").update(JSON.stringify(transcriptRevisionProjection(entries))).digest("hex");
+  const previous = revisions.get(key);
+  const revision = previous?.signature === signature ? previous.revision : (previous?.revision ?? 0) + 1;
+  revisions.set(key, { signature, revision });
+  return { revision, status: entries.length ? "available" : "empty", timing: boundedTiming(entries) };
+}
+function projectRun(value, key, revisions) {
+  const run = object(value.run) && !Array.isArray(value.run) ? value.run : {};
+  const rawAgents = Array.isArray(run.agents) ? run.agents : [];
+  const agents = rawAgents.map((agent) => {
+    if (!object(agent)) return agent;
+    if (agent.activity === void 0) return agent;
+    const activity = object(agent.activity) ? agent.activity : {};
+    return { ...agent, activity: { ...activity, text: boundedString(activity.text) } };
+  });
+  const transcripts = {};
+  const source = object(value.transcripts) && !Array.isArray(value.transcripts) ? value.transcripts : {};
+  for (const [agentId, transcript] of Object.entries(source)) transcripts[agentId] = sourceMetadata(transcript, `${key}	${agentId}`, revisions);
+  return { ...value, run: { ...run, agents }, transcripts };
+}
+function projectSubagent(value, key, revisions) {
+  return { ...value, transcript: sourceMetadata(value.transcript, key, revisions) };
+}
+function projectPublisher(metadata, publisher, revisions) {
+  const publisherId2 = typeof publisher.id === "string" ? publisher.id : "";
+  return { ...publisher, runs: metadata.runs.map((run) => projectRun(run, `${publisherId2}	${run.run.id}`, revisions)), subagents: metadata.subagents.map((subagent) => projectSubagent(subagent, `${publisherId2}	subagent	${subagent.id}`, revisions)) };
+}
+function minimalStatePublisher(publisher) {
+  return boundedLiveValue(publisher) ?? {};
+}
+function publisherStateFrame(publisher, runs, subagents, truncated = false) {
+  const publisherSummary = { ...publisher };
+  delete publisherSummary.runs;
+  delete publisherSummary.subagents;
+  return { type: "publisher:state", publisher: { ...publisherSummary, ...truncated ? { truncated: true } : {} }, runs, subagents, ...truncated ? { truncated: true } : {} };
+}
+function encodeLiveState(publisher) {
+  const projected = minimalStatePublisher(publisher);
+  const publisherJson = JSON.stringify(publisherStateFrame(projected, [], []).publisher);
+  const runs = Array.isArray(projected.runs) ? projected.runs : [];
+  const subagents = Array.isArray(projected.subagents) ? projected.subagents : [];
+  const prefix = `{"type":"publisher:state","publisher":${publisherJson},"runs":[`;
+  const baseBytes = Buffer.byteLength(`${prefix}],"subagents":[]}`);
+  const truncatedBytes = Buffer.byteLength(',"truncated":true');
+  const selectedRuns = [];
+  const selectedSubagents = [];
+  let bytes = baseBytes;
+  const state = { truncated: false };
+  const add = (serialized, target) => {
+    const nextBytes = bytes + Buffer.byteLength(serialized) + (target.length ? 1 : 0);
+    if (nextBytes + truncatedBytes >= MAX_LIVE_STATE_BYTES) return false;
+    target.push(serialized);
+    bytes = nextBytes;
+    return true;
+  };
+  const addValue = (value, target) => {
+    if (bytes + truncatedBytes >= MAX_LIVE_STATE_BYTES) {
+      state.truncated = true;
+      return;
+    }
+    let serializedValue;
+    try {
+      serializedValue = JSON.stringify(value);
+    } catch {
+      state.truncated = true;
+      return;
+    }
+    if (typeof serializedValue !== "string" || !add(serializedValue, target)) state.truncated = true;
+  };
+  for (let index = 0; index < Math.max(runs.length, subagents.length); index += 1) {
+    const run = runs[index];
+    if (run !== void 0) addValue(run, selectedRuns);
+    const subagent = subagents[index];
+    if (subagent !== void 0) addValue(subagent, selectedSubagents);
+  }
+  return `${prefix}${selectedRuns.join(",")}],"subagents":[${selectedSubagents.join(",")}]${state.truncated ? ',"truncated":true' : ""}}`;
+}
+function createTrajectoryController(agentDir) {
+  let socket;
+  let connectionGeneration = 0;
+  let pollTimer;
+  let reconnectTimer;
+  let reconnectLoop;
+  let currentInput;
+  let configuredPort;
+  let closing = false;
+  const transcriptRevisions = /* @__PURE__ */ new Map();
+  const pendingTranscripts = /* @__PURE__ */ new Map();
+  const stopPolling = () => {
+    if (pollTimer !== void 0) {
+      clearInterval(pollTimer);
+      pollTimer = void 0;
+    }
+  };
+  const clearTranscriptRequests = () => {
+    for (const request of pendingTranscripts.values()) clearTimeout(request.timer);
+    pendingTranscripts.clear();
+  };
+  const startPolling = () => {
+    stopPolling();
+    pollTimer = setInterval(() => {
+      void sendState().catch((error) => {
+        if (!closing) console.error(`Trajectory state publish failed: ${errorText(error)}`);
+      });
+    }, 1e3);
+    pollTimer.unref();
+  };
+  let stateLoad;
+  let lastState;
+  const publisherValue = (input) => ({ id: publisherId(input.cwd, input.sessionId), title: `session ${input.sessionId.slice(0, 8)}`, cwd: input.cwd, sessionId: input.sessionId, themes: input.themes, connected: true });
+  const sendState = async () => {
+    const activeSocket = socket;
+    if (activeSocket !== void 0 && stateLoad?.socket === activeSocket) return stateLoad.task;
+    const task = (async () => {
+      const input = currentInput;
+      if (!activeSocket || !input || activeSocket.readyState !== 1) return;
+      const metadata = await input.loadMetadata();
+      if (closing || socket !== activeSocket) return;
+      const publisher = projectPublisher(metadata, publisherValue(input), transcriptRevisions);
+      const serialized = encodeLiveState(publisher);
+      if (serialized === lastState) return;
+      lastState = serialized;
+      activeSocket.send(serialized);
+    })();
+    if (activeSocket !== void 0) stateLoad = { socket: activeSocket, task };
+    try {
+      await task;
+    } finally {
+      if (stateLoad?.task === task) stateLoad = void 0;
+    }
+  };
+  const abandonSocket = (candidate) => {
+    if (socket !== candidate) return;
+    socket = void 0;
+    lastState = void 0;
+    stopPolling();
+    clearTranscriptRequests();
+    candidate.close();
+  };
+  const publishConnectedState = async (next, input) => {
+    startPolling();
+    try {
+      await sendState();
+      if (closing || currentInput !== input) return;
+      if (socket !== next || next.readyState !== 1) throw new Error("Trajectory connection closed before state publish");
+    } catch (error) {
+      if (!closing && socket === next && currentInput === input) abandonSocket(next);
+      throw error;
+    }
+  };
+  const transcriptFromFallback = async (input, request) => {
+    const boundedTranscriptResult = (result) => {
+      try {
+        if (result.status === "available" && Buffer.byteLength(JSON.stringify(result.entries)) > TRAJECTORY_MAX_TRANSCRIPT_BYTES) return { status: "oversized", revision: result.revision, entries: [], error: "Transcript is too large" };
+      } catch {
+        return { status: "failed", revision: result.revision, entries: [], error: "Transcript failed" };
+      }
+      return result;
+    };
+    const boundedResult = (entries, revision) => {
+      try {
+        if (Buffer.byteLength(JSON.stringify(entries)) > TRAJECTORY_MAX_TRANSCRIPT_BYTES) return { status: "oversized", revision, entries: [], error: "Transcript is too large" };
+      } catch {
+        return { status: "failed", revision, entries: [], error: "Transcript failed" };
+      }
+      return { status: entries.length ? "available" : "empty", revision, entries };
+    };
+    if (input.loadTranscript) {
+      const result = await input.loadTranscript(request);
+      const revisionChanged = request.revision !== void 0 && result.revision !== request.revision && result.status !== "missing" && result.status !== "failed" && result.status !== "oversized" && result.status !== "disconnected";
+      return boundedTranscriptResult(revisionChanged ? { ...result, status: "available", entries: [], error: "Transcript revision is stale" } : result);
+    }
+    if (request.runId !== void 0 && request.agentId !== void 0 && request.subagentId === void 0) {
+      const runs = await input.loadRuns();
+      const run = runs.find((candidate) => candidate.run.id === request.runId);
+      const entries = run?.transcripts[request.agentId];
+      const metadata = sourceMetadata(entries, `${publisherId(input.cwd, input.sessionId)}	${request.runId}	${request.agentId}`, transcriptRevisions);
+      if (request.revision !== void 0 && request.revision !== metadata.revision) return { status: "available", revision: Number(metadata.revision), entries: [], error: "Transcript revision is stale" };
+      if (run === void 0 || entries === void 0) return { status: "missing", revision: Number(metadata.revision), entries: [], error: "Transcript not found" };
+      return boundedResult(entries, Number(metadata.revision));
+    }
+    if (request.subagentId !== void 0 && request.runId === void 0 && request.agentId === void 0) {
+      const subagents = await input.loadSubagents();
+      const subagent = subagents.find((candidate) => candidate.id === request.subagentId);
+      const entries = subagent?.transcript;
+      const metadata = sourceMetadata(entries, `${publisherId(input.cwd, input.sessionId)}	subagent	${request.subagentId}`, transcriptRevisions);
+      if (request.revision !== void 0 && request.revision !== metadata.revision) return { status: "available", revision: Number(metadata.revision), entries: [], error: "Transcript revision is stale" };
+      if (subagent === void 0 || entries === void 0) return { status: "missing", revision: Number(metadata.revision), entries: [], error: "Transcript not found" };
+      return boundedResult(entries, Number(metadata.revision));
+    }
+    return { status: "missing", revision: 0, entries: [], error: "Transcript not found" };
+  };
+  const sendTranscriptResult = (next, generation, message, result) => {
+    const requestId = String(message.requestId);
+    const pending = pendingTranscripts.get(requestId);
+    if (!pending || pending.generation !== generation || socket !== next || closing || pending.publisherId !== message.publisherId || pending.runId !== message.runId || pending.agentId !== message.agentId || pending.subagentId !== message.subagentId || pending.revision !== message.revision) return;
+    clearTimeout(pending.timer);
+    pendingTranscripts.delete(requestId);
+    const failed = result.error !== void 0 || result.status === "missing" || result.status === "failed" || result.status === "oversized" || result.status === "disconnected";
+    let safeResult = result;
+    try {
+      if (!failed && Buffer.byteLength(JSON.stringify(result.entries)) > TRAJECTORY_MAX_TRANSCRIPT_BYTES) safeResult = { status: "oversized", revision: result.revision, entries: [], error: "Transcript is too large" };
+    } catch {
+      safeResult = { status: "failed", revision: result.revision, entries: [], error: "Transcript failed" };
+    }
+    const safeFailed = safeResult.error !== void 0 || safeResult.status === "missing" || safeResult.status === "failed" || safeResult.status === "oversized" || safeResult.status === "disconnected";
+    const error = typeof safeResult.error === "string" ? safeResult.error.slice(0, 1024) : safeResult.status;
+    next.send(JSON.stringify({ type: "publisher:transcript-result", requestId: message.requestId, publisherId: message.publisherId, ...message.runId === void 0 ? {} : { runId: message.runId }, ...message.agentId === void 0 ? {} : { agentId: message.agentId }, ...message.subagentId === void 0 ? {} : { subagentId: message.subagentId }, ...message.revision === void 0 ? {} : { requestedRevision: message.revision }, ok: !safeFailed, status: safeResult.status, revision: safeResult.revision, ...safeFailed ? { error } : { entries: safeResult.entries } }));
+  };
+  const handleTranscriptRequest = (next, generation, message, input) => {
+    const requestId = typeof message.requestId === "string" ? message.requestId : "";
+    const revision = typeof message.revision === "number" && Number.isSafeInteger(message.revision) && message.revision >= 0 ? message.revision : void 0;
+    const target = { ...typeof message.runId === "string" ? { runId: message.runId } : {}, ...typeof message.agentId === "string" ? { agentId: message.agentId } : {}, ...typeof message.subagentId === "string" ? { subagentId: message.subagentId } : {}, ...revision === void 0 ? {} : { requestedRevision: revision } };
+    const existing = pendingTranscripts.get(requestId);
+    if (!requestId || existing === void 0 && pendingTranscripts.size >= MAX_TRANSCRIPT_REQUESTS) {
+      next.send(JSON.stringify({ type: "publisher:transcript-result", requestId, publisherId: message.publisherId, ...target, ok: false, status: "failed", revision: revision ?? 0, error: "Too many transcript requests" }));
+      return;
+    }
+    if (existing !== void 0) {
+      const original = { requestId, publisherId: existing.publisherId, ...existing.runId === void 0 ? {} : { runId: existing.runId }, ...existing.agentId === void 0 ? {} : { agentId: existing.agentId }, ...existing.subagentId === void 0 ? {} : { subagentId: existing.subagentId }, ...existing.revision === void 0 ? {} : { revision: existing.revision } };
+      sendTranscriptResult(next, generation, original, { status: "failed", revision: existing.revision ?? 0, entries: [], error: "Duplicate transcript request" });
+      return;
+    }
+    const timer = setTimeout(() => {
+      const pending2 = pendingTranscripts.get(requestId);
+      if (!pending2 || pending2.timer !== timer) return;
+      pendingTranscripts.delete(requestId);
+      if (socket === next && !closing && next.readyState === 1) next.send(JSON.stringify({ type: "publisher:transcript-result", requestId, publisherId: pending2.publisherId, ...pending2.runId === void 0 ? {} : { runId: pending2.runId }, ...pending2.agentId === void 0 ? {} : { agentId: pending2.agentId }, ...pending2.subagentId === void 0 ? {} : { subagentId: pending2.subagentId }, ...pending2.revision === void 0 ? {} : { requestedRevision: pending2.revision }, ok: false, status: "failed", revision: pending2.revision ?? 0, error: "Transcript request timed out" }));
+    }, TRANSCRIPT_REQUEST_TIMEOUT_MS);
+    const pending = { generation, timer, publisherId: message.publisherId, ...typeof message.runId === "string" ? { runId: message.runId } : {}, ...typeof message.agentId === "string" ? { agentId: message.agentId } : {}, ...typeof message.subagentId === "string" ? { subagentId: message.subagentId } : {}, ...revision === void 0 ? {} : { revision } };
+    pendingTranscripts.set(requestId, pending);
+    const request = { ...typeof message.runId === "string" ? { runId: message.runId } : {}, ...typeof message.agentId === "string" ? { agentId: message.agentId } : {}, ...typeof message.subagentId === "string" ? { subagentId: message.subagentId } : {}, ...revision === void 0 ? {} : { revision } };
+    const requestMessage = { ...message, revision };
+    void transcriptFromFallback(input, request).then((result) => {
+      sendTranscriptResult(next, generation, requestMessage, result);
+    }, (error) => {
+      sendTranscriptResult(next, generation, requestMessage, { status: "failed", revision: 0, entries: [], error: errorText(error) });
+    }).catch(() => void 0);
+  };
+  const connect = async (port, input) => {
+    const Constructor = trajectoryWebSocket();
+    if (!Constructor) throw new Error("Trajectory requires a WebSocket-capable Node runtime");
+    const next = new Constructor(`ws://127.0.0.1:${String(port)}/ws`);
+    const generation = connectionGeneration + 1;
+    let established = false;
+    connectionGeneration = generation;
+    socket = next;
+    const onClose = () => {
+      if (socket !== next) return;
+      socket = void 0;
+      lastState = void 0;
+      stopPolling();
+      clearTranscriptRequests();
+      if (established && !closing) scheduleReconnect();
+    };
+    next.addEventListener("close", onClose);
+    next.addEventListener("error", onClose);
+    next.addEventListener("message", (event) => {
+      try {
+        const message = JSON.parse(typeof event === "object" && event !== null && "data" in event ? String(event.data) : "");
+        if (!object(message)) return;
+        if (message.type === "publisher:replaced") {
+          established = false;
+          return;
+        }
+        if (message.type === "publisher:transcript" && typeof message.requestId === "string" && typeof message.publisherId === "string" && (typeof message.runId === "string" && typeof message.agentId === "string" || typeof message.subagentId === "string")) {
+          handleTranscriptRequest(next, generation, message, input);
+          return;
+        }
+        if (message.type !== "publisher:action" || typeof message.requestId !== "string") return;
+        const sendActionResponse = (response) => {
+          if (socket !== next || closing || next.readyState !== 1) return;
+          let serialized;
+          try {
+            serialized = JSON.stringify(response);
+          } catch {
+            serialized = JSON.stringify({ type: "publisher:action-result", requestId: response.requestId, publisherId: response.publisherId, ok: false, error: "Trajectory action result is invalid" });
+          }
+          if (Buffer.byteLength(serialized) >= MAX_FRAME_BYTES) serialized = JSON.stringify({ type: "publisher:action-result", requestId: response.requestId, publisherId: response.publisherId, ok: false, error: "Trajectory action result is too large" });
+          next.send(serialized);
+        };
+        const sendActionResult = (value) => {
+          sendActionResponse({ type: "publisher:action-result", requestId: message.requestId, publisherId: publisherId(input.cwd, input.sessionId), ...object(value) ? { ok: true, result: value } : { ok: true } });
+        };
+        if (!isTrajectoryAction(message.action)) {
+          sendActionResponse({ type: "publisher:action-result", requestId: message.requestId, publisherId: publisherId(input.cwd, input.sessionId), ok: false, error: "Unsupported Trajectory action" });
+          return;
+        }
+        if (!isTrajectoryTarget(message.target)) {
+          sendActionResponse({ type: "publisher:action-result", requestId: message.requestId, publisherId: publisherId(input.cwd, input.sessionId), ok: false, error: "Invalid Trajectory action target" });
+          return;
+        }
+        const target = message.target;
+        const actionError = trajectoryActionError(message.action, target);
+        if (actionError !== void 0) {
+          sendActionResponse({ type: "publisher:action-result", requestId: message.requestId, publisherId: publisherId(input.cwd, input.sessionId), ok: false, error: actionError });
+          return;
+        }
+        if (message.action === "share") {
+          void shareTrajectoryRun({ cwd: input.cwd, sessionId: input.sessionId, runId: target.id }).then((result) => {
+            sendActionResult(result);
+          }, (error) => {
+            sendActionResponse({ type: "publisher:action-result", requestId: message.requestId, publisherId: publisherId(input.cwd, input.sessionId), ok: false, error: errorText(error).slice(0, 1024) });
+          }).catch(() => void 0);
+          return;
+        }
+        void input.handleAction({ action: message.action, target, ...typeof message.name === "string" ? { name: message.name } : {}, ...message.payload === void 0 ? {} : { payload: message.payload } }).then((result) => {
+          sendActionResult(result);
+        }, (error) => {
+          sendActionResponse({ type: "publisher:action-result", requestId: message.requestId, publisherId: publisherId(input.cwd, input.sessionId), ok: false, error: errorText(error).slice(0, 1024) });
+        }).catch(() => void 0);
+      } catch {
+      }
+    });
+    await new Promise((resolve5, reject) => {
+      let settled = false;
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        if (error) reject(error);
+        else resolve5();
+      };
+      next.addEventListener("open", () => {
+        finish();
+      });
+      next.addEventListener("error", () => {
+        finish(new Error("Could not connect to Trajectory server"));
+      });
+      next.addEventListener("close", () => {
+        finish(new Error("Could not connect to Trajectory server"));
+      });
+    });
+    if (closing || currentInput !== input || socket !== next || next.readyState !== 1) {
+      next.close();
+      throw new Error("Trajectory connection was replaced");
+    }
+    established = true;
+    next.send(JSON.stringify({ type: "publisher:attach", publisherId: publisherId(input.cwd, input.sessionId) }));
+  };
+  let reconnectCancel;
+  const waitReconnect = (ms) => new Promise((resolve5) => {
+    const timer = setTimeout(() => {
+      if (reconnectTimer === timer) reconnectTimer = void 0;
+      reconnectCancel = void 0;
+      resolve5();
+    }, ms);
+    timer.unref();
+    reconnectTimer = timer;
+    reconnectCancel = () => {
+      clearTimeout(timer);
+      if (reconnectTimer === timer) reconnectTimer = void 0;
+      reconnectCancel = void 0;
+      resolve5();
+    };
+  });
+  const scheduleReconnect = () => {
+    if (closing || reconnectLoop !== void 0 || configuredPort === void 0) return;
+    const reconnectInput = () => closing || socket !== void 0 || currentInput === void 0 || configuredPort === void 0 ? void 0 : { port: configuredPort, input: currentInput };
+    reconnectLoop = (async () => {
+      let backoff = RECONNECT_INITIAL_DELAY_MS;
+      while (reconnectInput() !== void 0) {
+        await waitReconnect(backoff);
+        const active = reconnectInput();
+        if (active === void 0) return;
+        const { port, input } = active;
+        const isCurrent = () => !closing && currentInput === input && configuredPort === port;
+        try {
+          const server = await ensureTrajectoryServer(agentDir, port);
+          if (!isCurrent()) return;
+          await connect(server.port, input);
+          if (!isCurrent()) return;
+          const activeSocket = socket;
+          if (!activeSocket) throw new Error("Trajectory connection closed before state publish");
+          await publishConnectedState(activeSocket, input);
+          return;
+        } catch (error) {
+          console.error(`Trajectory reconnect failed: ${errorText(error)}`);
+          backoff = Math.min(RECONNECT_MAX_DELAY_MS, backoff * 2);
+        }
+      }
+    })().finally(() => {
+      reconnectLoop = void 0;
+      if (!closing && socket === void 0 && currentInput !== void 0 && configuredPort !== void 0) scheduleReconnect();
+    });
+  };
+  return {
+    async open(input) {
+      closing = false;
+      currentInput = input;
+      const envPort = process.env.PI_WORKFLOW_TRAJECTORY_PORT;
+      configuredPort = envPort !== void 0 && /^\d+$/.test(envPort) ? trajectoryPort(Number(envPort)) : trajectoryPort(input.port);
+      const server = await ensureTrajectoryServer(agentDir, configuredPort);
+      if (!socket || socket.readyState !== 1) await connect(server.port, input);
+      stopPolling();
+      const activeSocket = socket;
+      if (!activeSocket) throw new Error("Trajectory connection closed before state publish");
+      await publishConnectedState(activeSocket, input);
+      return server;
+    },
+    async close() {
+      closing = true;
+      const input = currentInput;
+      const reconnect = reconnectLoop;
+      currentInput = void 0;
+      configuredPort = void 0;
+      reconnectCancel?.();
+      stopPolling();
+      clearTranscriptRequests();
+      lastState = void 0;
+      connectionGeneration += 1;
+      const activeSocket = socket;
+      if (activeSocket?.readyState === 1 && input) activeSocket.send(JSON.stringify({ type: "publisher:detach", publisherId: publisherId(input.cwd, input.sessionId) }));
+      socket = void 0;
+      activeSocket?.close();
+      if (reconnect) await reconnect;
+    }
+  };
+}
+function registerTrajectoryExtension(pi, options = {}) {
+  const controller = options.controller ?? createTrajectoryController(options.agentDir ?? getAgentDir3());
+  const openUrl = options.openUrl ?? openTrajectoryUrl;
+  let autoAttached = false;
+  const notify = (context, message, level) => {
+    const current = object(context) ? context : void 0;
+    const ui = current && object(current.ui) ? current.ui : void 0;
+    if (typeof ui?.notify === "function") Reflect.apply(ui.notify, ui, [message, level]);
+  };
+  const attach = async (provider, context) => {
+    try {
+      return await controller.open(provider(context));
+    } catch (error) {
+      notify(context, `Unable to attach Trajectory: ${errorText(error)}`, "error");
+      return void 0;
+    }
+  };
+  const open4 = async (provider, context) => {
+    const server = await attach(provider, context);
+    if (server === void 0) return;
+    const url = trajectoryUrl(server.port);
+    openUrl(url);
+    notify(context, `Trajectory opened at ${url}`, "info");
+  };
+  const host = {
+    open: open4,
+    autoAttach(provider, context) {
+      if (autoAttached || !context.hasUI) return;
+      autoAttached = true;
+      void attach(provider, context);
+    },
+    close: () => controller.close()
+  };
+  setTrajectoryHost(host);
+  pi.on("session_shutdown", async () => {
+    try {
+      await host.close();
+    } finally {
+      clearTrajectoryHost(host);
+    }
+  });
+  return host;
+}
+function extension(pi) {
+  registerTrajectoryExtension(pi);
+}
+export {
+  DEFAULT_TRAJECTORY_PORT,
+  TRAJECTORY_IDLE_EXIT_MS,
+  TRAJECTORY_LOCK_NAME,
+  createTrajectoryController,
+  extension as default,
+  exportTrajectoryRunHtml,
+  openTrajectoryUrl,
+  registerTrajectoryExtension,
+  shareTrajectoryRun,
+  trajectoryServerPath,
+  trajectoryUrl
+};
+//# sourceMappingURL=index.js.map