pi-extensible-workflows 1.0.0 → 2.0.0

package/dist/src/persistence.d.ts

@@ -47,6 +47,11 @@ export interface WorktreeReference {
     cwd: string;
     base: string;
 }
+export interface BorrowedWorktreeBinding {
+    name: string;
+    sourceRunId: string;
+    owner: string;
+}
 export declare function projectStorageKey(cwd: string): string;
 export declare function runsDirectory(cwd: string, sessionId: string, home?: string): string;
 export declare class SessionLease {
@@ -60,14 +65,18 @@ export declare class SessionLease {
 export declare function acquireSessionLease(cwd: string, sessionId: string, home?: string): Promise<SessionLease>;
 export declare function listRunIds(cwd: string, sessionId: string, home?: string): Promise<string[]>;
 export declare function structuralPath(...names: string[]): string;
+export declare function atomicWriteFile(path: string, content: string): Promise<void>;
+export declare function atomicWriteFile(path: string, content: string, sync: true): void;
 export declare class RunStore {
     readonly cwd: string;
     readonly sessionId: string;
     readonly runId: string;
+    readonly home: string;
     readonly directory: string;
     private journalWrite;
     private stateWrite;
     private worktreeWrite;
+    private borrowedWorktreeWrite;
     private snapshotWrite;
     private launchSnapshotWrite;
     private systemPromptWrite;
@@ -102,11 +111,30 @@ export declare class RunStore {
     answerCheckpoint(name: string, approved: boolean): Promise<AwaitingCheckpoint | undefined>;
     private expectedWorktree;
     private markerPath;
+    private namedWorktreeOwner;
+    private worktreeName;
     private structuralWorktree;
+    private borrowedWorktreeRecords;
+    borrowedWorktrees(): Promise<readonly BorrowedWorktreeBinding[]>;
+    private borrowedWorktree;
+    private sourceRun;
+    validateParentRun(parentRunId: string): Promise<void>;
+    private ownedWorktree;
+    private resolveBorrowedWorktree;
+    private findNamedWorktree;
+    resolveNamedWorktree(name: string, seen?: Set<string>): Promise<{
+        reference: WorktreeReference;
+        sourceRunId: string;
+        owner: string;
+    }>;
+    validateBorrowedWorktrees(): Promise<void>;
+    ownsWorktree(owner: string): Promise<boolean>;
     private cleanupMarker;
     private cleanupOrphanWorktrees;
     validateWorktree(owner: string, cwd?: string): Promise<WorktreeReference>;
     worktree(owner: string): Promise<WorktreeReference>;
+    private resolveNamedWorktreeFromParent;
+    private bindBorrowedWorktree;
     snapshotWorktree(owner: string): Promise<string>;
     worktrees(): Promise<readonly WorktreeReference[]>;
     changedWorktrees(): Promise<readonly WorktreeReference[]>;

package/dist/src/persistence.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { execFile } from "node:child_process";
+import { renameSync, rmSync, writeFileSync } from "node:fs";
 import { access, link, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { homedir } from "node:os";
@@ -182,21 +183,45 @@ export function structuralPath(...names) {
         throw new WorkflowError("INVALID_METADATA", "Structural paths require non-empty explicit names");
     return names.map((name) => encodeURIComponent(name)).join("/");
 }
-async function atomicJson(path, value) {
+export function atomicWriteFile(path, content, sync = false) {
     const temporary = `${path}.${String(process.pid)}.${randomUUID()}.tmp`;
-    await writeFile(temporary, `${JSON.stringify(value)}\n`, { encoding: "utf8", mode: 0o600 });
-    await rename(temporary, path);
+    if (sync) {
+        try {
+            writeFileSync(temporary, content, { encoding: "utf8", mode: 0o600 });
+            renameSync(temporary, path);
+        }
+        catch (error) {
+            try {
+                rmSync(temporary, { force: true });
+            }
+            catch { /* Preserve the original write error. */ }
+            throw error;
+        }
+        return;
+    }
+    return writeFile(temporary, content, { encoding: "utf8", mode: 0o600 }).then(() => rename(temporary, path)).catch(async (error) => {
+        try {
+            await rm(temporary, { force: true });
+        }
+        catch { /* Preserve the original write error. */ }
+        throw error;
+    });
+}
+async function atomicJson(path, value) {
+    await atomicWriteFile(path, `${JSON.stringify(value)}\n`);
 }
 async function json(path) { return JSON.parse(await readFile(path, "utf8")); }
 export class RunStore {
     cwd;
     sessionId;
     runId;
+    home;
     directory;
     journalWrite = Promise.resolve();
     // ponytail: serializes one RunStore instance; cross-process run sharing remains unsupported.
     stateWrite = Promise.resolve();
     worktreeWrite = Promise.resolve();
+    borrowedWorktreeWrite = Promise.resolve();
     snapshotWrite = Promise.resolve();
     launchSnapshotWrite = Promise.resolve();
     // ponytail: the session lease prevents concurrent RunStore writers for one run.
@@ -206,6 +231,7 @@ export class RunStore {
         this.cwd = cwd;
         this.sessionId = sessionId;
         this.runId = runId;
+        this.home = home;
         this.cwd = resolve(cwd);
         this.directory = join(runsDirectory(this.cwd, sessionId, home), safePart(runId));
     }
@@ -221,6 +247,7 @@ export class RunStore {
             await atomicJson(join(temporary, "journal.json"), { completed: {}, awaiting: {}, decisions: {} });
             await atomicJson(join(temporary, "ownership.json"), []);
             await atomicJson(join(temporary, "worktrees.json"), []);
+            await atomicJson(join(temporary, "borrowed-worktrees.json"), []);
             await atomicJson(join(temporary, "state.json"), run);
             await atomicJson(join(temporary, "system-prompts.json"), { version: 1, entries: [] });
             await atomicJson(join(temporary, "conversations.json"), { version: 1, conversations: {} });
@@ -277,7 +304,7 @@ export class RunStore {
         await write;
     }
     async appendEvent(event) {
-        await this.updateState((run) => ({ ...run, events: [...(run.events ?? []), ...(run.events?.some((current) => current.message === event.message) ? [] : [event])] }));
+        await this.updateState((run) => ({ ...run, events: [...(run.events ?? []), ...(run.events?.some((current) => current.type === event.type && current.message === event.message) ? [] : [event])] }));
     }
     async saveOwnership(nodes) {
         await atomicJson(join(this.directory, "ownership.json"), nodes);
@@ -424,6 +451,26 @@ export class RunStore {
         const key = createHash("sha256").update(`${this.sessionId}\0${this.runId}\0${owner}`).digest("hex").slice(0, 16);
         return join(this.directory, `worktree-${key}.creating`);
     }
+    namedWorktreeOwner(name) {
+        if (!name.trim())
+            throw new WorkflowError("WORKTREE_FAILED", "Named worktree names must be non-empty");
+        return structuralPath("worktree", "named", name.trim());
+    }
+    worktreeName(owner) {
+        const prefix = `${structuralPath("worktree", "named")}/`;
+        if (!owner.startsWith(prefix))
+            return undefined;
+        const encoded = owner.slice(prefix.length);
+        if (!encoded || encoded.includes("/"))
+            return undefined;
+        try {
+            const name = decodeURIComponent(encoded);
+            return name.trim() ? name : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     structuralWorktree(owner, record) {
         if (!record || typeof record !== "object")
             throw new Error(`Invalid worktree record for ${owner}`);
@@ -435,6 +482,123 @@ export class RunStore {
             throw new Error(`Invalid worktree record for ${owner}`);
         return candidate;
     }
+    async borrowedWorktreeRecords(wait = true) {
+        if (wait)
+            await this.borrowedWorktreeWrite;
+        const records = await json(join(this.directory, "borrowed-worktrees.json")).catch((error) => { if (error.code === "ENOENT")
+            return []; throw error; });
+        if (!Array.isArray(records))
+            throw new WorkflowError("WORKTREE_FAILED", "Borrowed worktree bindings are invalid");
+        const seen = new Set();
+        return records.map((record) => {
+            if (!record || typeof record !== "object")
+                throw new WorkflowError("WORKTREE_FAILED", "Borrowed worktree binding is invalid");
+            const candidate = record;
+            if (typeof candidate.name !== "string" || !candidate.name.trim() || candidate.name !== candidate.name.trim() || typeof candidate.sourceRunId !== "string" || !candidate.sourceRunId || typeof candidate.owner !== "string" || candidate.owner !== this.namedWorktreeOwner(candidate.name))
+                throw new WorkflowError("WORKTREE_FAILED", "Borrowed worktree binding is invalid");
+            if (seen.has(candidate.name))
+                throw new WorkflowError("WORKTREE_FAILED", `Duplicate borrowed worktree binding for ${candidate.name}`);
+            seen.add(candidate.name);
+            return { name: candidate.name, sourceRunId: candidate.sourceRunId, owner: candidate.owner };
+        });
+    }
+    async borrowedWorktrees() { return this.borrowedWorktreeRecords(); }
+    async borrowedWorktree(name) {
+        return (await this.borrowedWorktreeRecords()).find((binding) => binding.name === name);
+    }
+    async sourceRun(sourceRunId) {
+        if (!sourceRunId || sourceRunId === this.runId)
+            throw new WorkflowError("WORKTREE_FAILED", "Borrowed worktree source run is invalid");
+        const source = new RunStore(this.cwd, this.sessionId, sourceRunId, this.home);
+        try {
+            const loaded = await source.load();
+            if (!["completed", "failed", "stopped"].includes(loaded.run.state))
+                throw new Error(`Source run ${sourceRunId} is not terminal`);
+            return source;
+        }
+        catch (error) {
+            if (error instanceof WorkflowError && error.code === "WORKTREE_FAILED")
+                throw error;
+            throw new WorkflowError("WORKTREE_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    async validateParentRun(parentRunId) { await this.sourceRun(parentRunId); }
+    async ownedWorktree(owner, cwd) {
+        const records = await json(join(this.directory, "worktrees.json"));
+        const matches = records.filter((candidate) => candidate && typeof candidate === "object" && candidate.owner === owner);
+        if (matches.length !== 1)
+            throw new Error(`Missing or duplicate worktree record for ${owner}`);
+        const record = this.structuralWorktree(owner, matches[0]);
+        if (cwd !== undefined && resolve(cwd) !== resolve(record.cwd))
+            throw new Error(`Invalid worktree record for ${owner}`);
+        await access(record.cwd);
+        return record;
+    }
+    async resolveBorrowedWorktree(binding, seen) {
+        try {
+            const source = await this.sourceRun(binding.sourceRunId);
+            const resolved = await source.findNamedWorktree(binding.name, seen);
+            if (!resolved)
+                throw new Error(`Missing named worktree ${binding.name} in source run ${binding.sourceRunId}`);
+            if (resolved.owner !== binding.owner)
+                throw new Error(`Borrowed worktree binding does not match source owner for ${binding.name}`);
+            return resolved;
+        }
+        catch (error) {
+            throw error instanceof WorkflowError && error.code === "WORKTREE_FAILED" ? error : new WorkflowError("WORKTREE_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    async findNamedWorktree(name, seen = new Set()) {
+        const owner = this.namedWorktreeOwner(name);
+        if (seen.has(this.runId))
+            throw new WorkflowError("WORKTREE_FAILED", "Borrowed worktree bindings contain a cycle");
+        const nextSeen = new Set(seen);
+        nextSeen.add(this.runId);
+        const binding = await this.borrowedWorktree(name);
+        if (binding) {
+            const loaded = await this.load();
+            if (loaded.run.parentRunId === undefined)
+                throw new WorkflowError("WORKTREE_FAILED", `Borrowed worktree ${name} has no parent run`);
+            const parent = await this.sourceRun(loaded.run.parentRunId);
+            const resolved = await parent.findNamedWorktree(name, nextSeen);
+            if (!resolved || resolved.sourceRunId !== binding.sourceRunId || resolved.owner !== binding.owner)
+                throw new WorkflowError("WORKTREE_FAILED", `Borrowed worktree binding for ${name} is not inherited from its parent run`);
+            return resolved;
+        }
+        const records = await json(join(this.directory, "worktrees.json"));
+        const matches = records.filter((candidate) => candidate && typeof candidate === "object" && candidate.owner === owner);
+        if (matches.length === 0)
+            return undefined;
+        try {
+            const reference = await this.ownedWorktree(owner);
+            return { reference, sourceRunId: this.runId, owner };
+        }
+        catch (error) {
+            throw new WorkflowError("WORKTREE_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    async resolveNamedWorktree(name, seen = new Set()) {
+        const resolved = await this.findNamedWorktree(name, seen);
+        if (!resolved)
+            throw new WorkflowError("WORKTREE_FAILED", `Missing named worktree ${name}`);
+        return resolved;
+    }
+    async validateBorrowedWorktrees() {
+        try {
+            const loaded = await this.load();
+            if (loaded.run.parentRunId !== undefined)
+                await this.validateParentRun(loaded.run.parentRunId);
+            for (const binding of await this.borrowedWorktreeRecords())
+                await this.resolveBorrowedWorktree(binding, new Set([this.runId]));
+        }
+        catch (error) {
+            throw error instanceof WorkflowError && error.code === "WORKTREE_FAILED" ? error : new WorkflowError("WORKTREE_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    async ownsWorktree(owner) {
+        const records = await json(join(this.directory, "worktrees.json"));
+        return records.filter((candidate) => candidate && typeof candidate === "object" && candidate.owner === owner).length === 1;
+    }
     async cleanupMarker(markerPath) {
         let marker;
         try {
@@ -467,15 +631,15 @@ export class RunStore {
     async validateWorktree(owner, cwd) {
         try {
             await this.load();
-            const records = await json(join(this.directory, "worktrees.json"));
-            const matches = records.filter((candidate) => candidate && typeof candidate === "object" && candidate.owner === owner);
-            if (matches.length !== 1)
-                throw new Error(`Missing or duplicate worktree record for ${owner}`);
-            const record = this.structuralWorktree(owner, matches[0]);
-            if (cwd !== undefined && resolve(cwd) !== resolve(record.cwd))
-                throw new Error(`Invalid worktree record for ${owner}`);
-            await access(record.cwd);
-            return record;
+            const name = this.worktreeName(owner);
+            const binding = name ? await this.borrowedWorktree(name) : undefined;
+            if (binding) {
+                const resolved = await this.resolveBorrowedWorktree(binding, new Set([this.runId]));
+                if (cwd !== undefined && resolve(cwd) !== resolve(resolved.reference.cwd))
+                    throw new Error(`Invalid worktree record for ${owner}`);
+                return resolved.reference;
+            }
+            return await this.ownedWorktree(owner, cwd);
         }
         catch (error) {
             throw error instanceof WorkflowError && error.code === "WORKTREE_FAILED" ? error : new WorkflowError("WORKTREE_FAILED", error instanceof Error ? error.message : String(error));
@@ -483,10 +647,21 @@ export class RunStore {
     }
     async worktree(owner) {
         const write = this.worktreeWrite.then(async () => {
-            await this.load();
+            const loaded = await this.load();
             const recordsPath = join(this.directory, "worktrees.json");
             let records = await json(recordsPath).catch((error) => { if (error.code === "ENOENT")
                 return []; throw error; });
+            const name = this.worktreeName(owner);
+            const binding = name ? await this.borrowedWorktree(name) : undefined;
+            if (binding)
+                return (await this.resolveBorrowedWorktree(binding, new Set([this.runId]))).reference;
+            if (name && loaded.run.parentRunId !== undefined) {
+                const resolved = await this.resolveNamedWorktreeFromParent(name, loaded.run.parentRunId);
+                if (resolved) {
+                    await this.bindBorrowedWorktree({ name, sourceRunId: resolved.sourceRunId, owner: resolved.owner });
+                    return resolved.reference;
+                }
+            }
             const existing = records.find((record) => record.owner === owner);
             if (existing)
                 return this.validateWorktree(owner);
@@ -541,6 +716,25 @@ export class RunStore {
         this.worktreeWrite = write.then(() => undefined, () => undefined);
         return write;
     }
+    async resolveNamedWorktreeFromParent(name, parentRunId) {
+        const source = await this.sourceRun(parentRunId);
+        return source.findNamedWorktree(name, new Set([this.runId]));
+    }
+    async bindBorrowedWorktree(binding) {
+        const write = this.borrowedWorktreeWrite.then(async () => {
+            const records = [...await this.borrowedWorktreeRecords(false)];
+            const existing = records.find((candidate) => candidate.name === binding.name);
+            if (existing) {
+                if (JSON.stringify(existing) !== JSON.stringify(binding))
+                    throw new WorkflowError("WORKTREE_FAILED", `Borrowed worktree binding for ${binding.name} changed`);
+                return;
+            }
+            records.push(binding);
+            await atomicJson(join(this.directory, "borrowed-worktrees.json"), records);
+        });
+        this.borrowedWorktreeWrite = write.then(() => undefined, () => undefined);
+        await write;
+    }
     async snapshotWorktree(owner) {
         try {
             const write = this.snapshotWrite.then(async () => {
@@ -570,13 +764,16 @@ export class RunStore {
     async worktrees() {
         const records = await json(join(this.directory, "worktrees.json")).catch((error) => { if (error.code === "ENOENT")
             return []; throw error; });
-        const validated = await Promise.all(records.map(async (record) => { try {
+        const bindings = await this.borrowedWorktreeRecords();
+        const boundOwners = new Set(bindings.map((binding) => binding.owner));
+        const owned = await Promise.all(records.filter((record) => !boundOwners.has(record.owner)).map(async (record) => { try {
             return await this.validateWorktree(record.owner);
         }
         catch {
             return undefined;
         } }));
-        return validated.filter((record) => record !== undefined);
+        const borrowed = await Promise.all(bindings.map(async (binding) => (await this.resolveBorrowedWorktree(binding, new Set([this.runId]))).reference));
+        return [...owned.filter((record) => record !== undefined), ...borrowed];
     }
     async changedWorktrees() {
         const changed = [];

package/dist/src/session-inspector.d.ts

@@ -63,6 +63,7 @@ export interface InspectorViewState {
     scroll: number;
 }
 export declare function transcriptLines(entries: readonly SessionEntry[]): string[];
+export declare function transcriptFileLines(path: string): string[];
 export declare function matchSession(query: string, sessions: readonly SessionInfo[]): SessionInfo;
 export declare function loadSessionReport(path: string, home?: string): Promise<SessionReport>;
 export declare function renderInspector(report: SessionReport, state: InspectorViewState, width?: number, height?: number, highlighter?: (script: string) => string[]): string[];

package/dist/src/session-inspector.js

@@ -45,6 +45,9 @@ export function transcriptLines(entries) {
         return index ? ["", ...lines] : lines;
     });
 }
+export function transcriptFileLines(path) {
+    return transcriptLines(SessionManager.open(path).buildContextEntries());
+}
 function mergedModels(groups) {
     const totals = new Map();
     for (const group of groups)

package/dist/src/workflow-evals.d.ts

@@ -252,6 +252,7 @@ export interface CaptureCaseInput {
     maxCost: number;
 }
 export declare function parseSemanticJudge(raw: string, criteria: readonly SemanticCriterion[]): CriterionResult[];
+export declare function findSessionFile(directory: string, sessionId: string): string | undefined;
 export declare function captureEvalCase(input: CaptureCaseInput): Promise<EvalCaseResult>;
 export interface IsolatedProcessOptions {
     childPath: string;

package/dist/src/workflow-evals.js

@@ -8,13 +8,12 @@ import { Value } from "typebox/value";
 import { getAgentDir, parseFrontmatter, SessionManager } from "@earendil-works/pi-coding-agent";
 import { CAPTURE_ERROR_PREFIX, CAPTURE_IDENTITY, resolveWorkflowSkillPath } from "./eval-capture-extension.js";
 export { resolveWorkflowSkillPath } from "./eval-capture-extension.js";
-import { ERROR_CODES, inspectWorkflowScript, loadAgentDefinitions, runWorkflow, WorkflowError } from "./index.js";
+import { ERROR_CODES, inspectWorkflowScript, isObject, loadAgentDefinitions, runWorkflow, WORKFLOW_CALL_KINDS, WorkflowError } from "./index.js";
 const CASE_PROCESS_GRACE_MS = 1_000;
 export const SAFE_PARENT_EVAL_TOOLS = Object.freeze(["read", "grep", "find", "bash", "workflow"]);
 const EVAL_MODEL_TOKEN = "$EVAL_MODEL";
 const semantic = (description) => [{ id: "intent", description }];
 const JSON_RESULT_TYPES = ["null", "boolean", "number", "integer", "string", "array", "object"];
-const WORKFLOW_CALL_KINDS = ["agent", "conversation", "parallel", "pipeline", "checkpoint", "phase", "withWorktree"];
 const AGENT_OPTION_NAMES = ["role", "model", "thinking", "tools", "retries"];
 const expectationKeys = ["firstSignificantAction", "firstTool", "firstBatchToolSequence", "parentToolSequence", "workflowCallCount", "requiredOperations", "forbiddenOperations", "requiredRoles", "minimumAgentCalls", "requireOutputSchema", "expectedResults", "agentPolicies", "requiredAgentOrder", "requiredAgentStructures", "requiredDataFlow"];
 const caseKeys = ["id", "prompt", "timeoutMs", "maxCost", "expectations", "expectedWorkflowCalls", "semanticCriteria"];
@@ -234,7 +233,6 @@ catch (error) {
     cases.push(candidate);
 } return Object.freeze(cases); }
 export const INITIAL_WORKFLOW_EVAL_CASES = loadWorkflowEvalCases();
-function isObject(value) { return typeof value === "object" && value !== null && !Array.isArray(value); }
 function isJson(value) { if (value === null || typeof value === "string" || typeof value === "boolean")
     return true; if (typeof value === "number")
     return Number.isFinite(value); if (Array.isArray(value))
@@ -709,6 +707,7 @@ export async function replayWorkflowScript(script, args = null, signal) {
                 active -= 1;
             }
         },
+        worktree: async () => ({ path: "/worktrees/eval", branch: "eval-branch" }),
         phase: (name) => { phases.push(name); },
         log: (message) => { logs.push(message); },
     }, signal);
@@ -862,7 +861,7 @@ function semanticJudgePrompt(evalCase, calls, cwd, home) {
         return [];
     } }));
     const roleText = [...usedRoles].map((role) => `${role}: ${roles[role]?.description ?? "no description"}`).join("\n") || "none";
-    const docs = "agent(prompt, options) delegates; parallel(name, tasks) runs independent tasks concurrently; pipeline(name, items, stages) applies ordered stages; prompt(template, data) carries values into prompts. A role owns model/thinking/tools policy.";
+    const docs = "agent(prompt, options) delegates; shell(command, options) runs a deterministic host command and returns exitCode/stdout/stderr; parallel(name, tasks) runs independent tasks concurrently; pipeline(name, items, stages) applies ordered stages; prompt(template, data) carries values into prompts. A role owns model/thinking/tools policy.";
     return `Judge whether the captured workflow design satisfies each criterion. Do not execute it. Return only JSON: {"criteria":[{"id":"criterion id","pass":true,"evidence":"specific script evidence"}]}.\n\nOriginal request:\n${evalCase.prompt}\n\nCriteria:\n${JSON.stringify(evalCase.semanticCriteria ?? [])}\n\nDSL:\n${docs}\n\nRelevant roles:\n${roleText}\n\nCaptured workflow script(s):\n${calls.map((call, index) => `--- ${String(index)} ---\n${call.script ?? "<missing>"}`).join("\n")}`;
 }
 async function runSemanticJudge(input, calls, cwd, home, sessionDir, maxCost) {
@@ -945,6 +944,27 @@ function seedEvalProject(cwd, home, model) {
             writeFileSync(path, `${content.slice(0, frontmatterEnd).replace(/^model:.*$/m, `model: ${model}`)}${content.slice(frontmatterEnd)}`);
     }
 }
+export function findSessionFile(directory, sessionId) {
+    if (!existsSync(directory))
+        return undefined;
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            const found = findSessionFile(path, sessionId);
+            if (found)
+                return found;
+        }
+        else if (entry.name.endsWith(".jsonl")) {
+            try {
+                const header = JSON.parse(readFileSync(path, "utf8").split("\n")[0] ?? "{}");
+                if (isObject(header) && header.id === sessionId)
+                    return path;
+            }
+            catch { /* Ignore incomplete sessions. */ }
+        }
+    }
+    return undefined;
+}
 async function findParentSession(cwd, sessionDir, sessionId) {
     try {
         const sessions = await SessionManager.list(cwd, sessionDir);
@@ -953,28 +973,7 @@ async function findParentSession(cwd, sessionDir, sessionId) {
             return found.path;
     }
     catch { /* Fall through to the JSONL scan. */ }
-    const visit = (directory) => {
-        if (!existsSync(directory))
-            return undefined;
-        for (const entry of readdirSync(directory, { withFileTypes: true })) {
-            const path = join(directory, entry.name);
-            if (entry.isDirectory()) {
-                const found = visit(path);
-                if (found)
-                    return found;
-            }
-            else if (entry.name.endsWith(".jsonl")) {
-                try {
-                    const header = JSON.parse(readFileSync(path, "utf8").split("\n")[0] ?? "{}");
-                    if (isObject(header) && header.id === sessionId)
-                        return path;
-                }
-                catch { /* Ignore incomplete files. */ }
-            }
-        }
-        return undefined;
-    };
-    return visit(sessionDir);
+    return findSessionFile(sessionDir, sessionId);
 }
 function emptyAccounting(cost = 0) { return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost, models: [] }; }
 function emptyMetrics(requiredWorkflowCallCount = 1) { return { parentUsageThroughCandidate: null, parentOutputTokensThroughCandidate: null, nonWorkflowToolSequenceBeforeCandidate: [], nonWorkflowToolCallCountBeforeCandidate: 0, workflowCallCountBeforeCandidate: 0, invalidWorkflowCallCount: 0, productionValidationErrorCodes: [], candidateCallIndices: [], staticCandidates: [], semanticCriteria: [], anyValidCandidate: false, requiredWorkflowCallCount, surplusWorkflowCallCount: 0 }; }

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "pi-extensible-workflows",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Deterministic multi-agent workflow orchestration for Pi",
   "homepage": "https://vekexasia.github.io/pi-extensible-workflows/",
-  "repository": { "type": "git", "url": "git+https://github.com/vekexasia/pi-extensible-workflows.git" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vekexasia/pi-extensible-workflows.git"
+  },
   "type": "module",
   "keywords": [
     "pi-package",
@@ -28,8 +31,9 @@
     "build": "rm -rf dist && tsc -p tsconfig.json && chmod +x dist/src/cli.js",
     "inspect": "node dist/src/cli.js inspect",
     "lint": "eslint .",
-    "test": "npm run build && node --test 'dist/test/*.test.js'",
-    "acceptance": "npm run build && node --test dist/test/runtime-acceptance.test.js",
+    "test": "npm run build && TEST_FILES='dist/test/*.test.js' npm run test:run",
+    "test:run": "tmp=$(mktemp -d); trap 'rm -rf \"$tmp\"' EXIT; TMPDIR=\"$tmp\" node --test $TEST_FILES",
+    "acceptance": "npm run build && TEST_FILES='dist/test/runtime-acceptance.test.js' npm run test:run",
     "docs:check": "node scripts/check-docs.mjs",
     "check": "npm run lint && npm test && npm run docs:check",
     "evals": "npm run build && node dist/src/workflow-evals.js",