clinkx 1.1.1 → 1.2.0

package/dist/verified-repair/host.js

@@ -0,0 +1,612 @@
+import { lstatSync, mkdtempSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { assertIndependentRepairReview, assertRepairBounded, assertRepairCitations, FixProposalSchema, InvestigationSchema, MAX_REPAIR_CONTRACT_BYTES, MAX_REPAIR_PACKET_BYTES, MAX_REPAIR_PROPOSAL_BYTES, MAX_REPAIR_RECORD_BYTES, parseRegressionOutcome, RepairInputSchema, RepairPacketSchema, RepairRecordSchema, RepairReviewSchema, repairSourceDigest, RelativePathSchema, RepairRoutesSchema, RepairSourceFactSchema, ReplacementBatchSchema, } from "../../clinkx-workflows/dist/verified-repair/contract.js";
+import { readContainedAbsoluteFile } from "../../clinkx-workflows/dist/contained-file.js";
+import { parseAllowedRootsEnv } from "../allowed-roots.js";
+import { hasDisallowedSecretMaterial, scanSecretPath } from "../context-builder/secrets.js";
+import { hasCredentialTokenShape } from "../../clinkx-workflows/dist/dashboard/session-log-redaction.js";
+import { ExpectedSchema, ManifestSchema, ResultSchema } from "../project-verification/contract.js";
+import { json, readBounded, runtimeDigest, safePath, sha } from "../project-verification/files.js";
+import { assertCurrent, assertSeparated, authorizedDirectory, captureFiles, materialize, reconcileAppliedPaths, text, writeReplacement } from "./files.js";
+class RepairGateError extends Error {
+    status;
+    constructor(message, status = "failed") {
+        super(message);
+        this.status = status;
+    }
+}
+const proofRef = (proof) => ({ phase: proof.phase,
+    evidence_directory: proof.evidence_directory, expectations_sha256: proof.expectations_sha256 });
+const facts = (files, replacements) => files.map((file) => {
+    const bytes = replacements.get(file.path) ?? file.bytes;
+    return { path: file.path, sha256: sha(bytes), size_bytes: bytes.length };
+});
+const SourceModesSchema = z.array(z.object({ path: RelativePathSchema, mode: z.number().int().min(0).max(0o7777) }).strict()).min(1).max(1000);
+export class NativeVerifiedRepairHost {
+    service;
+    rename;
+    constructor(service, rename = renameSync) {
+        this.service = service;
+        this.rename = rename;
+    }
+    async prepare(options) {
+        return this.service.operation(async (native) => {
+            const read = await readContainedAbsoluteFile(parseAllowedRootsEnv({ rejectBroadRoots: true }), options.contractPath, { wantContent: true, requireRegular: true, requireExactRequestedPath: true, maxBytes: MAX_REPAIR_CONTRACT_BYTES });
+            const contractText = read.content;
+            if (hasCredentialTokenShape(contractText) || hasDisallowedSecretMaterial(contractText, false))
+                throw new Error("repair contract contains credential-like material; remove it before capture");
+            let input;
+            try {
+                input = RepairInputSchema.parse(JSON.parse(contractText));
+            }
+            catch {
+                throw new Error("invalid reviewed repair contract; use the strict clinkx-verified-repair-input-v1 schema");
+            }
+            const project = authorizedDirectory(input.project_path, true);
+            const parent = authorizedDirectory(input.evidence_parent, false);
+            const copyParent = authorizedDirectory(input.verification_copy_parent, true);
+            assertSeparated(project, parent, copyParent);
+            const manifests = [...new Set([input.regression_manifest, input.required_manifest,
+                    ...(input.copy_preparation.status === "declared" ? [input.copy_preparation.manifest] : [])])];
+            const declared = [...new Set([...input.source_inputs, ...manifests])];
+            if (declared.some((path) => scanSecretPath(path).length !== 0))
+                throw new Error("credential-like paths cannot be captured or copied by verified repair");
+            const files = captureFiles(project, declared);
+            if (files.some((file) => hasCredentialTokenShape(text(file.bytes)) || hasDisallowedSecretMaterial(text(file.bytes), false)))
+                throw new Error("declared source contains credential-like material; it cannot enter a repair capture or copy");
+            for (const path of manifests) {
+                const captured = files.find((file) => file.path === path);
+                if (captured.bytes.length > MAX_REPAIR_CONTRACT_BYTES)
+                    throw new Error("reviewed manifest exceeds 256 KiB");
+                const manifest = ManifestSchema.parse(JSON.parse(text(captured.bytes)));
+                if (manifest.inputs.some((path) => !input.source_inputs.includes(path))
+                    || input.source_inputs.some((path) => !manifest.inputs.includes(path))) {
+                    throw new Error("each reviewed manifest must include every declared source input and no undeclared inputs");
+                }
+                if (path === input.regression_manifest && (manifest.checks.length !== 1 || manifest.checks[0].id !== input.observation.check_id)) {
+                    throw new Error("regression manifest must have exactly the bound observation check");
+                }
+            }
+            for (const path of [...input.regression_paths, ...input.implementation_paths]) {
+                const file = files.find((file) => file.path === path);
+                if (file.bytes.length > 64 * 1024)
+                    throw new Error("writable repair file exceeds 64 KiB; narrow the repair scope");
+                text(file.bytes);
+            }
+            const originalFacts = facts(files, new Map());
+            // Dispatch uses this frozen data, never the original contract or live source path.
+            const runtime = { sha256: runtimeDigest(), node_version: process.version };
+            const binding = { contract_sha256: sha(contractText), input, source_facts: originalFacts,
+                source_modes: files.map((file) => ({ path: file.path, mode: file.mode })), routes: options.routes, runtime };
+            const frozenDigest = sha(json(binding));
+            const context = json({ ...binding, sources: files.map((file) => ({ path: file.path, content: text(file.bytes), original_content: text(file.bytes) })) });
+            assertRepairBounded({ context, source_facts: originalFacts }, MAX_REPAIR_PACKET_BYTES);
+            const reread = await readContainedAbsoluteFile(parseAllowedRootsEnv({ rejectBroadRoots: true }), options.contractPath, { wantContent: true, requireRegular: true, requireExactRequestedPath: true, maxBytes: MAX_REPAIR_CONTRACT_BYTES });
+            if (sha(reread.content) !== binding.contract_sha256)
+                throw new Error("repair contract changed during capture");
+            assertCurrent(project, new Map(files.map((file) => [file.path, file.sha256])), new Map(files.map((file) => [file.path, file.mode])));
+            native.signal.throwIfAborted();
+            const evidence = mkdtempSync(join(parent, `repair-${options.runId}-`));
+            try {
+                mkdirSync(join(evidence, "capture"), { mode: 0o700 });
+                for (const [index, file] of files.entries())
+                    writeFileSync(join(evidence, "capture", `${index}.bytes`), file.bytes, { flag: "wx", mode: 0o600 });
+                writeFileSync(join(evidence, "contract.json"), contractText, { flag: "wx", mode: 0o600 });
+                writeFileSync(join(evidence, "capture.json"), json({ frozen_digest: frozenDigest, ...binding }), { flag: "wx", mode: 0o600 });
+                return new PreparedNativeRepair(this.service, options, { ...input, project_path: project, evidence_parent: parent,
+                    verification_copy_parent: copyParent }, files, frozenDigest, evidence, runtime, this.rename);
+            }
+            catch (error) {
+                rmSync(evidence, { recursive: true, force: true });
+                throw error;
+            }
+        }, options.signal);
+    }
+    async readInterruptedRun(options) {
+        return this.service.operation(async () => {
+            let descriptorBytes;
+            try {
+                descriptorBytes = readBounded(options.runDir, "verified-repair-capture.v1.json", 4096);
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    return undefined;
+                throw error;
+            }
+            const descriptor = JSON.parse(descriptorBytes.toString("utf8"));
+            if (descriptor["schema_version"] !== "clinkx-verified-repair-capture-v1" || descriptor["run_id"] !== options.runId
+                || typeof descriptor["evidence_directory"] !== "string" || typeof descriptor["capture_sha256"] !== "string")
+                throw new Error("interrupted capture descriptor is invalid");
+            const evidence = authorizedDirectory(descriptor["evidence_directory"], false);
+            const captureBytes = readBounded(evidence, "capture.json", MAX_REPAIR_CONTRACT_BYTES);
+            if (sha(captureBytes) !== descriptor["capture_sha256"])
+                throw new Error("interrupted capture identity is unavailable");
+            const capture = JSON.parse(captureBytes.toString("utf8"));
+            const input = RepairInputSchema.parse(capture["input"]);
+            const routes = RepairRoutesSchema.parse(capture["routes"]);
+            const sourceFacts = RepairSourceFactSchema.array().min(1).max(1000).parse(capture["source_facts"]);
+            const modes = SourceModesSchema.parse(capture["source_modes"]);
+            if (modes.length !== sourceFacts.length || new Set(modes.map((entry) => entry.path)).size !== modes.length
+                || modes.some((entry) => !sourceFacts.some((fact) => fact.path === entry.path)))
+                throw new Error("interrupted mode capture is invalid");
+            const { frozen_digest: frozenDigest, ...binding } = capture;
+            if (typeof frozenDigest !== "string" || sha(json(binding)) !== frozenDigest)
+                throw new Error("interrupted frozen capture does not bind its facts");
+            const project = authorizedDirectory(input.project_path, true);
+            if (relative(input.evidence_parent, evidence).startsWith("..") || !evidence.startsWith(join(input.evidence_parent, `repair-${options.runId}-`)))
+                throw new Error("interrupted evidence path does not belong to the captured run");
+            const applied = [];
+            const unauthenticated = new Set();
+            for (const phase of ["regression", "implementation"]) {
+                let bytes;
+                try {
+                    bytes = readBounded(evidence, `${phase}-proposal.json`, MAX_REPAIR_PROPOSAL_BYTES);
+                }
+                catch (error) {
+                    if (error.code === "ENOENT")
+                        continue;
+                    throw error;
+                }
+                const batch = ReplacementBatchSchema.parse(JSON.parse(bytes.toString("utf8")));
+                let authenticated = false;
+                try {
+                    const pin = JSON.parse(readBounded(options.runDir, `verified-repair-${phase}.v1.json`, 4096).toString("utf8"));
+                    authenticated = pin["schema_version"] === "clinkx-verified-repair-batch-v1" && pin["run_id"] === options.runId
+                        && pin["phase"] === phase && pin["frozen_digest"] === frozenDigest && pin["proposal_sha256"] === sha(bytes);
+                }
+                catch { /* An uncommitted or altered proposal cannot authenticate replacement bytes. */ }
+                const allowed = phase === "regression" ? input.regression_paths : input.implementation_paths;
+                for (const replacement of batch) {
+                    if (!allowed.includes(replacement.path) || sourceFacts.find((fact) => fact.path === replacement.path)?.sha256 !== replacement.original_sha256)
+                        throw new Error("interrupted proposal is outside captured scope");
+                    applied.push({ phase, path: replacement.path, original_sha256: replacement.original_sha256,
+                        replacement_sha256: sha(Buffer.from(replacement.replacement_text)), status: "unknown" });
+                    if (!authenticated)
+                        unauthenticated.add(replacement.path);
+                }
+            }
+            const current = [];
+            let total = 0;
+            for (const fact of sourceFacts) {
+                try {
+                    const bytes = readBounded(project, fact.path, Math.min(16 * 1024 * 1024, 64 * 1024 * 1024 - total));
+                    total += bytes.length;
+                    if (total > 64 * 1024 * 1024)
+                        throw new Error("interrupted declared inputs exceed capture bound");
+                    current.push({ path: fact.path, sha256: sha(bytes), size_bytes: bytes.length });
+                }
+                catch { /* Missing declared files remain unknown; no reads become mutation authority. */ }
+            }
+            const reconciled = reconcileAppliedPaths(project, applied);
+            for (const entry of reconciled)
+                if (unauthenticated.has(entry.path) && entry.status !== "original")
+                    entry.status = "unknown";
+            const unexplained = current.filter((fact) => {
+                const original = sourceFacts.find((source) => source.path === fact.path);
+                const edit = reconciled.find((entry) => entry.path === fact.path && !unauthenticated.has(entry.path));
+                return fact.sha256 !== original.sha256 && (edit === undefined || fact.sha256 !== edit.replacement_sha256);
+            });
+            const modeDrift = modes.filter((entry) => {
+                try {
+                    return (lstatSync(safePath(project, entry.path)).mode & 0o7777) !== entry.mode;
+                }
+                catch {
+                    return true;
+                }
+            });
+            const unknown = reconciled.some((entry) => entry.status === "unknown") || current.length !== sourceFacts.length || unexplained.length > 0 || modeDrift.length > 0;
+            return RepairRecordSchema.parse({ schema_version: "clinkx-verified-repair-record-v1", run_id: options.runId,
+                execution_status: "interrupted", repair_status: unknown ? "failed" : "incomplete", frozen_digest: frozenDigest,
+                project_path: project, routes, source_facts: sourceFacts, current_source_facts: current, applied_paths: reconciled,
+                proofs: [], gaps: ["Worker ended without terminal publication; current hashes only classify the retained admitted edits.",
+                    "Original live proof pins and cleanup completion are unavailable; no verification or mutation replay is authorized.",
+                    ...[...unauthenticated].slice(0, 12).map((path) => `Uncommitted or altered proposal: ${path}; replacement bytes are unknown.`),
+                    ...unexplained.slice(0, 12).map((fact) => `Unexplained declared input drift: ${fact.path}`),
+                    ...modeDrift.slice(0, 12).map((entry) => `Declared input mode drift: ${entry.path}`)],
+                error_phase: "interrupted", owner_acceptance: "not_recorded",
+                owner_next_steps: ["Inspect current edits and retained private capture; preserve unknown changes and submit a fresh explicit run contract.",
+                    "Inspect possible .clinkx-repair-*.tmp residue from a killed write; confirm ownership before deleting anything."],
+                limitations: ["Read-only interrupted-run reconciliation establishes current declared byte classifications, not successful phase execution or acceptance.",
+                    "Owned copy or command resources from a killed worker may require operator inspection; this read does not delete or replay anything."],
+            });
+        });
+    }
+}
+class PreparedNativeRepair {
+    service;
+    options;
+    input;
+    files;
+    frozenDigest;
+    evidence;
+    runtime;
+    rename;
+    step = "captured";
+    activePhase = "capture";
+    failure;
+    gaps = [];
+    replacements = new Map();
+    expected;
+    modes;
+    applied = [];
+    proofs = [];
+    integrity = new Map();
+    investigation;
+    fix;
+    review;
+    copy;
+    closed = false;
+    constructor(service, options, input, files, frozenDigest, evidence, runtime, rename) {
+        this.service = service;
+        this.options = options;
+        this.input = input;
+        this.files = files;
+        this.frozenDigest = frozenDigest;
+        this.evidence = evidence;
+        this.runtime = runtime;
+        this.rename = rename;
+        this.expected = new Map(files.map((file) => [file.path, file.sha256]));
+        this.modes = new Map(files.map((file) => [file.path, file.mode]));
+    }
+    async capture(signal) {
+        await this.assertProviderPhase("investigate", signal);
+        const captureBytes = readBounded(this.evidence, "capture.json", MAX_REPAIR_CONTRACT_BYTES);
+        writeFileSync(join(this.options.runDir, "verified-repair-capture.v1.json"), json({ schema_version: "clinkx-verified-repair-capture-v1",
+            run_id: this.options.runId, evidence_directory: this.evidence, capture_sha256: sha(captureBytes) }), { mode: 0o600, flag: "wx" });
+        return this.packet("capture");
+    }
+    validateProviderOutput(value) {
+        assertRepairBounded(value, MAX_REPAIR_PROPOSAL_BYTES);
+        const content = JSON.stringify(value);
+        if (hasCredentialTokenShape(content) || hasDisallowedSecretMaterial(content, false))
+            throw new RepairGateError("repair artifact contains credential-like material; publication is rejected");
+    }
+    async assertProviderPhase(phase, signal) {
+        signal?.throwIfAborted();
+        this.requireStep(phase === "investigate" ? "captured" : phase === "repair" ? "reproduced" : "fixed");
+        try {
+            this.assertRuntime();
+            assertCurrent(this.input.project_path, this.expected, this.modes);
+        }
+        catch (error) {
+            this.fail(error);
+            throw error;
+        }
+        if (phase === "review") {
+            try {
+                await this.service.operation((native) => this.inspectFixed(native), signal);
+            }
+            catch (error) {
+                this.fail(error);
+                throw error;
+            }
+        }
+    }
+    async reproduce(proposal, signal) {
+        return this.phase("reproduce", signal, async (native) => {
+            this.requireStep("captured");
+            assertRepairBounded(proposal, MAX_REPAIR_PROPOSAL_BYTES);
+            const parsed = InvestigationSchema.parse(proposal);
+            this.assertIdentity(parsed.frozen_digest);
+            assertRepairCitations(parsed.diagnosis.citations, facts(this.files, this.replacements), this.sourceText());
+            this.investigation = parsed;
+            this.apply(parsed.regression_replacements, "regression", this.input.regression_paths, native.signal);
+            await this.run(native, "reproduce", this.input.project_path, this.input.regression_manifest, "assertion_failed");
+            this.step = "reproduced";
+            return this.packet("reproduce");
+        });
+    }
+    async fixed(proposal, signal) {
+        return this.phase("fixed", signal, async (native) => {
+            this.requireStep("reproduced");
+            assertRepairBounded(proposal, MAX_REPAIR_PROPOSAL_BYTES);
+            const parsed = FixProposalSchema.parse(proposal);
+            this.assertIdentity(parsed.frozen_digest);
+            assertRepairCitations(parsed.citations, facts(this.files, this.replacements), this.sourceText());
+            this.fix = parsed;
+            this.apply(parsed.implementation_replacements, "implementation", this.input.implementation_paths, native.signal);
+            for (const proof of this.proofs)
+                proof.applicable = false;
+            await this.run(native, "fixed_regression", this.input.project_path, this.input.regression_manifest, "assertion_passed");
+            await this.run(native, "fixed_required", this.input.project_path, this.input.required_manifest);
+            this.inspectFixed(native);
+            this.step = "fixed";
+            return this.packet("fixed");
+        });
+    }
+    async independently(review, signal) {
+        return this.phase("independent", signal, async (native) => {
+            this.requireStep("fixed");
+            assertRepairBounded(review, MAX_REPAIR_PROPOSAL_BYTES);
+            this.review = RepairReviewSchema.parse(review);
+            assertIndependentRepairReview(this.review, this.frozenDigest, facts(this.files, this.replacements), this.reviewProofs(), this.sourceText());
+            this.inspectFixed(native);
+            if (this.input.copy_preparation.status === "unavailable")
+                throw new RepairGateError("independent verification unavailable: " + this.input.copy_preparation.reason, "blocked");
+            this.copy = mkdtempSync(join(this.input.verification_copy_parent, `clinkx-repair-${this.options.runId}-`));
+            try {
+                materialize(this.copy, this.files, this.replacements);
+                this.checkCopy();
+                await this.run(native, "copy_preparation", this.copy, this.input.copy_preparation.manifest);
+                this.checkCopy();
+                await this.run(native, "copy_fixed", this.copy, this.input.regression_manifest, "assertion_passed");
+                for (const path of this.input.implementation_paths) {
+                    const file = this.files.find((file) => file.path === path);
+                    writeReplacement(this.copy, path, file.bytes, file.mode, this.expected.get(path), native.signal);
+                }
+                this.checkCopy(true);
+                await this.run(native, "copy_without_fix", this.copy, this.input.regression_manifest, "assertion_failed", true);
+                for (const path of this.input.implementation_paths) {
+                    const file = this.files.find((file) => file.path === path);
+                    writeReplacement(this.copy, path, this.replacements.get(path) ?? file.bytes, file.mode, file.sha256, native.signal);
+                }
+                this.checkCopy();
+                await this.run(native, "copy_restored", this.copy, this.input.regression_manifest, "assertion_passed");
+                this.inspectFixed(native);
+                await this.run(native, "final_required", this.input.project_path, this.input.required_manifest);
+                const final = this.proofs.find((proof) => proof.phase === "final_required");
+                this.inspectProof(native, final);
+                const attached = await native.attach({ project: this.input.project_path, manifest: this.input.required_manifest,
+                    evidence: final.evidence_directory }, { runId: this.options.runId, runsRoot: resolve(this.options.runDir, ".."),
+                    requestId: randomUUID(), pin: final.expectations_sha256 });
+                if (attached.status !== "complete")
+                    throw new RepairGateError("final verification attachment is not complete");
+                this.step = "independent";
+                return this.packet("independent");
+            }
+            finally {
+                this.removeCopy();
+            }
+        });
+    }
+    async abort(reason) {
+        if (reason !== null && typeof reason === "object" && "kind" in reason && reason.kind === "invalid_artifact") {
+            this.failure = "failed";
+            this.activePhase = "phase" in reason && typeof reason.phase === "string" ? reason.phase : "provider_artifact";
+            const message = "message" in reason && typeof reason.message === "string" ? reason.message : "invalid provider artifact";
+            if (this.gaps.length < 64)
+                this.gaps.push(message.slice(0, 6000));
+            return;
+        }
+        if (this.failure === undefined) {
+            this.failure = "incomplete";
+            this.gaps.push(reason instanceof Error ? reason.message.slice(0, 6000) || "workflow interrupted" : "workflow interrupted or provider delivery unavailable");
+        }
+    }
+    async cleanup() { this.removeCopy(); this.closed = true; }
+    async record(executionStatus) {
+        const current = [];
+        for (const file of this.files) {
+            try {
+                const bytes = readBounded(this.input.project_path, file.path);
+                current.push({ path: file.path, sha256: sha(bytes), size_bytes: bytes.length });
+            }
+            catch {
+                if (!this.gaps.includes(`declared input unavailable: ${file.path}`))
+                    this.gaps.push(`declared input unavailable: ${file.path}`);
+                this.failure = "failed";
+            }
+        }
+        try {
+            assertCurrent(this.input.project_path, this.expected, this.modes);
+        }
+        catch (error) {
+            this.failure = "failed";
+            this.fail(error);
+            for (const proof of this.proofs)
+                if (proof.project_path === this.input.project_path)
+                    proof.applicable = false;
+        }
+        for (const [index, entry] of reconcileAppliedPaths(this.input.project_path, this.applied).entries())
+            this.applied[index] = entry;
+        if (current.some((file) => this.expected.get(file.path) !== file.sha256)) {
+            this.failure = "failed";
+            for (const proof of this.proofs)
+                if (proof.project_path === this.input.project_path)
+                    proof.applicable = false;
+            if (!this.gaps.includes("declared inputs changed before terminal publication"))
+                this.gaps.push("declared inputs changed before terminal publication");
+        }
+        const verified = this.step === "independent" && this.failure === undefined && executionStatus === "completed" && this.closed;
+        if (!verified && this.closed && this.gaps.length === 0)
+            this.gaps.push("repair did not complete every required phase");
+        const record = RepairRecordSchema.parse({ schema_version: "clinkx-verified-repair-record-v1", run_id: this.options.runId,
+            execution_status: executionStatus, repair_status: verified ? "verified" : this.failure ?? "incomplete", frozen_digest: this.frozenDigest,
+            project_path: this.input.project_path, routes: this.options.routes, source_facts: facts(this.files, new Map()), current_source_facts: current,
+            ...(this.step === "fixed" || this.step === "independent" ? { fixed_source_digest: repairSourceDigest(facts(this.files, this.replacements)) } : {}),
+            applied_paths: this.applied, proofs: this.proofs, ...(this.review === undefined ? {} : { review: this.review }),
+            gaps: this.gaps, ...(verified ? {} : { error_phase: this.activePhase }), owner_acceptance: "not_recorded",
+            owner_next_steps: ["Inspect the retained edits, causal proof and independent findings before recording acceptance or integrating.",
+                ...(verified ? [] : ["Preserve current edits; resolve the reported gap and submit a fresh explicit repair contract. Interrupted mutations cannot resume."])],
+            limitations: ["Scope is limited to declared inputs and reviewed commands; external services and the full environment are not authenticated.",
+                "Providers have prompt restrictions, without an enforced filesystem sandbox.", "In-place writes are per-file replacements, not a multi-file transaction; failed or cancelled runs preserve edits.",
+                "Copy evidence identifies the disposable copy; final required proof identifies the selected working tree.", "Verification is separate from owner acceptance and general engineering benefit remains unknown."],
+        });
+        assertRepairBounded(record, MAX_REPAIR_RECORD_BYTES);
+        if (this.closed) {
+            const temporary = join(this.evidence, `.terminal-${randomUUID()}.tmp`);
+            writeFileSync(temporary, json(record), { mode: 0o600, flag: "wx" });
+            renameSync(temporary, join(this.evidence, "terminal-record.json"));
+        }
+        return record;
+    }
+    requireStep(step) {
+        if (this.closed || this.failure !== undefined || this.step !== step)
+            throw new RepairGateError(`repair phase prerequisite unavailable: expected ${step}`, "blocked");
+    }
+    assertIdentity(digest) { if (digest !== this.frozenDigest)
+        throw new RepairGateError("proposal frozen identity mismatch"); }
+    sourceText() { return new Map(this.files.map((file) => [file.path, text(this.replacements.get(file.path) ?? file.bytes)])); }
+    reviewProofs() { return this.proofs.filter((proof) => proof.phase === "fixed_regression" || proof.phase === "fixed_required").map(proofRef); }
+    packet(phase, replacements = this.replacements) {
+        const packet = RepairPacketSchema.parse({ schema_version: "clinkx-verified-repair-packet-v1", frozen_digest: this.frozenDigest,
+            phase, source_facts: facts(this.files, replacements), proofs: this.proofs,
+            context: json({ defect: this.input.defect, observation: this.input.observation, runtime: this.runtime,
+                regression_paths: this.input.regression_paths, implementation_paths: this.input.implementation_paths,
+                sources: this.files.map((file) => ({ path: file.path, content: text(replacements.get(file.path) ?? file.bytes),
+                    original_sha256: file.sha256, original_content: text(file.bytes) })),
+                ...(this.investigation === undefined ? {} : { diagnosis: InvestigationSchema.parse(this.investigation).diagnosis }),
+                ...(this.fix === undefined ? {} : { fix_explanation: FixProposalSchema.parse(this.fix).explanation }),
+                fixed_source_digest: repairSourceDigest(facts(this.files, replacements)), review_proof_refs: this.reviewProofs() }),
+        });
+        assertRepairBounded(packet, MAX_REPAIR_PACKET_BYTES);
+        return packet;
+    }
+    apply(batch, phase, allowed, signal) {
+        assertCurrent(this.input.project_path, this.expected, this.modes);
+        const validated = batch.map((replacement) => {
+            if (!allowed.includes(replacement.path) || replacement.original_sha256 !== this.expected.get(replacement.path))
+                throw new RepairGateError("replacement path or original hash is not admitted");
+            const file = this.files.find((file) => file.path === replacement.path);
+            const bytes = Buffer.from(replacement.replacement_text, "utf8");
+            if (hasCredentialTokenShape(replacement.replacement_text) || hasDisallowedSecretMaterial(replacement.replacement_text, false))
+                throw new RepairGateError("replacement contains credential-like material; no batch writes were admitted");
+            if (text(bytes) !== replacement.replacement_text || sha(bytes) === replacement.original_sha256)
+                throw new RepairGateError("replacement must change exact regular UTF-8 bytes");
+            return { replacement, file, bytes };
+        });
+        const proposed = new Map(this.replacements);
+        for (const item of validated)
+            proposed.set(item.replacement.path, item.bytes);
+        this.packet(phase === "regression" ? "reproduce" : "fixed", proposed);
+        // Retain the entire admitted batch before the first rename for crash reconciliation.
+        const proposalBytes = json(batch);
+        writeFileSync(join(this.evidence, `${phase}-proposal.json`), proposalBytes, { mode: 0o600, flag: "wx" });
+        writeFileSync(join(this.options.runDir, `verified-repair-${phase}.v1.json`), json({ schema_version: "clinkx-verified-repair-batch-v1",
+            run_id: this.options.runId, phase, frozen_digest: this.frozenDigest, proposal_sha256: sha(proposalBytes) }), { mode: 0o600, flag: "wx" });
+        for (const { replacement, bytes } of validated)
+            this.applied.push({ phase, path: replacement.path,
+                original_sha256: replacement.original_sha256, replacement_sha256: sha(bytes), status: "original" });
+        for (const { replacement, file, bytes } of validated) {
+            assertCurrent(this.input.project_path, this.expected, this.modes);
+            writeReplacement(this.input.project_path, replacement.path, bytes, file.mode, replacement.original_sha256, signal, this.rename);
+            this.replacements.set(replacement.path, bytes);
+            this.expected.set(replacement.path, sha(bytes));
+            const entry = this.applied.find((entry) => entry.path === replacement.path);
+            entry.status = "applied";
+            // An interrupted receipt never authorizes replay. Current hashes classify the edit.
+            writeFileSync(join(this.evidence, `write-${this.applied.indexOf(entry)}.json`), json(entry), { mode: 0o600, flag: "wx" });
+            assertCurrent(this.input.project_path, this.expected, this.modes);
+        }
+    }
+    checkCopy(withoutFix = false) {
+        if (this.copy === undefined)
+            throw new Error("owned verification copy is unavailable");
+        const expected = new Map(this.expected);
+        if (withoutFix)
+            for (const path of this.input.implementation_paths)
+                expected.set(path, this.files.find((file) => file.path === path).sha256);
+        assertCurrent(this.copy, expected, this.modes);
+    }
+    async run(native, phase, project, manifest, outcome, withoutFix = false) {
+        this.activePhase = phase;
+        this.assertRuntime();
+        assertCurrent(this.input.project_path, this.expected, this.modes);
+        if (project !== this.input.project_path)
+            this.checkCopy(withoutFix);
+        const evidence = join(this.evidence, `attempt-${phase}`);
+        const options = { project, manifest, evidence };
+        const result = await native.run(options);
+        // The original pin comes from the runner return, never a later evidence read.
+        const pin = result.expectations_sha256;
+        const expected = ExpectedSchema.parse(JSON.parse(readBounded(evidence, "expected.json", 2 * 1024 * 1024).toString("utf8")));
+        const proof = { phase, evidence_directory: evidence, expectations_sha256: pin,
+            project_path: project, source_digest: expected.expectations.identity.source_sha256,
+            coverage_status: result.status, applicable: result.status !== "inapplicable" };
+        this.proofs.push(proof);
+        const integrity = new Map();
+        for (const path of ["expected.json", "observations.json", "completion.json", "proof.json",
+            ...expected.manifest.checks.flatMap((check) => [`checks/${check.id}/result.json`, `checks/${check.id}/stdout.log`, `checks/${check.id}/stderr.log`])]) {
+            integrity.set(path, sha(readBounded(evidence, path, path.endsWith(".log") ? 1024 * 1024 : 2 * 1024 * 1024)));
+        }
+        this.integrity.set(evidence, integrity);
+        assertCurrent(this.input.project_path, this.expected, this.modes);
+        if (project !== this.input.project_path)
+            this.checkCopy(withoutFix);
+        const inspected = native.inspect(options, pin);
+        proof.coverage_status = inspected.status;
+        proof.applicable = !inspected.reasons.some((reason) => ["inputs_changed_during_run", "current_identity_mismatch", "current_identity_unavailable"].includes(reason.code));
+        if (outcome !== undefined) {
+            const id = this.input.observation.check_id;
+            const command = ResultSchema.parse(JSON.parse(readBounded(evidence, `checks/${id}/result.json`, 16 * 1024).toString("utf8")));
+            let observation;
+            try {
+                observation = parseRegressionOutcome(readBounded(evidence, `checks/${id}/stdout.log`, 1024 * 1024).toString("utf8"), this.input.observation);
+            }
+            catch {
+                throw new RepairGateError("regression outcome is invalid or does not bind the reviewed case and assertion; raw captures remain private");
+            }
+            proof.outcome = observation;
+            if (observation.outcome !== outcome || command.signal !== null || !command.cleanup_ok
+                || (outcome === "assertion_failed" ? command.reason !== "nonzero_exit" || command.exit_code === null || command.exit_code === 0
+                    : command.reason !== "passed" || command.exit_code !== 0))
+                throw new RepairGateError("exact regression assertion was not observed with a clean harness");
+            if (outcome === "assertion_failed") {
+                if (inspected.status !== "failed" || inspected.reasons.some((reason) => !["failed_check", "command_failed"].includes(reason.code)))
+                    throw new RepairGateError("failed regression proof has invalid or inapplicable evidence");
+            }
+            else if (inspected.status !== "complete")
+                throw new RepairGateError("fixed regression native coverage is not complete");
+        }
+        else if (inspected.status !== "complete")
+            throw new RepairGateError("required native coverage is not complete");
+    }
+    inspectProof(native, proof) {
+        const digests = this.integrity.get(proof.evidence_directory);
+        if (digests === undefined)
+            throw new RepairGateError("original phase capture authority unavailable");
+        for (const [path, digest] of digests)
+            if (sha(readBounded(proof.evidence_directory, path, path.endsWith(".log") ? 1024 * 1024 : 2 * 1024 * 1024)) !== digest)
+                throw new RepairGateError("phase capture changed since the host retained it");
+        const manifest = proof.phase === "fixed_regression" ? this.input.regression_manifest : this.input.required_manifest;
+        const inspected = native.inspect({ project: this.input.project_path, manifest, evidence: proof.evidence_directory }, proof.expectations_sha256);
+        proof.coverage_status = inspected.status;
+        proof.applicable = inspected.status === "complete";
+        if (inspected.status !== "complete")
+            throw new RepairGateError("fixed proof no longer qualifies with its original pin");
+    }
+    inspectFixed(native) {
+        this.assertRuntime();
+        assertCurrent(this.input.project_path, this.expected, this.modes);
+        for (const phase of ["fixed_regression", "fixed_required"]) {
+            const proof = this.proofs.find((proof) => proof.phase === phase);
+            if (proof === undefined)
+                throw new RepairGateError("fixed phase proof missing", "blocked");
+            this.inspectProof(native, proof);
+        }
+    }
+    async phase(phase, signal, operation) {
+        this.activePhase = phase;
+        try {
+            return await this.service.operation(operation, signal);
+        }
+        catch (error) {
+            this.fail(error);
+            throw error;
+        }
+    }
+    fail(error) {
+        if (this.failure === undefined)
+            this.failure = error instanceof RepairGateError ? error.status : "failed";
+        const message = error instanceof Error ? error.message : "repair host operation failed";
+        if (this.gaps.length < 64 && !this.gaps.includes(message))
+            this.gaps.push(message.slice(0, 6000) || "repair host operation failed");
+    }
+    assertRuntime() {
+        if (process.version !== this.runtime.node_version || runtimeDigest() !== this.runtime.sha256)
+            throw new RepairGateError("repair runtime identity changed since capture");
+    }
+    removeCopy() {
+        if (this.copy !== undefined) {
+            const removed = this.copy;
+            rmSync(removed, { recursive: true, force: true });
+            this.copy = undefined;
+            for (const proof of this.proofs)
+                if (proof.project_path === removed)
+                    proof.applicable = false;
+        }
+    }
+}
+//# sourceMappingURL=host.js.map