@marcoscale98/pi-extensible-workflows 5.17.0-fork.1 → 6.2.1-fork.1

package/src/settings.ts

@@ -1,20 +1,23 @@
 import { atomicWriteFile } from "./persistence.js";
 import { mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir, type ToolAnnotations } from "@earendil-works/pi-coding-agent";
+import type { AgentResourcePolicy, AgentResourceSelectorSources, AgentResourceSelectors, AgentResourceSelectorSet, ContextFileScope, JsonValue, WorkflowExtensionSettings, WorkflowRetentionSettings, WorkflowSettings, WorkflowSettingsOverrides, WorkflowSettingsResolution, WorkflowSettingsSources } from "./types.js";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import type { AgentResourcePolicy, AgentResourceSelectors, AgentResourceSelectorSet, ContextFileScope, JsonValue, WorkflowExtensionSettings, WorkflowRetentionSettings, WorkflowSettings, WorkflowSettingsOverrides, WorkflowSettingsResolution, WorkflowSettingsSources } from "./types.js";
-import { isContextFileScope } from "./types.js";
-import { annotateModelAliasError, deepFreeze, errorText, fail, isNodeError, jsonValue, modelCapability, object, positiveInteger, resourcePatternHasMagic, unknownModel, validateModelAliases, validateResourcePattern, validWorkflowExtensionNamespace } from "./utils.js";
 import { canonicalPath, workflowProjectSettingsPath } from "./paths.js";
 export { workflowProjectSettingsPath } from "./paths.js";
+import { isContextFileScope } from "./types.js";
+import { annotateModelAliasError, deepFreeze, errorText, fail, isNodeError, modelCapability, object, positiveInteger, unknownModel, validateModelAliases } from "./utils.js";
+import { jsonValue, resourcePatternHasMagic, validateResourcePattern, validWorkflowExtensionNamespace } from "./utils.js";
 
-const ROLE_DIRECTORY = "pi-extensible-workflows";
+const WORKFLOW_DIRECTORY = "pi-extensible-workflows";
 export const DEFAULT_SETTINGS: Readonly<WorkflowSettings> = Object.freeze({ concurrency: 8, backgroundWidget: true });
-export function workflowSettingsPath(agentDir = getAgentDir()): string { return join(agentDir, ROLE_DIRECTORY, "settings.json"); }
+export function workflowSettingsPath(agentDir = getAgentDir()): string { return join(agentDir, WORKFLOW_DIRECTORY, "settings.json"); }
 function normalizedResourcePath(value: string, settingsPath: string): string {
-  if (value === "*") return value;
+  // Built-in extensions are named `builtin:<name>`, not by a path.
+  if (value === "*" || value.startsWith("builtin:")) return value;
   let expanded = value === "~" ? homedir() : value.startsWith("~/") || value.startsWith("~\\") ? join(homedir(), value.slice(2)) : value;
   if (expanded.startsWith("file://")) expanded = fileURLToPath(expanded);
   const resolved = resolve(dirname(settingsPath), expanded);
@@ -63,18 +66,19 @@ function selectorsFromSettings(settings: Readonly<WorkflowSettings | WorkflowSet
   };
 }
 function selectorSet(value: AgentResourceSelectors | undefined): AgentResourceSelectorSet { return { skills: [...(value?.skills ?? [])], extensions: [...(value?.extensions ?? [])], ...(value?.tools === undefined ? {} : { tools: [...value.tools] }) }; }
