pi-pstack-native 0.0.0-stage → 1.0.0

package/dist/program/coordinator.d.ts

@@ -0,0 +1,75 @@
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import type { WorkflowRunSpec } from '../runtime/types.js';
+import type { WorkflowEngine } from '../workflow/engine.js';
+export interface Unit {
+    key: string;
+    spec: WorkflowRunSpec;
+    workflowId?: string;
+    ordersRevision?: number;
+    ordersAcknowledgement?: {
+        revision: number;
+        actor: string;
+        reason: string;
+        at: string;
+    };
+    state: 'pending' | 'running' | 'needs-verify' | 'blocked' | 'failed' | 'ready-to-integrate' | 'reconciled';
+    ledgerRefs: string[];
+}
+export interface OrdersDrift {
+    key: string;
+    dispatchedRevision: number | null;
+    currentRevision: number;
+    message: string;
+}
+export interface Program {
+    id: string;
+    owner: string;
+    revision: number;
+    state: 'pilot' | 'scaling' | 'paused' | 'blocked' | 'completed';
+    maxConcurrency: number;
+    units: Unit[];
+    inbox: {
+        id: string;
+        key: string;
+        state: Unit['state'];
+        processed: boolean;
+    }[];
+    orders?: {
+        revision: number;
+        instructions: string[];
+        digest: string;
+    };
+    blockedReason?: {
+        code: 'ORDERS_STALE';
+        units: {
+            key: string;
+            dispatchedRevision: number | null;
+        }[];
+        currentRevision: number;
+        message: string;
+    };
+    completionPredicate: 'all-units-verified';
+    createdAt: string;
+}
+export declare function ordersDrift(program: Program, unit: Unit): OrdersDrift | undefined;
+export declare class ProgramCoordinator {
+    private workflows;
+    constructor(workflows: WorkflowEngine);
+    create(owner: string, specs: {
+        key: string;
+        spec: WorkflowRunSpec;
+    }[], maxConcurrency?: number): Program;
+    get(id: string, owner: string): Program;
+    private drift;
+    private assertOrdersDigest;
+    private blockOrders;
+    run(id: string, ctx: ExtensionContext): Promise<Program>;
+    drain(id: string, owner: string): Program;
+    close(id: string, owner: string): Program;
+    updateOrders(id: string, owner: string, instructions: string[], reason: string): Program;
+    acknowledgeOrders(id: string, owner: string, key: string, revision: number, reason: string): Program;
+    resume(id: string, owner: string): Program & {
+        staleUnits: OrdersDrift[];
+    };
+    pause(id: string, owner: string): Program;
+}

package/dist/program/coordinator.js

