@skill-harness/adapters 0.17.0 → 0.19.0

package/dist/evidence-archive.js

@@ -1,225 +0,0 @@
-import { closeSync, constants, fsyncSync, fstatSync, linkSync, lstatSync, mkdirSync, openSync, readSync, unlinkSync, writeFileSync, } from "node:fs";
-import { createHash, randomUUID } from "node:crypto";
-import { join, parse, resolve, sep } from "node:path";
-const LIMIT = 8 * 1024 * 1024;
-const HASH = /^[a-f0-9]{64}$/;
-const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
-const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
-const absent = (error) => error?.code === "ENOENT";
-function fail(message) { throw new Error(`archive: ${message}`); }
-function keys(value, expected) {
-    return !!value && typeof value === "object" && !Array.isArray(value)
-        && Object.keys(value).length === expected.length && Object.keys(value).every(key => expected.includes(key));
-}
-function validReference(value) {
-    if (!keys(value, ["schema", "sourceId", "parser", "sha256", "bytes", "retention"]))
-        return false;
-    return value.schema === "archive-source-v1"
-        && typeof value.sourceId === "string" && ID.test(value.sourceId)
-        && keys(value.parser, ["id", "version"])
-        && typeof value.parser.id === "string" && ID.test(value.parser.id)
-        && typeof value.parser.version === "string" && ID.test(value.parser.version)
-        && typeof value.sha256 === "string" && HASH.test(value.sha256)
-        && Number.isSafeInteger(value.bytes) && Number(value.bytes) >= 0 && Number(value.bytes) <= LIMIT
-        && typeof value.retention === "string" && ["exact", "redacted", "reference-only"].includes(value.retention);
-}
-/** Reject existing symlink ancestors. This is a trusted local-writer boundary, not an OS sandbox. */
-function directory(path, create) {
-    if (!constants.O_NOFOLLOW || !constants.O_DIRECTORY || !constants.O_NONBLOCK)
-        fail("required filesystem flags unavailable");
-    const absolute = resolve(path);
-    let current = parse(absolute).root;
-    for (const part of absolute.slice(current.length).split(sep).filter(Boolean)) {
-        current = join(current, part);
-        let stat;
-        try {
-            stat = lstatSync(current);
-        }
-        catch (error) {
-            if (!absent(error) || !create)
-                throw error;
-            mkdirSync(current, { mode: 0o700 });
-            stat = lstatSync(current);
-        }
-        if (stat.isSymbolicLink())
-            fail("symlink directory refused");
-        if (!stat.isDirectory())
-            fail("non-directory path refused");
-    }
-    const stat = lstatSync(absolute);
-    if ((stat.mode & 0o077) !== 0)
-        fail("archive directory must be private");
-    if (process.getuid && stat.uid !== process.getuid())
-        fail("archive directory owner mismatch");
-}
-function syncDirectory(path) {
-    const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
-    try {
-        fsyncSync(fd);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function readVerified(path, hash, limit = LIMIT) {
-    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-    try {
-        const stat = fstatSync(fd);
-        if (!stat.isFile() || stat.size > limit || (stat.mode & 0o077) !== 0)
-            fail("invalid retained file");
-        const buffer = Buffer.alloc(limit + 1);
-        let size = 0;
-        while (size <= limit) {
-            const count = readSync(fd, buffer, size, buffer.length - size, size);
-            if (!count)
-                break;
-            size += count;
-        }
-        if (size > limit)
-            fail("retained byte limit exceeded");
-        const bytes = buffer.subarray(0, size);
-        if (digest(bytes) !== hash)
-            fail("content identity mismatch");
-        return bytes;
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function put(root, category, bytes) {
-    const hash = digest(bytes);
-    const dir = join(root, category);
-    directory(dir, true);
-    const target = join(dir, hash);
-    try {
-        readVerified(target, hash);
-        return hash;
-    }
-    catch (error) {
-        if (!absent(error))
-            throw error;
-    }
-    const temporary = join(dir, `.pending-${randomUUID()}`);
-    let owned = false;
-    try {
-        const fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-        owned = true;
-        try {
-            writeFileSync(fd, bytes);
-            fsyncSync(fd);
-        }
-        finally {
-            closeSync(fd);
-        }
-        try {
-            linkSync(temporary, target);
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-            readVerified(target, hash); // Never overwrite an existing corrupt or redirected object.
-        }
-    }
-    finally {
-        if (owned)
-            unlinkSync(temporary); // Only this invocation's own staging file.
-    }
-    syncDirectory(dir);
-    return hash;
-}
-/** External explicit ingestion only: no session writes, worker callbacks, network or automatic discovery. */
-export function retainArchiveSource(root, input) {
-    if (!(input.bytes instanceof Uint8Array))
-        fail("bytes required");
-    if (input.bytes.byteLength > LIMIT)
-        fail("source byte limit exceeded");
-    const bytes = Buffer.from(input.bytes);
-    const reference = {
-        schema: "archive-source-v1", sourceId: input.sourceId,
-        parser: { id: input.parser?.id, version: input.parser?.version },
-        sha256: digest(bytes), bytes: bytes.length, retention: input.retention,
-    };
-    if (!validReference(reference))
-        fail("invalid metadata or retention policy");
-    directory(root, true);
-    if (reference.retention !== "reference-only")
-        put(root, "objects", bytes);
-    // A manifest becomes visible only after its required content has been persisted.
-    const manifestId = put(root, "manifests", Buffer.from(JSON.stringify(reference)));
-    syncDirectory(resolve(root));
-    return { manifestId, reference };
-}
-/** Metadata only for explicit archive inventory. Does not claim content availability. */
-export function readArchiveSourceReference(root, manifestId) {
-    if (!HASH.test(manifestId))
-        return { status: 'error', reason: 'invalid manifest identity' };
-    try {
-        directory(root, false);
-        directory(join(root, 'manifests'), false);
-        const text = readVerified(join(root, 'manifests', manifestId), manifestId, 8192).toString('utf8');
-        const reference = JSON.parse(text);
-        if (!validReference(reference) || JSON.stringify(reference) !== text)
-            fail('invalid manifest');
-        return { status: 'available', reference };
-    }
-    catch (error) {
-        return absent(error) ? { status: 'missing', reason: 'manifest' } : { status: 'error', reason: 'invalid or inaccessible retained evidence' };
-    }
-}
-export function readArchiveSource(root, manifestId, maxBytes = LIMIT) {
-    if (!Number.isSafeInteger(maxBytes) || maxBytes < 0 || maxBytes > LIMIT)
-        return { status: "error", reason: "invalid read bound" };
-    try {
-        const manifest = readArchiveSourceReference(root, manifestId);
-        if (manifest.status !== 'available')
-            return manifest;
-        const { reference } = manifest;
-        if (reference.retention === "reference-only")
-            return { status: "missing", reason: "not-retained" };
-        if (reference.bytes > maxBytes)
-            return { status: "error", reason: "read bound exceeded" };
-        let bytes;
-        try {
-            directory(join(root, "objects"), false);
-            bytes = readVerified(join(root, "objects", reference.sha256), reference.sha256, maxBytes);
-        }
-        catch (error) {
-            if (absent(error))
-                return { status: "missing", reason: "content" };
-            throw error;
-        }
-        if (bytes.length !== reference.bytes)
-            fail("retained length mismatch");
-        return { status: "available", reference, bytes };
-    }
-    catch {
-        // No raw paths, content or exception payloads escape into exported diagnostics.
-        return { status: "error", reason: "invalid or inaccessible retained evidence" };
-    }
-}
-/** Syntax/byte coverage only. No semantic validation, branch inference, deduplication or acceptance. */
-export function parseArchivedJsonl(bytes) {
-    if (bytes.byteLength > LIMIT)
-        fail("source byte limit exceeded");
-    const buffer = Buffer.from(bytes);
-    const records = [];
-    const errors = [];
-    let start = 0;
-    let line = 1;
-    while (start < buffer.length) {
-        const newline = buffer.indexOf(10, start);
-        if (newline < 0)
-            break;
-        try {
-            const text = new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(start, newline));
-            records.push({ line, start, end: newline + 1, value: JSON.parse(text) });
-        }
-        catch {
-            errors.push({ line, start, reason: "invalid-json" });
-        }
-        start = newline + 1;
-        line++;
-    }
-    return { status: errors.length ? "error" : start === buffer.length ? "complete" : "partial", records, errors, completeBytes: start, pendingBytes: buffer.length - start };
-}
-//# sourceMappingURL=evidence-archive.js.map

package/dist/execution-projection-schema.d.ts

@@ -1,10 +0,0 @@
-/** Read-model contract only. It cannot carry an acceptance or activation grant. */
-export declare const EXECUTION_ARCHIVE_PROJECTION_SCHEMA: {
-    type: string;
-    properties: Record<string, object>;
-    required: string[];
-    additionalProperties: boolean;
-    $schema: string;
-    $id: string;
-};
-export declare function assertExecutionProjection(value: unknown): void;

package/dist/execution-projection-schema.js

@@ -1,30 +0,0 @@
-import { Compile } from "typebox/compile";
-const text = { type: "string", minLength: 1, maxLength: 512 };
-const hash = { type: "string", pattern: "^[a-f0-9]{64}$" };
-const nullable = (schema) => ({ anyOf: [schema, { type: "null" }] });
-const list = (items) => ({ type: "array", items, maxItems: 4096, uniqueItems: true });
-const closed = (properties) => ({ type: "object", properties, required: Object.keys(properties), additionalProperties: false });
-function freeze(value) { if (value && typeof value === "object") {
-    Object.values(value).forEach(freeze);
-    Object.freeze(value);
-} return value; }
-/** Read-model contract only. It cannot carry an acceptance or activation grant. */
-export const EXECUTION_ARCHIVE_PROJECTION_SCHEMA = freeze({
-    $schema: "https://json-schema.org/draft/2020-12/schema",
-    $id: "https://github.com/mojomanyana/skill-harness/contracts/execution-archive/v1/projection.schema.json",
-    ...closed({ version: { const: "execution-archive-projection-v1" },
-        executions: { type: "array", maxItems: 4096, items: closed({
-                executionId: text, parentExecutionIds: list(nullable(text)), retainedSessionIds: list(text), activeBranch: { const: null },
-                toolCallIds: list(nullable(text)), archiveIds: list(text), runtime: { enum: ["running", "terminal", "conflict"] },
-                outcome: nullable(closed({ code: nullable({ type: "integer", minimum: -2147483648, maximum: 2147483647 }),
-                    signal: nullable(text), timedOut: { type: "boolean" }, aborted: { type: "boolean" }, truncated: { type: "boolean" }, failed: { type: "boolean" } })),
-                sourceReferences: list(hash), issues: list(text), coverage: { const: "partial" }, acceptance: { const: "not-assessed" },
-            }) }, acceptance: { const: "not-assessed" },
-    }),
-});
-const compiled = Compile(EXECUTION_ARCHIVE_PROJECTION_SCHEMA);
-export function assertExecutionProjection(value) {
-    if (!compiled.Check(value) || Buffer.byteLength(JSON.stringify(value)) > 8 * 1024 * 1024)
-        throw new Error("invalid or oversized execution archive projection");
-}
-//# sourceMappingURL=execution-projection-schema.js.map

package/dist/execution-retention-archive.d.ts

@@ -1,69 +0,0 @@
-import { RETENTION_CONTENT_KINDS } from "./generated/retention-v2-contract.js";
-import type { ExecutionRetentionManifest } from "./generated/retention-v2-types.js";
-export type RetentionContentKind = typeof RETENTION_CONTENT_KINDS[number];
-export interface RetentionProjection {
-    version: "retention-projection-v1";
-    sourceSha256: string;
-    producerCommit: string;
-    archiveId: string;
-    identity: ExecutionRetentionManifest["identity"];
-    runtime: "running" | "terminal";
-    outcome: ExecutionRetentionManifest["outcome"];
-    content: Record<RetentionContentKind, {
-        status: "available" | "missing" | "mismatch";
-        sha256: string | null;
-        bytes: number | null;
-    }>;
-    sessionId: string | null;
-    reportedBranch: {
-        state: "unknown" | "observed";
-        leafId: string | null;
-    };
-    activeBranch: null;
-    coverage: "partial";
-    issues: string[];
-    acceptance: "not-assessed";
-}
-/** Caller already owns an exact-content policy. No paths from the producer are opened here. */
-export declare function ingestRetainedExecution(root: string, input: {
-    manifest: Uint8Array;
-    blobs: ReadonlyMap<string, Uint8Array>;
-    retention: "exact";
-    sourceId?: string;
-}): {
-    snapshotId: string;
-    projection: RetentionProjection;
-};
-/** Recompute availability from current retained bytes; a deleted blob never inherits its old available status. */
-export declare function readRetainedExecution(root: string, snapshotId: string): {
-    snapshotId: string;
-    sourceId: string;
-    manifest: ExecutionRetentionManifest;
-    projection: RetentionProjection;
-};
-/** Order-independent joins, not an acceptance engine. Logical child names and native parents are not execution keys. */
-export declare function projectRetainedExecutions(snapshots: readonly RetentionProjection[]): {
-    version: "execution-archive-projection-v1";
-    executions: {
-        executionId: string;
-        parentExecutionIds: (string | null)[];
-        retainedSessionIds: string[];
-        activeBranch: null;
-        toolCallIds: (string | null)[];
-        archiveIds: string[];
-        runtime: string;
-        outcome: {
-            code: number | null;
-            signal: string | null;
-            timedOut: boolean;
-            aborted: boolean;
-            truncated: boolean;
-            failed: boolean;
-        } | null;
-        sourceReferences: string[];
-        issues: string[];
-        coverage: "partial";
-        acceptance: "not-assessed";
-    }[];
-    acceptance: "not-assessed";
-};

package/dist/execution-retention-archive.js

@@ -1,154 +0,0 @@
-import { createHash } from "node:crypto";
-import { parseExecutionRetentionManifest, RETENTION_CONTENT_KINDS } from "./generated/retention-v2-contract.js";
-import { parseNativeSessionBytes } from "./generated/retention-v2-native.js";
-import { RETENTION_V2_COMMIT } from "./generated/retention-v2-pin.js";
-import { retainArchiveSource, readArchiveSource } from "./evidence-archive.js";
-import { assertExecutionProjection } from "./execution-projection-schema.js";
-const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
-const SHA = /^[a-f0-9]{64}$/;
-const parseManifest = (bytes) => parseExecutionRetentionManifest(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
-function project(manifest, manifestBytes, supplied) {
-    const content = {};
-    const issues = [...manifest.coverage.losses];
-    for (const kind of RETENTION_CONTENT_KINDS) {
-        const ref = manifest.content[kind], bytes = ref.path ? supplied.get(ref.path) : undefined;
-        const status = ref.status === "missing" || bytes === undefined ? "missing"
-            : bytes instanceof Uint8Array && bytes.byteLength === ref.bytes && hash(bytes) === ref.sha256 ? "available" : "mismatch";
-        content[kind] = { status, sha256: status === "available" ? ref.sha256 : null, bytes: status === "available" ? ref.bytes : null };
-        if (status !== "available")
-            issues.push(`content-${status}:${kind}`);
-    }
-    let sessionId = null;
-    if (content.session.status === "available") {
-        const native = manifest.nativeSession;
-        if (!native.source || !native.sessionPath || !native.sessionId)
-            issues.push("native-session-locator-unavailable");
-        else {
-            const parsed = parseNativeSessionBytes(supplied.get(manifest.content.session.path), {
-                source: native.source, path: native.sessionPath, expectedSessionId: native.sessionId,
-                truncated: native.status === "truncated",
-                ...(native.branchState === "observed" ? { liveLeaf: { sessionId: native.sessionId, leafId: native.branchLeafId } } : {}),
-            });
-            // This checks retained format/chain consistency, never authenticates the manifest's live observation.
-            if (parsed.observation.status !== native.status || parsed.observation.sha256 !== native.sha256
-                || parsed.observation.lastPersistedEntryId !== native.lastPersistedEntryId)
-                issues.push("native-session-inconsistent");
-            else
-                sessionId = parsed.observation.sessionId;
-        }
-    }
-    if (manifest.nativeSession.branchState === "observed")
-        issues.push("active-branch-not-independently-verified");
-    return {
-        version: "retention-projection-v1", sourceSha256: hash(manifestBytes), producerCommit: RETENTION_V2_COMMIT,
-        archiveId: manifest.archiveId, identity: manifest.identity, runtime: manifest.state, outcome: manifest.outcome,
-        content, sessionId, reportedBranch: { state: manifest.nativeSession.branchState, leafId: manifest.nativeSession.branchLeafId },
-        activeBranch: null, coverage: "partial", issues: [...new Set(issues)].sort(), acceptance: "not-assessed",
-    };
-}
-/** Caller already owns an exact-content policy. No paths from the producer are opened here. */
-export function ingestRetainedExecution(root, input) {
-    if (input.retention !== "exact")
-        throw new Error("native semantic ingestion requires explicit exact-content policy; archive redacted/reference-only data as opaque evidence");
-    const bytes = Buffer.from(input.manifest);
-    const manifest = parseManifest(bytes);
-    for (const ref of Object.values(manifest.content)) {
-        const supplied = ref.path ? input.blobs.get(ref.path) : undefined;
-        if (supplied !== undefined && (!(supplied instanceof Uint8Array) || supplied.byteLength > 1024 * 1024))
-            throw new Error("retention blob exceeds input bounds");
-    }
-    const projection = project(manifest, bytes, input.blobs);
-    const source = retainArchiveSource(root, { sourceId: input.sourceId ?? `retention-${manifest.archiveId}`, parser: { id: "pi-daddy-execution-retention", version: "2.0" }, retention: "exact", bytes });
-    const blobs = {};
-    for (const kind of RETENTION_CONTENT_KINDS) {
-        blobs[kind] = null;
-        const ref = manifest.content[kind];
-        if (!ref.path || input.blobs.get(ref.path) === undefined)
-            continue;
-        // Preserve bounded mismatched bytes as forensic input; their presence never makes them valid evidence.
-        blobs[kind] = retainArchiveSource(root, { sourceId: `${manifest.archiveId}-${kind}`, parser: { id: "opaque-bytes", version: "1" }, retention: "exact", bytes: input.blobs.get(ref.path) }).manifestId;
-    }
-    const snapshot = { version: "retention-archive-snapshot-v1", producerCommit: RETENTION_V2_COMMIT, manifestId: source.manifestId, blobs };
-    const stored = retainArchiveSource(root, { sourceId: `execution-${manifest.archiveId}`, parser: { id: "retention-archive-snapshot", version: "1" }, retention: "exact", bytes: Buffer.from(JSON.stringify(snapshot)) });
-    return { snapshotId: stored.manifestId, projection };
-}
-/** Recompute availability from current retained bytes; a deleted blob never inherits its old available status. */
-export function readRetainedExecution(root, snapshotId) {
-    const stored = readArchiveSource(root, snapshotId);
-    if (stored.status !== "available" || stored.reference.retention !== "exact")
-        throw new Error("retention snapshot missing or invalid");
-    const text = stored.bytes.toString("utf8"), snapshot = JSON.parse(text);
-    if (JSON.stringify(snapshot) !== text || !snapshot || Object.keys(snapshot).sort().join() !== "blobs,manifestId,producerCommit,version"
-        || snapshot.version !== "retention-archive-snapshot-v1" || snapshot.producerCommit !== RETENTION_V2_COMMIT || !SHA.test(snapshot.manifestId)
-        || !snapshot.blobs || Object.keys(snapshot.blobs).sort().join() !== [...RETENTION_CONTENT_KINDS].sort().join()
-        || Object.values(snapshot.blobs).some(id => id !== null && (typeof id !== "string" || !SHA.test(id))))
-        throw new Error("invalid retention snapshot");
-    const source = readArchiveSource(root, snapshot.manifestId);
-    if (source.status !== "available" || source.reference.retention !== "exact")
-        throw new Error("retained producer manifest missing or invalid");
-    const manifest = parseManifest(source.bytes);
-    const supplied = new Map();
-    for (const kind of RETENTION_CONTENT_KINDS) {
-        const id = snapshot.blobs[kind], ref = manifest.content[kind];
-        if (!id || !ref.path)
-            continue;
-        const content = readArchiveSource(root, id);
-        if (content.status === "available" && content.reference.retention === "exact")
-            supplied.set(ref.path, content.bytes);
-    }
-    return { snapshotId, sourceId: source.reference.sourceId, manifest, projection: project(manifest, source.bytes, supplied) };
-}
-/** Order-independent joins, not an acceptance engine. Logical child names and native parents are not execution keys. */
-export function projectRetainedExecutions(snapshots) {
-    if (snapshots.length > 4096)
-        throw new Error("retention projection exceeds snapshot bound");
-    const unique = [...new Map(snapshots.map(p => [JSON.stringify(p), p])).values()];
-    const objectKey = (value) => JSON.stringify(Object.keys(value).sort().map(key => [key, value[key]]));
-    const groups = new Map();
-    for (const snapshot of unique) {
-        const id = snapshot.identity.executionId;
-        groups.set(id, [...(groups.get(id) ?? []), snapshot]);
-    }
-    const lineageIssue = (start) => {
-        const seen = new Set();
-        let id = start;
-        while (id !== null && groups.has(id)) {
-            if (seen.has(id))
-                return "cyclic-parentage";
-            seen.add(id);
-            const parents = [...new Set(groups.get(id).map(p => p.identity.parentExecutionId))];
-            if (parents.length !== 1)
-                return "ambiguous-parentage";
-            id = parents[0];
-        }
-        return null;
-    };
-    const executions = [...groups].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([executionId, values]) => {
-        const identities = new Set(values.map(p => objectKey(p.identity)));
-        const terminals = values.filter(p => p.runtime === "terminal");
-        const outcomes = new Set(terminals.map(p => objectKey(p.outcome)));
-        const issues = new Set(values.flatMap(p => p.issues));
-        if (identities.size > 1)
-            issues.add("execution-identity-conflict");
-        if (outcomes.size > 1)
-            issues.add("terminal-outcome-conflict");
-        const lineage = lineageIssue(executionId);
-        if (lineage)
-            issues.add(lineage);
-        const parentExecutionIds = [...new Set(values.map(p => p.identity.parentExecutionId))].sort();
-        const retainedSessionIds = [...new Set(values.map(p => p.sessionId).filter((id) => id !== null))].sort();
-        if (retainedSessionIds.length > 1)
-            issues.add("session-identity-conflict");
-        if (parentExecutionIds.some(id => id !== null && !groups.has(id)))
-            issues.add("parent-not-in-snapshot");
-        return { executionId, parentExecutionIds, retainedSessionIds, activeBranch: null, toolCallIds: [...new Set(values.map(p => p.identity.toolCallId))].sort(),
-            archiveIds: [...new Set(values.map(p => p.archiveId))].sort(),
-            runtime: identities.size > 1 || outcomes.size > 1 ? "conflict" : terminals.length ? "terminal" : "running",
-            outcome: identities.size === 1 && outcomes.size === 1 ? terminals[0].outcome : null,
-            sourceReferences: [...new Set(values.map(p => p.sourceSha256))].sort(), issues: [...issues].sort(), coverage: "partial", acceptance: "not-assessed" };
-    });
-    const projection = { version: "execution-archive-projection-v1", executions, acceptance: "not-assessed" };
-    assertExecutionProjection(projection);
-    return projection;
-}
-//# sourceMappingURL=execution-retention-archive.js.map

package/dist/generated/retention-v2-contract.d.ts

@@ -1,72 +0,0 @@
-import type { ExecutionRetentionManifest } from "./retention-v2-types.js";
-export declare const RETENTION_CONTENT_KINDS: readonly ["stdout", "stderr", "paneSnapshot", "checkReceipt", "result", "session"];
-export declare const RETENTION_SCHEMA: {
-    allOf: ({
-        if: {
-            properties: {
-                state: {
-                    const: unknown;
-                };
-                nativeSession?: undefined;
-            };
-        };
-        then: {
-            properties: {
-                outcome: {
-                    const: unknown;
-                };
-                nativeSession?: undefined;
-                native?: undefined;
-            };
-        };
-        else: {
-            properties: {
-                outcome: {
-                    type: string;
-                };
-            };
-        };
-    } | {
-        if: {
-            properties: {
-                nativeSession: {
-                    properties: {
-                        branchState: {
-                            const: unknown;
-                        };
-                    };
-                };
-                state?: undefined;
-            };
-        };
-        then: {
-            properties: {
-                nativeSession: {
-                    properties: {
-                        branchLeafId: {
-                            const: unknown;
-                        };
-                    };
-                };
-                native: {
-                    properties: {
-                        branchLeafId: {
-                            const: unknown;
-                        };
-                    };
-                };
-                outcome?: undefined;
-            };
-        };
-        else?: undefined;
-    })[];
-    type: string;
-    properties: Record<string, object>;
-    required: string[];
-    additionalProperties: boolean;
-    $schema: string;
-    $id: string;
-};
-/** Closed, detached versioned wire builder; never authenticates the supplied observation. */
-export declare function buildExecutionRetentionManifest(value: unknown): ExecutionRetentionManifest;
-export declare function parseExecutionRetentionManifest(text: string): ExecutionRetentionManifest;