@skill-harness/adapters 0.12.0 → 0.13.0

package/dist/archive-policy.js

@@ -0,0 +1,135 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,44 @@
+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>, facts: WorkSignalFacts): {
+    linkageManifestId: string;
+    version: string;
+    bindingProfile: string;
+    workManifestId: string;
+    workSha256: string;
+    producerCommit: string;
+    projectionManifestId: string;
+    observationId: string;
+    caseBatchId: string;
+    candidateIds: string[];
+    authorityBasis: string;
+    acceptance: string;
+};

package/dist/archived-work.js

@@ -0,0 +1,59 @@
+import { readArchiveSource, retainArchiveSource } from "./evidence-archive.js";
+import { projectWorkLedger } from "./generated/work-v4/reader.js";
+import { WORK_V4_READER_COMMIT } from "./generated/work-v4/pin.js";
+import { captureWorkCandidates } from "./work-case-archive.js";
+import { retainWorkSignalObservation } from "./work-signal-observation.js";
+import { captureWorkSignalCases } from "./work-signal-cases.js";
+/** Pinned producer's actual pure reader/projector, with no append/inspect/file-writing API in the generated facade. */
+export function readArchivedWork(root, manifestId, context = { selectedSnapshot: null, authority: null }) {
+    const source = readArchiveSource(root, manifestId);
+    if (source.status !== "available")
+        return { state: source.status === "missing" ? "missing" : "error", manifestId, reason: "work-source-unavailable" };
+    if (source.reference.retention !== "exact" || source.reference.parser.id !== "pi-daddy-work-ledger" || source.reference.parser.version !== "4")
+        return { state: "error", manifestId, reason: "exact-work-v4-source-required" };
+    try {
+        const text = new TextDecoder("utf-8", { fatal: true }).decode(source.bytes);
+        const projection = projectWorkLedger(text, context);
+        return { state: "available", manifestId, sourceSha256: source.reference.sha256, producerCommit: WORK_V4_READER_COMMIT, projection };
+    }
+    catch {
+        return { state: "error", manifestId, reason: "invalid-work-source-or-context" };
+    }
+}
+/** Preserve raw work bytes, derived facts and candidate batch linkage. No authority is read from an archive/context file. */
+export function captureArchivedWorkCandidates(root, manifestId, context, options) {
+    const read = readArchivedWork(root, manifestId, context);
+    if (read.state !== "available" || read.projection.errors.length || read.projection.scopeState !== "valid")
+        throw new Error("work source/selection incomplete; cannot nominate behavior");
+    const cases = captureWorkCandidates(root, read.projection, options);
+    const linkage = { version: "archived-work-candidates-v1", workManifestId: manifestId, workSha256: read.sourceSha256, producerCommit: read.producerCommit,
+        observationId: cases.observationId, caseBatchId: cases.batchId, candidateIds: cases.candidateIds, authorityBasis: "independently-supplied-host-context", acceptance: "not-assessed" };
+    const stored = retainArchiveSource(root, { sourceId: `work-case-link-${read.sourceSha256}`, parser: { id: "archived-work-candidates", version: "1" }, retention: "exact", bytes: Buffer.from(JSON.stringify(linkage)) });
+    return { ...linkage, linkageManifestId: stored.manifestId };
+}
+/** Derive binding/coverage/acceptance fields from the real pinned P01 projection, not caller replacements. */
+export function captureArchivedWorkSignals(root, manifestId, context, facts) {
+    const read = readArchivedWork(root, manifestId, context);
+    if (read.state !== "available" || read.projection.errors.length || read.projection.scopeState !== "valid" || !read.projection.selectedSnapshot || !read.projection.runtime)
+        throw new Error("work source/selection incomplete; cannot capture signals");
+    const work = read.projection, snapshotDigest = read.projection.selectedSnapshot.digest;
+    const snapshot = { snapshotDigest, scopeValid: true,
+        obligations: work.obligations.map(o => ({ id: o.binding.obligation.id, digest: o.binding.obligation.digest,
+            intentDigest: o.binding.intent.digest, policyDigest: o.binding.policy.digest, artifactDigest: o.binding.artifact?.digest ?? null,
+            acceptance: o.acceptance,
+            coverage: [o.artifactCoverage.state, o.evidenceCoverage.state].includes("conflicted") ? "conflicted"
+                : [o.artifactCoverage.state, o.evidenceCoverage.state].includes("unavailable") ? "unavailable"
+                    : o.artifactCoverage.state === "available" && o.evidenceCoverage.state === "available" && o.problems.every(p => p.code === "TRUSTED_REJECTION") ? "available" : "unknown" })) };
+    // All four digests here are REVISION identities, not artifact content digests.
+    // Duplicate obligation bindings cannot be collapsed by this input profile; its validator refuses them.
+    const observation = retainWorkSignalObservation(root, snapshot, facts);
+    const projection = retainArchiveSource(root, { sourceId: `work-signal-projection-${read.sourceSha256}`, parser: { id: "pi-daddy-work-projection", version: "1" }, retention: "exact", bytes: Buffer.from(JSON.stringify(work)) });
+    const cases = captureWorkSignalCases(root, observation.manifestId);
+    const linkage = { version: "archived-work-signals-v1", bindingProfile: "work-v4-revision-digests-v1", workManifestId: manifestId,
+        workSha256: read.sourceSha256, producerCommit: read.producerCommit, projectionManifestId: projection.manifestId,
+        observationId: observation.manifestId, caseBatchId: cases.batchId, candidateIds: cases.candidateIds,
+        authorityBasis: "independently-supplied-host-context", acceptance: "not-assessed" };
+    const stored = retainArchiveSource(root, { sourceId: `work-signal-link-${read.sourceSha256}`, parser: { id: "archived-work-signals", version: "1" }, retention: "exact", bytes: Buffer.from(JSON.stringify(linkage)) });
+    return { ...linkage, linkageManifestId: stored.manifestId };
+}
+//# sourceMappingURL=archived-work.js.map

package/dist/blind-intervention.d.ts

@@ -0,0 +1,29 @@
+import { type BlindQualityChoice, type InterventionManifest, type InterventionEvidence, type InterventionQualification } from "@skill-harness/core";
+/** Explicit private retention. Host role declarations are NOT authentication. No provider is called. */
+export declare function retainBlindIntervention(root: string, manifest: InterventionManifest, evidence: InterventionEvidence[], qualification: InterventionQualification, author: string): string;
+/** One immutable quality choice per comparison. Reopening cannot reset the reveal gate. */
+export declare function openBlindIntervention(root: string, id: string, author: string): Readonly<{
+    view: () => {
+        version: string;
+        cards: {
+            label: string;
+            artifactDigests: string[];
+        }[];
+        limitations: string[];
+    };
+    quality(): BlindQualityChoice | null;
+    readArtifact: (label: string, hash: string) => Buffer<ArrayBuffer>;
+    choose(input: BlindQualityChoice): BlindQualityChoice;
+    reveal(): {
+        manifestId: string;
+        choice: BlindQualityChoice;
+        arms: {
+            label: string;
+            armId: string;
+            configuration: Record<import("@skill-harness/core").InterventionAxis, string>;
+            cost: number | null;
+            costUnit: string;
+        }[];
+        routingDefault: null;
+    };
+}>;