@@ -0,0 +1,169 @@
+import { protocol, transact, uid, hash } from "../runtime/protocol.js";
+import { buildDispatch, commitDispatch, materializeDispatch, requireDispatch } from "./dispatch.js";
+export function ordersDrift(program, unit) {
+    if (!program.orders || !unit.workflowId)
+        return undefined;
+    if (unit.ordersRevision === program.orders.revision || unit.ordersAcknowledgement?.revision === program.orders.revision)
+        return undefined;
+    const dispatchedRevision = unit.ordersRevision ?? null;
+    return { key: unit.key, dispatchedRevision, currentRevision: program.orders.revision, message: `STALE_ORDERS: unit ${unit.key} was dispatched under orders revision ${dispatchedRevision ?? 'none'}, current revision ${program.orders.revision}` };
+}
+export class ProgramCoordinator {
+    workflows;
+    constructor(workflows) { this.workflows = workflows; }
+    create(owner, specs, maxConcurrency = 4) {
+        if (!specs.length || new Set(specs.map(s => s.key)).size !== specs.length)
+            throw new Error('INVALID_UNITS');
+        if (specs.some(s => s.spec.nodes.some(n => !n.brief || n.brief.contractLevel !== 'strict')))
+            throw new Error('PROGRAM_REQUIRES_STRICT_BRIEFS');
+        const p = { id: uid('program'), owner, revision: 0, state: 'pilot', maxConcurrency: Math.max(1, Math.min(16, maxConcurrency)), units: specs.map(s => ({ ...s, state: 'pending', ledgerRefs: [] })), inbox: [], completionPredicate: 'all-units-verified', createdAt: new Date().toISOString() };
+        return transact('program-created', p.id, owner, s => { s.programs[p.id] = p; return p; });
+    }
+    get(id, owner) { const p = protocol().programs[id]; if (!p || p.owner !== owner)
+        throw new Error('PROGRAM_NOT_FOUND'); return p; }
+    drift(program) { return program.units.flatMap(unit => { const found = ordersDrift(program, unit); return found ? [found] : []; }); }
+    assertOrdersDigest(program) { if (program.orders && program.orders.digest !== hash(program.orders.instructions))
+        throw new Error('ORDERS_INTEGRITY_MISMATCH: stored standing orders do not match their digest'); }
+    blockOrders(id, owner, drift) {
+        return transact('program-orders-stale', id, owner, s => { const p = s.programs[id]; p.state = 'blocked'; p.blockedReason = { code: 'ORDERS_STALE', units: drift.map(d => ({ key: d.key, dispatchedRevision: d.dispatchedRevision })), currentRevision: drift[0].currentRevision, message: drift.map(d => d.message).join('; ') }; p.revision++; return p; });
+    }
+    async run(id, ctx) {
+        const owner = ctx.sessionManager.getSessionId();
+        const p = this.get(id, owner);
+        if (p.state === 'paused' || p.state === 'completed')
+            return p;
+        this.assertOrdersDigest(p);
+        const stale = this.drift(p);
+        if (stale.length)
+            return this.blockOrders(id, owner, stale);
+        const runUnit = async (key) => {
+            let unit = this.get(id, owner).units.find(u => u.key === key);
+            if (!unit.workflowId) {
+                const currentProgram = this.get(id, owner);
+                const orders = currentProgram.orders;
+                this.assertOrdersDigest(currentProgram);
+                const workflow = this.workflows.build({ ...unit.spec, nodes: unit.spec.nodes.map(n => ({ ...n, brief: n.brief && orders ? { ...n.brief, id: `${n.brief.id}.${currentProgram.id}.${unit.key}`, revision: 1, standingOrders: orders.instructions } : n.brief })), parentSessionId: owner, contractLevel: 'strict' });
+                const dispatch = buildDispatch({ programId: id, unitKey: key, owner, workflow, ordersRevision: orders?.revision });
+                transact('unit-dispatched', id, owner, s => {
+                    const u = s.programs[id].units.find((x) => x.key === key);
+                    if (u.workflowId && u.workflowId !== dispatch.workflowId)
+                        throw new Error('UNIT_ALREADY_DISPATCHED');
+                    u.workflowId = dispatch.workflowId;
+                    u.state = 'running';
+                    if (orders)
+                        u.ordersRevision = orders.revision;
+                    commitDispatch(s, dispatch);
+                    return { key, workflowId: dispatch.workflowId, dispatchId: dispatch.id };
+                });
+                unit = this.get(id, owner).units.find(u => u.key === key);
+            }
+            materializeDispatch(requireDispatch(unit.workflowId), (record) => this.workflows.materialize(record));
+            const wf = await this.workflows.run(unit.workflowId, ctx);
+            transact('unit-completion', id, owner, s => {
+                const program = s.programs[id];
+                const u = program.units.find(x => x.key === key);
+                u.ledgerRefs = Object.values(wf.calls).flatMap(c => c.verification?.ledgerId ?? []);
+                u.state = wf.state === 'failed' || wf.state === 'cancelled' ? 'failed' : this.workflows.acceptedWorkflow(wf) ? 'ready-to-integrate' : 'blocked';
+                program.inbox.push({ id: uid('inbox'), key, state: u.state, processed: false });
+                program.revision++;
+                return { key, state: u.state };
+            });
+        };
+        if (p.state === 'pilot') {
+            await runUnit(p.units[0].key);
+            const pilot = this.get(id, owner).units[0];
+            transact('pilot-settled', id, owner, s => { s.programs[id].state = pilot.state === 'ready-to-integrate' ? 'scaling' : 'blocked'; return { state: s.programs[id].state }; });
+            const stalled = this.drift(this.get(id, owner));
+            if (stalled.length)
+                return this.blockOrders(id, owner, stalled);
+            if (pilot.state !== 'ready-to-integrate')
+                return this.get(id, owner);
+        }
+        const active = new Map();
+        while (true) {
+            const current = this.get(id, owner);
+            if (current.state === 'paused') {
+                await Promise.all(active.values());
+                return this.get(id, owner);
+            }
+            const drift = this.drift(current);
+            if (drift.length) {
+                await Promise.all(active.values());
+                return this.blockOrders(id, owner, drift);
+            }
+            for (const unit of current.units) {
+                if (active.size >= current.maxConcurrency)
+                    break;
+                if (!['pending', 'running', 'blocked'].includes(unit.state) || active.has(unit.key))
+                    continue;
+                const promise = runUnit(unit.key).finally(() => active.delete(unit.key));
+                active.set(unit.key, promise);
+            }
+            if (!active.size)
+                break;
+            await Promise.race(active.values());
+            if (this.get(id, owner).units.some(u => u.state === 'blocked' || u.state === 'failed')) {
+                await Promise.all(active.values());
+                break;
+            }
+        }
+        const late = this.drift(this.get(id, owner));
+        return late.length ? this.blockOrders(id, owner, late) : this.drain(id, owner);
+    }
+    drain(id, owner) {
+        this.get(id, owner);
+        return transact('inbox-drained', id, owner, s => { const p = s.programs[id]; for (const e of p.inbox) {
+            if (e.processed)
+                continue;
+            e.processed = true;
+            const u = p.units.find(u => u.key === e.key);
+            if (u.state === 'ready-to-integrate')
+                u.state = 'reconciled';
+        } p.revision++; return p; });
+    }
+    close(id, owner) {
+        const p = this.get(id, owner);
+        const failures = p.units.filter(u => { const wf = u.workflowId ? this.workflows.get(u.workflowId) : undefined; return u.state !== 'reconciled' || !wf || !this.workflows.acceptedWorkflow(wf); });
+        if (failures.length)
+            throw new Error(`PROGRAM_CLOSE_BLOCKED: ${failures.map(u => u.key).join(',')}`);
+        return transact('program-closed', id, owner, s => { s.programs[id].state = 'completed'; return s.programs[id]; });
+    }
+    updateOrders(id, owner, instructions, reason) {
+        this.get(id, owner);
+        if (!reason.trim() || !instructions.length || instructions.some(x => typeof x !== 'string'))
+            throw new Error('INVALID_STANDING_ORDERS');
+        return transact('program-orders-revised', id, owner, s => { const p = s.programs[id]; p.orders = { revision: (p.orders?.revision ?? 0) + 1, instructions, digest: hash(instructions) }; p.revision++; return { ...p, reason }; });
+    }
+    acknowledgeOrders(id, owner, key, revision, reason) {
+        const p = this.get(id, owner);
+        if (!reason.trim())
+            throw new Error('INVALID_STANDING_ORDERS_ACKNOWLEDGEMENT');
+        this.assertOrdersDigest(p);
+        if (!p.orders)
+            throw new Error('NO_STANDING_ORDERS');
+        if (p.orders.revision !== revision)
+            throw new Error(`ORDERS_REVISION_MISMATCH: acknowledgement names revision ${revision}, current revision ${p.orders.revision}`);
+        const unit = p.units.find(u => u.key === key);
+        if (!unit)
+            throw new Error('UNKNOWN_UNIT');
+        if (!unit.workflowId)
+            throw new Error('UNIT_NOT_DISPATCHED');
+        return transact('unit-orders-acknowledged', id, owner, s => {
+            const current = s.programs[id];
+            if (current.orders?.revision !== revision)
+                throw new Error(`ORDERS_REVISION_MISMATCH: acknowledgement names revision ${revision}, current revision ${current.orders?.revision ?? 'none'}`);
+            this.assertOrdersDigest(current);
+            current.units.find(u => u.key === key).ordersAcknowledgement = { revision, actor: owner, reason, at: new Date().toISOString() };
+            current.revision++;
+            return current;
+        });
+    }
+    resume(id, owner) {
+        const p = this.get(id, owner);
+        if (!['paused', 'blocked'].includes(p.state))
+            throw new Error('PROGRAM_NOT_RESUMABLE');
+        const resumed = transact('program-resumed', id, owner, s => { const p = s.programs[id]; p.state = ['ready-to-integrate', 'reconciled'].includes(p.units[0].state) ? 'scaling' : 'pilot'; return p; });
+        return { ...resumed, staleUnits: this.drift(resumed) };
+    }
+    pause(id, owner) { this.get(id, owner); return transact('program-paused', id, owner, s => { s.programs[id].state = 'paused'; return s.programs[id]; }); }
+}

