harnery 0.10.0 → 0.12.0

package/dist/core/workflow/engine.js

@@ -28,29 +28,52 @@ import { createHash, randomBytes } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { snapshotRepo } from "../context/index.js";
+import { evaluatePolicy, normalizePolicy, PolicyDeniedError, policyDigest, summarizePolicyRequest, } from "../policy/index.js";
 import { probeBilling } from "./billing.js";
+import { buildWorkflowProof, createEvidenceRecord, digestResult, normalizeWorkflowMeta, writeWorkflowProof, } from "./proof.js";
+import { WORKFLOW_PROOF_SCHEMA_VERSION } from "./types.js";
 import { parseStageOutput, validateAgainstSchema } from "./validate.js";
 const DEFAULT_MAX_AGENTS = 50;
 const DEFAULT_CONCURRENCY = 4;
 const DEFAULT_MAX_ATTEMPTS = 2;
 const DEFAULT_TIMEOUT_MS = 300_000;
 const DEFAULT_MAX_TURNS = 25;
+const DEFAULT_POLICY_ASK_TIMEOUT_MS = 60_000;
+const MAX_POLICY_DECISIONS = 50;
+export class WorkflowRunError extends Error {
+    runId;
+    proofPath;
+    constructor(message, runId, proofPath, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = "WorkflowRunError";
+        this.runId = runId;
+        this.proofPath = proofPath;
+    }
+}
 export async function runWorkflow(scriptPath, opts) {
     const absScript = isAbsolute(scriptPath) ? scriptPath : resolve(process.cwd(), scriptPath);
     const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(absScript).href)));
     if (typeof mod.default !== "function") {
         throw new Error(`${scriptPath}: workflow script must \`export default async (ctx) => …\``);
     }
