@tea-agent/loop-agent 0.41.0 → 0.42.0-next.1

package/dist/workflows/dag/context-transfer/context-bundle.js

@@ -0,0 +1,423 @@
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { CONTEXT_BUNDLE_LIMITS, computeBundleManifestSha256, contextBundleManifestV1Schema, effectiveNodeContextV1Schema, } from "../../../shared/context-transfer.js";
+import { redactSecretsWithFindings, redactSensitivePathsWithFindings, } from "../../../shared/preview.js";
+import { evaluatePiSessionCapability, renderPiSessionJsonl, } from "../../../adapters/context-transfer/pi-session.js";
+import { renderGenericHandoff, renderReadableTranscript, } from "./renderers.js";
+import { computeCanonicalHash } from "../../../task/contract/hash.js";
+import { readFileBoundarySafe } from "../path-safety.js";
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function canonicalJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+const sha256Hex = z.string().regex(/^[a-f0-9]{64}$/);
+/** Strict shape of the materialized managed-task-contract component. */
+const taskContractMaterialSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    taskId: z.string().min(1),
+    revision: z.number().int().nonnegative(),
+    projectionVersion: z.literal(1),
+    canonicalizerVersion: z.literal(1),
+    taskConfigSchemaVersion: z.literal(1),
+    sourceHashes: z
+        .object({
+        requirementSha256: sha256Hex,
+        constraintsSha256: sha256Hex,
+        referenceManifestSha256: sha256Hex.optional(),
+        requirementLedgerSha256: sha256Hex.optional(),
+    })
+        .strict(),
+    taskConfigSha256: sha256Hex,
+    canonicalHash: sha256Hex,
+})
+    .strict();
+/**
+ * Read a run-owned material with full path safety and TOCTOU protection:
+ * reject symlinked or hardlinked intermediates/final entry and non-regular
+ * files (device/FIFO), open with O_NOFOLLOW and read via the fd so a swapped
+ * path can never redirect the bundle to content outside the run. Hash/size
+ * verification still runs on the returned bytes.
+ */
+async function readBundleMaterial(runDir, relativePath) {
+    try {
+        return await readFileBoundarySafe({
+            boundaryRoot: path.resolve(runDir),
+            targetPath: path.resolve(runDir, ...relativePath.split("/")),
+            label: `context bundle material ${relativePath}`,
+        });
+    }
+    catch (error) {
+        throw new Error(`CONTEXT_COMPONENT_UNAVAILABLE: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function isTextualMedia(mediaType) {
+    const normalized = mediaType.split(";", 1)[0].trim().toLowerCase();
+    return (normalized.startsWith("text/") ||
+        normalized.includes("json") ||
+        normalized.includes("xml") ||
+        normalized.includes("yaml") ||
+        normalized.includes("javascript"));
+}
+function applyBundleSecurityPass(files, profile) {
+    let detectedFindingCount = 0;
+    let redactedFindingCount = 0;
+    let credentialFindingCount = 0;
+    let sensitivePathFindingCount = 0;
+    const securedFiles = files.map((file) => {
+        if (file.redaction === "omitted" || !isTextualMedia(file.mediaType)) {
+            return file;
+        }
+        const sourceText = file.bytes.toString("utf8");
+        const credentialScan = redactSecretsWithFindings(sourceText);
+        const pathScan = redactSensitivePathsWithFindings(sourceText);
+        const fileFindingCount = credentialScan.findingCount + pathScan.findingCount;
+        credentialFindingCount += credentialScan.findingCount;
+        sensitivePathFindingCount += pathScan.findingCount;
+        detectedFindingCount += fileFindingCount;
+        if (profile === "raw" || fileFindingCount === 0)
+            return file;
+        redactedFindingCount += fileFindingCount;
+        const redacted = redactSensitivePathsWithFindings(credentialScan.redacted).redacted;
+        return {
+            ...file,
+            bytes: Buffer.from(redacted, "utf8"),
+            redaction: "redacted",
+            sourceSha256: sha256(file.bytes),
+        };
+    });
+    return {
+        files: securedFiles,
+        detectedFindingCount,
+        redactedFindingCount,
+        credentialFindingCount,
+        sensitivePathFindingCount,
+    };
+}
+export async function buildContextBundle(input) {
+    const profile = input.profile ?? "redacted";
+    const target = input.target ?? "generic";
+    if (profile === "raw" && !input.rawAcknowledgement) {
+        throw new Error("RAW_EXPORT_ACKNOWLEDGEMENT_REQUIRED");
+    }
+    const receiptPath = path.join(input.runDir, input.nodeId, "context-receipts", `attempt-${input.attempt}.json`);
+    let receiptBytes;
+    try {
+        receiptBytes = await readFileBoundarySafe({
+            boundaryRoot: path.resolve(input.runDir),
+            targetPath: receiptPath,
+            label: "context receipt",
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/missing|ENOENT|no such/i.test(message)) {
+            throw new Error("CONTEXT_RECEIPT_MISSING");
+        }
+        throw new Error(`CONTEXT_COMPONENT_UNAVAILABLE: ${message}`);
+    }
+    const receipt = effectiveNodeContextV1Schema.parse(JSON.parse(receiptBytes.toString("utf8")));
+    if (receipt.identity.runId !== input.runId ||
+        receipt.identity.nodeId !== input.nodeId ||
+        receipt.identity.attempt !== input.attempt) {
+        throw new Error("CONTEXT_COMPONENT_UNAVAILABLE: receipt ownership mismatch");
+    }
+    let files = [];
+    for (const component of receipt.orderedComponents) {
+        if (!component.materializedPath || component.inclusion === "omitted")
+            continue;
+        const source = await readBundleMaterial(input.runDir, component.materializedPath);
+        if (source.byteLength !== component.bytes ||
+            sha256(source) !== component.sha256) {
+            throw new Error("CONTEXT_COMPONENT_UNAVAILABLE: material hash mismatch");
+        }
+        if (component.kind === "task-contract") {
+            // Independently verify the materialized canonical hash: strictly parse
+            // the canonical-hash material (versions, sha256s, sourceHashes), then
+            // recompute computeCanonicalHash and require it to match both the
+            // material's claim and the receipt's authoritative hash. Without strict
+            // parsing, malformed materials (e.g. non-object sourceHashes) could be
+            // accepted as long as they carry a self-consistent hash.
+            let parsed;
+            try {
+                parsed = taskContractMaterialSchema.safeParse(JSON.parse(source.toString("utf8")));
+            }
+            catch {
+                throw new Error("CONTEXT_COMPONENT_UNAVAILABLE: task contract material is not valid JSON");
+            }
+            if (!parsed.success) {
+                throw new Error(`CONTEXT_COMPONENT_UNAVAILABLE: task contract material failed strict validation: ${parsed.error.issues
+                    .map((issue) => issue.path.join("."))
+                    .join(", ")}`);
+            }
+            const material = parsed.data;
+            const recomputed = computeCanonicalHash({
+                sourceHashes: material.sourceHashes,
+                taskConfigSha256: material.taskConfigSha256,
+                projectionVersion: material.projectionVersion,
+                canonicalizerVersion: material.canonicalizerVersion,
+                taskConfigSchemaVersion: material.taskConfigSchemaVersion,
+            });
+            if (recomputed !== material.canonicalHash ||
+                material.canonicalHash !== component.authoritativeSource?.sha256) {
+                throw new Error("CONTEXT_COMPONENT_UNAVAILABLE: task contract canonical hash mismatch");
+            }
+        }
+        const bundlePath = component.kind === "system-prompt"
+            ? "context/system-prompt.md"
+            : component.kind === "user-prompt"
+                ? "context/user-message.md"
+                : `context/components/${String(component.index).padStart(4, "0")}.bin`;
+        files.push({
+            path: bundlePath,
+            bytes: source,
+            mediaType: component.mediaType,
+            origin: component.source.identity,
+            redaction: "none",
+        });
+    }
+    files.push({
+        path: "context/receipt.json",
+        bytes: receiptBytes,
+        mediaType: "application/json",
+        origin: `${input.nodeId}/context-receipts/attempt-${input.attempt}.json`,
+        redaction: "none",
+    });
+    let sessionEventLines = [];
+    if (target === "readable") {
+        try {
+            sessionEventLines = (await readBundleMaterial(input.runDir, `${input.nodeId}/session-events.jsonl`)).toString("utf8").split(/\r?\n/).filter(Boolean);
+        }
+        catch (error) {
+            // Only a genuinely absent event stream (missing file) is treated as "no
+            // events" for historical/non-Pi nodes. Any safety rejection (symlink /
+            // hardlink / non-regular material) must fail closed: an attacker must not
+            // be able to mask a tampered stream as "node had no events".
+            const message = error instanceof Error ? error.message : String(error);
+            if (!/missing|no such|ENOENT|not found/i.test(message)) {
+                throw error;
+            }
+        }
+    }
+    const handoff = renderGenericHandoff({
+        runId: input.runId,
+        nodeId: input.nodeId,
+        attempt: input.attempt,
+        receipt,
+        profile,
+    });
+    files.push({
+        path: target === "readable" ? "transcript.md" : "handoff.md",
+        bytes: Buffer.from(target === "readable"
+            ? renderReadableTranscript({ receipt, eventLines: sessionEventLines })
+            : handoff, "utf8"),
+        mediaType: "text/markdown; charset=utf-8",
+        origin: target === "readable"
+            ? "loop-agent/readable-transcript-v1"
+            : "loop-agent/generic-handoff-v1",
+        redaction: "none",
+    });
+    const piCapability = target === "pi-session"
+        ? evaluatePiSessionCapability(receipt)
+        : undefined;
+    if (target === "pi-session" && piCapability?.compatible) {
+        files.push({
+            path: "pi/session.jsonl",
+            bytes: Buffer.from(renderPiSessionJsonl({
+                receipt,
+                runId: input.runId,
+                nodeId: input.nodeId,
+                attempt: input.attempt,
+            }), "utf8"),
+            mediaType: "application/x-ndjson",
+            origin: "loop-agent/pi-session-adapter-v1",
+            redaction: "none",
+        });
+    }
+    const securityPass = applyBundleSecurityPass(files, profile);
+    files = securityPass.files;
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    const totalBytes = files.reduce((total, file) => total + file.bytes.byteLength, 0);
+    if (files.length > CONTEXT_BUNDLE_LIMITS.fileCount ||
+        totalBytes > CONTEXT_BUNDLE_LIMITS.totalUncompressedBytes ||
+        files.some((file) => file.bytes.byteLength > CONTEXT_BUNDLE_LIMITS.singleFileBytes)) {
+        throw new Error("CONTEXT_BUNDLE_TOO_LARGE");
+    }
+    const runSpecBytes = await readBundleMaterial(input.runDir, "run.json");
+    const bundleSeed = {
+        runId: input.runId,
+        nodeId: input.nodeId,
+        attempt: input.attempt,
+        profile,
+        target,
+        contextDigest: receipt.contextDigest,
+    };
+    const manifestWithoutHash = {
+        schemaVersion: 1,
+        bundleId: `ctx-${sha256(JSON.stringify(bundleSeed)).slice(0, 24)}`,
+        createdAt: receipt.identity.capturedAt,
+        source: {
+            repoIdentity: sha256(path.resolve(input.runDir)).slice(0, 24),
+            runId: input.runId,
+            nodeId: input.nodeId,
+            attempt: input.attempt,
+        },
+        profile,
+        target,
+        reproducibility: {
+            level: target === "readable"
+                ? "readable-transcript"
+                : piCapability?.reproducibility ?? "semantic-handoff",
+            reasons: [
+                "dispatch messages and runtime capability facts captured before model call",
+                ...(piCapability?.reasonCodes ?? []),
+            ],
+            limitations: [
+                "model output and external tool state are not deterministic",
+                ...(piCapability?.limitations ?? []),
+            ],
+        },
+        bindings: {
+            frozenRunSpecSha256: sha256(runSpecBytes),
+            contextReceiptSha256: sha256(receiptBytes),
+            contextDigest: receipt.contextDigest,
+        },
+        runtime: {
+            executor: receipt.runtime.executor,
+            ...(receipt.runtime.resolvedModel
+                ? { model: receipt.runtime.resolvedModel }
+                : {}),
+            skills: receipt.runtime.skills.map((id) => ({ id })),
+            extensions: receipt.runtime.extensions.map((id) => ({
+                id,
+                status: "resolved",
+            })),
+            tools: receipt.runtime.activeTools.map((name) => ({
+                name,
+                available: true,
+            })),
+        },
+        files: files.map((file) => ({
+            path: file.path,
+            sha256: sha256(file.bytes),
+            bytes: file.bytes.byteLength,
+            mediaType: file.mediaType,
+            origin: file.origin,
+            redaction: file.redaction,
+            ...(file.sourceSha256 ? { sourceSha256: file.sourceSha256 } : {}),
+        })),
+        omissions: [],
+        security: {
+            secretScan: securityPass.detectedFindingCount > 0 ? "warning" : "pass",
+            findingCounts: {
+                detected: securityPass.detectedFindingCount,
+                credentials: securityPass.credentialFindingCount,
+                sensitivePaths: securityPass.sensitivePathFindingCount,
+                ...(profile === "redacted"
+                    ? { redacted: securityPass.redactedFindingCount }
+                    : {}),
+            },
+            ...(input.rawAcknowledgement
+                ? { rawAcknowledgement: input.rawAcknowledgement }
+                : {}),
+        },
+    };
+    const manifest = contextBundleManifestV1Schema.parse({
+        ...manifestWithoutHash,
+        bundleSha256: computeBundleManifestSha256(manifestWithoutHash),
+    });
+    const archiveFiles = [
+        ...files,
+        {
+            path: "manifest.json",
+            bytes: Buffer.from(canonicalJson(manifest), "utf8"),
+            mediaType: "application/json",
+            origin: "loop-agent/context-bundle-manifest-v1",
+            redaction: "none",
+        },
+    ].sort((a, b) => a.path.localeCompare(b.path));
+    return { manifest, files, zipBytes: deterministicZip(archiveFiles) };
+}
+export async function writeContextBundleDirectory(bundle, outputDir) {
+    await mkdir(outputDir, { recursive: true });
+    for (const file of bundle.files) {
+        const target = path.resolve(outputDir, ...file.path.split("/"));
+        if (!target.startsWith(`${path.resolve(outputDir)}${path.sep}`)) {
+            throw new Error("unsafe bundle output path");
+        }
+        await mkdir(path.dirname(target), { recursive: true });
+        await writeFile(target, file.bytes, { flag: "wx" });
+    }
+    await writeFile(path.join(outputDir, "manifest.json"), canonicalJson(bundle.manifest), { flag: "wx" });
+}
+const CRC_TABLE = Array.from({ length: 256 }, (_, index) => {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+        value = (value & 1) !== 0 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+    }
+    return value >>> 0;
+});
+function crc32(bytes) {
+    let crc = 0xffffffff;
+    for (const byte of bytes)
+        crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function deterministicZip(files) {
+    const localParts = [];
+    const centralParts = [];
+    let offset = 0;
+    for (const file of files) {
+        const name = Buffer.from(file.path, "utf8");
+        const data = file.bytes;
+        const crc = crc32(data);
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4);
+        local.writeUInt16LE(0x0800, 6);
+        local.writeUInt16LE(0, 8);
+        local.writeUInt16LE(0, 10);
+        local.writeUInt16LE(33, 12);
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(data.byteLength, 18);
+        local.writeUInt32LE(data.byteLength, 22);
+        local.writeUInt16LE(name.byteLength, 26);
+        local.writeUInt16LE(0, 28);
+        localParts.push(local, name, data);
+        const central = Buffer.alloc(46);
+        central.writeUInt32LE(0x02014b50, 0);
+        central.writeUInt16LE(20, 4);
+        central.writeUInt16LE(20, 6);
+        central.writeUInt16LE(0x0800, 8);
+        central.writeUInt16LE(0, 10);
+        central.writeUInt16LE(0, 12);
+        central.writeUInt16LE(33, 14);
+        central.writeUInt32LE(crc, 16);
+        central.writeUInt32LE(data.byteLength, 20);
+        central.writeUInt32LE(data.byteLength, 24);
+        central.writeUInt16LE(name.byteLength, 28);
+        central.writeUInt16LE(0, 30);
+        central.writeUInt16LE(0, 32);
+        central.writeUInt16LE(0, 34);
+        central.writeUInt16LE(0, 36);
+        central.writeUInt32LE(0, 38);
+        central.writeUInt32LE(offset, 42);
+        centralParts.push(central, name);
+        offset += local.byteLength + name.byteLength + data.byteLength;
+    }
+    const centralBytes = Buffer.concat(centralParts);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(0, 4);
+    end.writeUInt16LE(0, 6);
+    end.writeUInt16LE(files.length, 8);
+    end.writeUInt16LE(files.length, 10);
+    end.writeUInt32LE(centralBytes.byteLength, 12);
+    end.writeUInt32LE(offset, 16);
+    end.writeUInt16LE(0, 20);
+    return Buffer.concat([...localParts, centralBytes, end]);
+}

package/dist/workflows/dag/context-transfer/operator-actions.js

@@ -0,0 +1,61 @@
+import path from "node:path";
+import { buildArtifactBindingGraph } from "../artifact-bindings.js";
+import { readFileBoundarySafe } from "../path-safety.js";
+import { locateDagRun, readDagRunSpec, readDagRunState, } from "../lifecycle.js";
+import { executeDagArtifactOverrideRerun, planDagArtifactOverride, } from "../rerun-run.js";
+import { buildContextBundle, } from "./context-bundle.js";
+export async function buildDagRunContextBundle(input) {
+    const located = await locateDagRun(input.cwd, input.runId);
+    if (!located)
+        throw new Error(`dag run not found: ${input.runId}`);
+    return buildContextBundle({
+        runDir: located.runDir,
+        runId: input.runId,
+        nodeId: input.nodeId,
+        attempt: input.attempt,
+        profile: input.profile,
+        target: input.target,
+        ...(input.rawAcknowledgement
+            ? { rawAcknowledgement: input.rawAcknowledgement }
+            : {}),
+    });
+}
+export async function readRevisionParentArtifact(input) {
+    const located = await locateDagRun(input.cwd, input.runId);
+    if (!located || located.lifecycle !== "completed") {
+        throw new Error("artifact revision requires a completed parent run");
+    }
+    const spec = await readDagRunSpec(located.runDir);
+    const state = await readDagRunState(located.runDir);
+    const declaration = buildArtifactBindingGraph(spec).artifacts.find((entry) => entry.artifactId === input.artifactId &&
+        entry.producerNodeId === input.producerNodeId);
+    if (!declaration)
+        throw new Error("ARTIFACT_BINDING_UNAVAILABLE");
+    const fact = state.nodes[input.producerNodeId]?.declaredArtifacts?.find((entry) => entry.artifactId === input.artifactId);
+    if (fact?.status !== "materialized" || !fact.sha256 || !fact.revisionEligible) {
+        throw new Error("ARTIFACT_NOT_REVISION_ELIGIBLE");
+    }
+    const parentPath = path.resolve(located.runDir, ...declaration.path.split("/"));
+    const resolvedRunDir = path.resolve(located.runDir);
+    if (!parentPath.startsWith(`${resolvedRunDir}${path.sep}`)) {
+        throw new Error("ARTIFACT_REVISION_PATH_INVALID");
+    }
+    // Final regular single-link check (rejects symlink/hardlink/device/FIFO)
+    // on top of the per-segment boundary walk, with a TOCTOU-safe fd read.
+    const parentBytes = await readFileBoundarySafe({
+        boundaryRoot: resolvedRunDir,
+        targetPath: parentPath,
+        label: `artifact parent ${input.artifactId}`,
+    });
+    return {
+        declaration,
+        parentSha256: fact.sha256,
+        parentBytes,
+    };
+}
+export async function planArtifactRevisionContinuation(input) {
+    return planDagArtifactOverride(input);
+}
+export async function executeArtifactRevisionContinuation(input) {
+    return executeDagArtifactOverrideRerun(input);
+}

package/dist/workflows/dag/context-transfer/renderers.js

@@ -0,0 +1,93 @@
+function textFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (!part || typeof part !== "object")
+            return "";
+        const record = part;
+        if (record.type === "text" && typeof record.text === "string") {
+            return record.text;
+        }
+        if (record.type === "thinking" && typeof record.thinking === "string") {
+            return `[thinking captured]\n${record.thinking}`;
+        }
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+export function renderGenericHandoff(input) {
+    const componentTable = input.receipt.orderedComponents.map((component) => `| ${component.index} | ${component.kind} | ${component.logicalName} | ${component.inclusion} | ${component.sha256} |`);
+    return [
+        "# Agent handoff",
+        "",
+        `- run: ${input.runId}`,
+        `- node: ${input.nodeId}`,
+        `- attempt: ${input.attempt}`,
+        `- context digest: ${input.receipt.contextDigest}`,
+        `- profile: ${input.profile}`,
+        "",
+        "## Resume instructions",
+        "",
+        "Use `context/system-prompt.md` as system/developer context and `context/user-message.md` as the user message. Read other materialized components in receipt order. Verify every payload hash against `manifest.json` before importing. The bundle restores captured inputs, not deterministic model output, credentials, or external tool state.",
+        "",
+        "## Ordered context index",
+        "",
+        "| # | kind | name | inclusion | source sha256 |",
+        "|---:|---|---|---|---|",
+        ...componentTable,
+        "",
+    ].join("\n");
+}
+export function renderReadableTranscript(input) {
+    const output = [
+        "# Node transcript",
+        "",
+        `Context digest: ${input.receipt.contextDigest}`,
+        "",
+        "The exact dispatched system and user messages are stored in `context/`. Missing thinking or tool events are not reconstructed.",
+        "",
+    ];
+    let turn = 0;
+    const seenMessages = new Set();
+    for (const line of input.eventLines) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (event.type === "turn_start") {
+            turn += 1;
+            output.push(`## Turn ${turn}`, "");
+            continue;
+        }
+        if (event.type === "tool_execution_start") {
+            output.push(`### Tool call: ${String(event.toolName ?? "unknown")}`, "", "```json", JSON.stringify(event.args ?? null, null, 2), "```", "");
+            continue;
+        }
+        if (event.type === "tool_execution_end") {
+            output.push(`### Tool result: ${String(event.toolName ?? "unknown")}${event.isError === true ? " (error)" : ""}`, "", textFromContent(event.result?.content) || "[result not captured as text]", "");
+            continue;
+        }
+        if (event.type !== "message_end" || !event.message || typeof event.message !== "object") {
+            continue;
+        }
+        const message = event.message;
+        const fingerprint = JSON.stringify(message);
+        if (seenMessages.has(fingerprint))
+            continue;
+        seenMessages.add(fingerprint);
+        const role = typeof message.role === "string" ? message.role : "unknown";
+        const body = textFromContent(message.content);
+        output.push(`### ${role}`, "", body || "[message content not captured]", "");
+    }
+    if (turn === 0 && seenMessages.size === 0) {
+        output.push("No session events were captured for this attempt.", "");
+    }
+    return output.join("\n");
+}