package/dist/program/dispatch.d.ts

@@ -0,0 +1,20 @@
+import type { DispatchRecord, WorkflowRecord } from '../runtime/types.js';
+type DispatchStore = {
+    dispatches: Record<string, DispatchRecord>;
+};
+export declare function briefDigest(workflow: WorkflowRecord): string;
+export declare function dispatchKey(programId: string, unitKey: string): string;
+export declare function buildDispatch(input: {
+    programId: string;
+    unitKey: string;
+    owner: string;
+    workflow: WorkflowRecord;
+    ordersRevision?: number;
+}): DispatchRecord;
+export declare function commitDispatch(store: DispatchStore, dispatch: DispatchRecord): DispatchRecord;
+export declare function findDispatch(workflowId: string): DispatchRecord | undefined;
+export declare function requireDispatch(workflowId: string): DispatchRecord;
+/** Committed intent is the truth. The workflow file is rebuilt from it, never edited into agreement. */
+export declare function materializeDispatch(dispatch: DispatchRecord, write: (record: WorkflowRecord) => void): DispatchRecord;
+export declare function dispatchVeto(workflowId: string, file: WorkflowRecord | undefined): string | undefined;
+export {};

package/dist/program/dispatch.js

@@ -0,0 +1,82 @@
+import { hash, protocol, transact } from "../runtime/protocol.js";
+import { workflowPath } from "../runtime/home.js";
+import { readJson } from "../runtime/store.js";
+export function briefDigest(workflow) {
+    return hash(Object.keys(workflow.calls).sort().map((key) => [key, workflow.calls[key].brief ? hash(workflow.calls[key].brief) : null]));
+}
+export function dispatchKey(programId, unitKey) {
+    return `dsp_${hash({ programId, unitKey }).slice(0, 24)}`;
+}
+export function buildDispatch(input) {
+    return {
+        id: dispatchKey(input.programId, input.unitKey),
+        owner: input.owner,
+        programId: input.programId,
+        unitKey: input.unitKey,
+        workflowId: input.workflow.id,
+        briefDigest: briefDigest(input.workflow),
+        ...(input.ordersRevision === undefined ? {} : { ordersRevision: input.ordersRevision }),
+        state: 'committed',
+        workflow: input.workflow,
+        createdAt: new Date().toISOString(),
+    };
+}
+function sameIntent(a, b) {
+    return a.programId === b.programId && a.unitKey === b.unitKey && a.owner === b.owner && a.workflowId === b.workflowId &&
+        a.briefDigest === b.briefDigest && a.ordersRevision === b.ordersRevision && hash(a.workflow) === hash(b.workflow);
+}
+export function commitDispatch(store, dispatch) {
+    const existing = store.dispatches[dispatch.id];
+    if (!existing) {
+        store.dispatches[dispatch.id] = dispatch;
+        return dispatch;
+    }
+    if (!sameIntent(existing, dispatch))
+        throw new Error(`DISPATCH_CONFLICT: ${dispatch.id} was already committed with a different description`);
+    return existing;
+}
+export function findDispatch(workflowId) {
+    return Object.values(protocol().dispatches).find((dispatch) => dispatch.workflowId === workflowId);
+}
+export function requireDispatch(workflowId) {
+    const dispatch = findDispatch(workflowId);
+    if (!dispatch)
+        throw new Error(`ORPHAN_WORKFLOW: ${workflowId} has no committed dispatch record`);
+    return dispatch;
+}
+/** Committed intent is the truth. The workflow file is rebuilt from it, never edited into agreement. */
+export function materializeDispatch(dispatch, write) {
+    const existing = readJson(workflowPath(dispatch.workflowId), undefined);
+    if (!existing)
+        write(dispatch.workflow);
+    else if (hash(existing) !== hash(dispatch.workflow))
+        throw new Error(`DISPATCH_MATERIALIZE_CONFLICT: ${dispatch.workflowId} on disk differs from the committed dispatch`);
+    if (dispatch.state === 'materialized')
+        return dispatch;
+    return transact('dispatch-materialized', dispatch.id, dispatch.owner, (state) => {
+        const current = state.dispatches[dispatch.id];
+        if (!current || current.state === 'materialized')
+            return current ?? dispatch;
+        current.state = 'materialized';
+        current.materializedAt = new Date().toISOString();
+        return current;
+    });
+}
+export function dispatchVeto(workflowId, file) {
+    const state = protocol();
+    const units = Object.values(state.programs)
+        .flatMap((program) => (program.units ?? []).map((unit) => ({ program, unit })));
+    const references = units.find(({ unit }) => unit.workflowId === workflowId);
+    const dispatch = Object.values(state.dispatches).find((candidate) => candidate.workflowId === workflowId);
+    if (!references && !dispatch)
+        return undefined;
+    if (!references || !dispatch)
+        return 'ORPHAN_WORKFLOW';
+    if (dispatch.programId !== references.program.id || dispatch.unitKey !== references.unit.key)
+        return 'DISPATCH_MISMATCH';
+    if (!file)
+        return 'DISPATCH_NOT_MATERIALIZED';
+    if (briefDigest(file) !== dispatch.briefDigest)
+        return 'DISPATCH_DRIFT';
+    return undefined;
+}

