@skill-harness/adapters 0.17.0 → 0.19.0

package/dist/archive-checkpoint.js

@@ -1,116 +0,0 @@
-import { createHash } from "node:crypto";
-import { parseArchivedJsonl, readArchiveSource, retainArchiveSource, } from "./evidence-archive.js";
-const hash = (value) => createHash("sha256").update(value).digest("hex");
-const SHA = /^[a-f0-9]{64}$/;
-const LIMIT = 8 * 1024 * 1024;
-const parserEqual = (a, b) => a.id === b.id && a.version === b.version;
-function reject() { throw new Error("invalid archive checkpoint"); }
-function parseCheckpoint(bytes) {
-    const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-    const v = JSON.parse(text);
-    if (JSON.stringify(v) !== text)
-        reject();
-    const names = ["version", "sourceId", "sourceManifestId", "sourceSha256", "sourceBytes", "previousCheckpointId", "lineage", "declaredParser", "reader", "retention", "change", "syntax", "completeBytes", "pendingBytes", "invalidLines", "issues", "activeBranch", "acceptance"];
-    if (!v || Object.keys(v).length !== names.length || Object.keys(v).some(k => !names.includes(k))
-        || v.version !== "archive-checkpoint-v1" || v.reader !== "jsonl-syntax-v1"
-        || typeof v.sourceId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(v.sourceId)
-        || ![v.sourceManifestId, v.sourceSha256, v.lineage].every(h => typeof h === "string" && SHA.test(h))
-        || !(v.previousCheckpointId === null || (typeof v.previousCheckpointId === "string" && SHA.test(v.previousCheckpointId)))
-        || ![v.sourceBytes, v.completeBytes, v.pendingBytes, v.invalidLines].every(n => Number.isSafeInteger(n) && n >= 0 && n <= LIMIT)
-        || v.completeBytes + v.pendingBytes !== v.sourceBytes
-        || !v.declaredParser || Object.keys(v.declaredParser).sort().join() !== "id,version"
-        || ![v.declaredParser.id, v.declaredParser.version].every(s => typeof s === "string" && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(s))
-        || !["exact", "redacted", "reference-only"].includes(v.retention)
-        || !["initial", "append", "replaced", "unknown"].includes(v.change)
-        || !["complete", "partial", "error", "unavailable"].includes(v.syntax)
-        || (v.retention === "reference-only" && (v.syntax !== "unavailable" || v.completeBytes !== 0 || v.invalidLines !== 0))
-        || !Array.isArray(v.issues) || v.issues.length > 16 || v.issues.some(i => typeof i !== "string" || i.length > 128)
-        || v.activeBranch !== null || v.acceptance !== "not-assessed")
-        reject();
-    return v;
-}
-function records(checkpoint, source) {
-    if (source.status !== "available")
-        return [];
-    const parsed = parseArchivedJsonl(source.bytes);
-    return parsed.records.map(record => ({
-        ...record, id: hash(JSON.stringify([checkpoint.sourceId, checkpoint.lineage, record.start, hash(source.bytes.subarray(record.start, record.end))])),
-    }));
-}
-/** Restart from the immutable checkpoint ID. This never advances a worker or invokes a gate. */
-export function readArchiveCheckpoint(root, checkpointId) {
-    const stored = readArchiveSource(root, checkpointId);
-    if (stored.status !== "available" || stored.reference.retention !== "exact")
-        reject();
-    const checkpoint = parseCheckpoint(stored.bytes);
-    const source = readArchiveSource(root, checkpoint.sourceManifestId);
-    if (source.status === "available") {
-        const ref = source.reference;
-        if (ref.sourceId !== checkpoint.sourceId || ref.sha256 !== checkpoint.sourceSha256 || ref.bytes !== checkpoint.sourceBytes
-            || ref.retention !== checkpoint.retention || !parserEqual(ref.parser, checkpoint.declaredParser))
-            reject();
-        const actual = parseArchivedJsonl(source.bytes);
-        if (actual.status !== checkpoint.syntax || actual.completeBytes !== checkpoint.completeBytes
-            || actual.pendingBytes !== checkpoint.pendingBytes || actual.errors.length !== checkpoint.invalidLines)
-            reject();
-    }
-    return { checkpoint, source, records: records(checkpoint, source) };
-}
-/** Caller supplies an explicit snapshot, policy and prior receipt. No inferred active branch or acceptance. */
-export function ingestArchiveSnapshot(root, input) {
-    // Inspect the prior bytes BEFORE storing this snapshot, so reacquisition cannot disguise a prior gap.
-    const previous = input.previousCheckpointId ? readArchiveCheckpoint(root, input.previousCheckpointId) : undefined;
-    if (previous && previous.checkpoint.sourceId !== input.sourceId)
-        throw new Error("checkpoint source mismatch");
-    const captured = retainArchiveSource(root, input);
-    const source = readArchiveSource(root, captured.manifestId);
-    const issues = [];
-    let change = previous ? "unknown" : "initial";
-    let lineage = captured.manifestId;
-    if (previous) {
-        if (!parserEqual(previous.checkpoint.declaredParser, captured.reference.parser) || previous.checkpoint.retention !== input.retention) {
-            issues.push("parser-or-representation-changed");
-        }
-        else if (previous.source.status !== "available") {
-            issues.push("previous-content-unavailable");
-        }
-        else if (input.retention !== "exact") {
-            issues.push("non-exact-continuity-unknown");
-        }
-        else if (source.status === "available") {
-            if (captured.manifestId === previous.checkpoint.sourceManifestId) {
-                return { ...previous, checkpointId: input.previousCheckpointId, change: "repeat", newRecords: [] };
-            }
-            if (source.bytes.length >= previous.source.bytes.length && source.bytes.subarray(0, previous.source.bytes.length).equals(previous.source.bytes)) {
-                change = "append";
-                lineage = previous.checkpoint.lineage;
-            }
-            else {
-                change = "replaced";
-                issues.push("source-replaced");
-            }
-        }
-    }
-    if (input.retention === "redacted")
-        issues.push("redacted-representation");
-    if (source.status !== "available")
-        issues.push("content-not-retained");
-    const syntax = source.status === "available" ? parseArchivedJsonl(source.bytes) : undefined;
-    const checkpoint = {
-        version: "archive-checkpoint-v1", sourceId: input.sourceId,
-        sourceManifestId: captured.manifestId, sourceSha256: captured.reference.sha256, sourceBytes: captured.reference.bytes,
-        previousCheckpointId: input.previousCheckpointId ?? null, lineage,
-        declaredParser: captured.reference.parser, reader: "jsonl-syntax-v1", retention: input.retention, change,
-        syntax: syntax?.status ?? "unavailable", completeBytes: syntax?.completeBytes ?? 0,
-        pendingBytes: syntax?.pendingBytes ?? captured.reference.bytes, invalidLines: syntax?.errors.length ?? 0,
-        issues, activeBranch: null, acceptance: "not-assessed",
-    };
-    const result = retainArchiveSource(root, {
-        sourceId: `checkpoint-${hash(input.sourceId)}`, parser: { id: "archive-checkpoint", version: "1" },
-        retention: "exact", bytes: Buffer.from(JSON.stringify(checkpoint)),
-    });
-    const all = records(checkpoint, source);
-    return { checkpointId: result.manifestId, checkpoint, source, records: all, change,
-        newRecords: change === "append" ? all.filter(record => record.start >= previous.checkpoint.completeBytes) : all };
-}
-//# sourceMappingURL=archive-checkpoint.js.map

