@parcha/agentrun-pi 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/workflow-store.js

@@ -0,0 +1,249 @@
+import { constants } from 'node:fs';
+import { link, lstat, mkdir, open, readdir, realpath, rename, unlink } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { join, resolve } from 'node:path';
+import { inspectWorkflow, validateWorkflow } from '@parcha/agentrun-dsl';
+export class WorkflowStoreError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'WorkflowStoreError';
+    }
+}
+const validName = (name) => {
+    if (typeof name !== 'string' || !/^[a-z0-9][a-z0-9_-]{0,63}$/.test(name))
+        throw new WorkflowStoreError('invalid_name', 'Use a workflow name of 1–64 lowercase letters, digits, hyphens or underscores, starting with a letter or digit.');
+};
+const validDigest = (digest) => {
+    if (typeof digest !== 'string' || !/^[a-f0-9]{64}$/.test(digest))
+        throw new WorkflowStoreError('invalid_revision', 'A workflow revision must be its complete SHA-256 digest.');
+};
+const missing = (error) => error?.code === 'ENOENT';
+const unsafe = () => new WorkflowStoreError('unsafe_path', 'Workflow storage requires real directories and regular files, without symbolic links.');
+function checkedWorkflow(value) {
+    try {
+        // Inspection rejects non-JSON values before cloning. Neither check executes code.
+        const inspection = inspectWorkflow(value);
+        const workflow = structuredClone(value);
+        const validation = validateWorkflow(workflow, { executeCode: false });
+        if (!validation.ok)
+            throw new Error('invalid workflow');
+        return { workflow, digest: inspection.sha256 };
+    }
+    catch {
+        throw new WorkflowStoreError('invalid_workflow', 'Workflow failed nonexecuting structure, syntax or schema validation. Inspect it before saving.');
+    }
+}
+/** Local procedure revisions, not execution state or authority. The host still
+ * preflights loaded workflows against current capabilities and approves each run.
+ * This is not a sandbox against a process concurrently replacing project directories.
+ */
+export class WorkflowStore {
+    projectDirectory;
+    constructor(projectDirectory) { this.projectDirectory = resolve(projectDirectory); }
+    async directory(name, create = false) {
+        if (name !== undefined)
+            validName(name);
+        let directory = await realpath(this.projectDirectory);
+        for (const component of ['.pi', 'agentrun', 'workflows', ...(name === undefined ? [] : [name])]) {
+            directory = join(directory, component);
+            if (create) {
+                try {
+                    await mkdir(directory, { mode: 0o700 });
+                }
+                catch (error) {
+                    if (error.code !== 'EEXIST')
+                        throw error;
+                }
+            }
+            let stat;
+            try {
+                stat = await lstat(directory);
+            }
+            catch (error) {
+                if (missing(error) && !create)
+                    return undefined;
+                throw error;
+            }
+            if (!stat.isDirectory() || stat.isSymbolicLink() || await realpath(directory) !== directory)
+                throw unsafe();
+        }
+        return directory;
+    }
+    async read(name, digest) {
+        validName(name);
+        validDigest(digest);
+        const directory = await this.directory(name);
+        if (!directory)
+            throw new WorkflowStoreError('not_found', 'Saved workflow revision not found.');
+        const path = join(directory, `${digest}.json`);
+        let handle;
+        try {
+            handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        }
+        catch (error) {
+            if (missing(error))
+                throw new WorkflowStoreError('not_found', 'Saved workflow revision not found.');
+            if (error.code === 'ELOOP')
+                throw unsafe();
+            throw error;
+        }
+        let value;
+        try {
+            if (!(await handle.stat()).isFile() || await realpath(path) !== path)
+                throw unsafe();
+            try {
+                value = JSON.parse(await handle.readFile('utf8'));
+            }
+            catch {
+                throw new WorkflowStoreError('invalid_record', 'Saved workflow record is not valid JSON.');
+            }
+        }
+        finally {
+            await handle.close();
+        }
+        if (!value || typeof value !== 'object' || Array.isArray(value)
+            || Object.keys(value).sort().join(',') !== 'createdAt,digest,name,version,workflow'
+            || value.version !== 1 || value.name !== name || value.digest !== digest
+            || typeof value.createdAt !== 'string' || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(value.createdAt)
+            || !Number.isFinite(Date.parse(value.createdAt)) || new Date(value.createdAt).toISOString() !== value.createdAt)
+            throw new WorkflowStoreError('invalid_record', 'Saved workflow metadata does not match its revision.');
+        const checked = checkedWorkflow(value.workflow);
+        if (checked.digest !== digest)
+            throw new WorkflowStoreError('invalid_record', 'Saved workflow content does not match its digest.');
+        return { name, digest, createdAt: value.createdAt, workflowName: checked.workflow.name, workflow: checked.workflow };
+    }
+    async latest(name) {
+        const directory = await this.directory(name);
+        if (!directory)
+            return undefined;
+        const path = join(directory, 'latest');
+        let handle;
+        try {
+            handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        }
+        catch (error) {
+            if (missing(error))
+                return undefined;
+            if (error.code === 'ELOOP')
+                throw unsafe();
+            throw error;
+        }
+        try {
+            const stat = await handle.stat();
+            if (!stat.isFile() || await realpath(path) !== path)
+                throw unsafe();
+            if (stat.size !== 65)
+                throw new WorkflowStoreError('invalid_record', 'Saved workflow latest revision is invalid.');
+            const value = await handle.readFile('utf8');
+            if (!/^[a-f0-9]{64}\n$/.test(value))
+                throw new WorkflowStoreError('invalid_record', 'Saved workflow latest revision is invalid.');
+            return value.slice(0, -1);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    /** All revisions, newest first; the active revision leads within a timestamp tie. */
+    async list() {
+        const directory = await this.directory();
+        if (!directory)
+            return [];
+        const revisions = [];
+        const latest = new Map();
+        for (const name of await readdir(directory)) {
+            validName(name);
+            const child = await this.directory(name);
+            if (!child)
+                continue;
+            const active = await this.latest(name);
+            if (active)
+                latest.set(name, active);
+            for (const file of await readdir(child)) {
+                // Unpublished files survive an interrupted write and never become revisions.
+                if (/^\.pending-[a-f0-9-]+$/.test(file) || file === 'latest')
+                    continue;
+                if (!/^[a-f0-9]{64}\.json$/.test(file))
+                    throw new WorkflowStoreError('invalid_record', 'Unexpected file in workflow revision storage.');
+                const { workflow: _workflow, ...revision } = await this.read(name, file.slice(0, -5));
+                revisions.push(revision);
+            }
+        }
+        return revisions.sort((a, b) => b.createdAt.localeCompare(a.createdAt) || a.name.localeCompare(b.name)
+            || Number(b.digest === latest.get(b.name)) - Number(a.digest === latest.get(a.name)) || a.digest.localeCompare(b.digest));
+    }
+    async load(name, digest) {
+        validName(name);
+        if (digest !== undefined)
+            return this.read(name, digest);
+        const latest = await this.latest(name);
+        if (latest)
+            return this.read(name, latest);
+        // Revisions saved before the latest pointer was introduced remain readable.
+        const revisions = (await this.list()).filter(item => item.name === name);
+        const revision = revisions[0];
+        if (!revision)
+            throw new WorkflowStoreError('not_found', 'Saved workflow not found.');
+        if (revisions[1]?.createdAt === revision.createdAt)
+            throw new WorkflowStoreError('ambiguous_revision', 'Saved workflow revisions share a timestamp. Load by complete digest or save the intended revision again.');
+        return this.read(name, revision.digest);
+    }
+    /** Publish a complete immutable revision atomically; identical saves are idempotent. */
+    async save(name, value) {
+        validName(name);
+        const { workflow, digest } = checkedWorkflow(value);
+        const directory = (await this.directory(name, true));
+        const temporary = join(directory, `.pending-${randomUUID()}`);
+        const target = join(directory, `${digest}.json`);
+        const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        try {
+            await handle.writeFile(JSON.stringify({ version: 1, name, digest, createdAt: new Date().toISOString(), workflow }, null, 2) + '\n');
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        // Hard-link publication is atomic and, unlike rename, never overwrites a revision.
+        if (await this.directory(name) !== directory)
+            throw unsafe();
+        try {
+            await link(temporary, target);
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+        const saved = await this.read(name, digest);
+        await unlink(temporary);
+        const parent = await open(directory, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            await parent.sync();
+        }
+        finally {
+            await parent.close();
+        }
+        // This rename is the linearization point for "load by name", even when
+        // different revisions have identical millisecond timestamps.
+        const pointerTemporary = join(directory, `.pending-${randomUUID()}`);
+        const pointer = await open(pointerTemporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        try {
+            await pointer.writeFile(`${digest}\n`);
+            await pointer.sync();
+        }
+        finally {
+            await pointer.close();
+        }
+        if (await this.directory(name) !== directory)
+            throw unsafe();
+        await rename(pointerTemporary, join(directory, 'latest'));
+        const updatedParent = await open(directory, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            await updatedParent.sync();
+        }
+        finally {
+            await updatedParent.close();
+        }
+        return saved;
+    }
+}

package/dist/workflow-view.d.ts

@@ -0,0 +1,64 @@
+import { type WorkflowDeps } from '@parcha/agentrun-dsl';
+import type { ExtensionRunReport } from './extension-service.js';
+type Event = Parameters<NonNullable<WorkflowDeps['onEvent']>>[0];
+type JudgeRequest = Parameters<NonNullable<WorkflowDeps['runJudge']>>[0];
+export interface WorkflowViewNode {
+    path: string;
+    label: string;
+    kind: string;
+    status: string;
+    summary: string;
+    details: string[];
+}
+export interface WorkflowView {
+    title: string;
+    digest: string;
+    status: string;
+    summary: string[];
+    nodes: WorkflowViewNode[];
+    output?: string[];
+}
+export interface DecisionEvidence {
+    path: string;
+    label: string;
+    questions: string;
+    evidence: string;
+    answer?: string;
+    accepted?: boolean;
+}
+export interface RunObservation {
+    steps: Record<string, {
+        label: string;
+        kind: string;
+        status: string;
+    }>;
+    decisions: DecisionEvidence[];
+    notes: Record<string, string>;
+    omitted: number;
+    routes?: Record<string, string>;
+}
+/** Display limits never admit, cancel, or modify execution. */
+export declare function readable(value: unknown, max?: number): string;
+export declare class WorkflowObservation {
+    readonly data: RunObservation;
+    private decisionBytes;
+    record(event: Event): void;
+    private recordSafe;
+    /** Capture the exact supplied questions/state, not an explanation invented afterward. */
+    requested(request: JudgeRequest): DecisionEvidence | undefined;
+    observe(deps: WorkflowDeps): WorkflowDeps;
+}
+export declare function progressLines(observation: RunObservation, terminalStatus?: string): string[];
+export declare function workflowView(workflow: unknown, options?: {
+    input?: Record<string, unknown>;
+    observation?: RunObservation;
+    report?: ExtensionRunReport;
+    running?: boolean;
+    mode?: string;
+    model?: string;
+    limits?: Record<string, number | null>;
+    availableTools?: string[];
+    savedName?: string;
+}): WorkflowView;
+export declare function formatWorkflowView(view: WorkflowView): string;
+export {};

package/dist/workflow-view.js

@@ -0,0 +1,268 @@
+import { inspectWorkflow } from '@parcha/agentrun-dsl';
+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)) : [];
+    const nodes = inspection.nodes.map(node => {
+        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)] : []),
+            ...(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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcha/agentrun-pi",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.3",
   "description": "Pi extension for building, running and evaluating AgentRun workflows",
   "type": "module",
   "license": "Apache-2.0",
@@ -22,13 +22,12 @@
   },
   "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"
   },
@@ -36,8 +35,8 @@
     "@earendil-works/pi-ai": "0.87.0"
   },
   "dependencies": {
-    "@parcha/agentrun-dsl": "0.1.0-beta.1",
-    "@parcha/agentrun-jev": "0.1.0-beta.1",
+    "@parcha/agentrun-dsl": "0.1.0-beta.3",
+    "@parcha/agentrun-jev": "0.1.0-beta.3",
     "@earendil-works/pi-agent-core": "0.87.0",
     "@earendil-works/pi-coding-agent": "0.87.0",
     "@earendil-works/pi-tui": "0.87.0",
@@ -67,7 +66,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[];