package/dist/runner/cli.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { auditWorktree } from '../worktree/manager.js';
+import { prepareStack, openStack } from '../delivery/stack.js';
+import { preparePR, openPreparedPR } from '../delivery/prepare.js';
+// Node >=22.19 executes the shipped TypeScript sources natively.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { runService } from './service.js';
+import { migrate } from '../runtime/migrate.js';
+import { protocol, hash, transact } from '../runtime/protocol.js';
+import { fingerprint } from '../artifacts/fingerprint.js';
+import { authorizeMerge, ship, refresh } from '../delivery/frontier.js';
+import { GitHubCLI } from '../delivery/provider.js';
+const [action,...args]=process.argv.slice(2);
+try {
+  if(action==='migrate')console.log(JSON.stringify(migrate(!args.includes('--apply')),null,2));
+  else if(action==='run') {
+    if(!args[0])throw new Error('run requires runner configuration JSON');
+    const controller=new AbortController();process.on('SIGTERM',()=>controller.abort());process.on('SIGINT',()=>controller.abort());
+    await runService(args[0],args.includes('--once'),controller.signal);
+  } else if(action==='approve-gate') {
+    const [cwd,briefPath,gateId]=args;const brief=JSON.parse(readFileSync(briefPath,'utf8'));const gate=brief.verification.find(g=>g.id===gateId);
+    if(gate?.kind!=='human-approval' || !args.includes('--approve'))throw new Error('Requires human-approval gate and explicit --approve');
+    const fp=fingerprint(cwd,args.includes('--committed')?'committed':'working');
+    transact('human-gate-approved',gateId,'human-cli',s=>{s.approvals[hash({fingerprint:fp,gate:hash(gate)})]={actor:'human-cli',at:new Date().toISOString(),briefId:brief.id};return {gateId};});
+    console.log('Human approval recorded for this exact fingerprint.');
+  } else if(action==='worktree-audit') {
+    const info=JSON.parse(readFileSync(args[0],'utf8'));console.log(JSON.stringify(await auditWorktree(info,args[1] ?? info.baseRef),null,2));
+  } else if(action==='stack-plan') {
+    const input=JSON.parse(readFileSync(args[0],'utf8'));const plan=await prepareStack(input,new GitHubCLI());
+    if(args[1])writeFileSync(args[1],JSON.stringify(plan,null,2)+'\n',{mode:0o600});
+    console.log(JSON.stringify(plan,null,2));
+  } else if(action==='stack-open') {
+    const plan=JSON.parse(readFileSync(args[0],'utf8'));console.log(JSON.stringify(await openStack(plan,new GitHubCLI(),args.includes('--approve')),null,2));
+  } else if(action==='ship') {
+    const spec=JSON.parse(readFileSync(args[0],'utf8'));const provider=new GitHubCLI();
+    if(!args.includes('--approve'))console.log(JSON.stringify(await ship(spec,provider),null,2));
+    else {
+      const n=Number(args[args.indexOf('--pr')+1]);const f=await refresh(spec,provider);const token=authorizeMerge(f,n,'human-cli');
+      console.log(JSON.stringify(await ship(spec,provider,{token,dryRun:false}),null,2));
+    }
+  } else if(action==='open-pr') {
+    const [cwd,ledgerId,detailsPath]=args;const details=JSON.parse(readFileSync(detailsPath,'utf8'));
+    const plan=preparePR(cwd,ledgerId,details);console.log(JSON.stringify(await openPreparedPR(cwd,plan,new GitHubCLI(),args.includes('--approve')),null,2));
+  } else if(action==='export') {writeFileSync(args[0],JSON.stringify(protocol(),null,2));console.log('Audit exported.');}
+  else throw new Error('Usage: pstack-runner run CONFIG [--once] | migrate [--apply] | approve-gate CWD BRIEF GATE --approve [--committed] | worktree-audit INFO [BASE] | stack-plan INPUT [OUTPUT] | stack-open PLAN [--approve] | ship STACK [--approve --pr NUMBER] | export FILE');
+} catch(error) {console.error(String(error));process.exitCode=1;}