package/dist/archive-facts.d.ts

@@ -1,19 +0,0 @@
-import type { WorkSignalFacts } from '@skill-harness/core';
-import { type GovernedArchiveRoute } from './archive-access.js';
-/** Operational fixed-order fact adapter, not arbitrary model/host fact inference.
- * The caller supplies independent scope/source pins; all actual bytes use consent. */
-export declare function readFixedOrderFacts(root: string, manifestId: string, route: GovernedArchiveRoute, raw: {
-    producerCommit: string;
-    scopeDigest: string;
-    population: string;
-    obligations: string[];
-}, now?: number): {
-    facts: WorkSignalFacts;
-    source: {
-        manifestId: string;
-        sha256: string;
-        producerCommit: string;
-    };
-    unknownNodes: any;
-    acceptance: "not-assessed";
-};

package/dist/archive-facts.js

@@ -1,20 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readGovernedArchive } from './archive-access.js';
-import { learningCopy } from './learning-journal.js';
-/** Operational fixed-order fact adapter, not arbitrary model/host fact inference.
- * The caller supplies independent scope/source pins; all actual bytes use consent. */
-export function readFixedOrderFacts(root, manifestId, route, raw, now = Date.now()) {
-    const expected = learningCopy(raw);
-    if (!/^[a-f0-9]{40}$/.test(expected.producerCommit) || !/^[a-f0-9]{64}$/.test(expected.scopeDigest) || typeof expected.population !== 'string' || !expected.population.length || expected.population.length > 512 || /[\u0000-\u001f\u007f]/.test(expected.population) || !Array.isArray(expected.obligations) || expected.obligations.length > 128 || expected.obligations.some(h => !/^[a-f0-9]{64}$/.test(h)))
-        throw Error('explicit fact source/scope pins required');
-    const read = readGovernedArchive(root, manifestId, 1024 * 1024, route, now);
-    if (read.status !== 'available' || read.reference.retention !== 'exact' || read.reference.parser.id !== 'factory-order-readback' || read.reference.parser.version !== '1')
-        throw Error('exact governed order readback required');
-    const value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(read.bytes));
-    if (value.kind !== 'actual-fixed-profile-order' || value.producerCommit !== expected.producerCommit || !Array.isArray(value.nodes) || !value.nodes.length || value.nodes.length > 128 || value.nodes.some((n) => !n || !expected.obligations.includes(n.obligation?.digest) || typeof n.state !== 'string'))
-        throw Error('order facts source/scope mismatch');
-    const digest = createHash('sha256').update(read.bytes).digest('hex');
-    const facts = { scopeDigest: expected.scopeDigest, version: 'fixed-order-facts-v1', population: expected.population, expectedWaits: [], checkpoints: [], violations: value.nodes.filter((n) => n.state === 'exhausted').map((n) => ({ obligationDigest: n.obligation.digest, status: 'FAIL', evidence: digest })), priorAccepted: [] };
-    return { facts, source: { manifestId, sha256: digest, producerCommit: expected.producerCommit }, unknownNodes: value.nodes.filter((n) => !['satisfied', 'exhausted'].includes(n.state)).length, acceptance: 'not-assessed' };
-}
-//# sourceMappingURL=archive-facts.js.map

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 {};