package/dist/workflows/dag/frontend-writer-rollback.js

@@ -370,6 +370,38 @@ async function inspectPath(repoRoot, relPath, deps) {
         throw error;
     }
 }
+/**
+ * Build the CAS attempt side of a rollback journal from the current worktree.
+ * This is used by high-risk artifact continuations, where the baseline is
+ * captured before the child starts and the complete attempt inventory is
+ * derived after the child settles (including changes from dynamic writers).
+ */
+export async function recordWriterAttemptFromCurrent(snapshot, options) {
+    const deps = resolveDeps(options.dependencies);
+    const working = structuredClone(snapshot);
+    const baselineByPath = new Map(working.existingFiles.map((file) => [file.path, file]));
+    const currentMatches = [];
+    await walkMatchingEntries(options.repoRoot, "", working.writeSet, deps, (match) => currentMatches.push(match));
+    const candidatePaths = new Set([
+        ...baselineByPath.keys(),
+        ...currentMatches.map((match) => match.relPath),
+    ]);
+    const attemptChangedPaths = [];
+    const attemptFileHashes = {};
+    for (const relPath of [...candidatePaths].sort((left, right) => left.localeCompare(right))) {
+        const baseline = baselineByPath.get(relPath);
+        const current = await inspectPath(options.repoRoot, relPath, deps);
+        const currentHash = current.kind === "absent" ? "absent" : current.hash;
+        const baselineHash = baseline?.baselineSha256 ?? "absent";
+        if (currentHash === baselineHash)
+            continue;
+        attemptChangedPaths.push(relPath);
+        attemptFileHashes[relPath] = currentHash;
+    }
+    working.attemptChangedPaths = attemptChangedPaths;
+    working.attemptFileHashes = attemptFileHashes;
+    return frontendWriterRollbackV1Schema.parse(working);
+}
 function ensureJournalFile(working, relPath, baselineSha256, attemptSha256) {
     let file = working.journal.files[relPath];
     if (!file) {