@skill-harness/adapters 0.16.0 → 0.18.0

package/dist/archive-observer.d.ts

@@ -1,21 +0,0 @@
-import { ingestPolicySource } from "./archive-policy.js";
-export interface ArchiveObserverOptions {
-    policyPath: string;
-    sourceId: string;
-    intervalMs: number;
-    maxPolls: number;
-    previousCheckpointId?: string;
-    signal?: AbortSignal;
-    /** Optional synchronous metadata consumer, never a worker hook. Its failure does not stop capture. */
-    onObservation?: (value: ReturnType<typeof ingestPolicySource>) => void;
-}
-/** Bounded external file observation. No worker process, socket, session API, prompt or control channel is used. */
-export declare function observeArchiveSource(options: ArchiveObserverOptions): Promise<{
-    observerId: `${string}-${string}-${string}-${string}-${string}`;
-    polls: number;
-    lastCheckpointId: string | null;
-    receiptId: string;
-    stopped: "aborted" | "poll-limit" | "policy-change";
-    gaps: string[];
-    workerInteractions: 0;
-}>;

package/dist/archive-observer.js

@@ -1,79 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { archivePolicyBinding, ingestPolicySource } from "./archive-policy.js";
-import { retainArchiveSource } from "./evidence-archive.js";
-function cadence(ms, signal) {
-    return new Promise(resolve => {
-        if (signal?.aborted) {
-            resolve();
-            return;
-        }
-        const finish = () => { clearTimeout(timer); signal?.removeEventListener("abort", finish); resolve(); };
-        const timer = setTimeout(finish, ms);
-        signal?.addEventListener("abort", finish, { once: true });
-    });
-}
-/** Bounded external file observation. No worker process, socket, session API, prompt or control channel is used. */
-export async function observeArchiveSource(options) {
-    if (!Number.isSafeInteger(options.intervalMs) || options.intervalMs < 1 || options.intervalMs > 60000
-        || !Number.isSafeInteger(options.maxPolls) || options.maxPolls < 1 || options.maxPolls > 128)
-        throw new Error("bounded observer interval/poll count required");
-    const binding = archivePolicyBinding(options.policyPath, options.sourceId), observerId = randomUUID(), startedAt = new Date().toISOString();
-    let lastCheckpointId = options.previousCheckpointId ?? null, polls = 0, receiptId = "", consumer = options.onObservation;
-    let stopped = "poll-limit", terminal = false;
-    const gaps = new Set();
-    const records = [];
-    const persist = () => retainArchiveSource(binding.archiveRoot, {
-        sourceId: `observer-${observerId}`, parser: { id: "archive-observer", version: "1" }, retention: "exact",
-        bytes: Buffer.from(JSON.stringify({ version: "archive-observer-v1", observerId, policySha256: binding.policySha256, sourceId: binding.sourceId,
-            startedAt, polls, lastCheckpointId, state: terminal ? "terminal" : "running", stopped: terminal ? stopped : null, gaps: [...gaps].sort(), records, workerInteractions: 0, continuity: "bounded-observations-not-complete-live-coverage" })),
-    }).manifestId;
-    for (let i = 0; i < options.maxPolls; i++) {
-        if (options.signal?.aborted) {
-            stopped = "aborted";
-            break;
-        }
-        try {
-            if (archivePolicyBinding(options.policyPath, options.sourceId).policySha256 !== binding.policySha256)
-                throw new Error("changed");
-        }
-        catch {
-            gaps.add("policy-changed-or-unavailable");
-            stopped = "policy-change";
-            break;
-        }
-        polls++;
-        try {
-            const observation = ingestPolicySource(options.policyPath, options.sourceId, lastCheckpointId ?? undefined, binding.policySha256);
-            lastCheckpointId = observation.checkpointId;
-            records.push({ poll: polls, at: new Date().toISOString(), checkpointId: lastCheckpointId, state: "captured" });
-            if (consumer) {
-                try {
-                    const returned = consumer(observation);
-                    if (returned && typeof returned.then === "function") {
-                        gaps.add("async-consumer-outcome-unobserved");
-                        consumer = undefined;
-                        // The unsupported asynchronous outcome is already an explicit durable gap; never await it on capture.
-                        void Promise.resolve(returned).catch(() => undefined);
-                    }
-                }
-                catch {
-                    gaps.add("observation-consumer-failed");
-                    consumer = undefined;
-                }
-            }
-        }
-        catch {
-            gaps.add("source-observation-failed");
-            records.push({ poll: polls, at: new Date().toISOString(), checkpointId: lastCheckpointId, state: "gap" });
-        }
-        receiptId = persist();
-        if (i + 1 < options.maxPolls)
-            await cadence(options.intervalMs, options.signal);
-    }
-    if (options.signal?.aborted)
-        stopped = "aborted";
-    terminal = true;
-    receiptId = persist();
-    return { observerId, polls, lastCheckpointId, receiptId, stopped, gaps: [...gaps].sort(), workerInteractions: 0 };
-}
-//# sourceMappingURL=archive-observer.js.map