package/dist/runner/lease.d.ts

@@ -0,0 +1,10 @@
+export interface Lease {
+    subject: string;
+    owner: string;
+    token: number;
+    expiresAt: number;
+}
+export declare function claimLease(subject: string, owner: string, ttlMs?: number): Lease;
+export declare function renewLease(lease: Lease, ttlMs?: number): Lease;
+export declare function assertLease(lease: Lease): void;
+export declare function releaseLease(lease: Lease): void;

package/dist/runner/lease.js

@@ -0,0 +1,24 @@
+import { protocol, transact } from "../runtime/protocol.js";
+export function claimLease(subject, owner, ttlMs = 30000) {
+    return transact('lease-claimed', subject, owner, s => {
+        const prior = s.leases[subject];
+        if (prior && prior.expiresAt > Date.now() && prior.owner !== owner)
+            throw new Error('LEASE_BUSY');
+        const lease = { subject, owner, token: (prior?.token ?? 0) + 1, expiresAt: Date.now() + ttlMs };
+        s.leases[subject] = lease;
+        return lease;
+    });
+}
+export function renewLease(lease, ttlMs = 30000) {
+    return transact('lease-renewed', lease.subject, lease.owner, s => {
+        const prior = s.leases[lease.subject];
+        if (!prior || prior.owner !== lease.owner || prior.token !== lease.token || prior.expiresAt <= Date.now())
+            throw new Error('LEASE_LOST');
+        prior.expiresAt = Date.now() + ttlMs;
+        return prior;
+    });
+}
+export function assertLease(lease) { const current = protocol().leases[lease.subject]; if (!current || current.owner !== lease.owner || current.token !== lease.token || current.expiresAt <= Date.now())
+    throw new Error('LEASE_LOST'); }
+export function releaseLease(lease) { transact('lease-released', lease.subject, lease.owner, s => { const current = s.leases[lease.subject]; if (current?.token === lease.token && current.owner === lease.owner)
+    current.expiresAt = 0; return { token: lease.token }; }); }

