harnery 0.22.0 → 0.23.0

package/dist/core/workflow/workspaces/paths.d.ts

@@ -0,0 +1,23 @@
+import type { FilesystemIdentity, ValidatedFilesystemRoot } from "./types.js";
+export type ValidatedRoot = ValidatedFilesystemRoot;
+export interface OpenContainedDirectory {
+    path: string;
+    descriptor_path: string;
+    fd: number;
+    identity: FilesystemIdentity;
+    close(): void;
+}
+export declare function filesystemIdentity(path: string): FilesystemIdentity;
+export declare function sameFilesystemIdentity(left: FilesystemIdentity, right: FilesystemIdentity): boolean;
+export declare function validateConfiguredRoot(root: string): ValidatedRoot;
+export declare function revalidateRoot(root: ValidatedRoot): void;
+export declare function assertSafeRelativeSegment(value: string, field: string): void;
+export declare function containsPath(root: string, candidate: string): boolean;
+export declare function assertContainedExisting(root: ValidatedRoot, candidate: string, label: string): string;
+export declare function createContainedDirectories(root: ValidatedRoot, segments: readonly string[]): string;
+export declare function openContainedDirectory(root: ValidatedRoot, segments: readonly string[]): OpenContainedDirectory;
+export declare function candidateUnderRoot(root: ValidatedRoot, segments: readonly string[]): string;
+export declare function assertPathIdentity(path: string, expected: FilesystemIdentity, label: string): void;
+export declare function descriptorBackedPathsSupported(): boolean;
+export declare function descriptorPath(fd: number): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/core/workflow/workspaces/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../src/core/workflow/workspaces/paths.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAI9E,MAAM,MAAM,aAAa,GAAG,uBAAuB,CAAC;AAEpD,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,CAAC;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAUnE;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,kBAAkB,EACxB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAIT;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAWlE;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CAQxD;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAiB5E;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAGrE;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,aAAa,EACnB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,MAAM,CAYR;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,aAAa,EACnB,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,MAAM,CAOR;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,aAAa,EACnB,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B,sBAAsB,CA2DxB;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAQ3F;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,kBAAkB,EAC5B,KAAK,EAAE,MAAM,GACZ,IAAI,CAON;AAwBD,wBAAgB,8BAA8B,IAAI,OAAO,CAOxD;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAKjD"}

package/dist/core/workflow/workspaces/paths.js