package/dist/archive-policy.d.ts

@@ -1,107 +0,0 @@
-import { type ArchiveRetention } from "./evidence-archive.js";
-export interface PolicySource {
-    id: string;
-    path: string;
-    parser: {
-        id: string;
-        version: string;
-    };
-    contentPolicy?: "manifest-only" | "referenced-blobs";
-}
-export interface ArchiveIngestionPolicy {
-    version: "archive-policy-v1" | "archive-policy-v2";
-    id: string;
-    revision: string;
-    sourceRoot: string;
-    archiveRoot: string;
-    maxBytes: number;
-    retention: ArchiveRetention;
-    expiresAt: string;
-    sources: PolicySource[];
-}
-/** Host-only policy binding for bounded external observation; no source bytes are read. */
-export declare function archivePolicyBinding(policyPath: string, sourceId: string): Readonly<{
-    policySha256: string;
-    archiveRoot: string;
-    sourceId: string;
-    archiveSourceId: string;
-    expiresAt: string;
-}>;
-/** Explicit operator-selected file policy. Not a credential, authorization attestation or hostile-agent sandbox. */
-export declare function ingestPolicySource(policyPath: string, sourceId: string, previousCheckpointId?: string, expectedPolicySha256?: string): {
-    change: string;
-    policyReceiptId: string;
-    kind: "execution-retention-v2";
-    checkpointId: string;
-    policySha256: string;
-    sourceId: string;
-    archiveSourceId: string;
-    sourceSha256: string;
-    sourceStatus: "available";
-    retention: "exact";
-    syntax: "not-applicable";
-    runtime: "running" | "terminal";
-    content: Record<"session" | "stdout" | "stderr" | "paneSnapshot" | "checkReceipt" | "result", {
-        status: "available" | "missing" | "mismatch";
-        sha256: string | null;
-        bytes: number | null;
-    }>;
-    activeBranch: null;
-    coverage: "partial";
-    issueCount: number;
-    acceptance: "not-assessed";
-} | {
-    sourceId: string;
-    archiveSourceId: string;
-    change: import("./archive-checkpoint.js").SnapshotChange | "repeat";
-    policyReceiptId: string;
-    checkpointId: string;
-    policySha256: string;
-    sourceSha256: string;
-    sourceStatus: "available" | "missing" | "error";
-    retention: ArchiveRetention;
-    syntax: "error" | "complete" | "partial" | "unavailable";
-    completeBytes: number;
-    pendingBytes: number;
-    invalidLines: number;
-    issues: string[];
-    activeBranch: null;
-    acceptance: "not-assessed";
-};
-/** Metadata-only CLI/read-model output; no payload, local path or policy file is exported. */
-export declare function inspectPolicyCheckpoint(policyPath: string, sourceId: string, checkpointId: string): {
-    kind: "execution-retention-v2";
-    checkpointId: string;
-    policySha256: string;
-    sourceId: string;
-    archiveSourceId: string;
-    sourceSha256: string;
-    sourceStatus: "available";
-    retention: "exact";
-    syntax: "not-applicable";
-    runtime: "running" | "terminal";
-    content: Record<"session" | "stdout" | "stderr" | "paneSnapshot" | "checkReceipt" | "result", {
-        status: "available" | "missing" | "mismatch";
-        sha256: string | null;
-        bytes: number | null;
-    }>;
-    activeBranch: null;
-    coverage: "partial";
-    issueCount: number;
-    acceptance: "not-assessed";
-} | {
-    sourceId: string;
-    archiveSourceId: string;
-    checkpointId: string;
-    policySha256: string;
-    sourceSha256: string;
-    sourceStatus: "available" | "missing" | "error";
-    retention: ArchiveRetention;
-    syntax: "error" | "complete" | "partial" | "unavailable";
-    completeBytes: number;
-    pendingBytes: number;
-    invalidLines: number;
-    issues: string[];
-    activeBranch: null;
-    acceptance: "not-assessed";
-};

