@parcha/agentrun-pi 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/workflow-view.js

@@ -0,0 +1,273 @@
+import { inspectWorkflow } from '@parcha/agentrun-dsl';
+import { workflowGraph } from '@parcha/agentrun-dsl/graph';
+import { cleanText } from './presentation.js';
+import { types as utilTypes } from 'node:util';
+/** Display limits never admit, cancel, or modify execution. */
+export function readable(value, max = 12_000) {
+    let text;
+    let excerpt = false;
+    try {
+        if (typeof value === 'string')
+            text = value;
+        // The controller explicitly requests complete expanded output; its structured
+        // report remains authoritative. Normal observation never uses this path.
+        else if (max === Number.MAX_SAFE_INTEGER)
+            text = JSON.stringify(value, null, 2) ?? '';
+        else {
+            let remaining = max, values = 0;
+            const seen = new Set();
+            const visit = (item, depth) => {
+                if (++values > 2_000 || remaining <= 0 || depth > 16) {
+                    excerpt = true;
+                    return '[Display excerpt]';
+                }
+                if (typeof item === 'string') {
+                    const part = item.slice(0, remaining);
+                    remaining -= part.length;
+                    if (part.length < item.length)
+                        excerpt = true;
+                    return part;
+                }
+                remaining -= 8;
+                if (item === null || typeof item === 'boolean' || typeof item === 'number')
+                    return item;
+                if (!item || typeof item !== 'object' || utilTypes.isProxy(item))
+                    return '[Non-JSON value]';
+                if (seen.has(item))
+                    return '[Repeated reference]';
+                const proto = Object.getPrototypeOf(item);
+                if (proto !== null && proto !== Object.prototype && proto !== Array.prototype)
+                    return '[Non-JSON value]';
+                seen.add(item);
+                const result = Array.isArray(item) ? [] : Object.create(null);
+                if (Array.isArray(item)) {
+                    const length = Math.min(item.length, 2_000);
+                    for (let index = 0; index < length; index++) {
+                        if (remaining <= 0 || values >= 2_000) {
+                            excerpt = true;
+                            break;
+                        }
+                        const descriptor = Object.getOwnPropertyDescriptor(item, String(index));
+                        result.push(descriptor && 'value' in descriptor ? visit(descriptor.value, depth + 1) : '[Unavailable element]');
+                    }
+                    if (result.length < item.length)
+                        excerpt = true;
+                    seen.delete(item);
+                    return result;
+                }
+                for (const key in item) {
+                    if (!Object.hasOwn(item, key))
+                        continue;
+                    if (remaining <= 0 || values >= 2_000) {
+                        excerpt = true;
+                        break;
+                    }
+                    const descriptor = Object.getOwnPropertyDescriptor(item, key);
+                    remaining -= key.length;
+                    Object.defineProperty(result, key, { value: 'value' in descriptor ? visit(descriptor.value, depth + 1) : '[Accessor not read]', enumerable: true, configurable: true });
+                }
+                seen.delete(item);
+                return result;
+            };
+            text = JSON.stringify(visit(value, 0), null, 2) ?? '';
+        }
+    }
+    catch {
+        return '[Not available as JSON]';
+    }
+    const clipped = text.length > max || excerpt;
+    return cleanText(text.slice(0, max)) + (clipped ? '\n… Display excerpt; additional content omitted.' : '');
+}
+const definitionPath = (path) => path.replace(/\/items\/\d+\/body/g, '/body').replace(/\/iterations\/\d+(?=\/|$)/g, '');
+const at = (value, path) => path.split('/').slice(1).reduce((item, key) => item && Object.hasOwn(item, key.replace(/~1/g, '/').replace(/~0/g, '~')) ? item[key.replace(/~1/g, '/').replace(/~0/g, '~')] : undefined, value);
+export class WorkflowObservation {
+    data = { steps: {}, decisions: [], notes: {}, routes: {}, omitted: 0 };
+    decisionBytes = 0;
+    record(event) {
+        try {
+            this.recordSafe(event);
+        }
+        catch {
+            this.data.omitted++;
+        }
+    }
+    recordSafe(event) {
+        const path = event.executionPath ?? `/label/${event.label}`;
+        const detail = event.detail;
+        if (event.type === 'node.start' || event.type === 'node.end') {
+            if (!Object.hasOwn(this.data.steps, path) && Object.keys(this.data.steps).length >= 2_000) {
+                this.data.omitted++;
+                return;
+            }
+            this.data.steps[path] = { label: cleanText(event.label), kind: String(detail?.kind ?? 'step'),
+                status: event.type === 'node.start' ? 'running' : detail?.status === 'ok' ? 'succeeded' : detail?.status === 'escalated' ? 'needs attention' : 'failed' };
+        }
+        // Escalation emits an evaluation event, not node.start/node.end. Project that
+        // existing interpreter evidence so the selected branch cannot look untouched.
+        if (event.type === 'escalate.evaluated') {
+            if (!Object.hasOwn(this.data.steps, path) && Object.keys(this.data.steps).length >= 2_000) {
+                this.data.omitted++;
+                return;
+            }
+            this.data.steps[path] = { label: cleanText(event.label), kind: 'escalate',
+                status: detail?.fired === true ? 'needs attention' : 'condition not met' };
+        }
+        if (event.type === 'judge.answered' || event.type === 'route.chosen' || event.type === 'ask.evaluated') {
+            const decision = this.data.decisions.findLast(item => item.path === path && item.accepted === undefined);
+            if (decision)
+                decision.accepted = true;
+        }
+        if (event.type === 'route.chosen' || event.type === 'loop.exited' || event.type === 'map.failed' || event.type === 'map.escalated') {
+            if (!Object.hasOwn(this.data.notes, path) && Object.keys(this.data.notes).length >= 200) {
+                this.data.omitted++;
+                return;
+            }
+            this.data.notes[path] = event.type === 'route.chosen' ? `Selected branch: ${readable(detail?.value, 500)}`
+                : event.type === 'loop.exited' ? `${detail?.iterations} iterations · ${detail?.reason === 'condition_met' ? 'stop condition met' : 'iteration bound reached; not proof of success'}`
+                    : `${detail?.completed} of ${detail?.of} items completed · ${event.type === 'map.failed' ? 'failed' : 'needs attention'}`;
+            if (event.type === 'route.chosen' && typeof detail?.value?.taken === 'string')
+                this.data.routes[path] = detail.value.taken;
+        }
+    }
+    /** Capture the exact supplied questions/state, not an explanation invented afterward. */
+    requested(request) {
+        if (this.data.decisions.length >= 32 || this.decisionBytes >= 128_000) {
+            this.data.omitted++;
+            return;
+        }
+        const item = { path: request.executionPath ?? `/label/${request.label}`, label: cleanText(request.label),
+            questions: readable(request.questions, 8_000), evidence: readable(request.state, 8_000) };
+        this.decisionBytes += item.questions.length + item.evidence.length;
+        this.data.decisions.push(item);
+        return item;
+    }
+    observe(deps) {
+        if (!deps.runJudge)
+            return deps;
+        const runJudge = deps.runJudge;
+        return { ...deps, runJudge: async (request) => {
+                let record;
+                try {
+                    record = this.requested(request);
+                }
+                catch {
+                    this.data.omitted++;
+                }
+                const result = await runJudge(request);
+                // A transport response is not acceptance; interpreter events confirm it later.
+                try {
+                    if (record)
+                        record.answer = readable(result.answers, 8_000);
+                }
+                catch {
+                    this.data.omitted++;
+                }
+                return result;
+            } };
+    }
+}
+export function progressLines(observation, terminalStatus) {
+    const steps = Object.values(observation.steps).map(step => terminalStatus && step.status === 'running'
+        ? { ...step, status: ['interrupted', 'cancelled'].includes(terminalStatus) ? 'interrupted' : 'completion not observed' } : step);
+    const count = (status) => steps.filter(step => step.status === status).length;
+    const active = steps.filter(step => step.status === 'running');
+    return [
+        `${count('succeeded')} succeeded · ${active.length} active · ${count('failed')} failed · ${count('needs attention')} need attention`,
+        ...(count('interrupted') ? [`${count('interrupted')} interrupted; completion not observed.`] : []),
+        ...(count('completion not observed') ? [`${count('completion not observed')} steps have no observed completion.`] : []),
+        ...active.slice(0, 3).map(step => `Working: ${step.label}`),
+        ...(active.length > 3 ? [`… ${active.length - 3} more active steps`] : []),
+        ...(observation.omitted ? ['Observation is partial; omitted details do not stop execution.'] : []),
+    ];
+}
+export function workflowView(workflow, options = {}) {
+    const inspection = inspectWorkflow(workflow);
+    const definition = workflow;
+    const observed = options.observation;
+    const status = options.running ? 'running' : options.report?.status ?? 'draft';
+    const required = definition.input ? definition.schemas[definition.input.schemaId]?.required ?? [] : [];
+    const missing = required.filter((key) => !Object.hasOwn(options.input ?? {}, key));
+    const tools = inspection.requires.tools;
+    const unavailable = options.availableTools ? tools.filter(name => !options.availableTools.includes(name)) : [];
+    // The nodes are the graph's (`@parcha/agentrun-dsl/graph`, the one the viewer's graph panel draws); inspection only adds what a step writes.
+    const writes = new Map(inspection.nodes.map(node => [node.path, node.writes]));
+    const nodes = workflowGraph(workflow).nodes.map(graphNode => {
+        const node = { ...graphNode, writes: writes.get(graphNode.path) };
+        const source = at(definition, node.path) ?? {};
+        const childRoot = node.path.lastIndexOf('/workflow/root');
+        const owner = childRoot < 0 ? definition : at(definition, node.path.slice(0, childRoot + '/workflow'.length));
+        const instances = Object.entries(observed?.steps ?? {}).filter(([path]) => definitionPath(path) === node.path);
+        const events = Object.entries(observed?.notes ?? {}).filter(([path]) => definitionPath(path) === node.path);
+        const decisions = observed?.decisions.filter(item => definitionPath(item.path) === node.path) ?? [];
+        const descendants = Object.entries(observed?.steps ?? {}).filter(([path]) => definitionPath(path).startsWith(`${node.path}/`));
+        const structural = ['chain', 'map', 'parallel', 'loop'].includes(node.kind);
+        const statuses = (instances.length ? instances : structural ? descendants : []).map(([, item]) => item.status);
+        const final = !!options.report && !options.running;
+        const skipped = final && !observed?.omitted && Object.entries(observed?.routes ?? {}).some(([routePath]) => {
+            const parent = definitionPath(routePath);
+            if (!node.path.startsWith(`${parent}/branches/`))
+                return false;
+            const branch = node.path.slice(`${parent}/branches/`.length).split('/')[0];
+            const choices = Object.entries(observed?.routes ?? {}).filter(([path]) => definitionPath(path) === parent);
+            return choices.length > 0 && choices.every(([, taken]) => taken.replace(/~/g, '~0').replace(/\//g, '~1') !== branch);
+        });
+        const nodeStatus = statuses.includes('running') ? final ? ['interrupted', 'cancelled'].includes(status) ? 'interrupted' : 'completion not observed' : 'running' : statuses.includes('failed') ? 'failed'
+            : statuses.some(value => ['interrupted', 'cancelled'].includes(value)) ? 'interrupted'
+                : statuses.includes('needs attention') ? 'needs attention'
+                    : structural && !instances.length && observed?.omitted ? 'completion not observed'
+                        : statuses.length && statuses.every(value => value === 'condition not met') ? 'condition not met'
+                            : statuses.length && statuses.every(value => value === 'succeeded' || value === 'condition not met') ? 'succeeded'
+                                : statuses.length ? 'completion not observed'
+                                    : events.length ? 'observed' : status === 'draft' ? 'planned' : skipped ? 'skipped (branch not selected)' : 'not observed';
+        const displayedStatus = structural && !instances.length && nodeStatus === 'succeeded' ? 'observed work succeeded' : nodeStatus;
+        const counts = instances.length > 1 ? `${statuses.filter(s => s === 'succeeded').length}/${instances.length} observed executions succeeded` : '';
+        const detail = [
+            `Step: ${node.label} [${node.kind}]`, `Definition: ${node.path}`, `State: ${displayedStatus}`,
+            ...(source.requires?.length ? [`Requires: ${source.requires.join(', ')}`] : []),
+            ...(source.state !== undefined ? ['Input binding:', readable(source.state)] : []),
+            ...(source.instructions ? ['Instructions:', readable(source.instructions)] : []),
+            ...(typeof source.valuePath === 'string' ? [`Branch chosen by state at ${readable(source.valuePath, 200)}; no model is asked.`, ...(typeof source.otherwise === 'string' ? [`Otherwise: ${readable(source.otherwise, 200)}`] : [])] : []),
+            ...(source.tools?.length ? [`Tools: ${source.tools.join(', ')}`] : []),
+            ...(source.tool ? [`Tool: ${source.tool}`] : []),
+            ...(source.args ? ['Tool arguments:', readable(source.args)] : []),
+            ...(source.code ? ['Code (not executed by inspection):', readable(source.code)] : []),
+            ...(source.until ? ['Stop condition:', readable(source.until), `Maximum iterations: ${source.maxIters ?? 'none configured'}`] : []),
+            ...(source.when ? ['Condition:', readable(source.when)] : []),
+            ...(source.out ? [`Output schema: ${source.out}`, readable(owner?.schemas?.[source.out])] : []),
+            ...(node.writes ? [`Writes: ${node.writes}`] : []),
+            ...(source.branches && !Array.isArray(source.branches) ? ['Branch rules:', readable(Object.fromEntries(Object.entries(source.branches).map(([name, value]) => [name, value.when ?? value.criteria ?? value.description ?? name])))] : []),
+            ...events.map(([path, note]) => `${path}: ${note}`),
+            ...decisions.flatMap((item, index) => [`Decision ${index + 1} · ${item.path}`, 'Actual questions and criteria:', item.questions,
+                'Actual evidence supplied:', item.evidence, item.accepted ? 'Interpreter accepted the answer:' : 'Response (acceptance not observed):', item.answer ?? 'No answer observed.',
+                'Confidence describes this judgment, not whole-workflow correctness.']),
+        ];
+        return { path: node.path, label: cleanText(node.label), kind: node.kind, status: displayedStatus,
+            summary: [counts, ...events.map(([, note]) => note)].filter(Boolean).join(' · '), details: detail.map(cleanText) };
+    });
+    return {
+        title: cleanText(inspection.name), digest: inspection.sha256, status,
+        summary: [
+            `${options.savedName ? `Saved: ${cleanText(options.savedName)} · ` : ''}Revision: ${inspection.sha256.slice(0, 12)} · ${options.mode ?? 'live adapters'}`,
+            ...(options.savedName ? [`Load this saved revision: /agentrun load ${cleanText(options.savedName)} ${inspection.sha256}`] : []),
+            `Input: ${inspection.inputSchema ?? 'object'} → Output: ${inspection.outputSchema}${inspection.outputPath ? ` (${inspection.outputPath})` : ''}`,
+            ...(missing.length ? [`Missing input: ${missing.join(', ')}`] : []),
+            `Tools: ${tools.join(', ') || 'none'}`,
+            ...(unavailable.length ? [`Unavailable without host configuration or approval: ${unavailable.join(', ')}`] : []),
+            ...(inspection.requires.executableCode ? ['Approval: code requires /agentrun run --trusted for each run (unsandboxed).'] : []),
+            ...(options.model && !options.mode?.startsWith('scripted') && inspection.requires.adapters.includes('runNode') ? [`Agent model: ${options.model}`] : []),
+            ...(options.limits ? [`Host limits: ${Object.entries(options.limits).map(([key, value]) => `${key}=${value ?? 'disabled'}`).join(', ')}`] : []),
+            ...(observed ? progressLines(observed, options.report && !options.running ? status : undefined) : ['Preflight checks syntax and admission; it does not prove task correctness.']),
+            ...(options.report?.error ? [`Failure: ${options.report.error.stage ?? 'workflow'} · ${options.report.error.message}`] : []),
+            ...(options.report?.uncertainEffects?.length ? ['Unknown tool outcomes: reconcile before restarting.'] : []),
+            ...(options.report?.traceTruncated ? ['Retained event trace is partial.'] : []),
+        ].map(cleanText), nodes,
+        ...(options.report?.output !== undefined ? { output: ['Output:', readable(options.report.output)] } : {}),
+    };
+}
+export function formatWorkflowView(view) {
+    return cleanText([`${view.title} · ${view.status}`, ...view.summary, '',
+        ...view.nodes.map(node => `${'  '.repeat(Math.min(5, node.path.split('/').length - 2))}${node.label} [${node.kind}] · ${node.status}${node.summary ? ` · ${node.summary}` : ''}`),
+        ...(view.output ? ['', ...view.output] : []),
+        '', 'Inspect a step for criteria, evidence, and observed decisions. Restart reruns the whole workflow; it is not resume.',
+    ].join('\n'));
+}

package/dist/workflows.d.ts

@@ -0,0 +1 @@
+export { WorkflowStore, WorkflowStoreError, type StoredWorkflow, type WorkflowRevision } from './workflow-store.js';

package/dist/workflows.js

@@ -0,0 +1,3 @@
+// Saved workflows for a host: the store the /agentrun extension keeps for its project directory, against a directory the host passes.
+// It loads nothing from pi, so a host that never runs the extension can import it.
+export { WorkflowStore, WorkflowStoreError } from './workflow-store.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcha/agentrun-pi",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.21",
   "description": "Pi extension for building, running and evaluating AgentRun workflows",
   "type": "module",
   "license": "Apache-2.0",
@@ -15,6 +15,18 @@
     "./extension": {
       "types": "./dist/extension.d.ts",
       "import": "./dist/extension.js"
+    },
+    "./durable": {
+      "types": "./dist/durable/index.d.ts",
+      "import": "./dist/durable/index.js"
+    },
+    "./signin": {
+      "types": "./dist/signin/index.d.ts",
+      "import": "./dist/signin/index.js"
+    },
+    "./workflows": {
+      "types": "./dist/workflows.d.ts",
+      "import": "./dist/workflows.js"
     }
   },
   "bin": {
@@ -22,26 +34,60 @@
   },
   "files": [
     "dist",
-    "skills",
     "README.md",
     "LICENSE",
     "NOTICE"
   ],
   "scripts": {
-    "build": "node ../../scripts/build-pi-demo.mjs && tsc -p tsconfig.json",
+    "build": "node ../../scripts/build-pi-demo.mjs && tsc -p tsconfig.json && node ../../scripts/render-pi-skill.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "node --test test/*.test.mjs"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.87.0"
+    "@earendil-works/chord": "1.1.0",
+    "@earendil-works/pi-agent-core": "1.1.0",
+    "@earendil-works/pi-ai": "1.1.0",
+    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@earendil-works/pi-durable": "1.1.0",
+    "@earendil-works/pi-tui": "1.1.0",
+    "@parcha/pi-durable-disk": "0.1.0-beta.21",
+    "typebox": "1.3.7"
   },
   "dependencies": {
-    "@parcha/agentrun-dsl": "0.1.0-beta.2",
-    "@parcha/agentrun-jev": "0.1.0-beta.2",
-    "@earendil-works/pi-agent-core": "0.87.0",
-    "@earendil-works/pi-coding-agent": "0.87.0",
-    "@earendil-works/pi-tui": "0.87.0",
-    "typebox": "1.3.7"
+    "@parcha/agentrun-dsl": "0.1.0-beta.21",
+    "@parcha/agentrun-jev": "0.1.0-beta.21"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*",
+    "@earendil-works/pi-durable": ">=1.0.4 <1.4.0",
+    "@earendil-works/chord": ">=1.0.4 <1.4.0"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-agent-core": {
+      "optional": true
+    },
+    "@earendil-works/pi-ai": {
+      "optional": true
+    },
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
+    },
+    "typebox": {
+      "optional": true
+    },
+    "@earendil-works/pi-durable": {
+      "optional": true
+    },
+    "@earendil-works/chord": {
+      "optional": true
+    }
   },
   "repository": {
     "type": "git",
@@ -67,7 +113,7 @@
       "./dist/extension.js"
     ],
     "skills": [
-      "./skills"
+      "./dist/skills"
     ]
   }
 }

package/dist/admission.d.ts

@@ -1,6 +0,0 @@
-export interface WorkflowAdmissionOptions {
-    rubricSections?: Record<string, string>;
-    allowExecutableCandidates?: boolean;
-    allowedEffectTools?: readonly string[];
-}
-export declare function workflowPolicyErrors(candidate: unknown, options: WorkflowAdmissionOptions): string[];

package/dist/admission.js

@@ -1,51 +0,0 @@
-export function workflowPolicyErrors(candidate, options) {
-    const errors = [];
-    const sections = Object.keys(options.rubricSections ?? {});
-    const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
-    const visit = (value) => {
-        const node = record(value);
-        if (!node)
-            return;
-        const kind = node.node;
-        if (!options.allowExecutableCandidates && ["code", "call", "artifact"].includes(String(kind)) && !(kind === "call" && node.via === "tool" && typeof node.tool === "string" && options.allowedEffectTools?.includes(node.tool)))
-            errors.push(`${kind} requires allowExecutableCandidates`);
-        if (sections.length && ["judge", "pick", "sift", "route"].includes(String(kind)))
-            errors.push(`${String(kind)} cannot carry supplied SOP sections; use an LLM node with sopSection`);
-        const llm = ["agent", "decide", "extract", "report"].includes(String(kind));
-        const predicate = kind === "loop" ? record(node.until) : kind === "escalate" ? record(node.when) : undefined;
-        if (sections.length && (predicate?.predicate === "ask" || (llm && node.verify !== undefined)))
-            errors.push("Semantic predicates and verify clauses require a separately reviewed question contract when rubric sections are supplied");
-        const proseArtifact = kind === "artifact" && (node.type === "markdown" || node.type === "report");
-        if (llm || proseArtifact) {
-            const included = Array.isArray(node.sopSection) ? node.sopSection : [node.sopSection];
-            for (const section of sections)
-                if (!included.includes(section))
-                    errors.push(`${String(node.label)} must include rubric section ${section}`);
-        }
-        switch (kind) {
-            case "chain":
-                if (Array.isArray(node.steps))
-                    node.steps.forEach(visit);
-                break;
-            case "parallel":
-                if (Array.isArray(node.branches))
-                    node.branches.forEach(visit);
-                break;
-            case "map":
-            case "loop":
-                visit(node.body);
-                break;
-            case "route": {
-                const branches = record(node.branches);
-                if (branches)
-                    Object.values(branches).forEach(branch => visit(record(branch)?.body));
-                break;
-            }
-            case "workflow":
-                visit(record(node.workflow)?.root);
-                break;
-        }
-    };
-    visit(record(candidate)?.root);
-    return errors;
-}

package/dist/author.d.ts

@@ -1,21 +0,0 @@
-import { type Workflow } from "@parcha/agentrun-dsl";
-import { type PiRunnerOptions } from "./runner.js";
-export declare const AUTHOR_CONTRACT = "You author AgentRun DSL v2 workflows as JSON data.\nDeliver with the submit tool, never prose or a filename. Make the smallest workflow satisfying the request.\nThe document has v:2, name, schemas (JSON Schema catalog), optional input:{schemaId}, output:{schemaId,path?}, root.\nEvery referenced schema must exist. Each LLM node has node:agent|decide|extract, label, instructions, out (schema id), as (state key), optional requires/tools/sopSection.\nA chain has node:chain, steps:[nodes]. A map has label, itemsPath, body, as, maxConcurrency. A loop has label, body, until, maxIters.\nA judge has label,state,out,as. Judge schemas use flat boolean/enum/integer properties; each property's description states its question. A route has label,state,instructions,branches:{name:{criteria,body}}, optional unsure:{branch,gte} and as.\nLLM instructions are literal text, never interpolated. The node receives workflow state as a JSON user message; refer to its keys in ordinary prose and declare required keys in requires. Use {stateKey} placeholders only in interpolated fields such as judge.state and call.args; whole placeholders preserve their value's type. Output.path selects a final state value validated by output.schemaId.\nOnly use tools named by the host. Never invent a tool, capability, evidence source or successful test.\nKeep the full rubric in its original source text. Every LLM node's sopSection must include ALL supplied rubric section names. Merged judgments inherit their parents' union. Do not paraphrase policy into instructions. If rubric sections are supplied, use LLM nodes for judgment; Jev nodes do not carry sopSection and require a separately reviewed question contract.\nKeep independent acceptance checks host-owned; never change their implementation, fixtures or thresholds to pass. A valid candidate is not automatically activated.\nCode, shell/effect calls and artifact delivery require explicit host authorization. Bound loops and parallelism; uncertainty should escalate or select an explicit fallback.\nExample: {\"v\":2,\"name\":\"summarize\",\"schemas\":{\"Result\":{\"type\":\"object\",\"properties\":{\"summary\":{\"type\":\"string\"}},\"required\":[\"summary\"],\"additionalProperties\":false}},\"output\":{\"schemaId\":\"Result\",\"path\":\"result\"},\"root\":{\"node\":\"extract\",\"label\":\"summarize\",\"instructions\":\"Summarize the text field from the JSON input faithfully.\",\"out\":\"Result\",\"as\":\"result\",\"requires\":[\"text\"]}}";
-export interface AuthorWorkflowOptions {
-    request: string;
-    outputDir: string;
-    pi: PiRunnerOptions;
-    inputKeys?: string[];
-    rubricSections?: Record<string, string>;
-    allowExecutableCandidates?: boolean;
-    maxCandidates?: number;
-    acceptance?: (candidate: Workflow) => Promise<string[]> | string[];
-}
-export interface AuthoredWorkflow {
-    workflow: Workflow;
-    path: string;
-    directory: string;
-    candidates: number;
-    checks: "structural" | "structural-and-host";
-}
-export declare function authorWorkflow(options: AuthorWorkflowOptions): Promise<AuthoredWorkflow>;

package/dist/author.js

@@ -1,72 +0,0 @@
-import { workflowPolicyErrors } from "./admission.js";
-import { randomUUID } from "node:crypto";
-import { mkdir, writeFile } from "node:fs/promises";
-import { resolve, join } from "node:path";
-import { validateWorkflow } from "@parcha/agentrun-dsl";
-import { createPiRunner } from "./runner.js";
-export const AUTHOR_CONTRACT = `You author AgentRun DSL v2 workflows as JSON data.
-Deliver with the submit tool, never prose or a filename. Make the smallest workflow satisfying the request.
-The document has v:2, name, schemas (JSON Schema catalog), optional input:{schemaId}, output:{schemaId,path?}, root.
-Every referenced schema must exist. Each LLM node has node:agent|decide|extract, label, instructions, out (schema id), as (state key), optional requires/tools/sopSection.
-A chain has node:chain, steps:[nodes]. A map has label, itemsPath, body, as, maxConcurrency. A loop has label, body, until, maxIters.
-A judge has label,state,out,as. Judge schemas use flat boolean/enum/integer properties; each property's description states its question. A route has label,state,instructions,branches:{name:{criteria,body}}, optional unsure:{branch,gte} and as.
-LLM instructions are literal text, never interpolated. The node receives workflow state as a JSON user message; refer to its keys in ordinary prose and declare required keys in requires. Use {stateKey} placeholders only in interpolated fields such as judge.state and call.args; whole placeholders preserve their value's type. Output.path selects a final state value validated by output.schemaId.
-Only use tools named by the host. Never invent a tool, capability, evidence source or successful test.
-Keep the full rubric in its original source text. Every LLM node's sopSection must include ALL supplied rubric section names. Merged judgments inherit their parents' union. Do not paraphrase policy into instructions. If rubric sections are supplied, use LLM nodes for judgment; Jev nodes do not carry sopSection and require a separately reviewed question contract.
-Keep independent acceptance checks host-owned; never change their implementation, fixtures or thresholds to pass. A valid candidate is not automatically activated.
-Code, shell/effect calls and artifact delivery require explicit host authorization. Bound loops and parallelism; uncertainty should escalate or select an explicit fallback.
-Example: {"v":2,"name":"summarize","schemas":{"Result":{"type":"object","properties":{"summary":{"type":"string"}},"required":["summary"],"additionalProperties":false}},"output":{"schemaId":"Result","path":"result"},"root":{"node":"extract","label":"summarize","instructions":"Summarize the text field from the JSON input faithfully.","out":"Result","as":"result","requires":["text"]}}`;
-export async function authorWorkflow(options) {
-    if (!options.request.trim())
-        throw new Error("Workflow request is required");
-    const maxCandidates = options.maxCandidates ?? 4;
-    if (!Number.isSafeInteger(maxCandidates) || maxCandidates < 1)
-        throw new Error("maxCandidates must be a positive integer");
-    const directory = resolve(options.outputDir, `candidate-${randomUUID()}`);
-    await mkdir(directory, { recursive: true });
-    await writeFile(join(directory, "request.json"), JSON.stringify({ request: options.request, inputKeys: options.inputKeys ?? [], rubricSections: options.rubricSections ?? {}, allowExecutableCandidates: options.allowExecutableCandidates ?? false, maxCandidates }, null, 2), { flag: "wx" });
-    let candidates = 0;
-    let acceptedPath;
-    const runner = createPiRunner({ ...options.pi, tools: [], maxSubmissions: maxCandidates });
-    try {
-        const workflow = await runner({
-            kind: "agent", label: "author-workflow", tools: [],
-            system: [AUTHOR_CONTRACT, `Executable candidates authorized: ${options.allowExecutableCandidates ?? false}.`, `All supplied rubric sections (authoritative): ${JSON.stringify(options.rubricSections ?? {})}`],
-            user: `${options.request}\nAvailable input keys: ${JSON.stringify(options.inputKeys ?? [])}`,
-            schema: { type: "object", additionalProperties: true },
-            async review(value) {
-                candidates++;
-                if (candidates > maxCandidates)
-                    throw new Error("Candidate limit exceeded");
-                const candidatePath = join(directory, `${String(candidates).padStart(3, "0")}.json`);
-                await writeFile(candidatePath, JSON.stringify(value, null, 2), { flag: "wx" });
-                const errors = workflowPolicyErrors(value, options);
-                if (!errors.length) {
-                    try {
-                        const verdict = validateWorkflow(value, { inputKeys: options.inputKeys });
-                        if (!verdict.ok)
-                            errors.push(...verdict.errors);
-                    }
-                    catch (error) {
-                        errors.push(`Invalid workflow: ${error instanceof Error ? error.message : String(error)}`);
-                    }
-                }
-                if (!errors.length && options.acceptance)
-                    errors.push(...await options.acceptance(structuredClone(value)));
-                await writeFile(join(directory, `${String(candidates).padStart(3, "0")}.review.json`), JSON.stringify({ accepted: !errors.length, checks: options.acceptance ? "structural-and-host" : "structural", errors }, null, 2), { flag: "wx" });
-                if (errors.length)
-                    return { accepted: false, message: errors.join("\n") };
-                acceptedPath = candidatePath;
-                return { accepted: true };
-            },
-        });
-        if (!acceptedPath)
-            throw new Error("Author returned without a retained accepted candidate");
-        await writeFile(join(directory, "result.json"), JSON.stringify({ status: "candidate", path: acceptedPath, candidates }, null, 2), { flag: "wx" });
-        return { workflow, path: acceptedPath, directory, candidates, checks: options.acceptance ? "structural-and-host" : "structural" };
-    }
-    catch (error) {
-        await writeFile(join(directory, "result.json"), JSON.stringify({ status: "failed", candidates, message: error instanceof Error ? error.message : String(error) }, null, 2), { flag: "wx" });
-        throw error;
-    }
-}

package/dist/benchmark-contract.d.ts

@@ -1,88 +0,0 @@
-export type BenchmarkSplit = 'development' | 'heldout';
-export type BenchmarkFinding = {
-    topicId: string;
-    status: 'supported' | 'conflicting' | 'insufficient';
-    summary: string;
-    sourceIds: string[];
-};
-export type BenchmarkCase = {
-    id: string;
-    split: BenchmarkSplit;
-    question: string;
-    topics: {
-        id: string;
-        question: string;
-    }[];
-    sources: {
-        id: string;
-        text: string;
-    }[];
-    expected: Omit<BenchmarkFinding, 'summary'>[];
-};
-export declare const benchmarkHash: (value: unknown) => string;
-export declare const benchmarkInstructions = "Answer using only the fictional source corpus. Produce exactly one finding for each supplied topic. Status supported means concrete evidence establishes a finding, including a negative or qualified answer. Conflicting means incompatible accounts. Insufficient means no concrete information answers the question. Preserve conditions and contrary evidence; cite every material source by ID. Do not invent facts or citations. Submit the final structured report.";
-export declare const benchmarkReportSchema: {
-    type: string;
-    additionalProperties: boolean;
-    required: string[];
-    properties: {
-        findings: {
-            type: string;
-            minItems: number;
-            items: {
-                type: string;
-                additionalProperties: boolean;
-                required: string[];
-                properties: {
-                    topicId: {
-                        type: string;
-                        minLength: number;
-                    };
-                    status: {
-                        enum: string[];
-                    };
-                    summary: {
-                        type: string;
-                        minLength: number;
-                    };
-                    sourceIds: {
-                        type: string;
-                        uniqueItems: boolean;
-                        items: {
-                            type: string;
-                            minLength: number;
-                        };
-                    };
-                };
-            };
-        };
-    };
-};
-export declare const benchmarkEvidenceSchema: {
-    type: string;
-    additionalProperties: boolean;
-    required: string[];
-    properties: {
-        relevant: {
-            type: string;
-            description: string;
-            criteria: {
-                true: string;
-                false: string;
-            };
-        };
-    };
-};
-export declare function benchmarkCases(split: BenchmarkSplit): BenchmarkCase[];
-/** Frozen independent checks. Never return these results to an authoring agent. */
-export declare function evaluatePiBenchmark(caseId: string, output: unknown): {
-    passed: boolean;
-    issues: string[];
-};
-export declare function benchmarkContract(): {
-    version: number;
-    fixturesSha256: string;
-    verifierSha256: string;
-    outputSchemaSha256: string;
-    instructionsSha256: string;
-};