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

package/dist/src/settings.js

@@ -0,0 +1,277 @@
+import { atomicWriteFile } from "./persistence.js";
+import { mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, 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";
+export const DEFAULT_SETTINGS = Object.freeze({ concurrency: 8, backgroundWidget: true });
+export function workflowSettingsPath(agentDir = getAgentDir()) { return join(agentDir, ROLE_DIRECTORY, "settings.json"); }
+function normalizedResourcePath(value, settingsPath) {
+    // 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);
+    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);
+}
+export function validateSelectorList(value, path, kind, errorCode = "INVALID_SETTINGS", normalizeExtensions = true) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value))
+        fail(errorCode, `${path}.${kind} must be an array`);
+    const normalized = [];
+    for (const [index, entry] of value.entries()) {
+        if (typeof entry !== "string" || !entry.trim())
+            fail(errorCode, `${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(errorCode, `${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(errorCode, `${path}.${kind}[${String(index)}] must be a valid path: ${errorText(error)}`);
+            }
+        }
+        try {
+            validateResourcePattern(selector);
+        }
+        catch (error) {
+            fail(errorCode, `${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 === undefined)
+        return undefined;
+    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 === undefined ? {} : { skills: settings.skills }),
+        ...(settings.extensions === undefined ? {} : { extensions: settings.extensions }),
+        ...(settings.tools === undefined ? {} : { tools: settings.tools }),
+    };
+}
+function selectorSet(value) { return { skills: [...(value?.skills ?? [])], extensions: [...(value?.extensions ?? [])], ...(value?.tools === undefined ? {} : { tools: [...value.tools] }) }; }
+export function validateContextFileScopes(value, rolePath) {
+    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`);
+    return [...value];
+}
+export function validateWorkflowExtensionSettings(value, settingsPath, errorCode = "INVALID_SETTINGS") {
+    if (value === undefined)
+        return undefined;
+    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}`);
+        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`);
+            if (raw.enableFullyInspectableMode !== undefined && typeof raw.enableFullyInspectableMode !== "boolean")
+                fail(errorCode, `${base}.herdr.enableFullyInspectableMode must be a boolean`);
+            normalized.herdr = Object.freeze({ ...(raw.enableFullyInspectableMode === undefined ? {} : { enableFullyInspectableMode: raw.enableFullyInspectableMode }) });
+            continue;
+        }
+        if (namespace === "trajectory") {
+            if (!object(raw))
+                fail(errorCode, `${base}.trajectory must be an object`);
+            if (Object.keys(raw).some((key) => key !== "port"))
+                fail(errorCode, `${base}.trajectory contains an unsupported setting`);
+            if (raw.port !== undefined && (!positiveInteger(raw.port) || raw.port > 65535))
+                fail(errorCode, `${base}.trajectory.port must be an integer from 1 to 65535`);
+            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);
+}
+function positiveRetentionInteger(value) { return positiveInteger(value) && Number.isSafeInteger(value); }
+function validateRetention(value, settingsPath) {
+    if (value === undefined)
+        return undefined;
+    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 !== undefined && !positiveRetentionInteger(value.olderThanDays))
+        fail("INVALID_SETTINGS", `${base}.olderThanDays must be a positive integer`);
+    if (value.maxTerminalRuns !== undefined && !positiveRetentionInteger(value.maxTerminalRuns))
+        fail("INVALID_SETTINGS", `${base}.maxTerminalRuns must be a positive integer`);
+    return Object.freeze({ ...(value.olderThanDays === undefined ? {} : { olderThanDays: value.olderThanDays }), ...(value.maxTerminalRuns === undefined ? {} : { maxTerminalRuns: value.maxTerminalRuns }) });
+}
+function parseSettings(path, partial) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(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 = 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}`);
+    const concurrency = parsed.concurrency === undefined ? (partial ? undefined : DEFAULT_SETTINGS.concurrency) : parsed.concurrency;
+    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");
+    const extensions = validateSelectorList(parsed.extensions, path, "extensions");
+    const extensionSettings = parsed.extensionSettings === undefined ? undefined : validateWorkflowExtensionSettings(parsed.extensionSettings, path, "INVALID_SETTINGS");
+    const retention = validateRetention(parsed.retention, path);
+    const worktreePostCreateCommand = validateWorktreePostCreateCommand(parsed.worktreePostCreateCommand, path);
+    return Object.freeze({
+        ...(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 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 };
+}
+export function validateModelAliasAvailability(aliases, names, availableModels, knownModels, settingsPath) {
+    for (const name of names) {
+        try {
+            const target = modelCapability(name, aliases, knownModels, settingsPath);
+            if (!availableModels.has(target))
+                unknownModel(name, target, settingsPath);
+        }
+        catch (error) {
+            throw annotateModelAliasError(error, name);
+        }
+    }
+}
+export function resolveAgentResourcePolicy(cwd, projectTrusted, globalSettingsPath = workflowSettingsPath()) {
+    const resolved = resolveWorkflowSettings(cwd, projectTrusted, globalSettingsPath);
+    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) } };
+}
+export function saveModelAliases(path = workflowSettingsPath(), aliases = {}) {
+    const normalized = validateModelAliases(aliases, path);
+    let parsed = {};
+    try {
+        loadSettings(path);
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        if (!isNodeError(error, "ENOENT"))
+            throw error;
+    }
+    if (!object(parsed))
+        fail("INVALID_SETTINGS", `Workflow settings at ${path} must be an object`);
+    mkdirSync(dirname(path), { recursive: true });
+    atomicWriteFile(path, `${JSON.stringify({ ...parsed, modelAliases: normalized }, null, 2)}\n`, true);
+}

package/dist/src/trajectory.d.ts

@@ -1,10 +1,43 @@
-import { type AwaitingCheckpoint, type EffectiveSystemPrompt, type PersistedRun } from "./persistence.js";
-import type { AgentAttemptSummary, JsonValue, LaunchSnapshot, WorkflowAgentSessionReference } from "./types.js";
+import { type AwaitingCheckpoint, type CompletedOperation, type EffectiveSystemPrompt, type PersistedRun } from "./persistence.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;
+export type TrajectoryAgentOutput = {
+    readonly status: "available";
+    readonly value: JsonValue;
+    readonly bytes: number;
+} | {
+    readonly status: "pending";
+} | {
+    readonly status: "failed" | "cancelled";
+    readonly code: string;
+    readonly message: string;
+} | {
+    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 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: PersistedRun;
+    run: TrajectoryRunRecord;
     snapshot: Readonly<LaunchSnapshot>;
     awaiting: readonly AwaitingCheckpoint[];
     createdAt?: string;
@@ -58,6 +91,7 @@ export type TrajectorySubagent = {
         readonly code: string;
         readonly message: string;
     } | TrajectorySubagentArtifact;
+    output: TrajectoryAgentOutput;
     transcript: readonly unknown[];
 };
 export type TrajectorySubagentMetadata = Omit<TrajectorySubagent, "transcript"> & {
@@ -104,13 +138,13 @@ export type TrajectoryPublisherInput = {
     cwd: string;
     sessionId: string;
     port?: number;
-    themes: boolean;
     loadRuns: TrajectoryRunLoader;
     loadSubagents: TrajectorySubagentLoader;
     loadMetadata: TrajectoryPublisherMetadataLoader;
     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;
@@ -120,6 +154,7 @@ export declare function withPiToolDescriptionsForTools(tools: readonly string[],
 }[];
 export declare function withResolvedAttemptResources(attempt: AgentAttemptSummary, cwd: string): Promise<AgentAttemptSummary>;
 export declare function withResolvedResources(run: PersistedRun, cwd: string): Promise<PersistedRun>;
+export declare function applyTrajectoryAgentOutputs(run: PersistedRun, operations: readonly CompletedOperation[]): TrajectoryRunRecord;
 export declare function loadTrajectoryRuns(cwd: string, sessionId: string, home?: string, overlay?: (run: PersistedRun) => PersistedRun): Promise<readonly TrajectoryRun[]>;
 export declare function createTrajectoryRunLoader(cwd: string, sessionId: string, home?: string, overlay?: (run: PersistedRun) => PersistedRun): TrajectoryRunLoader;
 export declare function createTrajectoryRunMetadataLoader(cwd: string, sessionId: string, home?: string, overlay?: (run: PersistedRun) => PersistedRun): TrajectoryRunMetadataLoader;

package/dist/src/trajectory.js

@@ -9,8 +9,26 @@ 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) {
+    if (options.resultTruncated)
+        return { status: "truncated", kind: "result", path: options.resultPath, bytes: options.resultBytes ?? 0 };
+    if (options.result !== undefined)
+        return { status: "available", value: options.result, bytes: serializedJsonBytes(options.result) };
+    if (options.failureTruncated)
+        return { status: "truncated", kind: "failure", path: options.failurePath, bytes: options.failureBytes ?? 0 };
+    if (options.failure !== undefined)
+        return { status: "failed", code: options.failure.code, message: options.failure.message };
+    if (options.state === "failed" || options.state === "stopped") {
+        const error = options.statusError ?? options.attempt?.error;
+        return { status: options.state === "stopped" ? "cancelled" : "failed", code: error?.code ?? (options.state === "stopped" ? "CANCELLED" : "AGENT_FAILED"), message: error?.message ?? `Subagent ${options.state}` };
+    }
+    if (options.state === "completed")
+        return { status: "unavailable" };
+    return { status: "pending" };
+}
 export { isTrajectoryAction, isTrajectoryTarget, trajectoryActionError } from "./trajectory-contracts.js";
 function sessionFile(reference) {
     const locator = reference?.locator;
@@ -33,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;
@@ -177,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))
@@ -254,11 +273,68 @@ function withoutAgentActivities(run) {
     });
     return agents.every((agent, index) => agent === run.agents[index]) ? run : { ...run, agents };
 }
+function serializedJsonBytes(value) {
+    const serialized = JSON.stringify(value);
+    return Buffer.byteLength(serialized, "utf8");
+}
+function failedAgentOutput(agent) {
+    const error = [...(agent.attemptDetails ?? [])].reverse().find((attempt) => attempt.error)?.error;
+    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)
+        return operationOutput(operation);
+    if (agent.state === "failed" || agent.state === "cancelled")
+        return failedAgentOutput(agent);
+    if (agent.state === "completed")
+        return { status: "unavailable" };
+    return { status: "pending" };
+}
+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)) }));
+    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);
+    const outputs = new Map(run.agents.map((agent) => [agent.id, agent.output]));
+    const agents = 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, ...(run.scriptCalls === undefined ? {} : { scriptCalls: run.scriptCalls }) };
+}
 async function loadTrajectoryRun(store, includeTranscripts = true) {
     const value = await store.load();
     const summary = await store.loadSummary().catch(() => undefined);
     const prompts = await store.systemPrompts().catch(() => []);
-    const run = withoutAgentActivities(await withResolvedResources(withPiToolDescriptions(applySystemPrompts(value.run, prompts)), store.cwd));
+    const prepared = withoutAgentActivities(await withResolvedResources(withPiToolDescriptions(applySystemPrompts(value.run, prompts)), store.cwd));
+    const operations = await store.replayableOperations().catch(() => []);
+    const run = applyTrajectoryAgentOutputs(prepared, operations);
     return { run, snapshot: value.snapshot, awaiting: await store.awaitingCheckpoints(), ...(summary?.createdAt === undefined ? {} : { createdAt: summary.createdAt }), transcripts: includeTranscripts ? await runTranscripts(run) : {} };
 }
 export async function loadTrajectoryRuns(cwd, sessionId, home = homedir(), overlay) {
@@ -266,7 +342,7 @@ export async function loadTrajectoryRuns(cwd, sessionId, home = homedir(), overl
     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);
+            loaded.push(overlay ? { ...value, run: overlayTrajectoryRun(value.run, overlay) } : value);
         }
         catch { /* Ignore corrupt or concurrently removed runs. */ }
     }
@@ -305,7 +381,7 @@ function createCachedRunLoader(cwd, sessionId, home, load, transcriptSignature,
                     entry = { value, stateMtimeMs: (await fileMtime(join(store.directory, "state.json"))) ?? 0, journalMtimeMs: (await fileMtime(join(store.directory, "journal.json"))) ?? 0, transcripts };
                     cache.set(runId, entry);
                 }
-                loaded.push(overlay ? { ...entry.value, run: overlay(entry.value.run) } : entry.value);
+                loaded.push(overlay ? { ...entry.value, run: overlayTrajectoryRun(entry.value.run, overlay) } : entry.value);
             }
             catch {
                 cache.delete(runId); /* Ignore corrupt or concurrently removed runs. */
@@ -513,6 +589,7 @@ async function loadTrajectorySubagent(directory, cwd, sessionId, includeTranscri
             ...(attempt === undefined ? {} : { attempt }),
             ...(result === undefined ? {} : { result }),
             ...(failure === undefined ? {} : { failure }),
+            output: subagentOutput({ state: status.state, statusError: status.error, attempt, result: resultValue === undefined ? undefined : boundedSubagentJson(resultValue), resultTruncated, resultPath, resultBytes, failure: failureValue === undefined ? undefined : subagentErrorValue(failureValue), failureTruncated, failurePath, failureBytes }),
         };
     }
     catch {

package/dist/src/types.d.ts

@@ -23,7 +23,7 @@ export declare const WORKFLOW_CHECKPOINT_STATE_CHANGED_EVENT = "workflow:checkpo
 export declare const WORKFLOW_BUDGET_EVENT = "workflow:budget-event";
 export declare const WORKFLOW_WORKTREE_CREATED_EVENT = "workflow:worktree-created";
 export declare const WORKFLOW_BLOCKED_EVENT = "workflow:blocked";
-export declare const ERROR_CODES: readonly ["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"];
+export declare const ERROR_CODES: readonly ["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", "TOOL_FAILED", "CANCELLED", "WORKER_UNRESPONSIVE", "WORKTREE_FAILED", "RESUME_INCOMPATIBLE", "BUDGET_EXHAUSTED", "INTERNAL_ERROR"];
 export declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
 export type WorkflowErrorCode = (typeof ERROR_CODES)[number];
@@ -190,7 +190,6 @@ export interface HerdrExtensionSettings {
 }
 export interface TrajectoryExtensionSettings {
     port?: number;
-    themes?: boolean;
 }
 export interface WorkflowExtensionSettings {
     readonly [namespace: string]: JsonValue;
@@ -216,9 +215,11 @@ export interface WorkflowRetentionSettings {
     olderThanDays?: number;
     maxTerminalRuns?: number;
 }
+export type CodemodeToolsSetting = "all" | "read-only" | "none";
 export interface WorkflowSettings {
     concurrency: number;
     backgroundWidget?: boolean;
+    codemodeTools?: CodemodeToolsSetting;
     modelAliases?: Readonly<Record<string, string>>;
     skills?: readonly string[];
     extensions?: readonly string[];
@@ -227,7 +228,7 @@ export interface WorkflowSettings {
     retention?: Readonly<WorkflowRetentionSettings>;
     worktreePostCreateCommand?: readonly string[];
 }
-export type WorkflowSettingsOverrides = Partial<Omit<WorkflowSettings, "backgroundWidget">>;
+export type WorkflowSettingsOverrides = Partial<Omit<WorkflowSettings, "backgroundWidget" | "codemodeTools">>;
 export interface WorkflowSettingsSources {
     concurrency: string;
     modelAliases: string;
@@ -404,6 +405,21 @@ export interface WorkflowPhaseShellActivity {
     active: number;
     startedAt: number;
 }
+/** A script call recorded for inspection. Tool payloads stay in the replay journal, not this record. Oversized shell inputs are JSON prefixes, with `inputBytes` their full size. */
+export interface WorkflowScriptCall {
+    kind: "shell" | "tool";
+    name: string;
+    path: string;
+    input?: JsonValue;
+    inputBytes?: number;
+    phase?: string;
+    startedAt: number;
+    finishedAt?: number;
+    error?: {
+        code: WorkflowErrorCode;
+        message?: string;
+    };
+}
 export interface RunRecord {
     id: string;
     workflowName: string;
@@ -420,6 +436,11 @@ export interface RunRecord {
     activeShells?: number;
     activeShellStartedAt?: number;
     activeShellsByPhase?: readonly WorkflowPhaseShellActivity[];
+    activeTools?: readonly {
+        name: string;
+        startedAt: number;
+    }[];
+    scriptCalls?: readonly WorkflowScriptCall[];
     error?: WorkflowErrorShape;
     failedAt?: string;
     budget?: WorkflowBudget;
@@ -836,6 +857,11 @@ export interface ShellIdentity {
     occurrence: number;
     worktreeOwner?: string;
 }
+/** A script `tools.<id>(args)` call: the n-th call of that tool within one structural scope. */
+export interface ToolIdentity {
+    structuralPath: readonly string[];
+    occurrence: number;
+}
 export interface WorkflowBridge {
     agent?: (prompt: string, options: Readonly<Record<string, JsonValue>>, signal: AbortSignal, identity: AgentIdentity) => Promise<JsonValue>;
     shell?: (command: string, options: ShellOptions, signal: AbortSignal, identity: ShellIdentity) => Promise<ShellResult>;
@@ -847,6 +873,7 @@ export interface WorkflowBridge {
     }>>;
     phase?: (name: string) => void | Promise<void>;
     log?: (message: string) => void | Promise<void>;
+    tool?: (identifier: string, args: Readonly<Record<string, JsonValue>>, signal: AbortSignal, identity: ToolIdentity) => Promise<JsonValue>;
 }
 export interface WorkflowExecution {
     result: Promise<JsonValue>;

package/dist/src/types.js

@@ -19,7 +19,7 @@ export const WORKFLOW_BLOCKED_EVENT = "workflow:blocked";
 export const 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",
+    "TOOL_FAILED", "CANCELLED", "WORKER_UNRESPONSIVE", "WORKTREE_FAILED", "RESUME_INCOMPATIBLE", "BUDGET_EXHAUSTED", "INTERNAL_ERROR",
 ];
 export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 export function roleNameOf(value) {

package/dist/src/utils.d.ts

@@ -1,4 +1,4 @@
-import { WorkflowError, type JsonValue, type ModelSpec, type ThinkingLevel, type WorkflowErrorCode, type WorkflowExtensionSettings } from "./types.js";
+import { WorkflowError, type JsonSchema, type JsonValue, type ModelSpec, type ThinkingLevel, type WorkflowErrorCode, type WorkflowExtensionSettings } from "./types.js";
 export declare class SerialLane {
     #private;
     run<T>(task: () => Promise<T>): Promise<T>;
@@ -6,6 +6,8 @@ export declare class SerialLane {
 export declare function object(value: unknown): value is Record<string, unknown>;
 export declare function sanitizeDisplayText(value: string): string;
 export { object as isObject };
+/** A short digest of a JSON value that ignores object key order. */
+export declare function jsonDigest(value: JsonValue): string;
 export declare function jsonValue(value: unknown, seen?: Set<object>): value is JsonValue;
 export declare function jsonObject(value: unknown): value is Record<string, JsonValue>;
 export declare function mergeWorkflowExtensionSettings(...layers: readonly (Readonly<WorkflowExtensionSettings> | undefined)[]): Readonly<WorkflowExtensionSettings> | undefined;
@@ -44,6 +46,23 @@ export declare function modelAliasName(value: string, aliases: Readonly<Record<s
 export declare function validateModelAliases(value: unknown, settingsPath?: string): Readonly<Record<string, string>>;
 export declare function unknownModel(value: string, target: string | undefined, settingsPath?: string): never;
 export declare function resolveModelReference(value: string, aliases?: Readonly<Record<string, string>>, knownModels?: ReadonlySet<string>, settingsPath?: string): ModelSpec;
+type ToolSource = {
+    getActiveTools(): string[];
+    getAllTools?(): readonly {
+        name: string;
+        exposure?: string;
+    }[];
+};
+/**
+ * Tools a session can reach, and so the ceiling for its agents: the declared tools plus the ones
+ * only codemode scripts call or tool_search loads, such as MCP tools with the default exposure.
+ * Agent sessions allow tools by name, so leaving these out would make them unreachable there.
+ */
+export declare function reachableTools(pi: ToolSource): string[];
+/** Provider of the virtual models that expose workflow model aliases in `/model`. */
+export declare const VIRTUAL_MODEL_PROVIDER = "workflow";
+/** Child sessions do not load the workflow extension, so they receive the alias target instead of its virtual model. */
+export declare function physicalModel(spec: ModelSpec, aliases?: Readonly<Record<string, string>>, knownModels?: ReadonlySet<string>, settingsPath?: string): ModelSpec;
 export declare function modelCapability(value: string | ModelSpec, aliases?: Readonly<Record<string, string>>, knownModels?: ReadonlySet<string>, settingsPath?: string): string;
 export declare function aliasDrift(previous: Readonly<Record<string, string>>, current: Readonly<Record<string, string>>): string[];
 export declare function validateResourcePattern(pattern: string): void;
@@ -55,3 +74,4 @@ export declare function createLaunchSnapshot(input: Omit<import("./types.js").La
     identityVersion?: number;
 }): Readonly<import("./types.js").LaunchSnapshot>;
 export declare function loadLaunchSnapshot(input: import("./types.js").LaunchSnapshot): Readonly<import("./types.js").LaunchSnapshot>;
+export declare function validateSchema(schema: unknown, at?: string): asserts schema is JsonSchema;