package/dist/archive-policy.js

@@ -1,135 +0,0 @@
-import { closeSync, constants, fstatSync, lstatSync, openSync, readSync } from "node:fs";
-import { createHash } from "node:crypto";
-import { dirname, isAbsolute, join, parse, resolve, sep } from "node:path";
-import { ingestArchiveSnapshot, readArchiveCheckpoint } from "./archive-checkpoint.js";
-import { retainArchiveSource } from "./evidence-archive.js";
-import { ingestNativePolicy, inspectNativePolicy } from "./archive-retention-policy.js";
-const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
-const forbidden = new Set([".pi", ".env", "auth.json", "credentials", "credentials.json"]);
-function fail() { throw new Error("archive policy refused invalid, expired or inaccessible input"); }
-const keys = (v, names) => !!v && typeof v === "object" && !Array.isArray(v)
-    && Object.keys(v).length === names.length && Object.keys(v).every(k => names.includes(k));
-const identifier = (v) => typeof v === "string" && ID.test(v);
-function regularBytes(path, limit) {
-    if (!constants.O_NOFOLLOW || !constants.O_NONBLOCK)
-        fail();
-    const absolute = resolve(path);
-    if (absolute.split(sep).some(part => forbidden.has(part)))
-        fail();
-    let current = parse(absolute).root;
-    for (const part of dirname(absolute).slice(current.length).split(sep).filter(Boolean)) {
-        current = join(current, part);
-        const stat = lstatSync(current);
-        if (!stat.isDirectory() || stat.isSymbolicLink())
-            fail();
-    }
-    const fd = openSync(absolute, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-    try {
-        const stat = fstatSync(fd);
-        if (!stat.isFile() || stat.size > limit || (stat.mode & 0o077) !== 0 || (process.getuid && stat.uid !== process.getuid()))
-            fail();
-        const bytes = Buffer.alloc(limit + 1);
-        let size = 0;
-        while (size <= limit) {
-            const n = readSync(fd, bytes, size, bytes.length - size, size);
-            if (!n)
-                break;
-            size += n;
-        }
-        if (size > limit)
-            fail();
-        return bytes.subarray(0, size);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function selectedPolicy(path, sourceId) {
-    const bytes = regularBytes(path, 65536);
-    const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-    const p = JSON.parse(text);
-    // Canonical JSON excludes duplicate-key ambiguity. This is a selected operator configuration, not a signed approval.
-    if (JSON.stringify(p) !== text || !keys(p, ["version", "id", "revision", "sourceRoot", "archiveRoot", "maxBytes", "retention", "expiresAt", "sources"])
-        || !["archive-policy-v1", "archive-policy-v2"].includes(p.version) || !identifier(p.id) || !identifier(p.revision)
-        || typeof p.sourceRoot !== "string" || !isAbsolute(p.sourceRoot) || typeof p.archiveRoot !== "string" || !isAbsolute(p.archiveRoot)
-        || resolve(p.sourceRoot) === resolve(p.archiveRoot)
-        || [p.sourceRoot, p.archiveRoot].some(root => root.split(/[\\/]/).some(part => forbidden.has(part)))
-        || !Number.isSafeInteger(p.maxBytes) || p.maxBytes < 1 || p.maxBytes > 8 * 1024 * 1024
-        || !["exact", "redacted", "reference-only"].includes(p.retention)
-        || typeof p.expiresAt !== "string" || !Number.isFinite(Date.parse(p.expiresAt))
-        || new Date(p.expiresAt).toISOString() !== p.expiresAt || Date.parse(p.expiresAt) <= Date.now()
-        || !Array.isArray(p.sources) || p.sources.length < 1 || p.sources.length > 128)
-        fail();
-    const ids = new Set();
-    for (const item of p.sources) {
-        if (!keys(item, p.version === "archive-policy-v2" ? ["id", "path", "parser", "contentPolicy"] : ["id", "path", "parser"]) || !identifier(item.id) || ids.has(item.id)
-            || typeof item.path !== "string" || !item.path || isAbsolute(item.path) || item.path.includes("\\")
-            || item.path.split("/").some(part => !part || part === "." || part === ".." || forbidden.has(part))
-            || !keys(item.parser, ["id", "version"]) || !identifier(item.parser.id) || !identifier(item.parser.version))
-            fail();
-        if (p.version === "archive-policy-v2" && !["manifest-only", "referenced-blobs"].includes(item.contentPolicy))
-            fail();
-        if (item.contentPolicy === "referenced-blobs" && (p.retention !== "exact" || item.parser.id !== "pi-daddy-execution-retention" || item.parser.version !== "2.0"))
-            fail();
-        ids.add(item.id);
-    }
-    const source = p.sources.find(s => s.id === sourceId);
-    if (!source)
-        fail();
-    const root = lstatSync(p.sourceRoot);
-    if (!root.isDirectory() || root.isSymbolicLink() || (root.mode & 0o077) !== 0 || (process.getuid && root.uid !== process.getuid()))
-        fail();
-    const archiveSourceId = `policy-source-${createHash("sha256").update(JSON.stringify([p.id, source.id, resolve(p.sourceRoot), source.path])).digest("hex")}`;
-    return { policy: p, source, archiveSourceId, policySha256: createHash("sha256").update(bytes).digest("hex") };
-}
-function metadata(result, checkpointId, policySha256) {
-    return { checkpointId, policySha256, sourceId: result.checkpoint.sourceId, sourceSha256: result.checkpoint.sourceSha256,
-        sourceStatus: result.source.status, retention: result.checkpoint.retention, syntax: result.checkpoint.syntax,
-        completeBytes: result.checkpoint.completeBytes, pendingBytes: result.checkpoint.pendingBytes,
-        invalidLines: result.checkpoint.invalidLines, issues: result.checkpoint.issues,
-        activeBranch: result.checkpoint.activeBranch, acceptance: result.checkpoint.acceptance };
-}
-/** Host-only policy binding for bounded external observation; no source bytes are read. */
-export function archivePolicyBinding(policyPath, sourceId) {
-    const selected = selectedPolicy(policyPath, sourceId);
-    return Object.freeze({ policySha256: selected.policySha256, archiveRoot: selected.policy.archiveRoot,
-        sourceId, archiveSourceId: selected.archiveSourceId, expiresAt: selected.policy.expiresAt });
-}
-/** Explicit operator-selected file policy. Not a credential, authorization attestation or hostile-agent sandbox. */
-export function ingestPolicySource(policyPath, sourceId, previousCheckpointId, expectedPolicySha256) {
-    try {
-        const { policy, source, archiveSourceId, policySha256 } = selectedPolicy(policyPath, sourceId);
-        if (expectedPolicySha256 !== undefined && expectedPolicySha256 !== policySha256)
-            throw new Error("archive policy changed");
-        if (source.contentPolicy === "referenced-blobs")
-            return ingestNativePolicy({ policy, source, archiveSourceId, policySha256 }, previousCheckpointId, regularBytes);
-        const bytes = regularBytes(join(policy.sourceRoot, source.path), policy.maxBytes);
-        const result = ingestArchiveSnapshot(policy.archiveRoot, { sourceId: archiveSourceId, parser: source.parser, retention: policy.retention, bytes, previousCheckpointId });
-        const receipt = retainArchiveSource(policy.archiveRoot, {
-            sourceId: `policy-${policySha256}`, parser: { id: "archive-policy-receipt", version: "1" }, retention: "exact",
-            bytes: Buffer.from(JSON.stringify({ version: "archive-policy-receipt-v1", policySha256, checkpointId: result.checkpointId, sourceId })),
-        });
-        return { ...metadata(result, result.checkpointId, policySha256), sourceId, archiveSourceId, change: result.change, policyReceiptId: receipt.manifestId };
-    }
-    catch {
-        fail();
-    }
-}
-/** Metadata-only CLI/read-model output; no payload, local path or policy file is exported. */
-export function inspectPolicyCheckpoint(policyPath, sourceId, checkpointId) {
-    try {
-        const { policy, source, archiveSourceId, policySha256 } = selectedPolicy(policyPath, sourceId);
-        if (source.contentPolicy === "referenced-blobs")
-            return inspectNativePolicy({ policy, source, archiveSourceId, policySha256 }, checkpointId);
-        const result = readArchiveCheckpoint(policy.archiveRoot, checkpointId);
-        const c = result.checkpoint;
-        if (c.sourceId !== archiveSourceId || c.retention !== policy.retention || c.sourceBytes > policy.maxBytes
-            || c.declaredParser.id !== source.parser.id || c.declaredParser.version !== source.parser.version)
-            fail();
-        return { ...metadata(result, checkpointId, policySha256), sourceId, archiveSourceId };
-    }
-    catch {
-        fail();
-    }
-}
-//# sourceMappingURL=archive-policy.js.map

package/dist/archive-read-capability.d.ts

@@ -1,49 +0,0 @@
-import { type GovernedArchiveRoute } from './archive-access.js';
-export interface ArchiveReadCapabilityOptions {
-    root: string;
-    /** Optional durable shared policy; absent preserves the historical raw route. */
-    access?: GovernedArchiveRoute;
-    /** Independently selected, content-reviewed artifact IDs; never accepted from model requests. */
-    manifestIds: readonly string[];
-    maxCalls: number;
-    /** Total returned bytes, not a claim about OS-level read bandwidth or process memory. */
-    maxBytes: number;
-    durationMs: number;
-    representations?: readonly ("exact" | "redacted")[];
-}
-/** A closed read interface for an existing host/tool integration, not an OS sandbox or model route qualification. */
-export declare function createArchiveReadCapability(options: ArchiveReadCapabilityOptions, clock?: () => number): Readonly<{
-    snapshot: Readonly<{
-        id: string;
-        version: string;
-        manifestIds: readonly any[];
-        maxCalls: number;
-        maxBytes: number;
-        durationMs: number;
-        representations: readonly string[];
-        access?: Readonly<{
-            directory: string;
-            purpose: string;
-        }> | undefined;
-    }>;
-    status: () => Readonly<{
-        calls: number;
-        bytes: number;
-        expired: boolean;
-    }>;
-    read(manifestId: string): Readonly<{
-        manifestId: string;
-        reference: Readonly<{
-            schema: "archive-source-v1";
-            sourceId: string;
-            parser: {
-                id: string;
-                version: string;
-            };
-            sha256: string;
-            bytes: number;
-            retention: import("./evidence-archive.js").ArchiveRetention;
-        }>;
-        bytes: Buffer<ArrayBuffer>;
-    }>;
-}>;

package/dist/archive-read-capability.js

@@ -1,45 +0,0 @@
-import { createHash } from "node:crypto";
-import { performance } from "node:perf_hooks";
-import { readGovernedArchive } from './archive-access.js';
-import { readArchiveSource } from "./evidence-archive.js";
-/** A closed read interface for an existing host/tool integration, not an OS sandbox or model route qualification. */
-export function createArchiveReadCapability(options, clock = () => performance.now()) {
-    if (!Array.isArray(options.manifestIds) || !options.manifestIds.length || options.manifestIds.length > 4096
-        || options.manifestIds.some(id => typeof id !== "string" || !/^[a-f0-9]{64}$/.test(id))
-        || !Number.isSafeInteger(options.maxCalls) || options.maxCalls < 1 || options.maxCalls > 128
-        || !Number.isSafeInteger(options.maxBytes) || options.maxBytes < 1 || options.maxBytes > 64 * 1024 * 1024
-        || !Number.isSafeInteger(options.durationMs) || options.durationMs < 1 || options.durationMs > 3600000)
-        throw new Error("invalid archive capability bounds");
-    const root = options.root, maxCalls = options.maxCalls, maxBytes = options.maxBytes, durationMs = options.durationMs;
-    const representations = [...new Set(options.representations ?? ["redacted"])].sort();
-    if (!representations.length || representations.some(r => r !== "exact" && r !== "redacted"))
-        throw new Error("invalid archive representation policy");
-    const ids = Object.freeze([...new Set(options.manifestIds)].sort()), allowed = new Set(ids), started = clock();
-    if (!Number.isFinite(started))
-        throw new Error("invalid host clock");
-    const access = options.access ? Object.freeze({ ...options.access }) : undefined;
-    const descriptor = { ...(access ? { access } : {}), version: "archive-read-capability-v1", manifestIds: ids, maxCalls, maxBytes, durationMs, representations: Object.freeze(representations) };
-    const snapshot = Object.freeze({ ...descriptor, id: createHash("sha256").update(JSON.stringify(descriptor)).digest("hex") });
-    let calls = 0, returned = 0;
-    const elapsed = () => { const now = clock(); if (!Number.isFinite(now) || now < started)
-        return Infinity; return now - started; };
-    return Object.freeze({
-        snapshot,
-        status: () => Object.freeze({ calls, bytes: returned, expired: elapsed() >= durationMs }),
-        read(manifestId) {
-            if (calls >= maxCalls || elapsed() >= durationMs)
-                throw new Error("archive read refused");
-            calls++;
-            if (typeof manifestId !== "string" || !allowed.has(manifestId))
-                throw new Error("archive read refused");
-            const limit = Math.min(8 * 1024 * 1024, maxBytes - returned);
-            const source = access ? readGovernedArchive(root, manifestId, limit, access) : readArchiveSource(root, manifestId, limit);
-            if (source.status !== "available" || !representations.includes(source.reference.retention)
-                || source.bytes.length > maxBytes - returned || elapsed() >= durationMs)
-                throw new Error("archive read refused");
-            returned += source.bytes.length;
-            return Object.freeze({ manifestId, reference: Object.freeze({ ...source.reference }), bytes: Buffer.from(source.bytes) });
-        },
-    });
-}
-//# sourceMappingURL=archive-read-capability.js.map

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

@@ -1,52 +0,0 @@
-import type { ArchiveIngestionPolicy, PolicySource } from "./archive-policy.js";
-interface Context {
-    policy: ArchiveIngestionPolicy;
-    source: PolicySource;
-    archiveSourceId: string;
-    policySha256: string;
-}
-export declare function inspectNativePolicy(context: Context, checkpointId: string): {
-    kind: "execution-retention-v2";
-    checkpointId: string;
-    policySha256: string;
-    sourceId: string;
-    archiveSourceId: string;
-    sourceSha256: string;
-    sourceStatus: "available";
-    retention: "exact";
-    syntax: "not-applicable";
-    runtime: "running" | "terminal";
-    content: Record<"session" | "stdout" | "stderr" | "paneSnapshot" | "checkReceipt" | "result", {
-        status: "available" | "missing" | "mismatch";
-        sha256: string | null;
-        bytes: number | null;
-    }>;
-    activeBranch: null;
-    coverage: "partial";
-    issueCount: number;
-    acceptance: "not-assessed";
-};
-export declare function ingestNativePolicy(context: Context, previous: string | undefined, readBytes: (path: string, limit: number) => Buffer): {
-    change: string;
-    policyReceiptId: string;
-    kind: "execution-retention-v2";
-    checkpointId: string;
-    policySha256: string;
-    sourceId: string;
-    archiveSourceId: string;
-    sourceSha256: string;
-    sourceStatus: "available";
-    retention: "exact";
-    syntax: "not-applicable";
-    runtime: "running" | "terminal";
-    content: Record<"session" | "stdout" | "stderr" | "paneSnapshot" | "checkReceipt" | "result", {
-        status: "available" | "missing" | "mismatch";
-        sha256: string | null;
-        bytes: number | null;
-    }>;
-    activeBranch: null;
-    coverage: "partial";
-    issueCount: number;
-    acceptance: "not-assessed";
-};
-export {};

package/dist/archive-retention-policy.js

@@ -1,49 +0,0 @@
-import { dirname, join } from "node:path";
-import { parseExecutionRetentionManifest } from "./generated/retention-v2-contract.js";
-import { ingestRetainedExecution, readRetainedExecution } from "./execution-retention-archive.js";
-import { retainArchiveSource } from "./evidence-archive.js";
-function metadata(context, checkpointId, projection) {
-    return {
-        kind: "execution-retention-v2", checkpointId, policySha256: context.policySha256,
-        sourceId: context.source.id, archiveSourceId: context.archiveSourceId, sourceSha256: projection.sourceSha256,
-        sourceStatus: "available", retention: "exact", syntax: "not-applicable",
-        runtime: projection.runtime, content: projection.content, activeBranch: null,
-        coverage: projection.coverage, issueCount: projection.issues.length, acceptance: projection.acceptance,
-    };
-}
-export function inspectNativePolicy(context, checkpointId) {
-    const read = readRetainedExecution(context.policy.archiveRoot, checkpointId);
-    if (read.sourceId !== context.archiveSourceId || Object.values(read.manifest.content).some(ref => ref.bytes !== null && ref.bytes > context.policy.maxBytes))
-        throw new Error("native snapshot outside policy");
-    return metadata(context, checkpointId, read.projection);
-}
-export function ingestNativePolicy(context, previous, readBytes) {
-    if (previous)
-        inspectNativePolicy(context, previous);
-    const path = join(context.policy.sourceRoot, context.source.path);
-    const manifestBytes = readBytes(path, Math.min(context.policy.maxBytes, 65536));
-    const manifest = parseExecutionRetentionManifest(new TextDecoder("utf-8", { fatal: true }).decode(manifestBytes));
-    const blobs = new Map();
-    for (const ref of Object.values(manifest.content)) {
-        if (!ref.path)
-            continue;
-        if (ref.bytes > context.policy.maxBytes)
-            throw new Error("native content exceeds policy bound");
-        try {
-            blobs.set(ref.path, readBytes(join(dirname(path), ref.path), Math.min(context.policy.maxBytes, 1024 * 1024)));
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-    }
-    const result = ingestRetainedExecution(context.policy.archiveRoot, {
-        manifest: manifestBytes, blobs, retention: "exact", sourceId: context.archiveSourceId,
-    });
-    const receipt = retainArchiveSource(context.policy.archiveRoot, {
-        sourceId: `policy-${context.policySha256}`, parser: { id: "archive-policy-receipt", version: "1" }, retention: "exact",
-        bytes: Buffer.from(JSON.stringify({ version: "archive-policy-receipt-v1", policySha256: context.policySha256, checkpointId: result.snapshotId, sourceId: context.source.id })),
-    });
-    return { ...metadata(context, result.snapshotId, result.projection), change: previous === result.snapshotId ? "repeat" : previous ? "observation" : "initial", policyReceiptId: receipt.manifestId };
-}
-//# sourceMappingURL=archive-retention-policy.js.map

package/dist/archived-work.d.ts

@@ -1,45 +0,0 @@
-import { type WorkProjectionContext, type WorkFrozen, type WorkProjection } from "./generated/work-v4/reader.js";
-import type { WorkDetectionOptions } from "./work-candidates.js";
-import type { WorkSignalFacts } from "@skill-harness/core";
-export type ArchivedWork = {
-    state: "available";
-    manifestId: string;
-    sourceSha256: string;
-    producerCommit: string;
-    projection: WorkFrozen<WorkProjection>;
-} | {
-    state: "missing" | "error";
-    manifestId: string;
-    reason: string;
-};
-/** Pinned producer's actual pure reader/projector, with no append/inspect/file-writing API in the generated facade. */
-export declare function readArchivedWork(root: string, manifestId: string, context?: WorkFrozen<WorkProjectionContext>): ArchivedWork;
-/** Preserve raw work bytes, derived facts and candidate batch linkage. No authority is read from an archive/context file. */
-export declare function captureArchivedWorkCandidates(root: string, manifestId: string, context: WorkFrozen<WorkProjectionContext>, options: WorkDetectionOptions): {
-    linkageManifestId: string;
-    version: string;
-    workManifestId: string;
-    workSha256: string;
-    producerCommit: string;
-    observationId: string;
-    caseBatchId: string;
-    candidateIds: string[];
-    authorityBasis: string;
-    acceptance: string;
-};
-/** Derive binding/coverage/acceptance fields from the real pinned P01 projection, not caller replacements. */
-export declare function captureArchivedWorkSignals(root: string, manifestId: string, context: WorkFrozen<WorkProjectionContext>, suppliedFacts: WorkSignalFacts | null): {
-    linkageManifestId: string;
-    version: string;
-    bindingProfile: string;
-    workManifestId: string;
-    workSha256: string;
-    producerCommit: string;
-    projectionManifestId: string;
-    runtimeFactsManifestId: string;
-    observationId: string;
-    caseBatchId: string;
-    candidateIds: string[];
-    authorityBasis: string;
-    acceptance: string;
-};