-    const name = mod.meta?.name ?? scriptPath.replace(/^.*\//, "").replace(/\.[cm]?js$/, "");
+    const fallbackName = scriptPath.replace(/^.*\//, "").replace(/\.[cm]?js$/, "");
+    const meta = normalizeWorkflowMeta(mod.meta, fallbackName);
+    const name = meta.name;
     const runId = `wf-${new Date().toISOString().replace(/[:.]/g, "-")}-${randomBytes(3).toString("hex")}`;
     const runDir = join(opts.coordRoot, ".harnery", "workflows", runId);
     mkdirSync(runDir, { recursive: true });
     const journalPath = join(runDir, "journal.jsonl");
+    const proofPath = join(runDir, "proof.json");
     const maxAgents = opts.maxAgents ?? DEFAULT_MAX_AGENTS;
     const concurrency = opts.concurrency ?? DEFAULT_CONCURRENCY;
     const cwd = opts.cwd ?? opts.coordRoot;
     const log = opts.onLog ?? ((line) => process.stderr.write(`${line}\n`));
     const defaultHarness = opts.defaultHarness ?? "claude-code";
+    const isolation = opts.isolation ?? "shared";
+    const networkAccess = opts.networkAccess ?? "unknown";
+    const policy = opts.policy ? normalizePolicy(opts.policy, { baseDir: cwd }) : undefined;
+    const repoBefore = snapshotRepo(cwd);
     // Per-child fixed context overhead: children spawn in `cwd` and load its
     // repo-instructions file into their system prompt, cache-writing it once
     // per child. A fan-out multiplies this, so surface it BEFORE the burn.
@@ -66,11 +89,20 @@ export async function runWorkflow(scriptPath, opts) {
     let agentsSpawned = 0;
     let agentsCached = 0;
     let costUsd = 0;
+    let reservedCostUsd = 0;
     let currentStage = "";
     let agentSeq = 0;
+    let evidenceSeq = 0;
+    let policySeq = 0;
     const billingProbed = new Map();
+    const agentProofs = new Map();
+    const evidenceRecords = [];
+    const policyDecisions = [];
+    const acceptanceIds = new Set(meta.acceptance.map((criterion) => criterion.id));
     const journal = (event, data) => {
         const line = JSON.stringify({
+            schema_version: WORKFLOW_PROOF_SCHEMA_VERSION,
+            run_id: runId,
             ts: new Date().toISOString(),
             event,
             stage: currentStage,
@@ -95,7 +127,90 @@ export async function runWorkflow(scriptPath, opts) {
         inFlight--;
         waiters.shift()?.();
     };
+    // Policy checks that affect the shared cost reservation ledger serialize.
+    // Spawns still run concurrently after authorization; only the last-moment
+    // check-and-reserve section is exclusive.
+    let policyGate = Promise.resolve();
+    const withDispatchPolicyGate = async (work) => {
+        const previous = policyGate;
+        let open;
+        policyGate = new Promise((resolveGate) => {
+            open = resolveGate;
+        });
+        await previous;
+        try {
+            return await work();
+        }
+        finally {
+            open();
+        }
+    };
+    const authorizePolicyRequest = async (rawRequest) => {
+        if (!policy) {
+            throw new Error("external mutation authorization requires a host policy");
+        }
+        if (policyDecisions.length >= MAX_POLICY_DECISIONS) {
+            throw new Error(`workflow policy decision cap reached (${MAX_POLICY_DECISIONS}); split the workflow or reduce protected actions`);
+        }
+        const request = summarizePolicyRequest(rawRequest);
+        const evaluation = evaluatePolicy(policy, request);
+        const id = `p${++policySeq}`;
+        const checkedAt = new Date().toISOString();
+        journal("policy.check", {
+            id,
+            policy: policy.name,
+            policy_sha256: policyDigest(policy),
+            request,
+            verdict: evaluation.verdict,
+            rules: evaluation.rules,
+        });
+        let verdict = evaluation.verdict === "allow" ? "allow" : "deny";
+        let resolvedBy = "policy";
+        let reason = evaluation.reason;
+        if (evaluation.verdict === "ask") {
+            resolvedBy = "fail_closed";
+            if (!opts.resolvePolicyAsk) {
+                reason = `${evaluation.reason}; no host approval resolver is configured`;
+            }
+            else {
+                try {
+                    const resolution = await withTimeout(Promise.resolve(opts.resolvePolicyAsk(request, evaluation)), opts.policyAskTimeoutMs ?? DEFAULT_POLICY_ASK_TIMEOUT_MS);
+                    if (!resolution || (resolution.verdict !== "allow" && resolution.verdict !== "deny")) {
+                        reason = `${evaluation.reason}; host returned an invalid approval resolution`;
+                    }
+                    else {
+                        verdict = resolution.verdict;
+                        resolvedBy = "host";
+                        reason = boundedPolicyReason(resolution.reason ?? evaluation.reason);
+                    }
+                }
+                catch (error) {
+                    reason = `${evaluation.reason}; approval failed closed: ${error.message}`;
+                }
+            }
+        }
+        const decision = {
+            id,
+            checked_at: checkedAt,
+            policy: policy.name,
+            phase: request.phase,
+            initial_verdict: evaluation.verdict,
+            verdict,
+            resolved_by: resolvedBy,
+            reason: boundedPolicyReason(reason),
+            rule_codes: evaluation.rules.map((rule) => rule.code),
+            request,
+        };
+        policyDecisions.push(decision);
+        journal("policy.resolve", { ...decision });
+        if (decision.verdict === "deny") {
+            throw new PolicyDeniedError(`policy ${JSON.stringify(policy.name)} denied ${request.phase} ${JSON.stringify(request.action)}: ${decision.reason}`, decision.id);
+        }
+        return decision;
+    };
     const agent = async (prompt, agentOpts = {}) => {
+        let reservedForDispatch = 0;
+        let spawnCountClaimed = false;
         const harness = agentOpts.harness ?? defaultHarness;
         const spawner = opts.spawners[harness];
         if (!spawner) {
@@ -103,60 +218,157 @@ export async function runWorkflow(scriptPath, opts) {
         }
         const id = `a${++agentSeq}`;
         const label = agentOpts.label ?? `${prompt.slice(0, 60).replace(/\s+/g, " ")}…`;
+        const proofLabel = agentOpts.label ?? id;
         const maxAttempts = agentOpts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+        const agentProof = {
+            id,
+            label: proofLabel,
+            stage: currentStage || undefined,
+            harness,
+            model: agentOpts.model,
+            status: "failed",
+            attempts: 0,
+            duration_ms: 0,
+        };
+        agentProofs.set(id, agentProof);
         // Call identity for resume: same stage + harness + model + effort + turns + schema
         // + ORIGINAL prompt → same key. Retry-mutated prompts never enter the key.
         const key = agentCallKey(currentStage, harness, agentOpts, prompt);
         const cached = resumeCache.get(key);
         if (cached) {
             agentsCached++;
-            journal("agent.cached", { id, label, key, kind: cached.kind });
+            agentProof.status = "cached";
+            agentProof.result = digestResult(cached.value, cached.kind);
+            journal("agent.cached", {
+                id,
+                label,
+                key,
+                harness,
+                model: agentOpts.model ?? null,
+                kind: cached.kind,
+            });
             log(`[${name}] ${currentStage || "(no stage)"} → ${id} ${label} (cached from ${opts.resumeFrom})`);
             return cached.value;
         }
-        // Billing safeguard: on a harness's FIRST spawn this run, classify which
-        // auth its children will use and refuse the silent-override state (an
-        // exported API key shadowing a stored subscription login) unless the
-        // caller explicitly opted into API billing. Cached agents never reach
-        // this — no spawn, no billing.
-        if (!billingProbed.has(harness)) {
-            const probe = (opts.probeBilling ?? probeBilling)(harness);
-            billingProbed.set(harness, probe);
-            journal("billing.probe", {
+        if (policy) {
+            const estimateRequest = summarizePolicyRequest({
+                phase: "dispatch",
+                action: "spawn agent",
+                path: cwd,
                 harness,
-                mode: opts.subscriptionOnly ? "subscription" : probe.mode,
-                api_key_source: probe.apiKeySource,
-                login: probe.login,
-                subscription_only: Boolean(opts.subscriptionOnly),
+                model: agentOpts.model,
+                effort: agentOpts.effort,
+                max_attempts: maxAttempts,
+                max_turns: agentOpts.maxTurns ?? DEFAULT_MAX_TURNS,
+                timeout_ms: agentOpts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+                prompt_bytes: Buffer.byteLength(prompt),
+                isolation,
+                network_access: networkAccess,
+                current_cost_usd: round4(costUsd + reservedCostUsd),
+                projected_cost_usd: null,
             });
-            if (opts.subscriptionOnly) {
-                if (probe.login === "absent") {
-                    throw new Error(`subscription-only: no stored login detected for ${harness}; ` +
-                        `log the harness CLI in (or drop --subscription-only for a key-only host)`);
+            let projectedCost = null;
+            if (policy.max_cost_usd !== undefined && opts.estimateDispatchCost) {
+                try {
+                    const candidate = await opts.estimateDispatchCost(estimateRequest);
+                    if (candidate !== null && (!Number.isFinite(candidate) || candidate < 0)) {
+                        throw new Error("cost estimator returned a non-finite or negative value");
+                    }
+                    projectedCost = candidate;
+                }
+                catch (error) {
+                    journal("policy.cost_estimate_failed", {
+                        harness,
+                        model: agentOpts.model ?? null,
+                        error: boundedPolicyReason(error.message),
+                    });
                 }
-                log(`[billing] ${harness}: subscription-only (API-key vars scrubbed from child env)`);
             }
-            else if (probe.mode === "api-key-override" && !opts.allowApiBilling) {
-                throw new Error(`${probe.apiKeySource} is set AND a stored ${harness} login exists — the key silently ` +
-                    `overrides your subscription auth, so children would bill per-token API rates. ` +
-                    `Either unset ${probe.apiKeySource}, run with --subscription-only to scrub it from ` +
-                    `child envs, or pass --allow-api-billing if API billing is intended`);
+            try {
+                await withDispatchPolicyGate(async () => {
+                    assertAgentCapacity(agentsSpawned, maxAgents);
+                    const dispatchRequest = {
+                        ...estimateRequest,
+                        current_cost_usd: round4(costUsd + reservedCostUsd),
+                        projected_cost_usd: projectedCost,
+                    };
+                    await authorizePolicyRequest(dispatchRequest);
+                    if (policy.max_cost_usd !== undefined) {
+                        reservedForDispatch =
+                            projectedCost ?? Math.max(0, policy.max_cost_usd - dispatchRequest.current_cost_usd);
+                        reservedCostUsd += reservedForDispatch;
+                    }
+                    agentsSpawned++;
+                    spawnCountClaimed = true;
+                });
             }
-            else if (probe.mode === "api-key") {
-                log(`[billing] ${harness}: API-key billing (${probe.apiKeySource}; no stored login detected) — ` +
-                    `children bill per-token rates`);
+            catch (error) {
+                agentProof.error = error.message;
+                throw error;
+            }
+        }
+        else {
+            try {
+                assertAgentCapacity(agentsSpawned, maxAgents);
             }
-            else if (probe.mode === "api-key-override") {
-                log(`[billing] ${harness}: API-key billing (--allow-api-billing; key overrides stored login)`);
+            catch (error) {
+                agentProof.error = error.message;
+                throw error;
             }
-            else {
-                log(`[billing] ${harness}: subscription login`);
+        }
+        // Billing safeguard: on a harness's FIRST spawn this run, classify which
+        // auth its children will use and refuse the silent-override state (an
+        // exported API key shadowing a stored subscription login) unless the
+        // caller explicitly opted into API billing. Cached agents never reach
+        // this — no spawn, no billing.
+        try {
+            if (!billingProbed.has(harness)) {
+                const probe = (opts.probeBilling ?? probeBilling)(harness);
+                billingProbed.set(harness, probe);
+                journal("billing.probe", {
+                    harness,
+                    mode: opts.subscriptionOnly ? "subscription" : probe.mode,
+                    api_key_source: probe.apiKeySource,
+                    login: probe.login,
+                    subscription_only: Boolean(opts.subscriptionOnly),
+                });
+                if (opts.subscriptionOnly) {
+                    if (probe.login === "absent") {
+                        throw new Error(`subscription-only: no stored login detected for ${harness}; ` +
+                            `log the harness CLI in (or drop --subscription-only for a key-only host)`);
+                    }
+                    log(`[billing] ${harness}: subscription-only (API-key vars scrubbed from child env)`);
+                }
+                else if (probe.mode === "api-key-override" && !opts.allowApiBilling) {
+                    throw new Error(`${probe.apiKeySource} is set AND a stored ${harness} login exists — the key silently ` +
+                        `overrides your subscription auth, so children would bill per-token API rates. ` +
+                        `Either unset ${probe.apiKeySource}, run with --subscription-only to scrub it from ` +
+                        `child envs, or pass --allow-api-billing if API billing is intended`);
+                }
+                else if (probe.mode === "api-key") {
+                    log(`[billing] ${harness}: API-key billing (${probe.apiKeySource}; no stored login detected) — ` +
+                        `children bill per-token rates`);
+                }
+                else if (probe.mode === "api-key-override") {
+                    log(`[billing] ${harness}: API-key billing (--allow-api-billing; key overrides stored login)`);
+                }
+                else {
+                    log(`[billing] ${harness}: subscription login`);
+                }
             }
         }
-        if (agentsSpawned >= maxAgents) {
-            throw new Error(`workflow agent cap reached (${maxAgents}); raise --max-agents deliberately if the fan-out is intended`);
+        catch (error) {
+            reservedCostUsd = Math.max(0, reservedCostUsd - reservedForDispatch);
+            reservedForDispatch = 0;
+            if (spawnCountClaimed) {
+                agentsSpawned--;
+                spawnCountClaimed = false;
+            }
+            agentProof.error = error.message;
+            throw error;
         }
-        agentsSpawned++;
+        if (!spawnCountClaimed)
+            agentsSpawned++;
         await acquire();
         try {
             journal("agent.start", {
@@ -170,6 +382,7 @@ export async function runWorkflow(scriptPath, opts) {
             log(`[${name}] ${currentStage || "(no stage)"} → ${id} [${harness}] ${label}`);
             let attemptPrompt = prompt;
             let last = null;
+            let agentCostUsd = 0;
             for (let attempt = 1; attempt <= maxAttempts; attempt++) {
                 last = await spawner({
                     prompt: attemptPrompt,
@@ -181,12 +394,20 @@ export async function runWorkflow(scriptPath, opts) {
                     runId,
                     subscriptionOnly: opts.subscriptionOnly,
                 });
+                agentProof.attempts = attempt;
+                agentProof.duration_ms += last.durationMs;
+                agentCostUsd += last.costUsd ?? 0;
                 costUsd += last.costUsd ?? 0;
                 if (!last.ok) {
                     journal("agent.attempt_failed", { id, attempt, error: last.error });
                     continue; // spawn-level failure: retry with the original prompt
                 }
                 if (!agentOpts.schema) {
+                    agentProof.status = "succeeded";
+                    agentProof.cost_usd =
+                        agentCostUsd > 0 || last.costUsd !== undefined ? agentCostUsd : undefined;
+                    agentProof.session_id = last.sessionId;
+                    agentProof.result = digestResult(last.text, "text");
                     journal("agent.end", {
                         id,
                         key,
@@ -204,6 +425,11 @@ export async function runWorkflow(scriptPath, opts) {
                     ? [parsed.error]
                     : validateAgainstSchema(parsed.value, agentOpts.schema);
                 if (problems.length === 0) {
+                    agentProof.status = "succeeded";
+                    agentProof.cost_usd =
+                        agentCostUsd > 0 || last.costUsd !== undefined ? agentCostUsd : undefined;
+                    agentProof.session_id = last.sessionId;
+                    agentProof.result = digestResult(parsed.value, "json");
                     journal("agent.end", {
                         id,
                         key,
@@ -227,10 +453,19 @@ export async function runWorkflow(scriptPath, opts) {
             const reason = last?.ok
                 ? `schema validation failed after ${maxAttempts} attempt(s)`
                 : (last?.error ?? "spawn failed");
+            agentProof.cost_usd =
+                agentCostUsd > 0 || last?.costUsd !== undefined ? agentCostUsd : undefined;
+            agentProof.session_id = last?.sessionId;
+            agentProof.error = reason;
             journal("agent.failed", { id, error: reason });
-            throw new Error(`agent ${id} (${label}): ${reason}`);
+            throw new Error(`agent ${proofLabel}: ${reason}`);
+        }
+        catch (error) {
+            agentProof.error ??= error.message;
+            throw error;
         }
         finally {
+            reservedCostUsd = Math.max(0, reservedCostUsd - reservedForDispatch);
             release();
         }
     };
@@ -248,11 +483,83 @@ export async function runWorkflow(scriptPath, opts) {
         journal("stage.start", { title });
         log(`[${name}] ── stage: ${title}`);
     };
-    const ctx = { agent, parallel, stage, log };
+    const evidence = (input) => {
+        const record = createEvidenceRecord({
+            value: input,
+            sequence: evidenceSeq + 1,
+            acceptanceIds,
+            stage: currentStage || undefined,
+        });
+        evidenceSeq++;
+        evidenceRecords.push(record);
+        journal("evidence.recorded", { ...record });
+        return record.id;
+    };
+    const authorize = async (input) => {
+        const network = input.network === true || input.service !== undefined || input.target !== undefined
+            ? "enabled"
+            : "disabled";
+        return authorizePolicyRequest({
+            phase: "external_mutation",
+            action: input.action,
+            path: input.path ? resolve(cwd, input.path) : undefined,
+            isolation,
+            network_access: network,
+            service: input.service,
+            target: input.target,
+            current_cost_usd: round4(costUsd),
+        });
+    };
+    const ctx = { agent, parallel, stage, log, evidence, authorize };
     const t0 = Date.now();
-    journal("run.start", { name, script: absScript, max_agents: maxAgents, concurrency });
+    const startedAt = new Date(t0).toISOString();
+    journal("run.start", {
+        name,
+        script: absScript,
+        objective: meta.objective ?? null,
+        acceptance: meta.acceptance,
+        max_agents: maxAgents,
+        concurrency,
+        policy: policy ? { name: policy.name, sha256: policyDigest(policy) } : null,
+        isolation,
+        network_access: networkAccess,
+    });
     try {
         const result = await mod.default(ctx);
+        const endedAt = new Date().toISOString();
+        const durationMs = Date.now() - t0;
+        journal("run.end", {
+            ok: true,
+            agents: agentsSpawned,
+            cached: agentsCached,
+            cost_usd: round4(costUsd),
+            duration_ms: durationMs,
+        });
+        let proof;
+        try {
+            proof = buildWorkflowProof({
+                runId,
+                meta,
+                status: "succeeded",
+                startedAt,
+                endedAt,
+                durationMs,
+                journalPath,
+                before: repoBefore,
+                after: snapshotRepo(cwd),
+                agents: Array.from(agentProofs.values()),
+                evidence: evidenceRecords,
+                harnessEvidence: opts.harnessEvidence,
+                policy: policy
+                    ? { config: policy, decisions: policyDecisions, isolation, networkAccess }
+                    : undefined,
+                result,
+            });
+            writeWorkflowProof(proofPath, proof);
+        }
+        catch (error) {
+            throw new WorkflowRunError(`workflow completed but its proof packet could not be written: ${error.message}`, runId, proofPath, error);
+        }
         const report = {
             runId,
             name,
@@ -260,32 +567,57 @@ export async function runWorkflow(scriptPath, opts) {
             agentsSpawned,
             agentsCached,
             costUsd: round4(costUsd),
-            durationMs: Date.now() - t0,
+            durationMs,
             journalPath,
+            proofPath,
+            acceptance: proof.acceptance.summary,
             contextTokensPerChildEstimate,
             billing: Array.from(billingProbed.values()).map((p) => ({
                 harness: p.harness,
                 mode: opts.subscriptionOnly ? "subscription" : p.mode,
             })),
+            policy: proof.policy?.summary,
         };
-        journal("run.end", {
-            ok: true,
-            agents: agentsSpawned,
-            cached: agentsCached,
-            cost_usd: report.costUsd,
-            duration_ms: report.durationMs,
-        });
         return report;
     }
     catch (err) {
+        if (err instanceof WorkflowRunError)
+            throw err;
+        const endedAt = new Date().toISOString();
+        const durationMs = Date.now() - t0;
         journal("run.end", {
             ok: false,
             error: err.message,
             agents: agentsSpawned,
             cached: agentsCached,
             cost_usd: round4(costUsd),
+            duration_ms: durationMs,
         });
-        throw err;
+        try {
+            const proof = buildWorkflowProof({
+                runId,
+                meta,
+                status: "failed",
+                startedAt,
+                endedAt,
+                durationMs,
+                journalPath,
+                before: repoBefore,
+                after: snapshotRepo(cwd),
+                agents: Array.from(agentProofs.values()),
+                evidence: evidenceRecords,
+                harnessEvidence: opts.harnessEvidence,
+                policy: policy
+                    ? { config: policy, decisions: policyDecisions, isolation, networkAccess }
+                    : undefined,
+                error: err.message,
+            });
+            writeWorkflowProof(proofPath, proof);
+        }
+        catch (proofError) {
+            throw new WorkflowRunError(`${err.message}; proof packet write also failed: ${proofError.message}`, runId, proofPath, err);
+        }
+        throw new WorkflowRunError(err.message, runId, proofPath, err);
     }
 }
 /** Stable identity for one agent() call, for the resume cache. The ORIGINAL
@@ -347,3 +679,36 @@ function loadResumeCache(coordRoot, resumeFrom) {
 function round4(n) {
     return Math.round(n * 10_000) / 10_000;
 }
+function assertAgentCapacity(agentsSpawned, maxAgents) {
+    if (agentsSpawned >= maxAgents) {
+        throw new Error(`workflow agent cap reached (${maxAgents}); raise --max-agents deliberately if the fan-out is intended`);
+    }
+}
+function boundedPolicyReason(value) {
+    const normalized = Array.from(value, (character) => {
+        const code = character.charCodeAt(0);
+        return code < 32 || code === 127 ? " " : character;
+    })
+        .join("")
+        .replace(/\s+/g, " ")
+        .trim();
+    return normalized.length > 2_000 ? `${normalized.slice(0, 1_999)}…` : normalized;
+}
+async function withTimeout(promise, timeoutMs) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        throw new Error("policyAskTimeoutMs must be a positive finite number");
+    }
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`approval timed out after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/dist/core/workflow/index.d.ts

@@ -0,0 +1,5 @@
+export { runWorkflow, WorkflowRunError } from "./engine.js";
+export { buildWorkflowProof, createEvidenceRecord, digestResult, normalizeWorkflowMeta, readWorkflowProof, renderWorkflowProof, rollupAcceptance, writeWorkflowProof, } from "./proof.js";
+export type { AcceptanceCriterion, AcceptanceResult, AcceptanceStatus, AcceptanceSummary, AgentOpts, EngineOpts, EvidenceKind, EvidenceSource, EvidenceStatus, HarnessEvidenceCapability, HarnessEvidenceCoverage, HarnessName, ResultDigest, RunReport, Spawner, SpawnRequest, SpawnResult, StageSchema, WorkflowAgentProof, WorkflowContext, WorkflowEvidenceInput, WorkflowEvidenceRecord, WorkflowMeta, WorkflowModule, WorkflowPolicyProof, WorkflowProof, WorkflowProofUnknown, WorkflowRepoEvidence, WorkflowRepoSnapshot, WorkflowRunStatus, } from "./types.js";
+export { WORKFLOW_PROOF_SCHEMA_VERSION } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/workflow/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/workflow/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,EACT,UAAU,EACV,YAAY,EACZ,cAAc,EACd,cAAc,EACd,yBAAyB,EACzB,uBAAuB,EACvB,WAAW,EACX,YAAY,EACZ,SAAS,EACT,OAAO,EACP,YAAY,EACZ,WAAW,EACX,WAAW,EACX,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,sBAAsB,EACtB,YAAY,EACZ,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC"}

package/dist/core/workflow/index.js

@@ -0,0 +1,3 @@
+export { runWorkflow, WorkflowRunError } from "./engine.js";
+export { buildWorkflowProof, createEvidenceRecord, digestResult, normalizeWorkflowMeta, readWorkflowProof, renderWorkflowProof, rollupAcceptance, writeWorkflowProof, } from "./proof.js";
+export { WORKFLOW_PROOF_SCHEMA_VERSION } from "./types.js";

package/dist/core/workflow/proof.d.ts

@@ -0,0 +1,49 @@
+import type { RepoSnapshot } from "../context/index.js";
+import type { NormalizedPolicy, PolicyDecision, PolicyIsolation, PolicyNetworkAccess } from "../policy/index.js";
+import type { AcceptanceCriterion, AcceptanceResult, AcceptanceSummary, HarnessEvidenceCapability, ResultDigest, WorkflowAgentProof, WorkflowEvidenceInput, WorkflowEvidenceRecord, WorkflowMeta, WorkflowProof } from "./types.js";
+export interface NormalizedWorkflowMeta {
+    name: string;
+    description?: string;
+    objective?: string;
+    acceptance: AcceptanceCriterion[];
+}
+export interface BuildWorkflowProofInput {
+    runId: string;
+    meta: NormalizedWorkflowMeta;
+    status: "succeeded" | "failed";
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    journalPath: string;
+    before: RepoSnapshot;
+    after: RepoSnapshot;
+    agents: WorkflowAgentProof[];
+    evidence: WorkflowEvidenceRecord[];
+    harnessEvidence?: Readonly<Record<string, HarnessEvidenceCapability | undefined>>;
+    policy?: {
+        config: Readonly<NormalizedPolicy>;
+        decisions: readonly PolicyDecision[];
+        isolation: PolicyIsolation;
+        networkAccess: PolicyNetworkAccess;
+    };
+    result?: unknown;
+    error?: string;
+}
+export declare function normalizeWorkflowMeta(meta: WorkflowMeta | undefined, fallbackName: string): NormalizedWorkflowMeta;
+export declare function createEvidenceRecord(input: {
+    value: WorkflowEvidenceInput;
+    sequence: number;
+    acceptanceIds: ReadonlySet<string>;
+    stage?: string;
+    recordedAt?: string;
+}): WorkflowEvidenceRecord;
+export declare function rollupAcceptance(criteria: AcceptanceCriterion[], evidence: WorkflowEvidenceRecord[]): {
+    criteria: AcceptanceResult[];
+    summary: AcceptanceSummary;
+};
+export declare function digestResult(value: unknown, kind?: "text" | "json"): ResultDigest;
+export declare function buildWorkflowProof(input: BuildWorkflowProofInput): WorkflowProof;
+export declare function writeWorkflowProof(path: string, proof: WorkflowProof): void;
+export declare function readWorkflowProof(coordRoot: string, runId: string): WorkflowProof;
+export declare function renderWorkflowProof(proof: WorkflowProof): string;
+//# sourceMappingURL=proof.d.ts.map