package/dist/runner/service.d.ts

@@ -0,0 +1,8 @@
+export interface RunnerConfig {
+    agentDir: string;
+    model: string;
+    workflowIds: string[];
+    pollMs?: number;
+}
+export declare function runnerOnce(config: RunnerConfig): Promise<unknown[]>;
+export declare function runService(configPath: string, once?: boolean, signal?: AbortSignal): Promise<void>;

package/dist/runner/service.js

@@ -0,0 +1,66 @@
+import { readFileSync } from 'node:fs';
+import { join, isAbsolute } from 'node:path';
+import { AgentHost } from "../agent/host.js";
+import { WorkflowEngine } from "../workflow/engine.js";
+import { uid, transact } from "../runtime/protocol.js";
+import { claimLease, renewLease, releaseLease, assertLease } from "./lease.js";
+export async function runnerOnce(config) {
+    if (!isAbsolute(config.agentDir) || !config.model?.includes('/') || !Array.isArray(config.workflowIds))
+        throw new Error('RUNNER_REQUIRES_EXPLICIT_AGENT_DIR_MODEL_WORKFLOWS');
+    const { ModelRuntime, ModelRegistry } = await import('@earendil-works/pi-coding-agent');
+    const runtime = await ModelRuntime.create({ authPath: join(config.agentDir, 'auth.json'), modelsPath: join(config.agentDir, 'models.json'), allowModelNetwork: false });
+    const slash = config.model.indexOf('/');
+    const provider = config.model.slice(0, slash);
+    const model = runtime.getModel(provider, config.model.slice(slash + 1));
+    if (!model || !runtime.hasConfiguredAuth(provider)) {
+        transact('runner-blocked', 'runner', 'standalone', () => ({ reason: 'AUTHENTICATION_UNAVAILABLE', workflowIds: config.workflowIds }));
+        return [{ status: 'blocked', reason: 'AUTHENTICATION_UNAVAILABLE' }];
+    }
+    const host = new AgentHost({ agentDir: config.agentDir, modelRuntime: runtime });
+    const engine = new WorkflowEngine(host);
+    const output = [];
+    for (const id of config.workflowIds) {
+        const wf = engine.get(id);
+        if (!wf || ['completed', 'failed', 'cancelled', 'paused'].includes(wf.state))
+            continue;
+        const owner = uid('runner');
+        const lease = claimLease(id, owner);
+        let lost = false;
+        const timer = setInterval(() => { try {
+            renewLease(lease);
+        }
+        catch {
+            lost = true;
+            void engine.pause(id);
+            for (const a of host.list().filter(a => a.workflowId === id && a.state === 'running'))
+                void host.stop(a.id);
+        } }, 5000);
+        try {
+            assertLease(lease);
+            const ctx = { cwd: wf.parentCwd, model, thinkingLevel: 'medium', scopedModels: [], modelRegistry: new ModelRegistry(runtime), sessionManager: { getSessionId: () => wf.parentSessionId ?? `runner-${id}`, getSessionFile: () => undefined } };
+            output.push(await engine.run(id, ctx));
+            assertLease(lease);
+            if (lost)
+                throw new Error('LEASE_LOST');
+        }
+        finally {
+            clearInterval(timer);
+            releaseLease(lease);
+        }
+    }
+    return output;
+}
+export async function runService(configPath, once = false, signal) {
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    do {
+        try {
+            await runnerOnce(config);
+        }
+        catch (error) {
+            transact('runner-error', 'runner', 'standalone', () => ({ reason: String(error) }));
+        }
+        if (once || signal?.aborted)
+            return;
+        await new Promise(resolve => { const done = () => { clearTimeout(timer); signal?.removeEventListener('abort', done); resolve(); }; const timer = setTimeout(done, Math.max(1000, Math.min(config.pollMs ?? 5000, 30000))); signal?.addEventListener('abort', done, { once: true }); });
+    } while (!signal?.aborted);
+}

