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

package/dist/src/settings.js

@@ -0,0 +1,253 @@
+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) {
+    if (value === "*")
+        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"])]);
+    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 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 }), ...(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); }
+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,34 @@
-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 } 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 TrajectoryRunRecord = Omit<PersistedRun, "agents"> & {
+    readonly agents: readonly TrajectoryAgent[];
+};
 export type TrajectoryRun = {
-    run: PersistedRun;
+    run: TrajectoryRunRecord;
     snapshot: Readonly<LaunchSnapshot>;
     awaiting: readonly AwaitingCheckpoint[];
     createdAt?: string;
@@ -58,6 +82,7 @@ export type TrajectorySubagent = {
         readonly code: string;
         readonly message: string;
     } | TrajectorySubagentArtifact;
+    output: TrajectoryAgentOutput;
     transcript: readonly unknown[];
 };
 export type TrajectorySubagentMetadata = Omit<TrajectorySubagent, "transcript"> & {
@@ -104,7 +129,6 @@ export type TrajectoryPublisherInput = {
     cwd: string;
     sessionId: string;
     port?: number;
-    themes: boolean;
     loadRuns: TrajectoryRunLoader;
     loadSubagents: TrajectorySubagentLoader;
     loadMetadata: TrajectoryPublisherMetadataLoader;
@@ -120,6 +144,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

@@ -11,6 +11,23 @@ import { isNodeError, jsonValue, object, resourcePatternHasMagic, selectResource
 import { canonicalPath, sameFilesystemPath } from "./paths.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;
@@ -254,11 +271,48 @@ 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 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 (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)) }));
+    return { ...run, agents };
+}
+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 };
+}
 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 +320,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 +359,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 +567,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

@@ -190,7 +190,6 @@ export interface HerdrExtensionSettings {
 }
 export interface TrajectoryExtensionSettings {
     port?: number;
-    themes?: boolean;
 }
 export interface WorkflowExtensionSettings {
     readonly [namespace: string]: JsonValue;

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>;
@@ -55,3 +55,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;

package/dist/src/utils.js

@@ -223,3 +223,13 @@ export function resourcePatternHasMagic(pattern) { return /[*?\x5b\x5d{}()]/.tes
 export function unmatchedResourcePatterns(patterns, resources) { return patterns.filter((pattern) => !resources.some((resource) => resourcePatternMatches(resource, pattern))); }
 export function createLaunchSnapshot(input) { return deepFreeze(structuredClone({ ...input, identityVersion: input.identityVersion ?? LAUNCH_SNAPSHOT_IDENTITY_VERSION })); }
 export function loadLaunchSnapshot(input) { return deepFreeze(structuredClone(input)); }
+export function validateSchema(schema, at = "schema") {
+    if (!object(schema) || Object.getPrototypeOf(schema) !== Object.prototype || !jsonValue(schema))
+        fail("INVALID_SCHEMA", `${at} must be a plain JSON-compatible Schema object`);
+    if (typeof schema.type !== "string" && !Array.isArray(schema.type) && schema.$ref === undefined && schema.anyOf === undefined && schema.oneOf === undefined && schema.allOf === undefined && schema.const === undefined && schema.enum === undefined)
+        fail("INVALID_SCHEMA", `${at} has no JSON Schema shape`);
+    if (schema.required !== undefined && (!Array.isArray(schema.required) || schema.required.some((key) => typeof key !== "string")))
+        fail("INVALID_SCHEMA", `${at}.required must be an array of strings`);
+    if (schema.properties !== undefined && !object(schema.properties))
+        fail("INVALID_SCHEMA", `${at}.properties must be an object`);
+}

package/dist/src/validation.d.ts

@@ -1,24 +1,12 @@
-import type { AgentDefinition, AgentResourcePolicy, CheckpointInput, JsonSchema, JsonValue, PreflightCapabilities, PreflightResult, ShellOptions, StaticWorkflowCall, ValidatedWorkflowLaunch, WorkflowExtensionSettings, WorkflowMetadata, WorkflowRoleDirectoryRegistration, WorkflowSettings, WorkflowSettingsOverrides, WorkflowSettingsResolution, WorkflowValidationContext, WorkflowValidationParameters } from "./types.js";
+import type { CheckpointInput, JsonValue, PreflightCapabilities, PreflightResult, ShellOptions, StaticWorkflowCall, ValidatedWorkflowLaunch, WorkflowMetadata, WorkflowValidationContext, WorkflowValidationParameters } from "./types.js";
 import type { WorkflowRegistryApi } from "./registry.js";
-export { workflowProjectSettingsPath } from "./paths.js";
-export declare const DEFAULT_SETTINGS: Readonly<WorkflowSettings>;
+export { validateSchema } from "./utils.js";
+export { loadAgentDefinitions, loadProjectAgentDefinitions, parseRoleMarkdown, workflowRoleDirectories } from "./roles.js";
+export type { WorkflowRoleDirectoryInput } from "./roles.js";
+export { DEFAULT_SETTINGS, loadSettings, loadSettingsOverrides, resolveAgentResourcePolicy, resolveWorkflowSettings, saveModelAliases, validateContextFileScopes, validateModelAliasAvailability, validateSelectorList, validateWorkflowExtensionSettings, workflowProjectSettingsPath, workflowSettingsPath } from "./settings.js";
 export declare function validateCheckpoint(value: unknown): CheckpointInput;
-export declare function workflowSettingsPath(agentDir?: string): string;
-export declare function validateWorkflowExtensionSettings(value: unknown, settingsPath: string, errorCode?: "INVALID_SETTINGS" | "INVALID_METADATA", applyDefaults?: boolean): WorkflowExtensionSettings | undefined;
-export declare function loadSettings(path?: string): Readonly<WorkflowSettings>;
-export declare function loadSettingsOverrides(path: string): Readonly<WorkflowSettingsOverrides>;
-export declare function resolveWorkflowSettings(cwd: string, projectTrusted: boolean, globalSettingsPath?: string): WorkflowSettingsResolution;
-export declare function validateModelAliasAvailability(aliases: Readonly<Record<string, string>>, names: readonly string[], availableModels: ReadonlySet<string>, knownModels: ReadonlySet<string>, settingsPath?: string): void;
-export declare function resolveAgentResourcePolicy(cwd: string, projectTrusted: boolean, globalSettingsPath?: string): AgentResourcePolicy;
-export declare function saveModelAliases(path?: string, aliases?: Readonly<Record<string, string>>): void;
-export declare function parseRoleMarkdown(content: string, strict?: boolean, rolePath?: string): AgentDefinition;
-export declare function workflowRoleDirectories(agentDir?: string): readonly string[];
-export type WorkflowRoleDirectoryInput = string | WorkflowRoleDirectoryRegistration;
-export declare function loadProjectAgentDefinitions(cwd: string): Readonly<Record<string, AgentDefinition>>;
-export declare function loadAgentDefinitions(cwd: string, agentDir?: string, projectTrusted?: boolean, extensionRoleDirectories?: readonly WorkflowRoleDirectoryInput[]): Readonly<Record<string, AgentDefinition>>;
 export declare function instrumentWorkflow(script: string): string;
 export declare function workflowPrompt(template: string, values: Readonly<Record<string, JsonValue>>): string;
-export declare function validateSchema(schema: unknown, at?: string): asserts schema is JsonSchema;
 export declare function validateAgentOptions(value: unknown): Readonly<Record<string, JsonValue>>;
 export declare function validateShellOptions(value: unknown): ShellOptions;
 export declare function validateShellCommand(value: unknown): string;