@@ -0,0 +1,191 @@
+import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, realpathSync, statSync, } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+const WINDOWS_AMBIGUOUS = /[<>:"|?*]|[ .]$/;
+export function filesystemIdentity(path) {
+    const stat = statSync(path, { bigint: true });
+    if (stat.dev < 0n || stat.ino <= 0n) {
+        throw new Error(`filesystem identity is unavailable for ${path}`);
+    }
+    return {
+        platform: process.platform,
+        device: stat.dev.toString(),
+        inode: stat.ino.toString(),
+    };
+}
+export function sameFilesystemIdentity(left, right) {
+    return (left.platform === right.platform && left.device === right.device && left.inode === right.inode);
+}
+export function validateConfiguredRoot(root) {
+    assertAbsoluteUnambiguous(root, "writable root");
+    if (!existsSync(root))
+        throw new Error(`writable root does not exist: ${root}`);
+    if (lstatSync(root).isSymbolicLink())
+        throw new Error(`writable root must not be a symlink: ${root}`);
+    if (!lstatSync(root).isDirectory())
+        throw new Error(`writable root is not a directory: ${root}`);
+    const realpath = realpathSync(root);
+    if (realpath !== root) {
+        throw new Error(`writable root must not contain symlink components: ${root}`);
+    }
+    return { configured: root, realpath, identity: filesystemIdentity(realpath) };
+}
+export function revalidateRoot(root) {
+    const current = validateConfiguredRoot(root.configured);
+    if (current.realpath !== root.realpath ||
+        !sameFilesystemIdentity(current.identity, root.identity)) {
+        throw new Error(`writable root identity changed: ${root.configured}`);
+    }
+}
+export function assertSafeRelativeSegment(value, field) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new Error(`${field} must be set`);
+    if (containsControl(value))
+        throw new Error(`${field} contains control characters`);
+    if (value !== value.normalize("NFC"))
+        throw new Error(`${field} has ambiguous Unicode normalization`);
+    if (isAbsolute(value) ||
+        value === "." ||
+        value === ".." ||
+        value.includes("/") ||
+        value.includes("\\")) {
+        throw new Error(`${field} must be one safe relative segment`);
+    }
+    if (process.platform === "win32" && WINDOWS_AMBIGUOUS.test(value)) {
+        throw new Error(`${field} is ambiguous on this platform`);
+    }
+}
+export function containsPath(root, candidate) {
+    const rel = relative(resolve(root), resolve(candidate));
+    return rel === "" || (rel !== ".." && !rel.startsWith(`..${separator()}`) && !isAbsolute(rel));
+}
+export function assertContainedExisting(root, candidate, label) {
+    revalidateRoot(root);
+    assertAbsoluteUnambiguous(candidate, label);
+    if (!existsSync(candidate))
+        throw new Error(`${label} does not exist: ${candidate}`);
+    if (lstatSync(candidate).isSymbolicLink())
+        throw new Error(`${label} must not be a symlink`);
+    const real = realpathSync(candidate);
+    if (!containsPath(root.realpath, real)) {
+        throw new Error(`${label} ${JSON.stringify(candidate)} escapes ${JSON.stringify(root.configured)}`);
+    }
+    return real;
+}
+export function createContainedDirectories(root, segments) {
+    const opened = openContainedDirectory(root, segments);
+    try {
+        return opened.path;
+    }
+    finally {
+        opened.close();
+    }
+}
+export function openContainedDirectory(root, segments) {
+    if (segments.length === 0)
+        throw new Error("contained directory requires at least one segment");
+    if (!descriptorBackedPathsSupported()) {
+        throw new Error("descriptor-backed workspace paths are unavailable");
+    }
+    const fds = [];
+    try {
+        revalidateRoot(root);
+        let cursor = root.realpath;
+        let parentFd = openSync(cursor, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+        fds.push(parentFd);
+        if (!sameFilesystemIdentity(filesystemIdentity(descriptorPath(parentFd)), root.identity)) {
+            throw new Error("writable root descriptor identity changed");
+        }
+        for (const [index, segment] of segments.entries()) {
+            assertSafeRelativeSegment(segment, `path segment ${index + 1}`);
+            const candidate = join(descriptorPath(parentFd), segment);
+            if (existsSync(candidate)) {
+                const stat = lstatSync(candidate);
+                if (stat.isSymbolicLink() || !stat.isDirectory()) {
+                    throw new Error(`contained path component is not an owned directory: ${join(cursor, segment)}`);
+                }
+            }
+            else {
+                mkdirSync(candidate, { mode: 0o700 });
+            }
+            const childFd = openSync(candidate, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+            fds.push(childFd);
+            const real = realpathSync(descriptorPath(childFd));
+            if (!containsPath(root.realpath, real)) {
+                throw new Error(`contained path escaped root: ${join(cursor, segment)}`);
+            }
+            cursor = real;
+            parentFd = childFd;
+        }
+        revalidateRoot(root);
+        let closed = false;
+        return {
+            path: cursor,
+            descriptor_path: descriptorPath(parentFd),
+            fd: parentFd,
+            identity: filesystemIdentity(descriptorPath(parentFd)),
+            close() {
+                if (closed)
+                    return;
+                for (const fd of [...fds].reverse())
+                    closeSync(fd);
+                closed = true;
+            },
+        };
+    }
+    catch (error) {
+        for (const fd of [...fds].reverse())
+            closeSync(fd);
+        throw error;
+    }
+}
+export function candidateUnderRoot(root, segments) {
+    revalidateRoot(root);
+    for (const [index, segment] of segments.entries()) {
+        assertSafeRelativeSegment(segment, `path segment ${index + 1}`);
+    }
+    const candidate = join(root.realpath, ...segments);
+    if (!containsPath(root.realpath, candidate))
+        throw new Error("workspace candidate escapes root");
+    return candidate;
+}
+export function assertPathIdentity(path, expected, label) {
+    if (!existsSync(path) || lstatSync(path).isSymbolicLink()) {
+        throw new Error(`${label} is missing or is a symlink`);
+    }
+    if (!sameFilesystemIdentity(filesystemIdentity(path), expected)) {
+        throw new Error(`${label} identity changed`);
+    }
+}
+function assertAbsoluteUnambiguous(value, field) {
+    if (!value || containsControl(value))
+        throw new Error(`${field} contains control characters`);
+    if (!isAbsolute(value))
+        throw new Error(`${field} must be an absolute path`);
+    if (value !== value.normalize("NFC")) {
+        throw new Error(`${field} has ambiguous Unicode normalization`);
+    }
+    if (resolve(value) !== value) {
+        throw new Error(`${field} contains parent traversal or ambiguous path normalization`);
+    }
+}
+function separator() {
+    return process.platform === "win32" ? "\\" : "/";
+}
+function containsControl(value) {
+    return Array.from(value).some((character) => {
+        const code = character.charCodeAt(0);
+        return code < 32 || code === 127;
+    });
+}
+export function descriptorBackedPathsSupported() {
+    return (process.platform !== "win32" &&
+        constants.O_DIRECTORY !== undefined &&
+        constants.O_NOFOLLOW !== undefined &&
+        existsSync("/proc/self/fd"));
+}
+export function descriptorPath(fd) {
+    if (!descriptorBackedPathsSupported() || !Number.isSafeInteger(fd) || fd < 0) {
+        throw new Error("descriptor-backed workspace paths are unavailable");
+    }
+    return `/proc/self/fd/${fd}`;
+}

package/dist/core/workflow/workspaces/recovery.d.ts

@@ -0,0 +1,3 @@
+export type WorkflowLiveness = "active" | "inactive" | "unknown";
+export declare function readWorkflowLiveness(coordRoot: string, runId: string): WorkflowLiveness;
+//# sourceMappingURL=recovery.d.ts.map

package/dist/core/workflow/workspaces/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../../../../src/core/workflow/workspaces/recovery.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;AAEjE,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAiDvF"}

package/dist/core/workflow/workspaces/recovery.js

@@ -0,0 +1,50 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readWorkflowProof } from "../proof.js";
+export function readWorkflowLiveness(coordRoot, runId) {
+    const root = resolve(coordRoot);
+    const proofPath = join(root, ".harnery", "workflows", runId, "proof.json");
+    if (existsSync(proofPath)) {
+        try {
+            const proof = readWorkflowProof(root, runId);
+            return ["succeeded", "failed"].includes(proof.run.status) ? "inactive" : "unknown";
+        }
+        catch {
+            return "unknown";
+        }
+    }
+    const journalPath = join(root, ".harnery", "workflows", runId, "journal.jsonl");
+    if (!existsSync(journalPath))
+        return "unknown";
+    let events;
+    try {
+        events = readFileSync(journalPath, "utf8")
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return "unknown";
+    }
+    if (events.some((item) => item.run_id !== runId || typeof item.event !== "string")) {
+        return "unknown";
+    }
+    let liveness;
+    for (const item of events) {
+        if (item.event === "run.start" || item.event === "run.resume")
+            liveness = "active";
+        if (item.event === "run.parked")
+            liveness = "inactive";
+        if (item.event === "run.end") {
+            if (typeof item.ok !== "boolean")
+                return "unknown";
+            liveness = "inactive";
+        }
+        if (item.event === "workspace.reattach.failed") {
+            if (item.status !== "blocked" && item.status !== "lost")
+                return "unknown";
+            liveness = "inactive";
+        }
+    }
+    return liveness ?? "unknown";
+}

package/dist/core/workflow/workspaces/state.d.ts

@@ -0,0 +1,60 @@
+import type { GitRepositoryBinding, IntegrationApplyAttempt, IntegrationApplyReceipt, IntegrationAuthorization, IntegrationPlan, IntegrationReviewRecord, WorkspaceAllocationRequest, WorkspaceBinding, WorkspaceCancellationReceipt, WorkspaceCleanupAttempt, WorkspaceCleanupIntent, WorkspaceCleanupReceipt, WorkspaceCleanupResult } from "./types.js";
+export interface WorkspaceClaim {
+    schema_version: 1;
+    provider_id: string;
+    provider_version: string;
+    binding_id: string;
+    workspace_id: string;
+    request: WorkspaceAllocationRequest;
+    request_sha256: string;
+    recovery_token: string;
+    created_at: string;
+    workspace_root: string;
+    active_root: string;
+    writable_root: WorkspaceBinding["writable_root"];
+    repository: {
+        source_root: GitRepositoryBinding["source_root"];
+        common_dir: GitRepositoryBinding["common_dir"];
+        base_commit: string;
+        target_commit: string;
+        target_ref: string;
+        workspace_ref: string;
+        workspace_branch: string;
+    };
+}
+export interface WorkspaceProviderEvent {
+    schema_version: 1;
+    seq: number;
+    previous_sha256: string | null;
+    record_sha256: string;
+    event: string;
+    recorded_at: string;
+    request_sha256: string;
+    binding_id: string;
+    workspace_id: string;
+    data: Record<string, unknown>;
+}
+export declare function workflowRunDir(coordRoot: string, runId: string): string;
+export declare function workspaceRequestPath(coordRoot: string, runId: string): string;
+export declare function workspaceClaimPath(coordRoot: string, providerId: string, bindingId: string): string;
+export declare function workspaceEventsPath(coordRoot: string, providerId: string, bindingId: string): string;
+export declare function workspaceBindingPath(coordRoot: string, providerId: string, bindingId: string): string;
+export declare function workspaceLockPath(coordRoot: string, providerId: string, bindingId: string): string;
+export declare function writeWorkspaceRequest(coordRoot: string, request: WorkspaceAllocationRequest): string;
+export declare function readWorkspaceRequest(coordRoot: string, runId: string): WorkspaceAllocationRequest | undefined;
+export declare function writeWorkspaceClaim(coordRoot: string, claim: WorkspaceClaim): boolean;
+export declare function readWorkspaceClaim(coordRoot: string, providerId: string, bindingId: string): WorkspaceClaim | undefined;
+export declare function writeWorkspaceBinding(coordRoot: string, binding: WorkspaceBinding): boolean;
+export declare function readWorkspaceBinding(coordRoot: string, providerId: string, bindingId: string): WorkspaceBinding | undefined;
+export declare function appendWorkspaceEvent(coordRoot: string, claim: WorkspaceClaim, event: string, data?: Record<string, unknown>): WorkspaceProviderEvent;
+export declare function readWorkspaceEvents(coordRoot: string, providerId: string, bindingId: string): WorkspaceProviderEvent[];
+export declare function appendWorkflowJournalEvent(coordRoot: string, runId: string, event: string, data: Record<string, unknown>): void;
+export type WorkflowSupplement = WorkspaceBinding | IntegrationReviewRecord | IntegrationPlan | IntegrationAuthorization | IntegrationApplyReceipt | WorkspaceCleanupResult | WorkspaceCancellationReceipt | WorkspaceCleanupIntent | WorkspaceCleanupReceipt;
+export declare function appendCleanupAttempt(coordRoot: string, runId: string, input: Omit<WorkspaceCleanupAttempt, "seq" | "previous_sha256" | "record_sha256">): WorkspaceCleanupAttempt;
+export declare function appendIntegrationAttempt(coordRoot: string, runId: string, input: Omit<IntegrationApplyAttempt, "seq" | "previous_sha256" | "record_sha256">): IntegrationApplyAttempt;
+export declare function readIntegrationAttempts(coordRoot: string, runId: string): IntegrationApplyAttempt[];
+export declare function readCleanupAttempts(coordRoot: string, runId: string): WorkspaceCleanupAttempt[];
+export declare function writeWorkflowSupplement(coordRoot: string, runId: string, relativePath: string, value: WorkflowSupplement): string;
+export declare function readWorkflowSupplement<T>(coordRoot: string, runId: string, relativePath: string): T | undefined;
+export { canonicalJson, fileSha256, readJsonRecord, stableDigest, writeImmutableJson, } from "../durable-record.js";
+//# sourceMappingURL=state.d.ts.map

package/dist/core/workflow/workspaces/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../src/core/workflow/workspaces/state.ts"],"names":[],"mappings":"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"}

package/dist/core/workflow/workspaces/state.js

@@ -0,0 +1,296 @@
+import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { canonicalJson, fsyncParentDirectory, readJsonRecord, stableDigest, writeImmutableJson, } from "../durable-record.js";
+const JSON_LIMIT = 512 * 1024;
+const EVENT_LIMIT = 32 * 1024;
+const ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
+export function workflowRunDir(coordRoot, runId) {
+    assertId(runId, "run id");
+    return join(resolve(coordRoot), ".harnery", "workflows", runId);
+}
+export function workspaceRequestPath(coordRoot, runId) {
+    return join(workflowRunDir(coordRoot, runId), "workspace-request.json");
+}
+export function workspaceClaimPath(coordRoot, providerId, bindingId) {
+    assertId(providerId, "provider id");
+    assertId(bindingId, "binding id");
+    return join(resolve(coordRoot), ".harnery", "workspaces", providerId, bindingId, "claim.json");
+}
+export function workspaceEventsPath(coordRoot, providerId, bindingId) {
+    return join(dirname(workspaceClaimPath(coordRoot, providerId, bindingId)), "events.jsonl");
+}
+export function workspaceBindingPath(coordRoot, providerId, bindingId) {
+    return join(dirname(workspaceClaimPath(coordRoot, providerId, bindingId)), "binding.json");
+}
+export function workspaceLockPath(coordRoot, providerId, bindingId) {
+    return join(dirname(workspaceClaimPath(coordRoot, providerId, bindingId)), "operation.lease");
+}
+export function writeWorkspaceRequest(coordRoot, request) {
+    const path = workspaceRequestPath(coordRoot, request.run_id);
+    writeImmutableJson(path, request);
+    return path;
+}
+export function readWorkspaceRequest(coordRoot, runId) {
+    const path = workspaceRequestPath(coordRoot, runId);
+    return existsSync(path)
+        ? readJsonRecord(path, "workspace request")
+        : undefined;
+}
+export function writeWorkspaceClaim(coordRoot, claim) {
+    const path = workspaceClaimPath(coordRoot, claim.provider_id, claim.binding_id);
+    try {
+        return writeImmutableJson(path, claim);
+    }
+    catch (error) {
+        // A competing allocation may have won the exclusive link with its one
+        // random recovery token. The caller must read and validate that claim.
+        if (existsSync(path) && error.message.includes("immutable record already exists")) {
+            return false;
+        }
+        throw error;
+    }
+}
+export function readWorkspaceClaim(coordRoot, providerId, bindingId) {
+    const path = workspaceClaimPath(coordRoot, providerId, bindingId);
+    return existsSync(path) ? readJsonRecord(path, "workspace claim") : undefined;
+}
+export function writeWorkspaceBinding(coordRoot, binding) {
+    return writeImmutableJson(workspaceBindingPath(coordRoot, binding.provider.id, binding.binding_id), binding);
+}
+export function readWorkspaceBinding(coordRoot, providerId, bindingId) {
+    const path = workspaceBindingPath(coordRoot, providerId, bindingId);
+    return existsSync(path) ? readJsonRecord(path, "workspace binding") : undefined;
+}
+export function appendWorkspaceEvent(coordRoot, claim, event, data = {}) {
+    if (!event || event.length > 100 || Buffer.byteLength(JSON.stringify(data)) > EVENT_LIMIT / 2) {
+        throw new Error("workspace provider event is invalid or too large");
+    }
+    const path = workspaceEventsPath(coordRoot, claim.provider_id, claim.binding_id);
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const existed = existsSync(path);
+    const prior = readWorkspaceEvents(coordRoot, claim.provider_id, claim.binding_id);
+    const basis = {
+        schema_version: 1,
+        seq: prior.length + 1,
+        previous_sha256: prior.at(-1)?.record_sha256 ?? null,
+        event,
+        recorded_at: new Date().toISOString(),
+        request_sha256: claim.request_sha256,
+        binding_id: claim.binding_id,
+        workspace_id: claim.workspace_id,
+        data,
+    };
+    const record = {
+        ...basis,
+        record_sha256: stableDigest(basis),
+    };
+    const line = `${canonicalJson(record)}\n`;
+    if (Buffer.byteLength(line) > EVENT_LIMIT)
+        throw new Error("workspace provider event is too large");
+    const fd = openSync(path, "a", 0o600);
+    try {
+        writeFileSync(fd, line, "utf8");
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    chmodSync(path, 0o600);
+    if (!existed)
+        fsyncParentDirectory(path);
+    return record;
+}
+export function readWorkspaceEvents(coordRoot, providerId, bindingId) {
+    const path = workspaceEventsPath(coordRoot, providerId, bindingId);
+    if (!existsSync(path))
+        return [];
+    if (statSync(path).size > JSON_LIMIT * 4)
+        throw new Error("workspace event journal is too large");
+    const claim = readWorkspaceClaim(coordRoot, providerId, bindingId);
+    if (!claim)
+        throw new Error("workspace event authority claim is missing");
+    const records = readFileSync(path, "utf8")
+        .split("\n")
+        .filter(Boolean)
+        .map((line, index) => {
+        if (Buffer.byteLength(line) > EVENT_LIMIT) {
+            throw new Error(`workspace event ${index + 1} is too large`);
+        }
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch (error) {
+            throw new Error(`cannot parse workspace event ${index + 1}: ${error.message}`);
+        }
+        const { record_sha256, ...basis } = record;
+        const previous = index === 0 ? null : recordsDigestPlaceholder();
+        if (record.schema_version !== 1 ||
+            record.seq !== index + 1 ||
+            record.binding_id !== bindingId ||
+            record.workspace_id !== claim.workspace_id ||
+            record.request_sha256 !== claim.request_sha256 ||
+            record_sha256 !== stableDigest(basis) ||
+            (index === 0 && record.previous_sha256 !== null)) {
+            throw new Error(`workspace event ${index + 1} is corrupt`);
+        }
+        void previous;
+        return record;
+    });
+    for (let index = 1; index < records.length; index++) {
+        if (records[index].previous_sha256 !== records[index - 1].record_sha256) {
+            throw new Error(`workspace event ${index + 1} breaks the digest chain`);
+        }
+    }
+    return records;
+}
+// Keeps the JSON parser above free of a closure over a partially initialized array.
+function recordsDigestPlaceholder() {
+    return null;
+}
+export function appendWorkflowJournalEvent(coordRoot, runId, event, data) {
+    const path = join(workflowRunDir(coordRoot, runId), "journal.jsonl");
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const existed = existsSync(path);
+    const line = `${JSON.stringify({
+        schema_version: 1,
+        run_id: runId,
+        ts: new Date().toISOString(),
+        event,
+        ...data,
+    })}\n`;
+    if (Buffer.byteLength(line) > EVENT_LIMIT)
+        throw new Error("workflow journal event is too large");
+    const fd = openSync(path, "a", 0o600);
+    try {
+        writeFileSync(fd, line, "utf8");
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    if (!existed)
+        fsyncParentDirectory(path);
+}
+export function appendCleanupAttempt(coordRoot, runId, input) {
+    const path = join(workflowRunDir(coordRoot, runId), "cleanup", "attempts.jsonl");
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const existed = existsSync(path);
+    const prior = readCleanupAttempts(coordRoot, runId);
+    const basis = {
+        ...input,
+        seq: prior.length + 1,
+        previous_sha256: prior.at(-1)?.record_sha256 ?? null,
+    };
+    const attempt = {
+        ...basis,
+        record_sha256: stableDigest(basis),
+    };
+    const line = `${canonicalJson(attempt)}\n`;
+    if (Buffer.byteLength(line) > EVENT_LIMIT) {
+        throw new Error("workspace cleanup attempt is too large");
+    }
+    const fd = openSync(path, "a", 0o600);
+    try {
+        writeFileSync(fd, line, "utf8");
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    chmodSync(path, 0o600);
+    if (!existed)
+        fsyncParentDirectory(path);
+    return attempt;
+}
+export function appendIntegrationAttempt(coordRoot, runId, input) {
+    const path = join(workflowRunDir(coordRoot, runId), "integration", "attempts.jsonl");
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const existed = existsSync(path);
+    const prior = readIntegrationAttempts(coordRoot, runId);
+    const basis = {
+        ...input,
+        seq: prior.length + 1,
+        previous_sha256: prior.at(-1)?.record_sha256 ?? null,
+    };
+    const attempt = {
+        ...basis,
+        record_sha256: stableDigest(basis),
+    };
+    appendChainedRecord(path, attempt, "integration attempt");
+    if (!existed)
+        fsyncParentDirectory(path);
+    return attempt;
+}
+export function readIntegrationAttempts(coordRoot, runId) {
+    return readChainedRecords(join(workflowRunDir(coordRoot, runId), "integration", "attempts.jsonl"), "integration attempt");
+}
+export function readCleanupAttempts(coordRoot, runId) {
+    return readChainedRecords(join(workflowRunDir(coordRoot, runId), "cleanup", "attempts.jsonl"), "workspace cleanup attempt");
+}
+function appendChainedRecord(path, record, label) {
+    const line = `${canonicalJson(record)}\n`;
+    if (Buffer.byteLength(line) > EVENT_LIMIT) {
+        throw new Error(`${label} is too large`);
+    }
+    const fd = openSync(path, "a", 0o600);
+    try {
+        writeFileSync(fd, line, "utf8");
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    chmodSync(path, 0o600);
+}
+function readChainedRecords(path, label) {
+    if (!existsSync(path))
+        return [];
+    if (statSync(path).size > JSON_LIMIT * 4) {
+        throw new Error(`${label} journal is too large`);
+    }
+    const records = readFileSync(path, "utf8")
+        .split("\n")
+        .filter(Boolean)
+        .map((line, index) => {
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch (error) {
+            throw new Error(`cannot parse ${label} ${index + 1}: ${error.message}`);
+        }
+        const { record_sha256, ...basis } = record;
+        if (record.schema_version !== 1 ||
+            record.seq !== index + 1 ||
+            record_sha256 !== stableDigest(basis) ||
+            (index === 0 && record.previous_sha256 !== null)) {
+            throw new Error(`${label} ${index + 1} is corrupt`);
+        }
+        return record;
+    });
+    for (let index = 1; index < records.length; index++) {
+        if (records[index].previous_sha256 !== records[index - 1].record_sha256) {
+            throw new Error(`${label} ${index + 1} breaks the digest chain`);
+        }
+    }
+    return records;
+}
+export function writeWorkflowSupplement(coordRoot, runId, relativePath, value) {
+    if (relativePath.startsWith("/") ||
+        relativePath.split(/[\\/]/).some((part) => !part || part === "." || part === "..")) {
+        throw new Error("workflow supplement path is unsafe");
+    }
+    const path = join(workflowRunDir(coordRoot, runId), relativePath);
+    writeImmutableJson(path, value);
+    return path;
+}
+export function readWorkflowSupplement(coordRoot, runId, relativePath) {
+    const path = join(workflowRunDir(coordRoot, runId), relativePath);
+    return existsSync(path) ? readJsonRecord(path, relativePath) : undefined;
+}
+function assertId(value, field) {
+    if (!ID.test(value))
+        throw new Error(`${field} is invalid`);
+}
+export { canonicalJson, fileSha256, readJsonRecord, stableDigest, writeImmutableJson, } from "../durable-record.js";