package/dist/runtime/checkout.d.ts

@@ -0,0 +1,3 @@
+/** Canonicalize aliases (symlinks, subdirectories) to their individual checkout, not the shared Git common dir. */
+export declare function checkoutIdentity(cwd: string): string;
+export declare function writerLockKey(cwd: string): string;

package/dist/runtime/checkout.js

@@ -0,0 +1,20 @@
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+/** Canonicalize aliases (symlinks, subdirectories) to their individual checkout, not the shared Git common dir. */
+export function checkoutIdentity(cwd) {
+    const canonical = realpathSync(resolve(cwd));
+    try {
+        const root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            cwd: canonical, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return realpathSync(root);
+    }
+    catch {
+        return canonical;
+    }
+}
+export function writerLockKey(cwd) {
+    return createHash("sha256").update(checkoutIdentity(cwd)).digest("hex").slice(0, 20);
+}

package/dist/runtime/config.d.ts

@@ -0,0 +1,7 @@
+import type { ModelConfig, RuntimeConfig } from "./types.js";
+export declare const DEFAULT_CONFIG: RuntimeConfig;
+export declare const DEFAULT_MODELS: ModelConfig;
+export declare function loadConfig(): RuntimeConfig;
+export declare function saveConfig(config: RuntimeConfig): void;
+export declare function loadModels(): ModelConfig;
+export declare function saveModels(config: ModelConfig): void;

package/dist/runtime/config.js

