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

package/dist/src/settings.js

@@ -1,18 +1,21 @@
 import { atomicWriteFile } from "./persistence.js";
 import { mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 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 { 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";
-const ROLE_DIRECTORY = "pi-extensible-workflows";
+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 WORKFLOW_DIRECTORY = "pi-extensible-workflows";
 export const DEFAULT_SETTINGS = Object.freeze({ concurrency: 8, backgroundWidget: true });
-export function workflowSettingsPath(agentDir = getAgentDir()) { return join(agentDir, ROLE_DIRECTORY, "settings.json"); }
+export function workflowSettingsPath(agentDir = getAgentDir()) { return join(agentDir, WORKFLOW_DIRECTORY, "settings.json"); }
 function normalizedResourcePath(value, settingsPath) {
-    if (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://"))
@@ -81,23 +84,25 @@ function selectorsFromSettings(settings) {
     };
 }
 function selectorSet(value) { return { skills: [...(value?.skills ?? [])], extensions: [...(value?.extensions ?? [])], ...(value?.tools === undefined ? {} : { tools: [...value.tools] }) }; }
-export function validateContextFileScopes(value, rolePath) {
+export function validateContextFileScopes(value, sourcePath) {
     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`);
+        fail("INVALID_METADATA", `${sourcePath}.contextFiles must be an array containing only global, project, or cwd`);
     return [...value];
 }
 export function validateWorkflowExtensionSettings(value, settingsPath, errorCode = "INVALID_SETTINGS") {
     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 = {};
-    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`);
@@ -118,8 +123,6 @@ export function validateWorkflowExtensionSettings(value, settingsPath, errorCode
             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);
@@ -152,7 +155,7 @@ function parseSettings(path, partial) {
     }
     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})`);
@@ -164,6 +167,9 @@ function parseSettings(path, partial) {
     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");
@@ -172,49 +178,52 @@ function parseSettings(path, partial) {
     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()) { return parseSettings(path, false); }
+const READ_ONLY_WORKFLOW_TOOLS = 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, codemodeTools) {
+    const readOnly = READ_ONLY_WORKFLOW_TOOLS.has(name);
+    return { ...(codemodeTools === "none" || (codemodeTools === "read-only" && !readOnly) ? { exposure: "model-only" } : {}), ...(readOnly ? { annotations: { readOnlyHint: true } } : {}) };
+}
+/** The `codemodeTools` setting at load time. Invalid settings keep the default; launches report them. */
+export function loadCodemodeToolsSetting(agentDir) {
+    try {
+        return loadSettings(workflowSettingsPath(agentDir)).codemodeTools;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function loadSettingsOverrides(path) { return parseSettings(path, true); }
 export 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 === undefined && projectSelectors.tools === undefined ? {} : { tools: [...(globalSelectors.tools ?? []), ...(projectSelectors.tools ?? [])] }),
-    });
-    const hasExtensionSelectors = global.extensions !== undefined || project.extensions !== undefined;
-    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 === 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 consumerGlobal = loadSettings(globalSettingsPath);
+    const consumerProject = projectTrusted ? loadSettingsOverrides(projectSettingsPath) : Object.freeze({});
+    const global = consumerGlobal;
+    const project = consumerProject;
+    const selectorSources = { global: selectorsFromSettings(global), project: selectorsFromSettings(project) };
     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 }),
+        ...global, ...project,
+        skills: [...(global.skills ?? []), ...(project.skills ?? [])],
+        extensions: [...(global.extensions ?? []), ...(project.extensions ?? [])],
+        ...(global.tools === undefined && project.tools === undefined ? {} : { tools: [...(global.tools ?? []), ...(project.tools ?? [])] }),
     });
-    return { globalSettingsPath, projectSettingsPath, projectTrusted, global, project, effective, sources };
+    const sources = { concurrency: project.concurrency === undefined ? globalSettingsPath : projectSettingsPath, modelAliases: project.modelAliases === undefined ? globalSettingsPath : projectSettingsPath };
+    for (const key of ["skills", "extensions", "tools", "extensionSettings", "retention", "worktreePostCreateCommand"])
+        if (effective[key] !== undefined)
+            sources[key] = project[key] === undefined ? globalSettingsPath : projectSettingsPath;
+    return { globalSettingsPath, projectSettingsPath, projectTrusted, global, project, effective, sources, selectorSources };
 }
 export function validateModelAliasAvailability(aliases, names, availableModels, knownModels, settingsPath) {
     for (const name of names) {
@@ -233,7 +242,7 @@ export function resolveAgentResourcePolicy(cwd, projectTrusted, globalSettingsPa
     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 = {}) {
     const normalized = validateModelAliases(aliases, path);
@@ -251,3 +260,7 @@ export function saveModelAliases(path = workflowSettingsPath(), aliases = {}) {
     mkdirSync(dirname(path), { recursive: true });
     atomicWriteFile(path, `${JSON.stringify({ ...parsed, modelAliases: normalized }, null, 2)}\n`, true);
 }
+export function canonicalExtensionSelector(selector, cwd) {
+    const negated = selector.startsWith("!");
+    return `${negated ? "!" : ""}${normalizedResourcePath(negated ? selector.slice(1) : selector, join(cwd, "settings.json"))}`;
+}

package/dist/src/store.d.ts

@@ -1,4 +1,4 @@
-import { type JsonValue, type LaunchSnapshot, type WorkflowRunEvent } from "./types.js";
+import { type PreparedAgentConfiguration, type JsonValue, type LaunchSnapshot, type WorkflowLaunchMode, type WorkflowRunEvent } from "./types.js";
 import { type AwaitingCheckpoint, type BorrowedWorktreeBinding, type CompletedOperation, type EffectiveSystemPrompt, type PendingWorkflowDecision, type PersistedOwnershipNode, type PersistedRun, type RunSummary, type WorktreeReference } from "./decoders.js";
 export declare class RunStore {
     #private;
@@ -28,6 +28,8 @@ export declare class RunStore {
     loadSummary(): Promise<RunSummary>;
     saveState(run: PersistedRun): Promise<void>;
     updateState(update: (run: PersistedRun) => PersistedRun | Promise<PersistedRun>): Promise<PersistedRun>;
+    saveAgentConfiguration(key: string, configuration: PreparedAgentConfiguration): Promise<void>;
+    setLaunchMode(launchMode: WorkflowLaunchMode): Promise<void>;
     saveSnapshot(snapshot: Readonly<LaunchSnapshot>): Promise<void>;
     appendEvent(event: WorkflowRunEvent): Promise<void>;
     saveOwnership(nodes: readonly PersistedOwnershipNode[]): Promise<void>;

package/dist/src/store.js

@@ -24,7 +24,7 @@ function summaryFromRun(run, directory, journal, previous, fallbackCreatedAt, no
     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) { return join(directory, SYSTEM_PROMPT_STORAGE); }
 function systemPromptRecordsPath(directory) { return join(systemPromptStoragePath(directory), SYSTEM_PROMPT_RECORDS); }
@@ -171,6 +171,22 @@ export class RunStore {
         });
         return write;
     }
+    async saveAgentConfiguration(key, configuration) {
+        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) {
+        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) {
         const write = this.launchSnapshotLane.run(() => atomicJson(join(this.directory, "snapshot.json"), snapshot));
         await write;

package/dist/src/trajectory.d.ts

@@ -1,5 +1,5 @@
 import { type AwaitingCheckpoint, type CompletedOperation, type EffectiveSystemPrompt, type PersistedRun } from "./persistence.js";
-import type { AgentAttemptSummary, AgentRecord, JsonValue, LaunchSnapshot, WorkflowAgentSessionReference } from "./types.js";
+import type { AgentAttemptSummary, AgentRecord, JsonValue, LaunchSnapshot, WorkflowAgentSessionReference, WorkflowErrorCode, WorkflowScriptCall } from "./types.js";
 import { type SubagentProgress, type SubagentRunRequest, type SubagentStatus } from "../subagents/src/contracts.js";
 import type { TrajectoryAction, TrajectoryTarget } from "./trajectory-contracts.js";
 export declare const TRAJECTORY_MAX_TRANSCRIPT_BYTES: number;
@@ -24,8 +24,17 @@ export type TrajectoryAgentOutput = {
 export type TrajectoryAgent = AgentRecord & {
     readonly output: TrajectoryAgentOutput;
 };
-export type TrajectoryRunRecord = Omit<PersistedRun, "agents"> & {
+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;
@@ -54,7 +63,6 @@ export type TrajectorySubagent = {
     sessionId: string;
     cwd: string;
     label?: string;
-    role?: string;
     mode: "background" | "foreground";
     state: SubagentStatus["state"];
     startedAt?: number;
@@ -135,6 +143,7 @@ export type TrajectoryPublisherInput = {
     loadTranscript?: TrajectoryTranscriptLoader;
     handleAction: TrajectoryActionHandler;
 };
+export declare function isTimingTranscriptEntry(value: unknown): boolean;
 export declare function applySystemPrompts(run: PersistedRun, prompts: readonly EffectiveSystemPrompt[]): PersistedRun;
 export declare function applyToolDescriptions(run: PersistedRun, catalog: ReadonlyMap<string, string>): PersistedRun;
 export declare function withPiToolDescriptions(run: PersistedRun): PersistedRun;

package/dist/src/trajectory.js

@@ -9,6 +9,7 @@ import { normalizeSubagentRunRequest } from "../subagents/src/contracts.js";
 import { statusValue, subagentErrorValue } from "../subagents/src/decode.js";
 import { isNodeError, jsonValue, object, resourcePatternHasMagic, selectResourcesByLayers } from "./utils.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;
 function subagentOutput(options) {
@@ -50,7 +51,7 @@ function transcriptToolCallId(value) {
             return part.id;
     return undefined;
 }
-function isTimingTranscriptEntry(value) { return object(value) && value.type === "custom" && value.customType === "pi-workflows:tool-timing"; }
+export function isTimingTranscriptEntry(value) { return object(value) && value.type === "custom" && value.customType === TOOL_TIMING_ENTRY_TYPE; }
 function timingToolCallId(value) {
     if (!object(value) || !isTimingTranscriptEntry(value) || !object(value.data))
         return undefined;
@@ -194,7 +195,8 @@ export function withPiToolDescriptionsForTools(tools, cwd) {
 function canonicalExtensionSelector(selector, base) {
     const negated = selector.startsWith("!");
     const body = negated ? selector.slice(1) : selector;
-    if (body === "*" || body === "**" || body.startsWith("**/"))
+    // 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))
@@ -236,8 +238,8 @@ async function resolveResourceInspection(inspection, cwd, selectorCwd = cwd) {
         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, cwd) {
@@ -280,11 +282,20 @@ function failedAgentOutput(agent) {
     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) {
+    const bytes = serializedJsonBytes(operation.value);
+    return bytes > DEFAULT_MAX_BYTES ? { status: "truncated", kind: "result", bytes } : { status: "available", value: operation.value, bytes };
+}
+function outputForCall(call, operation) {
+    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, operation) {
-    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")
@@ -294,7 +305,18 @@ function outputForAgent(agent, operation) {
 export function applyTrajectoryAgentOutputs(run, operations) {
     const byPath = new Map(operations.map((operation) => [operation.path, operation]));
     const agents = 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) => {
+        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 = run;
+    return { ...rest, agents, ...(scriptCalls === undefined ? {} : { scriptCalls }) };
 }
 function overlayTrajectoryRun(run, overlay) {
     const overlaid = overlay(run);
@@ -304,7 +326,7 @@ function overlayTrajectoryRun(run, overlay) {
         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, includeTranscripts = true) {
     const value = await store.load();
@@ -555,7 +577,6 @@ async function loadTrajectorySubagent(directory, cwd, sessionId, includeTranscri
         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 }),