@petepetrash/circuit 0.1.0

package/dist/app/run-envelope/source-record.js

@@ -0,0 +1,648 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { sha256OfFile, sha256OfString } from '../../schemas/hashing.js';
+import { CompiledFlowId, RunId, StepId } from '../../schemas/ids.js';
+import { PROCESS_EVIDENCE_RELATIVE_PATH, ProcessEvidenceProjection as ProcessEvidenceProjectionSchema, } from '../../schemas/process-evidence.js';
+import { Sha256 } from '../../schemas/ref.js';
+import { RunEnvelopeRecord, } from '../../schemas/run-envelope.js';
+import { isDegradedCompletionOutcome } from '../../shared/outcome.js';
+import { runRelativePath } from '../../shared/run-artifact-io.js';
+export const RUN_ENVELOPE_RELATIVE_PATH = 'reports/run-envelope.json';
+export const RUN_SURFACE_RELATIVE_PATH = 'reports/run-surface.md';
+export const RUN_DECISION_PACKET_RELATIVE_DIR = 'reports/decision-packets';
+function childRunIdFromProjection(projection) {
+    return RunId.parse(projection.child_run_ref.run_id);
+}
+function evidenceFileRef(input) {
+    return {
+        kind: 'evidence',
+        ref: runRelativePath(input.runFolder, input.path),
+        sha256: sha256OfFile(input.path),
+        run_id: RunId.parse(input.runId),
+        flow_id: CompiledFlowId.parse(input.flowId),
+    };
+}
+function evidence(source, ref) {
+    return { source, ref };
+}
+function artifactLabel(ref) {
+    if (ref.ref === RUN_ENVELOPE_RELATIVE_PATH)
+        return 'Run envelope';
+    if (ref.ref === PROCESS_EVIDENCE_RELATIVE_PATH)
+        return 'Process evidence';
+    if (ref.ref === 'reports/result.json')
+        return 'Child result';
+    if (ref.ref.startsWith(`${RUN_DECISION_PACKET_RELATIVE_DIR}/`))
+        return 'Decision packet';
+    if (ref.kind === 'request')
+        return 'Decision request';
+    return ref.ref;
+}
+function markdownLink(label, path) {
+    return `[${label}](${path})`;
+}
+function renderSurfaceMarkdown(input) {
+    const artifactRefs = [
+        {
+            kind: 'report',
+            ref: RUN_ENVELOPE_RELATIVE_PATH,
+        },
+        ...input.record.surface_output.artifact_links,
+    ];
+    const uniqueArtifactRefs = artifactRefs.filter((ref, index, refs) => refs.findIndex((candidate) => candidate.ref === ref.ref) === index);
+    const artifactLine = uniqueArtifactRefs
+        .map((ref) => markdownLink(artifactLabel(ref), join(input.runFolder, ref.ref)))
+        .join(' · ');
+    return ['CIRCUIT', `⎿ ${input.record.surface_output.status_text}`, '', artifactLine, ''].join('\n');
+}
+function processAttemptOutcome(outcome) {
+    if (outcome === 'aborted')
+        return 'failed';
+    return outcome;
+}
+export function missingRunEvidence(projection) {
+    if (projection.outcome !== 'complete')
+        return undefined;
+    const refs = new Set(projection.evidence_refs.map((ref) => ref.ref));
+    const missingRefs = projection.declared_report_paths.filter((path) => !refs.has(path));
+    if (missingRefs.length === 0)
+        return undefined;
+    return {
+        claim_id: 'process-evidence',
+        reason: `Missing expected process evidence: ${missingRefs.join(', ')}.`,
+        missing_refs: missingRefs,
+    };
+}
+function runOutcome(input) {
+    if (input.missingEvidence !== undefined)
+        return 'needs_attention';
+    if (input.projection.outcome === 'checkpoint_waiting')
+        return 'needs_attention';
+    if (input.projection.outcome === 'aborted')
+        return 'failed';
+    return input.projection.outcome;
+}
+function selectionSourceFor(routedBy) {
+    if (routedBy === 'explicit')
+        return 'explicit_operator_request';
+    return 'recovery';
+}
+// S2: derive the kind of proof a given process is expected to produce. This is
+// the stable, deterministic mapping the recovery router (S5) re-uses to decide
+// which recovery flow an unmet required-evidence entry should route to. Keeping
+// it a pure function of the process id means the kind is always recoverable from
+// the envelope without enriching the (kind-blind) process evidence projection.
+// This is a deliberate hardcoded table for the single-claim model; deriving it
+// from each flow's declared proof capabilities is a deferred refinement (see
+// docs/specs/run-envelope-goal-loop-migration-v1.md). Unknown process ids fall
+// through to the conservative 'report' default.
+export function requiredEvidenceKindForProcess(processId) {
+    switch (processId) {
+        case 'fix':
+        case 'build':
+            return 'command';
+        case 'review':
+        case 'explore':
+            return 'review';
+        case 'pursue':
+        case 'prototype':
+            return 'report';
+        default:
+            return 'report';
+    }
+}
+function describeRequiredEvidence(kind, objective) {
+    switch (kind) {
+        case 'command':
+            return `A passing verification command proving: ${objective}`;
+        case 'review':
+            return `A review confirming no blocking findings for: ${objective}`;
+        case 'report':
+            return `A report-backed result proving: ${objective}`;
+        case 'source':
+            return `Source-backed justification for: ${objective}`;
+        case 'checkpoint':
+            return `An operator checkpoint resolving: ${objective}`;
+    }
+}
+// S2: author task-specific required evidence for Run's single done_when claim,
+// replacing the generic "projection exists" placeholder. Run has no Clarify step,
+// so the proof requirement is derived from the selected process and the operator
+// objective. Always returns at least one required entry to satisfy RunDoneClaim.
+export function deriveRequiredEvidence(processId, objective) {
+    const kind = requiredEvidenceKindForProcess(processId);
+    return [{ kind, description: describeRequiredEvidence(kind, objective), required: true }];
+}
+// S5: route a recovery attempt by the kind of evidence that is still unmet,
+// replacing the previous hardcoded "always review" follow-up. command -> fix
+// (get it passing/verified), report -> build (produce the result), review ->
+// review, source -> explore (justify the decision), checkpoint -> ask.
+export const RECOVERY_ROUTE_FOR_UNMET_EVIDENCE_KIND = {
+    command: 'fix',
+    report: 'build',
+    review: 'review',
+    source: 'explore',
+    checkpoint: 'checkpoint',
+};
+// When several kinds are unmet, the most actionable proof wins: a missing
+// command (failing/absent verification) is the strongest signal, then a missing
+// report, then review, then source justification, then an operator checkpoint.
+const RECOVERY_KIND_PRIORITY = [
+    'command',
+    'report',
+    'review',
+    'source',
+    'checkpoint',
+];
+export function recoveryRouteForUnmetKinds(unmetKinds) {
+    for (const kind of RECOVERY_KIND_PRIORITY) {
+        if (unmetKinds.includes(kind))
+            return RECOVERY_ROUTE_FOR_UNMET_EVIDENCE_KIND[kind];
+    }
+    return 'review';
+}
+function gateFor(input) {
+    if (input.projection.outcome === 'complete') {
+        if (input.missingEvidence !== undefined) {
+            return {
+                schema: 'run.completion-gate@v0',
+                verdict: 'needs_followup',
+                claim_results: [
+                    {
+                        claim_id: input.missingEvidence.claim_id,
+                        status: 'missing',
+                        evidence: [input.processEvidence],
+                        gap: input.missingEvidence.reason,
+                    },
+                ],
+                gate_passes: [],
+                clean_streak: 0,
+                required_passes: 2,
+                next_action: 'plan-followup-process',
+            };
+        }
+        return {
+            schema: 'run.completion-gate@v0',
+            verdict: 'complete',
+            claim_results: [
+                {
+                    claim_id: 'process-evidence',
+                    status: 'proved',
+                    evidence: [input.processEvidence],
+                },
+            ],
+            gate_passes: [
+                {
+                    pass_id: 'gate-process-evidence',
+                    attack_lens: 'required-evidence-present',
+                    evidence_checked: [input.processEvidence],
+                    verdict: 'gate-pass',
+                },
+                {
+                    pass_id: 'gate-child-outcome',
+                    attack_lens: 'child-outcome-consistent',
+                    evidence_checked: [input.processEvidence],
+                    verdict: 'gate-pass',
+                },
+            ],
+            clean_streak: 2,
+            required_passes: 2,
+            next_action: 'close',
+        };
+    }
+    if (input.projection.outcome === 'checkpoint_waiting') {
+        return {
+            schema: 'run.completion-gate@v0',
+            verdict: 'needs_followup',
+            claim_results: [
+                {
+                    claim_id: 'process-evidence',
+                    status: 'missing',
+                    evidence: [input.processEvidence],
+                    gap: 'The selected process is waiting for an operator checkpoint choice.',
+                },
+            ],
+            gate_passes: [],
+            clean_streak: 0,
+            required_passes: 2,
+            next_action: 'ask-operator',
+        };
+    }
+    if (input.projection.outcome === 'handoff') {
+        return {
+            schema: 'run.completion-gate@v0',
+            verdict: 'handoff',
+            claim_results: [
+                {
+                    claim_id: 'process-evidence',
+                    status: 'blocked',
+                    evidence: [input.processEvidence],
+                    gap: 'The selected process handed off before Run could close complete.',
+                },
+            ],
+            gate_passes: [],
+            clean_streak: 0,
+            required_passes: 2,
+            next_action: 'handoff',
+        };
+    }
+    const failed = input.projection.outcome === 'failed' || input.projection.outcome === 'aborted';
+    return {
+        schema: 'run.completion-gate@v0',
+        verdict: failed ? 'failed' : 'blocked',
+        claim_results: [
+            {
+                claim_id: 'process-evidence',
+                status: failed ? 'contradicted' : 'blocked',
+                evidence: [input.processEvidence],
+                gap: input.projection.blocked_reason ??
+                    input.projection.missing_evidence[0]?.reason ??
+                    'The selected process did not produce complete evidence.',
+            },
+        ],
+        gate_passes: [],
+        clean_streak: 0,
+        required_passes: 2,
+        next_action: failed ? 'failed' : 'blocked',
+    };
+}
+export function followupProcessId(primaryProcessId) {
+    // For Run's single done_when claim, the unmet evidence kind is the proof kind
+    // the primary process was expected to produce. Route the follow-up by that
+    // kind instead of always sending it to review.
+    const unmetKind = requiredEvidenceKindForProcess(primaryProcessId);
+    return CompiledFlowId.parse(recoveryRouteForUnmetKinds([unmetKind]));
+}
+function followupPlannedAttempt(input) {
+    if (input.missingEvidence === undefined)
+        return undefined;
+    const followupProcess = followupProcessId(input.primaryProcessId);
+    return {
+        attempt_id: 'attempt-followup-1',
+        process_id: followupProcess,
+        goal: `Run ${followupProcess} to produce the missing evidence to close: ${input.operatorIntent}`,
+        expected_evidence: [PROCESS_EVIDENCE_RELATIVE_PATH, ...input.missingEvidence.missing_refs],
+        depends_on_attempt_ids: ['attempt-primary'],
+        followup_for: {
+            claim_id: input.missingEvidence.claim_id,
+            prior_attempt_id: 'attempt-primary',
+            missing_evidence: [...input.missingEvidence.missing_refs],
+        },
+    };
+}
+function decisionPacketsFor(input) {
+    if (input.missingEvidence !== undefined) {
+        return [
+            {
+                schema: 'run.decision-packet@v0',
+                decision_id: 'decision-missing-evidence-followup',
+                reason: 'missing-evidence',
+                prompt: 'Choose whether Run should continue with the planned follow-up.',
+                choices: [
+                    {
+                        id: 'run-followup',
+                        label: 'Run follow-up',
+                        effect: 'Use the planned follow-up process to resolve the missing evidence.',
+                    },
+                    {
+                        id: 'stop',
+                        label: 'Stop here',
+                        effect: 'Leave the Run open with the missing evidence recorded.',
+                    },
+                ],
+                resume_target: {
+                    kind: 'run-envelope',
+                    run_id: input.childRunId,
+                },
+                artifact_refs: [input.processEvidence.ref],
+            },
+        ];
+    }
+    const checkpoint = input.projection.checkpoint;
+    if (checkpoint === undefined)
+        return [];
+    return [
+        {
+            schema: 'run.decision-packet@v0',
+            decision_id: 'decision-checkpoint-primary',
+            reason: 'process-checkpoint',
+            prompt: 'Choose how the selected process should continue.',
+            choices: checkpoint.allowed_choices.map((choice) => ({
+                id: choice,
+                label: choice,
+                effect: `Resume the checkpoint with '${choice}'.`,
+            })),
+            resume_target: {
+                kind: 'process-checkpoint',
+                run_id: input.childRunId,
+                step_id: checkpoint.step_id,
+                request_ref: checkpoint.request_ref,
+            },
+            artifact_refs: [input.processEvidence.ref, checkpoint.request_ref],
+        },
+    ];
+}
+function decisionPacketRelativePath(packet) {
+    const safeId = packet.decision_id.replace(/[^a-zA-Z0-9._-]+/g, '-');
+    return `${RUN_DECISION_PACKET_RELATIVE_DIR}/${safeId}.json`;
+}
+function decisionPacketArtifacts(input) {
+    return input.packets.map((packet) => {
+        const body = `${JSON.stringify(packet, null, 2)}\n`;
+        return {
+            packet,
+            body,
+            ref: {
+                kind: 'report',
+                ref: decisionPacketRelativePath(packet),
+                sha256: Sha256.parse(sha256OfString(body)),
+                run_id: input.runId,
+            },
+        };
+    });
+}
+function memoryUpdateEvents(input) {
+    return (input.updates ?? []).map((update) => ({
+        schema: 'run.memory-update-event@v0',
+        event_id: update.event_id,
+        scope: update.scope,
+        ...(update.scope === 'flow'
+            ? { flow_id: CompiledFlowId.parse(update.flow_id ?? input.processId) }
+            : {}),
+        action: update.action,
+        reason: update.reason,
+        summary: update.summary,
+        source_refs: [input.processEvidence.ref],
+        authority: 'hint_only',
+        ...(update.operator_indicator === undefined
+            ? {}
+            : { operator_indicator: update.operator_indicator }),
+    }));
+}
+function surfaceFor(input) {
+    const artifactLinks = [
+        input.processEvidence.ref,
+        ...(input.decisionPacketRefs ?? []),
+        ...(input.childResult === undefined ? [] : [input.childResult.ref]),
+        ...(input.checkpointRequest === undefined ? [] : [input.checkpointRequest]),
+    ];
+    // A degraded flow outcome on an otherwise-complete run is the one case where
+    // the flow quality word must reach the surface. Carry it so the machine
+    // record exposes the partial/failed result the run lifecycle outcome alone
+    // would hide. Clean runs leave flow_outcome absent.
+    const degradedFlowOutcome = input.outcome === 'complete' && isDegradedCompletionOutcome(input.flowOutcome)
+        ? input.flowOutcome
+        : undefined;
+    const base = {
+        schema: 'run.surface-output@v0',
+        outcome: input.outcome,
+        artifact_links: artifactLinks,
+        ...(degradedFlowOutcome === undefined ? {} : { flow_outcome: degradedFlowOutcome }),
+        ...(input.memoryIndicator === undefined ? {} : { memory_indicator: input.memoryIndicator }),
+    };
+    if (input.outcome === 'complete') {
+        if (degradedFlowOutcome !== undefined) {
+            // The run finished its process, but its own result is not a clean pass.
+            // Name the degradation rather than reading as an unqualified "Done", and
+            // carry the flow's own stated reason when it gave one so the caveat line
+            // says why, not just that it is caveated.
+            const reason = input.flowOutcomeReason?.trim();
+            const reasonSuffix = reason ? ` ${reason}` : '';
+            return {
+                ...base,
+                status_text: `Completed with caveats: ${input.processId} produced its required process evidence but reported a ${degradedFlowOutcome} outcome.${reasonSuffix}`,
+                next_action: 'close',
+            };
+        }
+        return {
+            ...base,
+            status_text: `Done: ${input.processId} completed with required process evidence.`,
+            next_action: 'close',
+        };
+    }
+    if (input.outcome === 'needs_attention') {
+        if (input.missingEvidence !== undefined) {
+            return {
+                ...base,
+                status_text: `Needs follow-up: ${input.processId} is missing expected process evidence.`,
+                next_action: 'plan-followup-process',
+                ...(input.decisionPacketRefs?.[0] === undefined
+                    ? {}
+                    : { decision_packet_ref: input.decisionPacketRefs[0] }),
+            };
+        }
+        return {
+            ...base,
+            status_text: `Needs input: ${input.processId} is waiting at a checkpoint.`,
+            next_action: 'ask-operator',
+            ...(input.decisionPacketRefs?.[0] === undefined
+                ? {}
+                : { decision_packet_ref: input.decisionPacketRefs[0] }),
+        };
+    }
+    if (input.outcome === 'blocked') {
+        return {
+            ...base,
+            status_text: `Blocked: ${input.processId} did not produce enough process evidence.`,
+            next_action: 'Inspect the process evidence and choose a recovery path.',
+        };
+    }
+    if (input.outcome === 'handoff') {
+        return {
+            ...base,
+            status_text: `Handoff ready: ${input.processId} paused with handoff evidence.`,
+            next_action: 'resume from handoff',
+        };
+    }
+    if (input.outcome === 'failed') {
+        return {
+            ...base,
+            status_text: `Failed: ${input.processId} could not close with the required process evidence.`,
+            next_action: 'Inspect the process evidence and rerun with a corrected goal.',
+        };
+    }
+    // Defensive default: every RunEnvelopeOutcome above is handled, so this only
+    // fires if a new outcome is added without a branch.
+    return {
+        ...base,
+        status_text: `Stopped: ${input.processId} could not close with enough process evidence.`,
+        next_action: 'Inspect the process evidence and rerun with a corrected goal.',
+    };
+}
+export function writeRunEnvelopeRecord(input) {
+    const projection = ProcessEvidenceProjectionSchema.parse(input.processEvidence.projection);
+    const processEvidencePath = input.processEvidence.path;
+    const childRunId = childRunIdFromProjection(projection);
+    const processEvidence = evidence('process_evidence', evidenceFileRef({
+        runFolder: input.runFolder,
+        path: processEvidencePath,
+        runId: childRunId,
+        flowId: projection.flow_id,
+    }));
+    const childResult = projection.result_ref === undefined
+        ? undefined
+        : evidence('child_result', projection.result_ref);
+    const missingEvidence = missingRunEvidence(projection);
+    const gate = gateFor({
+        projection,
+        processEvidence,
+        ...(missingEvidence && { missingEvidence }),
+    });
+    const outcome = runOutcome({ projection, ...(missingEvidence && { missingEvidence }) });
+    const processId = projection.flow_id;
+    const flowOutcome = input.flowOutcome;
+    const flowOutcomeReason = input.flowOutcomeReason;
+    const followupAttempt = followupPlannedAttempt({
+        operatorIntent: input.operatorIntent,
+        primaryProcessId: processId,
+        ...(missingEvidence && { missingEvidence }),
+    });
+    const decisionPackets = decisionPacketsFor({
+        projection,
+        processEvidence,
+        childRunId,
+        ...(missingEvidence && { missingEvidence }),
+    });
+    const decisionArtifacts = decisionPacketArtifacts({
+        runId: childRunId,
+        packets: decisionPackets,
+    });
+    const memoryEvents = memoryUpdateEvents({
+        processId,
+        processEvidence,
+        ...(input.memoryUpdates === undefined ? {} : { updates: input.memoryUpdates }),
+    });
+    // Slice 3 precedence rule: a write-side proposed/recorded memory-update
+    // indicator (Slice 5's surface) wins the single surface_output.memory_indicator;
+    // the recall-derived earned-precision indicator fills it only when no
+    // memory-write event exists. On a Slice-3-only corpus there are no write events,
+    // so the field carries the recall indicator; once Slice 5 also runs, the
+    // write-side indicator takes precedence and the recall one stays in the sidecar.
+    const writeIndicator = memoryEvents.find((event) => event.action === 'proposed' || event.action === 'recorded')?.operator_indicator;
+    const memoryIndicator = writeIndicator ?? input.recallMemoryIndicator;
+    const record = RunEnvelopeRecord.parse({
+        schema: 'run.envelope@v0',
+        run_id: projection.child_run_ref.run_id,
+        operator_intent: input.operatorIntent,
+        explicit_constraints: [],
+        explicit_process_request: input.selectedProcess.routed_by === 'explicit'
+            ? CompiledFlowId.parse(input.selectedProcess.process_id)
+            : undefined,
+        memory_context: {
+            used: input.memoryContext?.used ?? false,
+            memory_input_ids: [...(input.memoryContext?.memoryInputIds ?? [])],
+            authority: 'hint_only',
+        },
+        goal_contract: {
+            schema: 'run.goal-contract@v0',
+            objective: input.operatorIntent,
+            scope: {
+                in: [input.operatorIntent],
+                out: [],
+                assumptions: [],
+            },
+            constraints: [],
+            done_when: [
+                {
+                    id: 'process-evidence',
+                    claim: `The ${input.selectedProcess.process_id} work is complete with the required proof for: ${input.operatorIntent}`,
+                    required_evidence: deriveRequiredEvidence(input.selectedProcess.process_id, input.operatorIntent),
+                },
+            ],
+            recovery_policy: {
+                max_process_attempts: 2,
+                allowed_routes: ['retry-process', 'run-review', 'checkpoint', 'handoff', 'blocked'],
+            },
+            stop_conditions: ['Stop instead of closing complete when required evidence is missing.'],
+            completion_gate: {
+                required_passes: 2,
+                blocking_severities: ['critical', 'high', 'medium'],
+                reset_on_blocking_finding: true,
+            },
+        },
+        process_plan: {
+            schema: 'run.process-plan@v0',
+            selection_source: selectionSourceFor(input.selectedProcess.routed_by),
+            rationale: input.selectedProcess.router_reason,
+            planned_attempts: [
+                {
+                    attempt_id: 'attempt-primary',
+                    process_id: CompiledFlowId.parse(input.selectedProcess.process_id),
+                    goal: input.operatorIntent,
+                    expected_evidence: [PROCESS_EVIDENCE_RELATIVE_PATH],
+                    depends_on_attempt_ids: [],
+                },
+                ...(followupAttempt === undefined ? [] : [followupAttempt]),
+            ],
+        },
+        process_attempts: [
+            {
+                schema: 'run.process-attempt@v0',
+                attempt_id: 'attempt-primary',
+                process_id: CompiledFlowId.parse(input.selectedProcess.process_id),
+                goal: input.operatorIntent,
+                started_at: input.recordedAt,
+                ...(projection.outcome === 'checkpoint_waiting' ? {} : { completed_at: input.recordedAt }),
+                outcome: processAttemptOutcome(projection.outcome),
+                child_run: {
+                    run_id: projection.child_run_ref.run_id,
+                    run_folder: input.runFolder,
+                    ...(childResult === undefined ? {} : { result_ref: childResult }),
+                    trace_entries_observed: projection.trace_entries_observed,
+                    manifest_hash: projection.manifest_hash,
+                },
+                ...(projection.checkpoint === undefined
+                    ? {}
+                    : {
+                        checkpoint: {
+                            step_id: StepId.parse(projection.checkpoint.step_id),
+                            request_ref: projection.checkpoint.request_ref,
+                            allowed_choices: projection.checkpoint.allowed_choices,
+                        },
+                    }),
+                evidence_refs: [processEvidence, ...(childResult === undefined ? [] : [childResult])],
+                summary: projection.summary,
+                ...(projection.blocked_reason === undefined
+                    ? {}
+                    : { blocked_reason: projection.blocked_reason }),
+            },
+        ],
+        completion_gate: gate,
+        decision_packets: decisionPackets,
+        memory_update_events: memoryEvents,
+        surface_output: surfaceFor({
+            outcome,
+            processId,
+            processEvidence,
+            ...(flowOutcome === undefined ? {} : { flowOutcome }),
+            ...(flowOutcomeReason === undefined ? {} : { flowOutcomeReason }),
+            ...(missingEvidence && { missingEvidence }),
+            decisionPacketRefs: decisionArtifacts.map((artifact) => artifact.ref),
+            ...(memoryIndicator === undefined ? {} : { memoryIndicator }),
+            ...(childResult === undefined ? {} : { childResult }),
+            ...(projection.checkpoint === undefined
+                ? {}
+                : { checkpointRequest: projection.checkpoint.request_ref }),
+        }),
+        outcome,
+    });
+    const outPath = join(input.runFolder, RUN_ENVELOPE_RELATIVE_PATH);
+    mkdirSync(dirname(outPath), { recursive: true });
+    const decisionPacketPaths = decisionArtifacts.map((artifact) => {
+        const path = join(input.runFolder, artifact.ref.ref);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, artifact.body);
+        return path;
+    });
+    writeFileSync(outPath, `${JSON.stringify(record, null, 2)}\n`);
+    const surfacePath = join(input.runFolder, RUN_SURFACE_RELATIVE_PATH);
+    writeFileSync(surfacePath, renderSurfaceMarkdown({ runFolder: input.runFolder, record }));
+    return {
+        path: outPath,
+        processEvidencePath,
+        surfacePath,
+        decisionPacketPaths,
+        record,
+    };
+}
+//# sourceMappingURL=source-record.js.map