@@ -0,0 +1,46 @@
+import { configPath, modelConfigPath } from "./home.js";
+import { readJson, writeJsonAtomic } from "./store.js";
+export const DEFAULT_CONFIG = {
+    version: 1,
+    skillsEnabled: true,
+    defaultConcurrency: 4,
+    loopMissedPolicy: "run-once",
+};
+export const DEFAULT_MODELS = {
+    version: 1,
+    thinkingLevel: "inherit-parent",
+    fallbackPolicy: "same-family",
+    roles: {
+        worker: "inherit-parent",
+        reviewer: "inherit-parent",
+        scout: "inherit-parent",
+        architect: "inherit-parent",
+        verifier: "inherit-parent",
+        synthesizer: "inherit-parent",
+        integrator: "inherit-parent",
+        "poteto-agent": "inherit-parent",
+        "comment-sicko": "inherit-parent",
+    },
+};
+export function loadConfig() {
+    const raw = readJson(configPath(), DEFAULT_CONFIG);
+    return {
+        ...DEFAULT_CONFIG,
+        ...raw,
+        version: 1,
+        defaultConcurrency: Math.max(1, Math.min(16, Number(raw.defaultConcurrency) || DEFAULT_CONFIG.defaultConcurrency)),
+    };
+}
+export function saveConfig(config) { writeJsonAtomic(configPath(), config); }
+export function loadModels() {
+    const raw = readJson(modelConfigPath(), DEFAULT_MODELS);
+    const level = raw.thinkingLevel === undefined ? DEFAULT_MODELS.thinkingLevel : raw.thinkingLevel;
+    if (typeof level !== "string" || !["inherit-parent", "off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(level)) {
+        throw new Error(`Invalid thinkingLevel in ${modelConfigPath()}; edit it to inherit-parent, off, minimal, low, medium, high, xhigh, or max.`);
+    }
+    const fallbackPolicy = raw.fallbackPolicy ?? "disabled";
+    if (fallbackPolicy !== "disabled" && fallbackPolicy !== "same-family")
+        throw new Error(`Invalid fallbackPolicy in ${modelConfigPath()}; use disabled or same-family.`);
+    return { panels: raw.panels, workflows: raw.workflows, version: 1, roles: { ...DEFAULT_MODELS.roles, ...(raw.roles ?? {}) }, thinkingLevel: level, fallbackPolicy };
+}
+export function saveModels(config) { writeJsonAtomic(modelConfigPath(), config); }

package/dist/runtime/errors.d.ts

@@ -0,0 +1,2 @@
+import type { DurableError } from "./types.js";
+export declare function durableError(code: string, error: unknown, retryable?: boolean): DurableError;

package/dist/runtime/errors.js

@@ -0,0 +1,10 @@
+export function durableError(code, error, retryable = false) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        code,
+        message,
+        retryable,
+        ...(error instanceof Error && error.cause ? { cause: String(error.cause) } : {}),
+        occurredAt: new Date().toISOString(),
+    };
+}

package/dist/runtime/home.d.ts

@@ -0,0 +1,11 @@
+export declare function pstackHome(): string;
+export declare const homePath: (...parts: string[]) => string;
+export declare const workflowPath: (id: string) => string;
+export declare const agentPath: (id: string) => string;
+export declare const journalPath: (id: string) => string;
+export declare const lockPath: (name: string) => string;
+export declare const worktreeRoot: () => string;
+export declare const childSessionRoot: () => string;
+export declare const configPath: () => string;
+export declare const modelConfigPath: () => string;
+export declare const loopsPath: () => string;

package/dist/runtime/home.js

@@ -0,0 +1,15 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function pstackHome() {
+    return process.env.PSTACK_NATIVE_HOME || join(homedir(), ".pi", "agent", "pstack-native");
+}
+export const homePath = (...parts) => join(pstackHome(), ...parts);
+export const workflowPath = (id) => homePath("workflows", `${id}.json`);
+export const agentPath = (id) => homePath("agents", `${id}.json`);
+export const journalPath = (id) => homePath("journals", `${id}.jsonl`);
+export const lockPath = (name) => homePath("locks", `${name}.lock`);
+export const worktreeRoot = () => homePath("worktrees");
+export const childSessionRoot = () => homePath("sessions");
+export const configPath = () => homePath("config.json");
+export const modelConfigPath = () => homePath("models.json");
+export const loopsPath = () => homePath("loops", "loops.json");

package/dist/runtime/lock.d.ts

@@ -0,0 +1,12 @@
+export declare class FileLock {
+    private fd;
+    private owner;
+    private heldIdentity;
+    readonly path: string;
+    readonly staleMs: number;
+    constructor(path: string, staleMs?: number);
+    acquire(): boolean;
+    release(): void;
+    private clearStale;
+}
+export declare function withFileLock<T>(path: string, fn: () => Promise<T> | T): Promise<T>;