@skill-harness/adapters 0.13.0 → 0.15.0

package/dist/archived-work.d.ts

@@ -28,7 +28,7 @@ export declare function captureArchivedWorkCandidates(root: string, manifestId:
     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): {
+export declare function captureArchivedWorkSignals(root: string, manifestId: string, context: WorkFrozen<WorkProjectionContext>, suppliedFacts: WorkSignalFacts | null): {
     linkageManifestId: string;
     version: string;
     bindingProfile: string;
@@ -36,6 +36,7 @@ export declare function captureArchivedWorkSignals(root: string, manifestId: str
     workSha256: string;
     producerCommit: string;
     projectionManifestId: string;
+    runtimeFactsManifestId: string;
     observationId: string;
     caseBatchId: string;
     candidateIds: string[];

package/dist/archived-work.js

@@ -32,11 +32,11 @@ export function captureArchivedWorkCandidates(root, manifestId, context, options
     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) {
+export function captureArchivedWorkSignals(root, manifestId, context, suppliedFacts) {
     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 work = read.projection, runtime = read.projection.runtime, 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,
@@ -44,6 +44,25 @@ export function captureArchivedWorkSignals(root, manifestId, context, facts) {
             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" })) };
+    // Null means derive only facts the retained projection itself establishes. Empty arrays are explicit:
+    // runtime failure is not an objective violation, and absence cannot invent a deadline, expected wait,
+    // prior acceptance or authority. Coverage candidates still follow from the projected obligation.
+    const facts = suppliedFacts ?? { scopeDigest: snapshotDigest, version: "observed-work-v1", population: "retained-work",
+        expectedWaits: [], checkpoints: [], violations: [], priorAccepted: [] };
+    const runtimeFacts = {
+        version: "observed-work-runtime-v1", snapshotDigest, sourceManifestId: manifestId,
+        attempts: runtime.attempts.map(attempt => {
+            const eventDigests = runtime.occurrences.filter(occurrence => occurrence.payload.executionId === attempt.executionId &&
+                occurrence.payload.provenance === "observed" && ["completed", "failed", "cancelled"].includes(occurrence.payload.state))
+                .map(occurrence => occurrence.event.digest).sort();
+            return { executionId: attempt.executionId, state: attempt.state, resolution: attempt.resolution,
+                completionEvidence: { state: eventDigests.length ? "available" : "unavailable", eventDigests } };
+        }).sort((a, b) => a.executionId < b.executionId ? -1 : a.executionId > b.executionId ? 1 : 0),
+        obligations: snapshot.obligations.map(obligation => ({ obligationDigest: obligation.digest, acceptance: obligation.acceptance, coverage: obligation.coverage }))
+            .sort((a, b) => a.obligationDigest < b.obligationDigest ? -1 : a.obligationDigest > b.obligationDigest ? 1 : 0),
+        unavailable: ["checkpoint-evidence", "expected-wait-evidence", "prior-acceptance-history"],
+    };
+    const retainedRuntimeFacts = retainArchiveSource(root, { sourceId: `observed-runtime-${read.sourceSha256}`, parser: { id: "observed-work-runtime-facts", version: "1" }, retention: "exact", bytes: Buffer.from(JSON.stringify(runtimeFacts)) });
     // 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);
@@ -51,7 +70,7 @@ export function captureArchivedWorkSignals(root, manifestId, context, facts) {
     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,
+        runtimeFactsManifestId: retainedRuntimeFacts.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 };

package/dist/index.d.ts

@@ -18,6 +18,7 @@ export * from "./work-case-review.js";
 export * from "./archive-read-capability.js";
 export * from "./archived-work.js";
 export * from "./blind-intervention.js";
+export * from "./learning-lifecycle.js";
 export * from "./archive-observer.js";
 export * from "./weekly-investigation.js";
 export * from "./intervention-run.js";

package/dist/index.js

@@ -30,6 +30,7 @@ export * from "./work-case-review.js";
 export * from "./archive-read-capability.js";
 export * from "./archived-work.js";
 export * from "./blind-intervention.js";
+export * from "./learning-lifecycle.js";
 export * from "./archive-observer.js";
 export * from "./weekly-investigation.js";
 export * from "./intervention-run.js";

package/dist/learning-lifecycle.d.ts

@@ -0,0 +1,28 @@
+export interface LearningLifecycleInput {
+    caseManifestId: string;
+    hypothesisManifestId: string;
+    comparisonManifestId: string;
+    choiceManifestId: string | null;
+    adoptionManifestId: string | null;
+    rollbackManifestId: string | null;
+    outcomeManifestIds: string[];
+    predecessorManifestId: string | null;
+}
+export type LearningLifecycleState = 'awaiting-human-choice' | 'decision-recorded' | 'adopted-awaiting-outcome' | 'rolled-back' | 'outcome-observed';
+export interface LearningLifecycleView {
+    version: 'retained-learning-lifecycle-v1';
+    state: LearningLifecycleState;
+    predecessorManifestId: string | null;
+    links: {
+        case: string;
+        hypothesis: string;
+        comparison: string;
+        choice: string | null;
+        adoption: string | null;
+        rollback: string | null;
+        outcomes: string[];
+    };
+}
+/** Retains navigation only. Linked artifacts retain their own semantics and authority. */
+export declare function retainLearningLifecycle(root: string, input: LearningLifecycleInput): string;
+export declare function readLearningLifecycle(root: string, manifestId: string): LearningLifecycleView;

package/dist/learning-lifecycle.js

@@ -0,0 +1,66 @@
+import { readArchiveSource, retainArchiveSource } from './evidence-archive.js';
+const SHA = /^[a-f0-9]{64}$/;
+const closed = (value, names) => !!value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).sort().join() === names.sort().join();
+function available(root, id, parser) {
+    if (!SHA.test(id))
+        throw Error('invalid retained learning link');
+    const source = readArchiveSource(root, id);
+    if (source.status !== 'available' || source.reference.retention !== 'exact' || parser && source.reference.parser.id !== parser)
+        throw Error('retained learning link unavailable');
+    return source;
+}
+function validate(root, input, depth = 0) {
+    if (depth > 64)
+        throw Error('learning lifecycle predecessor bound exceeded');
+    if (!closed(input, ['caseManifestId', 'hypothesisManifestId', 'comparisonManifestId', 'choiceManifestId', 'adoptionManifestId', 'rollbackManifestId', 'outcomeManifestIds', 'predecessorManifestId']) || !Array.isArray(input.outcomeManifestIds) || input.outcomeManifestIds.length > 64 || new Set(input.outcomeManifestIds).size !== input.outcomeManifestIds.length)
+        throw Error('invalid bounded learning lifecycle');
+    for (const id of [input.caseManifestId, input.hypothesisManifestId, input.comparisonManifestId])
+        available(root, id);
+    for (const id of [input.choiceManifestId, input.adoptionManifestId, input.rollbackManifestId, ...input.outcomeManifestIds])
+        if (id !== null)
+            available(root, id);
+    if (input.adoptionManifestId && !input.choiceManifestId)
+        throw Error('quality choice required before adoption');
+    if (input.rollbackManifestId && !input.adoptionManifestId)
+        throw Error('adoption required before rollback');
+    if (input.outcomeManifestIds.length && !input.adoptionManifestId)
+        throw Error('adoption required before outcomes');
+    if (input.predecessorManifestId) {
+        const prior = read(root, input.predecessorManifestId, depth + 1);
+        if (prior.links.case !== input.caseManifestId || prior.links.hypothesis !== input.hypothesisManifestId || prior.links.comparison !== input.comparisonManifestId)
+            throw Error('learning lifecycle identity changed');
+        for (const key of ['choice', 'adoption', 'rollback'])
+            if (prior.links[key] !== null && prior.links[key] !== ({ choice: input.choiceManifestId, adoption: input.adoptionManifestId, rollback: input.rollbackManifestId })[key])
+                throw Error('learning lifecycle cannot regress or replace decisions');
+        if (prior.links.outcomes.some((id, index) => input.outcomeManifestIds[index] !== id))
+            throw Error('learning lifecycle cannot regress or replace outcomes');
+    }
+    const state = input.outcomeManifestIds.length ? 'outcome-observed' : input.rollbackManifestId ? 'rolled-back' : input.adoptionManifestId ? 'adopted-awaiting-outcome' : input.choiceManifestId ? 'decision-recorded' : 'awaiting-human-choice';
+    return { version: 'retained-learning-lifecycle-v1', state, predecessorManifestId: input.predecessorManifestId, links: { case: input.caseManifestId, hypothesis: input.hypothesisManifestId, comparison: input.comparisonManifestId, choice: input.choiceManifestId, adoption: input.adoptionManifestId, rollback: input.rollbackManifestId, outcomes: [...input.outcomeManifestIds] } };
+}
+/** Retains navigation only. Linked artifacts retain their own semantics and authority. */
+export function retainLearningLifecycle(root, input) {
+    const view = validate(root, input);
+    return retainArchiveSource(root, { sourceId: `learning-${view.links.comparison.slice(0, 24)}`, parser: { id: 'learning-lifecycle', version: '1' }, retention: 'exact', bytes: Buffer.from(JSON.stringify(view)) }).manifestId;
+}
+function read(root, manifestId, depth) {
+    if (depth > 64)
+        throw Error('learning lifecycle predecessor bound exceeded');
+    const source = available(root, manifestId, 'learning-lifecycle');
+    let value;
+    try {
+        value = JSON.parse(source.bytes.toString('utf8'));
+    }
+    catch {
+        throw Error('invalid retained learning lifecycle');
+    }
+    if (!closed(value, ['version', 'state', 'predecessorManifestId', 'links']) || value.version !== 'retained-learning-lifecycle-v1' || !closed(value.links, ['case', 'hypothesis', 'comparison', 'choice', 'adoption', 'rollback', 'outcomes']))
+        throw Error('invalid retained learning lifecycle');
+    const links = value.links;
+    const rebuilt = validate(root, { caseManifestId: links.case, hypothesisManifestId: links.hypothesis, comparisonManifestId: links.comparison, choiceManifestId: links.choice, adoptionManifestId: links.adoption, rollbackManifestId: links.rollback, outcomeManifestIds: links.outcomes, predecessorManifestId: value.predecessorManifestId }, depth);
+    if (rebuilt.state !== value.state || JSON.stringify(rebuilt) !== source.bytes.toString('utf8'))
+        throw Error('retained learning lifecycle changed');
+    return Object.freeze({ ...rebuilt, links: Object.freeze({ ...rebuilt.links, outcomes: Object.freeze(rebuilt.links.outcomes) }) });
+}
+export function readLearningLifecycle(root, manifestId) { return read(root, manifestId, 0); }
+//# sourceMappingURL=learning-lifecycle.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@skill-harness/adapters",
-    "version": "0.13.0",
+    "version": "0.15.0",
     "description": "skill-harness harness adapters — pi runner + claude-code judge routing (internal API)",
     "type": "module",
     "license": "MIT",
@@ -40,7 +40,7 @@
         "prepack": "node ../../scripts/release-pack.mjs --guard"
     },
     "dependencies": {
-        "@skill-harness/core": "0.13.0",
+        "@skill-harness/core": "0.15.0",
         "typebox": "1.3.4"
     }
 }