-export function validateContextFileScopes(value: unknown, rolePath: string): readonly ContextFileScope[] | undefined {
+export function validateContextFileScopes(value: unknown, sourcePath: string): readonly ContextFileScope[] | undefined {
   if (value === undefined) return undefined;
-  if (!Array.isArray(value) || !value.every(isContextFileScope)) fail("INVALID_METADATA", `${rolePath}.contextFiles must be an array containing only global, project, or cwd`);
+  if (!Array.isArray(value) || !value.every(isContextFileScope)) fail("INVALID_METADATA", `${sourcePath}.contextFiles must be an array containing only global, project, or cwd`);
   return [...value];
 }
 export function validateWorkflowExtensionSettings(value: unknown, settingsPath: string, errorCode: "INVALID_SETTINGS" | "INVALID_METADATA" = "INVALID_SETTINGS"): WorkflowExtensionSettings | undefined {
   if (value === undefined) return undefined;
+  if (!object(value) || !jsonValue(value)) fail(errorCode, `${settingsPath}.extensionSettings must be a JSON object`);
+  for (const namespace of Object.keys(value)) if (!validWorkflowExtensionNamespace(namespace)) fail(errorCode, `${settingsPath}.extensionSettings contains an invalid namespace: ${namespace}`);
+  const generic = value;
   const base = `${settingsPath}.extensionSettings`;
-  if (!object(value)) fail(errorCode, `${base} must be an object`);
   const normalized: Record<string, JsonValue> = {};
-  for (const [namespace, raw] of Object.entries(value)) {
-    if (!validWorkflowExtensionNamespace(namespace)) fail(errorCode, `${base} contains an invalid namespace: ${namespace}`);
+  for (const [namespace, raw] of Object.entries(generic)) {
     if (namespace === "herdr") {
       if (!object(raw)) fail(errorCode, `${base}.herdr must be an object`);
       if (Object.keys(raw).some((key) => key !== "enableFullyInspectableMode")) fail(errorCode, `${base}.herdr contains an unsupported setting`);
@@ -89,7 +93,6 @@ export function validateWorkflowExtensionSettings(value: unknown, settingsPath:
       normalized.trajectory = Object.freeze({ ...(raw.port === undefined ? {} : { port: raw.port }) });
       continue;
     }
-    if (!jsonValue(raw)) fail(errorCode, `${base}.${namespace} must be JSON-compatible`);
     normalized[namespace] = structuredClone(raw);
   }
   return deepFreeze(normalized as WorkflowExtensionSettings);
@@ -115,7 +118,7 @@ function parseSettings(path: string, partial: boolean): Readonly<WorkflowSetting
     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 = new Set(["concurrency", "modelAliases", "skills", "extensions", "extensionSettings", "tools", "retention", "worktreePostCreateCommand", ...(partial ? [] : ["backgroundWidget"]) ]);
+  const allowed = new Set(["concurrency", "modelAliases", "skills", "extensions", "extensionSettings", "tools", "retention", "worktreePostCreateCommand", ...(partial ? [] : ["backgroundWidget", "codemodeTools"]) ]);
   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}`);
@@ -123,6 +126,8 @@ function parseSettings(path: string, partial: boolean): Readonly<WorkflowSetting
   if (concurrency !== undefined && (!positiveInteger(concurrency) || concurrency > 16)) fail("INVALID_SETTINGS", `${path}.concurrency must be an integer from 1 to 16`);
   const backgroundWidget = parsed.backgroundWidget === undefined ? (partial ? undefined : DEFAULT_SETTINGS.backgroundWidget) : parsed.backgroundWidget;
   if (backgroundWidget !== undefined && typeof backgroundWidget !== "boolean") fail("INVALID_SETTINGS", `${path}.backgroundWidget must be a boolean`);
+  const codemodeTools = parsed.codemodeTools;
+  if (codemodeTools !== undefined && codemodeTools !== "all" && codemodeTools !== "read-only" && codemodeTools !== "none") fail("INVALID_SETTINGS", `${path}.codemodeTools must be "all", "read-only", or "none"`);
   const modelAliases = parsed.modelAliases === undefined ? undefined : validateModelAliases(parsed.modelAliases, path);
   const skills = validateSelectorList(parsed.skills, path, "skills");
   const tools = validateSelectorList(parsed.tools, path, "tools");
@@ -131,49 +136,45 @@ function parseSettings(path: string, partial: boolean): Readonly<WorkflowSetting
   const retention = validateRetention(parsed.retention, path);
   const worktreePostCreateCommand = validateWorktreePostCreateCommand(parsed.worktreePostCreateCommand, path);
   return Object.freeze({
-    ...(concurrency === undefined ? {} : { concurrency }), ...(backgroundWidget === undefined ? {} : { backgroundWidget }), ...(modelAliases === undefined ? {} : { modelAliases }),
+    ...(concurrency === undefined ? {} : { concurrency }), ...(backgroundWidget === undefined ? {} : { backgroundWidget }), ...(codemodeTools === undefined ? {} : { codemodeTools }), ...(modelAliases === undefined ? {} : { modelAliases }),
     ...(skills === undefined ? {} : { skills }), ...(extensions === undefined ? {} : { extensions }),
     ...(extensionSettings === undefined ? {} : { extensionSettings }), ...(tools === undefined ? {} : { tools }), ...(retention === undefined ? {} : { retention }),
     ...(worktreePostCreateCommand === undefined ? {} : { worktreePostCreateCommand }),
   });
 }
 export function loadSettings(path = workflowSettingsPath()): Readonly<WorkflowSettings> { return parseSettings(path, false); }
+const READ_ONLY_WORKFLOW_TOOLS: ReadonlySet<string> = new Set(["workflow_status", "workflow_catalog", "subagents_inspect"]);
+/**
+ * Exposure and annotations of a workflow or subagent tool. Under the global `codemodeTools` setting,
+ * `model-only` keeps the model's direct access and stops codemode scripts from calling the tool.
+ * Tools are registered once at load, so the setting is global and applies after a reload.
+ * Read-only tools carry `readOnlyHint` so permission extensions need not confirm them.
+ */
+export function workflowToolExposure(name: string, codemodeTools: WorkflowSettings["codemodeTools"]): { exposure?: "model-only"; annotations?: ToolAnnotations } {
+  const readOnly = READ_ONLY_WORKFLOW_TOOLS.has(name);
+  return { ...(codemodeTools === "none" || (codemodeTools === "read-only" && !readOnly) ? { exposure: "model-only" as const } : {}), ...(readOnly ? { annotations: { readOnlyHint: true } } : {}) };
+}
+/** The `codemodeTools` setting at load time. Invalid settings keep the default; launches report them. */
+export function loadCodemodeToolsSetting(agentDir?: string): WorkflowSettings["codemodeTools"] {
+  try { return loadSettings(workflowSettingsPath(agentDir)).codemodeTools; } catch { return undefined; }
+}
 export function loadSettingsOverrides(path: string): Readonly<WorkflowSettingsOverrides> { return parseSettings(path, true); }
-export function resolveWorkflowSettings(cwd: string, projectTrusted: boolean, globalSettingsPath = workflowSettingsPath()): WorkflowSettingsResolution {
+export function resolveWorkflowSettings(cwd: string, projectTrusted: boolean, globalSettingsPath = workflowSettingsPath()): WorkflowSettingsResolution & { selectorSources: AgentResourceSelectorSources } {
   const projectSettingsPath = workflowProjectSettingsPath(cwd);
-  const global = loadSettings(globalSettingsPath);
-  const project: Readonly<WorkflowSettingsOverrides> = projectTrusted ? loadSettingsOverrides(projectSettingsPath) : Object.freeze({});
-  const projectHas = (key: keyof WorkflowSettingsOverrides): boolean => Object.prototype.hasOwnProperty.call(project, key);
-  const sourceFor = (key: "skills" | "extensions" | "tools"): string => 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 === undefined && projectSelectors.tools === undefined ? {} : { tools: [...(globalSelectors.tools ?? []), ...(projectSelectors.tools ?? [])] }),
+  const consumerGlobal = loadSettings(globalSettingsPath);
+  const consumerProject: Readonly<WorkflowSettingsOverrides> = projectTrusted ? loadSettingsOverrides(projectSettingsPath) : Object.freeze({});
+  const global = consumerGlobal;
+  const project = consumerProject;
+  const selectorSources = { global: selectorsFromSettings(global), project: selectorsFromSettings(project) };
+  const effective: Readonly<WorkflowSettings> = Object.freeze({
+    ...global, ...project,
+    skills: [...(global.skills ?? []), ...(project.skills ?? [])],
+    extensions: [...(global.extensions ?? []), ...(project.extensions ?? [])],
+    ...(global.tools === undefined && project.tools === undefined ? {} : { tools: [...(global.tools ?? []), ...(project.tools ?? [])] }),
   });
-  const hasExtensionSelectors = global.extensions !== undefined || project.extensions !== undefined;
-  const extensionSettings = projectHas("extensionSettings") ? project.extensionSettings : global.extensionSettings;
-  const sources: WorkflowSettingsSources = {
-    concurrency: projectHas("concurrency") ? projectSettingsPath : globalSettingsPath,
-    modelAliases: projectHas("modelAliases") ? projectSettingsPath : globalSettingsPath,
-    skills: sourceFor("skills"), extensions: sourceFor("extensions"), tools: sourceFor("tools"),
-    ...(extensionSettings === undefined ? {} : { extensionSettings: projectHas("extensionSettings") ? projectSettingsPath : globalSettingsPath }),
-    ...(project.retention === undefined && global.retention === undefined ? {} : { retention: project.retention === undefined ? globalSettingsPath : projectSettingsPath }),
-    ...(projectHas("worktreePostCreateCommand") || global.worktreePostCreateCommand !== undefined ? { 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 === undefined ? {} : { modelAliases: global.modelAliases }),
-    ...(effectiveSelectors.skills.length ? { skills: effectiveSelectors.skills } : global.skills !== undefined || project.skills !== undefined ? { skills: effectiveSelectors.skills } : {}),
-    ...(hasExtensionSelectors ? { extensions: effectiveSelectors.extensions } : {}),
-    ...(extensionSettings === undefined ? {} : { extensionSettings }),
-    ...(effectiveSelectors.tools?.length ? { tools: effectiveSelectors.tools } : global.tools !== undefined || project.tools !== undefined ? { tools: effectiveSelectors.tools } : {}),
-    ...((project.retention ?? global.retention) === undefined ? {} : { retention: project.retention ?? global.retention }),
-    ...(projectHas("worktreePostCreateCommand") ? { worktreePostCreateCommand: project.worktreePostCreateCommand } : global.worktreePostCreateCommand === undefined ? {} : { worktreePostCreateCommand: global.worktreePostCreateCommand }),
-  });
-  return { globalSettingsPath, projectSettingsPath, projectTrusted, global, project, effective, sources };
+  const sources: WorkflowSettingsSources = { concurrency: project.concurrency === undefined ? globalSettingsPath : projectSettingsPath, modelAliases: project.modelAliases === undefined ? globalSettingsPath : projectSettingsPath };
+  for (const key of ["skills", "extensions", "tools", "extensionSettings", "retention", "worktreePostCreateCommand"] as const) if (effective[key] !== undefined) sources[key] = project[key] === undefined ? globalSettingsPath : projectSettingsPath;
+  return { globalSettingsPath, projectSettingsPath, projectTrusted, global, project, effective, sources, selectorSources };
 }
 export function validateModelAliasAvailability(aliases: Readonly<Record<string, string>>, names: readonly string[], availableModels: ReadonlySet<string>, knownModels: ReadonlySet<string>, settingsPath?: string): void {
   for (const name of names) {
@@ -188,7 +189,7 @@ export function resolveAgentResourcePolicy(cwd: string, projectTrusted: boolean,
   const global = selectorSet(selectorsFromSettings(resolved.global));
   const project = selectorSet(selectorsFromSettings(resolved.project));
   const effective = selectorSet(selectorsFromSettings(resolved.effective));
-  return { globalSettingsPath: resolved.globalSettingsPath, projectSettingsPath: resolved.projectSettingsPath, projectTrusted, global, project, effective, unmatchedSkills: [], unmatchedExtensions: [], unmatchedTools: [], selectorSources: { global: selectorsFromSettings(resolved.global), project: selectorsFromSettings(resolved.project) } };
+  return { globalSettingsPath: resolved.globalSettingsPath, projectSettingsPath: resolved.projectSettingsPath, projectTrusted, global, project, effective, unmatchedSkills: [], unmatchedExtensions: [], unmatchedTools: [], selectorSources: resolved.selectorSources };
 }
 export function saveModelAliases(path = workflowSettingsPath(), aliases: Readonly<Record<string, string>> = {}): void {
   const normalized = validateModelAliases(aliases, path);
@@ -204,3 +205,8 @@ export function saveModelAliases(path = workflowSettingsPath(), aliases: Readonl
   atomicWriteFile(path, `${JSON.stringify({ ...parsed, modelAliases: normalized }, null, 2)}\n`, true);
 }
 
+
+export function canonicalExtensionSelector(selector: string, cwd: string): string {
+  const negated = selector.startsWith("!");
+  return `${negated ? "!" : ""}${normalizedResourcePath(negated ? selector.slice(1) : selector, join(cwd, "settings.json"))}`;
+}

package/src/store.ts

@@ -4,7 +4,7 @@ import { access, mkdir, readdir, readFile, realpath, rename, rm, stat, writeFile
 import { homedir } from "node:os";
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
-import { HARD_TERMINAL_RUN_STATES, WorkflowError, type JsonValue, type LaunchSnapshot, type WorkflowErrorCode, type WorkflowRunEvent } from "./types.js";
+import { HARD_TERMINAL_RUN_STATES, WorkflowError, type PreparedAgentConfiguration, type JsonValue, type LaunchSnapshot, type WorkflowErrorCode, type WorkflowLaunchMode, type WorkflowRunEvent } from "./types.js";
 import { coerceWorkflowError, errorText, isNodeError, loadLaunchSnapshot, object, positiveInteger, SerialLane } from "./utils.js";
 import { budgetUsage } from "./budget.js";
 import {
@@ -32,7 +32,7 @@ function summaryFromRun(run: PersistedRun, directory: string, journal: Journal,
   const failedAt = run.failedAt ?? run.error?.failedAt;
   const replayablePaths = [...new Set([...(run.retry?.completedPaths ?? []), ...Object.keys(journal.completed)])];
   const incompletePaths = [...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) };
+  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, attempts }) => ({ id, name, ...(label ? { label } : {}), state, attempts })), ...(run.error ? { error: run.error } : {}), ...(failedAt ? { failedAt } : {}), replayablePaths, incompletePaths, artifacts: summaryArtifacts(directory) };
 }
 function systemPromptStoragePath(directory: string): string { return join(directory, SYSTEM_PROMPT_STORAGE); }
 function systemPromptRecordsPath(directory: string): string { return join(systemPromptStoragePath(directory), SYSTEM_PROMPT_RECORDS); }
@@ -163,6 +163,22 @@ export class RunStore {
     return write;
   }
 
+  async saveAgentConfiguration(key: string, configuration: PreparedAgentConfiguration): Promise<void> {
+    await this.launchSnapshotLane.run(async () => {
+      const snapshot = decodeLaunchSnapshot(await json(join(this.directory, "snapshot.json")));
+      if (!snapshot) throw new WorkflowError("RESUME_INCOMPATIBLE", "Workflow launch snapshot identity version is incompatible");
+      await atomicJson(join(this.directory, "snapshot.json"), { ...snapshot, agentConfigurations: { ...snapshot.agentConfigurations, [key]: configuration } });
+    });
+  }
+
+  async setLaunchMode(launchMode: WorkflowLaunchMode): Promise<void> {
+    await this.launchSnapshotLane.run(async () => {
+      const snapshot = decodeLaunchSnapshot(await json(join(this.directory, "snapshot.json")));
+      if (!snapshot) throw new WorkflowError("RESUME_INCOMPATIBLE", "Workflow launch snapshot identity version is incompatible");
+      await atomicJson(join(this.directory, "snapshot.json"), { ...snapshot, launchMode });
+    });
+  }
+
   async saveSnapshot(snapshot: Readonly<LaunchSnapshot>): Promise<void> {
     const write = this.launchSnapshotLane.run(() => atomicJson(join(this.directory, "snapshot.json"), snapshot));
     await write;

package/src/trajectory.ts

@@ -5,12 +5,13 @@ import { basename, dirname, join, resolve } from "node:path";
 import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, DefaultPackageManager, getAgentDir, SettingsManager, DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
 import { listRunIds, RunStore, type AwaitingCheckpoint, type CompletedOperation, type EffectiveSystemPrompt, type PersistedRun } from "./persistence.js";
 import { navigatorAttentionSortByState } from "./host-view.js";
-import type { AgentAttemptSummary, AgentRecord, JsonValue, LaunchSnapshot, WorkflowAgentSessionReference } from "./types.js";
+import type { AgentAttemptSummary, AgentRecord, JsonValue, LaunchSnapshot, WorkflowAgentSessionReference, WorkflowErrorCode, WorkflowScriptCall } from "./types.js";
 import { normalizeSubagentRunRequest, type SubagentProgress, type SubagentRunRequest, type SubagentStatus } from "../subagents/src/contracts.js";
 import { statusValue, subagentErrorValue } from "../subagents/src/decode.js";
 import { isNodeError, jsonValue, object, resourcePatternHasMagic, selectResourcesByLayers } from "./utils.js";
 import type { TrajectoryAction, TrajectoryTarget } from "./trajectory-contracts.js";
 import { canonicalPath, sameFilesystemPath } from "./paths.js";
+import { TOOL_TIMING_ENTRY_TYPE } from "./tool-timing.js";
 
 export const TRAJECTORY_MAX_TRANSCRIPT_BYTES = 2 * 1024 * 1024;
 const TRAJECTORY_MAX_NON_TIMING_ENTRIES = 400;
@@ -22,7 +23,8 @@ export type TrajectoryAgentOutput =
   | { readonly status: "truncated"; readonly kind: "result" | "failure"; readonly bytes: number; readonly path?: string }
   | { readonly status: "unavailable" };
 export type TrajectoryAgent = AgentRecord & { readonly output: TrajectoryAgentOutput };
-export type TrajectoryRunRecord = Omit<PersistedRun, "agents"> & { readonly agents: readonly TrajectoryAgent[] };
+export type TrajectoryScriptCall = WorkflowScriptCall & { readonly output: TrajectoryAgentOutput | { readonly status: "completed" } | { readonly status: "failed" | "cancelled"; readonly code: WorkflowErrorCode } };
+export type TrajectoryRunRecord = Omit<PersistedRun, "agents" | "scriptCalls"> & { readonly agents: readonly TrajectoryAgent[]; readonly scriptCalls?: readonly TrajectoryScriptCall[] };
 export type TrajectoryRun = {
   run: TrajectoryRunRecord;
   snapshot: Readonly<LaunchSnapshot>;
@@ -64,7 +66,6 @@ export type TrajectorySubagent = {
   sessionId: string;
   cwd: string;
   label?: string;
-  role?: string;
   mode: "background" | "foreground";
   state: SubagentStatus["state"];
   startedAt?: number;
@@ -124,7 +125,7 @@ function transcriptToolCallId(value: unknown): string | undefined {
   for (const part of message.content) if (object(part) && typeof part.id === "string") return part.id;
   return undefined;
 }
-function isTimingTranscriptEntry(value: unknown): boolean { return object(value) && value.type === "custom" && value.customType === "pi-workflows:tool-timing"; }
+export function isTimingTranscriptEntry(value: unknown): boolean { return object(value) && value.type === "custom" && value.customType === TOOL_TIMING_ENTRY_TYPE; }
 function timingToolCallId(value: unknown): string | undefined {
   if (!object(value) || !isTimingTranscriptEntry(value) || !object(value.data)) return undefined;
   return typeof value.data.toolCallId === "string" ? value.data.toolCallId : undefined;
@@ -243,7 +244,8 @@ export function withPiToolDescriptionsForTools(tools: readonly string[], cwd: st
 function canonicalExtensionSelector(selector: string, base: string): string {
   const negated = selector.startsWith("!");
   const body = negated ? selector.slice(1) : selector;
-  if (body === "*" || body === "**" || body.startsWith("**/")) return selector;
+  // Built-in extensions are named `builtin:<name>`, not by a path.
+  if (body === "*" || body === "**" || body.startsWith("**/") || body.startsWith("builtin:")) return selector;
   const resolved = resolve(base, body);
   if (resourcePatternHasMagic(body)) return `${negated ? "!" : ""}${resolved}`;
   return `${negated ? "!" : ""}${canonicalPath(resolved)}`;
@@ -279,8 +281,8 @@ async function resolveResourceInspection(inspection: ResourceInspection | undefi
   let discovered: DiscoveredResources;
   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);
+  const skills = inspection.skills.length ? inspection.skills : selectResourcesByLayers([sources.global.skills, sources.project.skills, sources.call?.skills], discovered.skills);
+  const extensions = inspection.extensions.length ? inspection.extensions : selectResourcesByLayers([sources.global.extensions, sources.project.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 };
 }
 export async function withResolvedAttemptResources(attempt: AgentAttemptSummary, cwd: string): Promise<AgentAttemptSummary> {
@@ -319,11 +321,17 @@ function failedAgentOutput(agent: PersistedRun["agents"][number]): TrajectoryAge
   const status = agent.state === "cancelled" ? "cancelled" : "failed";
   return { status, code: error?.code ?? (status === "cancelled" ? "CANCELLED" : "AGENT_FAILED"), message: error?.message ?? `Agent ${agent.state}` };
 }
+function operationOutput(operation: CompletedOperation): TrajectoryAgentOutput {
+  const bytes = serializedJsonBytes(operation.value);
+  return bytes > DEFAULT_MAX_BYTES ? { status: "truncated", kind: "result", bytes } : { status: "available", value: operation.value, bytes };
+}
+function outputForCall(call: WorkflowScriptCall, operation: CompletedOperation | undefined): TrajectoryScriptCall["output"] {
+  if (operation !== undefined) return call.kind === "tool" ? { status: "completed" } : operationOutput(operation);
+  if (call.error) return { status: call.error.code === "CANCELLED" ? "cancelled" : "failed", code: call.error.code, ...(call.kind === "shell" ? { message: call.error.message ?? "Shell failed" } : {}) };
+  return call.finishedAt === undefined ? { status: "pending" } : { status: "unavailable" };
+}
 function outputForAgent(agent: PersistedRun["agents"][number], operation: CompletedOperation | undefined): TrajectoryAgentOutput {
-  if (operation !== undefined) {
-    const bytes = serializedJsonBytes(operation.value);
-    return bytes > DEFAULT_MAX_BYTES ? { status: "truncated", kind: "result", bytes } : { status: "available", value: operation.value, bytes };
-  }
+  if (operation !== undefined) return operationOutput(operation);
   if (agent.state === "failed" || agent.state === "cancelled") return failedAgentOutput(agent);
   if (agent.state === "completed") return { status: "unavailable" };
   return { status: "pending" };
@@ -331,17 +339,27 @@ function outputForAgent(agent: PersistedRun["agents"][number], operation: Comple
 export function applyTrajectoryAgentOutputs(run: PersistedRun, operations: readonly CompletedOperation[]): TrajectoryRunRecord {
   const byPath = new Map(operations.map((operation) => [operation.path, operation]));
   const agents: readonly TrajectoryAgent[] = run.agents.map((agent) => ({ ...agent, output: outputForAgent(agent, agent.resultPath === undefined ? undefined : byPath.get(agent.resultPath)) }));
-  return { ...run, agents };
+  const scriptCalls = run.scriptCalls?.map((call): TrajectoryScriptCall => {
+    const recorded = { ...call, output: outputForCall(call, byPath.get(call.path)) };
+    if (call.kind === "tool") {
+      delete recorded.input;
+      delete recorded.inputBytes;
+      if (call.error) recorded.error = { code: call.error.code };
+    }
+    return recorded;
+  });
+  const rest: Omit<PersistedRun, "scriptCalls"> = run;
+  return { ...rest, agents, ...(scriptCalls === undefined ? {} : { scriptCalls }) };
 }
 function overlayTrajectoryRun(run: TrajectoryRunRecord, overlay: (run: PersistedRun) => PersistedRun): TrajectoryRunRecord {
-  const overlaid = overlay(run);
+  const overlaid: Omit<PersistedRun, "scriptCalls"> = overlay(run);
   const outputs = new Map(run.agents.map((agent) => [agent.id, agent.output]));
   const agents: readonly TrajectoryAgent[] = overlaid.agents.map((agent) => {
     const previous = outputs.get(agent.id);
     const output = previous?.status === "available" || previous?.status === "truncated" ? previous : outputForAgent(agent, undefined);
     return { ...agent, output };
   });
-  return { ...overlaid, agents };
+  return { ...overlaid, agents, ...(run.scriptCalls === undefined ? {} : { scriptCalls: run.scriptCalls }) };
 }
 async function loadTrajectoryRun(store: RunStore, includeTranscripts = true): Promise<TrajectoryRun> {
   const value = await store.load();
@@ -546,7 +564,6 @@ async function loadTrajectorySubagent(directory: string, cwd: string, sessionId:
     return {
       id, sessionId, cwd, mode: request.mode ?? "background", state: status.state, request, tools, transcript,
       ...(request.label === undefined ? {} : { label: request.label }),
-      ...(request.role === undefined ? {} : { role: request.role }),
       ...(status.startedAt === undefined ? {} : { startedAt: status.startedAt }),
       ...(status.finishedAt === undefined ? {} : { finishedAt: status.finishedAt }),
       ...(status.attempts === undefined ? {} : { attempts: status.attempts }),