@skill-harness/adapters 0.12.0 → 0.13.0

package/dist/weekly-investigation.js

@@ -0,0 +1,330 @@
+import { createHash } from 'node:crypto';
+import { isAbsolute } from 'node:path';
+import { constants, openSync, fstatSync, writeSync, fsyncSync, closeSync, realpathSync } from 'node:fs';
+import { screenResults, validateResults, parseLearningRequest, buildHypothesis, selectWeeklyInvestigation, authorizeInvestigation, previewInvestigationScenario, applyInvestigationScenario, freezeInvestigation, assertFrozenInvestigation } from '@skill-harness/core';
+import { createArchiveReadCapability } from './archive-read-capability.js';
+import { readArchiveSource } from './evidence-archive.js';
+import { readLearningCase } from './learning-case.js';
+import { learningJournal, learningCopy, learningHash, learningFile, registerLearningStore, verifyLearningStore } from './learning-journal.js';
+const sha = (bytes) => createHash('sha256').update(bytes).digest('hex');
+function confirmed(input) {
+    if (Object.keys(input).sort().join() !== 'archiveRoot,cases,maxCases,policyDigest,population,reader,week' || !isAbsolute(input.archiveRoot))
+        throw Error('closed absolute weekly input required');
+    if (!Array.isArray(input.cases) || !input.cases.length || input.cases.length > 32)
+        throw Error('bounded confirmed cases required');
+    return input.cases.map(c => { const { candidate, current, matched } = readLearningCase(input.archiveRoot, c); if (!matched || current?.disposition !== 'confirmed_defect' || candidate.detector.population !== input.population)
+        throw Error('current confirmed case decision and population required'); return candidate.id; });
+}
+function selection(input) { const ids = confirmed(input), reader = createArchiveReadCapability({ ...input.reader, root: input.archiveRoot }); return selectWeeklyInvestigation([], { week: input.week, population: input.population, policyDigest: input.policyDigest, archiveSnapshot: reader.snapshot.id, eligibleCaseIds: ids, maxCases: input.maxCases }); }
+export function createWeeklyInvestigation(directory, input) {
+    const safe = learningCopy(input), selected = selection(safe), initial = { type: 'initial', kind: 'weekly-investigation-v1', input: safe, selection: selected };
+    registerLearningStore(safe.archiveRoot, 'weekly', selected.key, directory, learningHash(initial));
+    try {
+        learningJournal(directory, initial);
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+        const old = learningJournal(directory).read()[0].value;
+        if (learningHash(old) !== learningHash(initial))
+            throw Error('weekly selection already frozen');
+    }
+    return openWeeklyInvestigation(directory);
+}
+/** Existing run is a finite inert data-only interpreter. The separate prepareModel/runModel
+ * composition forwards only capability-selected frozen bytes to an original producer model seam;
+ * it does not expose shell/filesystem tools or turn proposal evidence into execution authority. */
+export function openWeeklyInvestigation(directory) {
+    const journal = learningJournal(directory), initial = journal.read()[0].value;
+    if (initial.kind !== 'weekly-investigation-v1' || initial.type !== 'initial')
+        throw Error('wrong supervisor journal');
+    const input = initial.input, selected = initial.selection;
+    const inspect = () => {
+        verifyLearningStore(input.archiveRoot, 'weekly', selected.key, directory, learningHash(initial));
+        const events = journal.read();
+        let state = 'prepared', hypothesis = null, approved = false, preview = null, frozen = null, files = null, skillHash = null;
+        for (const { value: v } of events.slice(1)) {
+            switch (v.type) {
+                case 'model-prepared':
+                    if (state !== 'prepared')
+                        throw Error('invalid model preparation');
+                    state = 'model-prepared';
+                    break;
+                case 'claim':
+                    if (!['prepared', 'model-prepared'].includes(state))
+                        throw Error('invalid supervisor claim');
+                    state = 'claimed';
+                    break;
+                case 'read':
+                    if (state !== 'claimed')
+                        throw Error('invalid read phase');
+                    break;
+                case 'proposed':
+                    if (state !== 'claimed')
+                        throw Error('invalid proposal phase');
+                    hypothesis = buildHypothesis(v.hypothesis.proposal);
+                    if (hypothesis.id !== v.hypothesis.id)
+                        throw Error('proposal identity changed');
+                    state = 'proposed';
+                    break;
+                case 'failed':
+                    if (state !== 'claimed')
+                        throw Error('invalid failure phase');
+                    state = 'failed';
+                    break;
+                case 'approved':
+                    if (state !== 'proposed')
+                        throw Error('invalid approval phase');
+                    approved = true;
+                    state = 'approved';
+                    break;
+                case 'promotion-pending':
+                    if (state !== 'approved')
+                        throw Error('invalid promotion phase');
+                    preview = v.preview;
+                    state = 'promotion-pending';
+                    break;
+                case 'promoted':
+                    if (state !== 'promotion-pending')
+                        throw Error('invalid promotion completion');
+                    state = 'promoted';
+                    break;
+                case 'frozen':
+                    if (state !== 'promoted')
+                        throw Error('invalid freeze phase');
+                    frozen = v.frozen;
+                    files = v.files;
+                    skillHash = String(v.skillHash);
+                    state = 'frozen';
+                    break;
+                case 'edit-pending':
+                    if (state !== 'frozen')
+                        throw Error('invalid edit phase');
+                    state = 'edit-pending';
+                    break;
+                case 'edited':
+                    if (state !== 'edit-pending')
+                        throw Error('invalid edit completion');
+                    skillHash = String(v.skillHash);
+                    state = 'edited';
+                    break;
+                case 'screened':
+                    if (!['frozen', 'edited'].includes(state))
+                        throw Error('invalid screen phase');
+                    break;
+                default: throw Error('unknown supervisor event');
+            }
+        }
+        return learningCopy({ state, hypothesis, approved, preview, frozen, files, skillHash, selection: selected, tip: events.at(-1).id });
+    };
+    inspect();
+    const append = (prior, value) => journal.append(prior, value);
+    const inputs = (files) => ({ specSha256: sha(learningFile(files.spec)), rubricSha256: sha(learningFile(files.rubric)), judgePolicySha256: sha(learningFile(files.judgePolicy)), heldoutSha256: sha(learningFile(files.heldout)), configurationSha256: sha(learningFile(files.configuration)) });
+    const evaluation = () => { const s = inspect(); if (!s.frozen || !s.files || !['frozen', 'edited'].includes(s.state))
+        throw Error('frozen investigation required'); confirmed(input); assertFrozenInvestigation(s.frozen, inputs(s.files)); if (sha(learningFile(s.files.skill)) !== s.skillHash)
+        throw Error('candidate changed outside authorized edit'); return { frozen: s.frozen, caseIds: s.hypothesis.proposal.caseIds, skillSha256: s.skillHash, executionReady: false }; };
+    const previewScreen = (request) => {
+        const evaluated = evaluation(), s = inspect(), input = learningCopy(request);
+        if (Object.keys(input).sort().join() !== 'manifestIds,population' || typeof input.population !== 'string' || !input.population.length || input.population.length > 512 || !Array.isArray(input.manifestIds) || !input.manifestIds.length || input.manifestIds.length > 16 || new Set(input.manifestIds).size !== input.manifestIds.length || input.manifestIds.some(id => !/^[a-f0-9]{64}$/.test(id)))
+            throw Error('bounded distinct screen sources required');
+        const binding = { input, freeze: evaluated.frozen.digest, skillSha256: evaluated.skillSha256, scenarioId: String(s.preview.scenario.id) };
+        return { ...binding, digest: learningHash(binding) };
+    };
+    return { inspect, evaluation, previewScreen,
+        prepareModel(raw) {
+            const request = learningCopy(raw), s = inspect();
+            confirmed(input);
+            if (Object.keys(request).sort().join() !== 'kind,manifestIds,maxInputBytes,proposalLimits' || request.kind !== 'producer-archive-model-v1' || !Number.isSafeInteger(request.maxInputBytes) || request.maxInputBytes < 1 || request.maxInputBytes > 3000 || !Array.isArray(request.manifestIds) || !request.manifestIds.length || new Set(request.manifestIds).size !== request.manifestIds.length || request.manifestIds.length > input.reader.maxCalls || request.manifestIds.some(id => !input.reader.manifestIds.includes(id)) || Object.keys(request.proposalLimits).sort().join() !== 'judgeCalls,subjectCalls,wallMs' || Object.values(request.proposalLimits).some(n => !Number.isSafeInteger(n) || n < 0) || request.proposalLimits.wallMs < 1)
+                throw Error('bounded archive-only model request required');
+            const old = journal.read().find(e => e.value.type === 'model-prepared');
+            if (old) {
+                if (learningHash(old.value.request) !== learningHash(request) || s.state !== 'model-prepared')
+                    throw Error('model preparation changed or already claimed');
+                return learningCopy(old.value.prepared);
+            }
+            if (s.state !== 'prepared')
+                throw Error('weekly owner already claimed');
+            const reader = createArchiveReadCapability({ ...input.reader, root: input.archiveRoot });
+            const sources = request.manifestIds.map(id => { const r = reader.read(id); return { manifestId: r.manifestId, sha256: r.reference.sha256, bytesBase64: r.bytes.toString('base64') }; });
+            const text = JSON.stringify({ selection: selected, sources, proposalLimits: request.proposalLimits });
+            if (Buffer.byteLength(text) > request.maxInputBytes)
+                throw Error('archive model input overbudget');
+            const prepared = { input: text, digest: learningHash({ request, input: text, selection: selected }) };
+            append(s.tip, { type: 'model-prepared', request, prepared, sourceKind: 'producer-archive-model-v1' });
+            return prepared;
+        },
+        async runModel(preparedDigest, planSha256, invoke) {
+            const s = inspect(), prepared = journal.read().find(e => e.value.type === 'model-prepared')?.value;
+            if (s.state !== 'model-prepared' || !prepared || prepared.prepared.digest !== preparedDigest || !/^([a-f0-9]{64})$/.test(planSha256))
+                throw Error('frozen model preparation required');
+            confirmed(input);
+            const tip = append(s.tip, { type: 'claim', sourceKind: 'producer-archive-model-v1', preparedDigest, planSha256 }).id;
+            try {
+                const ref = await invoke(String(prepared.prepared.input)), rows = learningJournal(ref.hostPath).read(), obs = rows.find(r => r.value.type === 'observation' && r.value.id === ref.id), bound = rows.find(r => r.value.type === 'producer-ipc-bound' && r.value.id === ref.id), settled = rows.find(r => r.value.type === 'producer-ipc-settled' && r.value.id === ref.id);
+                if (!obs || !bound || !settled || bound.value.bindingHash !== settled.value.bindingHash || bound.value.binding.charterSha256 !== planSha256)
+                    throw Error('original model settlement required');
+                const h = buildHypothesis(JSON.parse(Buffer.from(String(obs.value.outputBase64), 'base64').toString('utf8')));
+                if (h.proposal.archiveSnapshot !== selected.archiveSnapshot || h.proposal.population !== selected.population || learningHash([...h.proposal.caseIds].sort()) !== learningHash([...selected.selectedCaseIds].sort()) || learningHash(h.proposal.limits) !== learningHash(prepared.request.proposalLimits))
+                    throw Error('model proposal scope/limits mismatch');
+                confirmed(input);
+                append(tip, { type: 'proposed', hypothesis: h, sourceKind: 'producer-archive-model-v1', source: { ...ref, observation: obs.id, settlement: settled.id, planSha256 }, approved: false });
+                return h;
+            }
+            catch (error) {
+                try {
+                    append(tip, { type: 'failed', reason: 'model-retro-failed; no retry' });
+                }
+                catch (persist) {
+                    throw new AggregateError([error, persist], 'retro failure persistence unknown');
+                }
+                throw error;
+            }
+        },
+        screen(request, authorizedLinks) {
+            const s = inspect(), preview = previewScreen(request);
+            if (!authorizedLinks.includes(preview.digest))
+                throw Error('independent exact screen linkage authority required');
+            if (inspect().tip !== s.tip)
+                throw Error('stale screen snapshot');
+            const seen = new Set();
+            const results = preview.input.manifestIds.map(id => {
+                const source = readArchiveSource(input.archiveRoot, id);
+                if (source.status !== 'available' || source.reference.retention !== 'exact' || source.reference.parser.id !== 'skill-harness-results' || source.bytes.length > 65536)
+                    throw Error('retained screen results unavailable');
+                if (seen.has(source.reference.sha256))
+                    throw Error('duplicate screen evidence bytes');
+                seen.add(source.reference.sha256);
+                const result = validateResults(parseLearningRequest(source.bytes.toString('utf8')));
+                if (source.reference.parser.version !== String(result.schema) || typeof result.skill !== 'string' || typeof result.model !== 'string' || new Set(result.scenarios.map(r => r.id)).size !== result.scenarios.length || !result.scenarios.some(r => r.id === preview.scenarioId))
+                    throw Error('screen result scenario/schema binding mismatch');
+                return result;
+            });
+            const report = screenResults(results), receipt = { ...preview, report: { scenarios: report.scenarios.filter(r => r.id === preview.scenarioId), criteria: report.criteria.filter(r => r.scenario_id === preview.scenarioId) }, exploratory: true, populationMatches: preview.input.population === selected.population, comparisonQualified: false };
+            const old = journal.read().find(e => e.value.type === 'screened' && e.value.receipt.digest === receipt.digest);
+            if (old) {
+                if (learningHash(old.value.receipt) !== learningHash(receipt))
+                    throw Error('screen receipt changed');
+                return receipt;
+            }
+            append(s.tip, { type: 'screened', receipt });
+            return receipt;
+        },
+        run(program) {
+            const before = inspect();
+            if (before.state !== 'prepared')
+                throw Error('weekly job already claimed; no automatic retry');
+            confirmed(input);
+            let tip = journal.append(before.tip, { type: 'claim' }).id;
+            try {
+                const host = learningCopy(program);
+                if (host.kind !== 'inert-v1' || Object.keys(host).sort().join() !== 'kind,requests' || !Array.isArray(host.requests) || host.requests.length > 128)
+                    throw Error('host denied');
+                const reader = createArchiveReadCapability({ ...input.reader, root: input.archiveRoot });
+                let reads = 0, h = null;
+                for (const request of host.requests) {
+                    if (h)
+                        throw Error('request after proposal denied');
+                    if (request.tool === 'archive.read' && Object.keys(request).sort().join() === 'manifestId,tool') {
+                        const result = reader.read(String(request.manifestId));
+                        tip = append(tip, { type: 'read', manifestId: result.manifestId, sha256: result.reference.sha256 }).id;
+                        reads++;
+                    }
+                    else if (request.tool === 'hypothesis' && Object.keys(request).sort().join() === 'proposal,tool') {
+                        h = buildHypothesis(request.proposal);
+                        if (!reads || h.proposal.archiveSnapshot !== selected.archiveSnapshot || h.proposal.population !== selected.population || learningHash([...h.proposal.caseIds].sort()) !== learningHash([...selected.selectedCaseIds].sort()) || h.proposal.limits.subjectCalls !== 0 || h.proposal.limits.judgeCalls !== 0)
+                            throw Error('confirmed case/read linkage or inert budget mismatch');
+                    }
+                    else
+                        throw Error('capability denied');
+                }
+                if (!h)
+                    throw Error('hypothesis missing');
+                confirmed(input);
+                append(tip, { type: 'proposed', hypothesis: h });
+                return h;
+            }
+            catch (error) {
+                try {
+                    append(tip, { type: 'failed', reason: 'inert-host-refused-or-failed' });
+                }
+                catch (persist) {
+                    throw new AggregateError([error, persist], 'supervisor failed; failure persistence unknown');
+                }
+                throw error;
+            }
+        },
+        approve(authority) { const s = inspect(); if (!s.hypothesis)
+            throw Error('hypothesis required'); const approval = authorizeInvestigation(s.hypothesis, authority); if (s.approved)
+            return approval; if (s.state !== 'proposed')
+            throw Error('proposal required'); confirmed(input); append(s.tip, { type: 'approved', approval }); return approval; },
+        preview(specPath, scenario) { const s = inspect(); if (!s.approved || !s.hypothesis)
+            throw Error('investigation approval required'); confirmed(input); return previewInvestigationScenario(s.hypothesis, specPath, scenario); },
+        promote(preview, authority) {
+            const s = inspect();
+            if (!s.hypothesis || !s.approved)
+                throw Error('approved investigation required');
+            authorizeInvestigation(s.hypothesis, authority);
+            if (!authority.promotions.includes(preview.digest))
+                throw Error('exact promotion authority required');
+            confirmed(input);
+            if (['promoted', 'frozen', 'edited'].includes(s.state) && s.preview?.digest === preview.digest) {
+                if (learningHash(s.preview) !== learningHash(preview))
+                    throw Error('promotion identity changed');
+                if (sha(learningFile(preview.specPath)) !== preview.afterSha256)
+                    throw Error('promoted scenario changed');
+                return { scenarioId: String(preview.scenario.id), replayed: true, sha256: preview.afterSha256, scope: 'scenario-only' };
+            }
+            if (s.state !== 'approved')
+                throw Error('pending effects are not retried');
+            if (learningHash(previewInvestigationScenario(s.hypothesis, preview.specPath, preview.scenario)) !== learningHash(preview))
+                throw Error('promotion identity changed');
+            const pending = append(s.tip, { type: 'promotion-pending', preview });
+            const result = applyInvestigationScenario(s.hypothesis, preview, authority);
+            append(pending.id, { type: 'promoted', result });
+            return result;
+        },
+        freeze(files, authority) { const s = inspect(); if (s.state !== 'promoted' || !s.hypothesis || !s.preview || files.spec !== s.preview.specPath || sha(learningFile(files.spec)) !== s.preview.afterSha256)
+            throw Error('promoted scenario binding required'); confirmed(input); const safe = learningCopy(files); for (const key of Object.keys(safe)) {
+            learningFile(safe[key]);
+            safe[key] = realpathSync(safe[key]);
+        } if (Object.keys(safe).sort().join() !== 'configuration,heldout,judgePolicy,rubric,skill,spec' || new Set(Object.values(safe)).size !== 6)
+            throw Error('distinct frozen evaluation and candidate paths required'); const frozen = freezeInvestigation(s.hypothesis, inputs(safe), authority); append(s.tip, { type: 'frozen', frozen, files: safe, skillHash: sha(learningFile(safe.skill)) }); return frozen; },
+        previewEdit(text) { evaluation(); const s = inspect(); if (s.state !== 'frozen' || typeof text !== 'string' || Buffer.byteLength(text) > 1024 * 1024)
+            throw Error('frozen bounded edit required'); return learningHash({ freeze: s.frozen.digest, path: s.files.skill, before: s.skillHash, after: sha(Buffer.from(text)) }); },
+        edit(text, authorizedDigests) {
+            const id = this.previewEdit(text), s = inspect();
+            if (!authorizedDigests.includes(id))
+                throw Error('independent exact edit authority required');
+            confirmed(input);
+            const pending = append(s.tip, { type: 'edit-pending', editId: id });
+            const fd = openSync(s.files.skill, constants.O_WRONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+            try {
+                const stat = fstatSync(fd);
+                if (!stat.isFile() || stat.nlink !== 1)
+                    throw Error('edit destination changed');
+                // Whole-file replacement is bounded and explicitly approved. Partial writes remain pending/error.
+                const bytes = Buffer.from(text);
+                let n = 0;
+                while (n < bytes.length) {
+                    const k = writeSync(fd, bytes, n, bytes.length - n, n);
+                    if (!k)
+                        throw Error('edit write stalled');
+                    n += k;
+                }
+                // Truncate only this explicitly approved candidate, never an evaluation input or historical evidence.
+                truncateCandidate(fd, bytes.length);
+                fsyncSync(fd);
+            }
+            finally {
+                closeSync(fd);
+            }
+            const current = sha(learningFile(s.files.skill));
+            if (current !== sha(Buffer.from(text)))
+                throw Error('edited candidate bytes changed');
+            append(pending.id, { type: 'edited', skillHash: current });
+            return evaluation();
+        }
+    };
+}
+import { ftruncateSync as truncateCandidate } from 'node:fs';
+//# sourceMappingURL=weekly-investigation.js.map

package/dist/work-candidates.d.ts

@@ -0,0 +1,29 @@
+import { type WorkCaptureCaseV2 } from "@skill-harness/core";
+import type { WorkProjection } from "./generated/retention-v2-work-types.js";
+export interface WorkDetectionOptions {
+    version: string;
+    population: string;
+    scopeDigest: string;
+    minEquivalentAttempts: number;
+    /** Explicit frozen domain facts, never inferred from worker prose. Values are obligation digests. */
+    expectedWaits: string[];
+    expectedFailures: string[];
+    exemplar?: {
+        unit: "wall_ms" | "tool_calls" | "usd";
+        maximum: number;
+    };
+    usage?: Record<string, {
+        observed: boolean;
+        cost: number;
+        unit: "wall_ms" | "tool_calls" | "usd";
+        evidence: string;
+    }>;
+}
+export declare const WORK_CANDIDATE_IMPLEMENTATION = "structural-work-v2";
+/** Consumes the actual P01 host projection, not arbitrary native wire or a new acceptance authority. */
+export declare function detectWorkCandidates(work: WorkProjection, options: WorkDetectionOptions): {
+    version: "work-candidates-v1";
+    cases: WorkCaptureCaseV2[];
+    issues: string[];
+    expected: string[];
+};

package/dist/work-candidates.js

@@ -0,0 +1,78 @@
+import { createHash } from "node:crypto";
+import { buildWorkCapture } from "@skill-harness/core";
+export const WORK_CANDIDATE_IMPLEMENTATION = "structural-work-v2";
+const hash = /^[a-f0-9]{64}$/;
+/** Consumes the actual P01 host projection, not arbitrary native wire or a new acceptance authority. */
+export function detectWorkCandidates(work, options) {
+    if (![options.version, options.population].every(s => typeof s === "string" && s.length > 0 && s.length <= 128 && !/[\u0000-\u001f\u007f]/.test(s))
+        || !Array.isArray(options.expectedWaits) || !Array.isArray(options.expectedFailures)
+        || options.expectedWaits.length > 4096 || options.expectedFailures.length > 4096
+        || options.expectedFailures.some(id => typeof id !== "string" || !id || id.length > 512)
+        || !Number.isSafeInteger(options.minEquivalentAttempts) || options.minEquivalentAttempts < 2 || options.minEquivalentAttempts > 256
+        || !hash.test(options.scopeDigest) || options.expectedWaits.some(d => !hash.test(d))
+        || (options.exemplar && (!Number.isFinite(options.exemplar.maximum) || options.exemplar.maximum < 0)))
+        throw new Error("invalid structural detector policy");
+    if (work.selectedSnapshot && work.selectedSnapshot.digest !== options.scopeDigest)
+        throw new Error("detector scope mismatch");
+    if (work.scopeState !== "valid" || !work.selectedSnapshot || !work.runtime || work.errors.length) {
+        return { version: "work-candidates-v1", cases: [], issues: ["work-scope-not-resolved"], expected: [] };
+    }
+    const policyDigest = createHash("sha256").update(JSON.stringify({ minEquivalentAttempts: options.minEquivalentAttempts, exemplar: options.exemplar ? { unit: options.exemplar.unit, maximum: options.exemplar.maximum } : null })).digest("hex");
+    const version = `${WORK_CANDIDATE_IMPLEMENTATION}:${options.version}:${policyDigest}`;
+    const cases = [], expected = [];
+    const waits = new Set(options.expectedWaits), expectedFailures = new Set(options.expectedFailures);
+    const occurrences = work.runtime.occurrences;
+    for (const obligation of work.obligations) {
+        const ref = obligation.binding.obligation;
+        const target = { kind: "work", snapshotDigest: work.selectedSnapshot.digest, obligationId: ref.id, obligationDigest: ref.digest };
+        const evidence = [target.snapshotDigest, target.obligationDigest];
+        const add = (reason, classification, metrics, refs = evidence) => {
+            cases.push(buildWorkCapture({ detector: { id: reason, version, population: options.population }, target, reason, classification, metrics, evidence: refs }));
+        };
+        if (waits.has(ref.digest)) {
+            expected.push(`declared-wait:${ref.digest}`);
+            continue;
+        }
+        if (obligation.acceptance === "unresolved" || obligation.artifactCoverage.state !== "available" || obligation.evidenceCoverage.state !== "available" || obligation.problems.some(problem => problem.code !== "TRUSTED_REJECTION")) {
+            add("coverage_gap", "coverage_issue", {});
+            continue;
+        }
+        for (const attempt of work.runtime.attempts)
+            if (expectedFailures.has(attempt.executionId) && attempt.bindings.some(b => b.obligation.digest === ref.digest))
+                expected.push(`expected-failure:${attempt.executionId}`);
+        const attempts = work.runtime.attempts.filter(attempt => attempt.resolution === "resolved"
+            && !expectedFailures.has(attempt.executionId)
+            && attempt.bindings.some(b => b.obligation.id === ref.id && b.obligation.digest === ref.digest)
+            && occurrences.some(o => o.payload.executionId === attempt.executionId && o.payload.obligation.id === ref.id && o.payload.obligation.digest === ref.digest
+                && o.payload.provenance === "observed" && ["completed", "failed"].includes(o.payload.state)));
+        if (obligation.acceptance === "accepted-under-supplied-authority") {
+            if (!work.authoritySnapshot || !options.exemplar || !attempts.length)
+                continue;
+            const usage = attempts.map(a => options.usage?.[a.executionId]);
+            if (usage.some(u => !u || !u.observed || u.unit !== options.exemplar.unit || !Number.isFinite(u.cost) || u.cost < 0 || !hash.test(u.evidence)))
+                continue;
+            const measuredCost = usage.reduce((sum, u) => sum + u.cost, 0);
+            if (measuredCost <= options.exemplar.maximum)
+                add("economical_exemplar", "candidate_exemplar", { measuredCost, costLimit: options.exemplar.maximum, costUnit: options.exemplar.unit }, [...evidence, ...usage.map(u => u.evidence)]);
+            continue;
+        }
+        const groups = new Map();
+        for (const attempt of attempts) {
+            const config = attempt.effectiveLabels.configurationDigest;
+            if (!config || !hash.test(config) || !attempt.observedLabels.some(label => label.configurationDigest === config))
+                continue;
+            const bindings = attempt.bindings.filter(b => b.obligation.id === ref.id && b.obligation.digest === ref.digest);
+            const bindingKeys = bindings.map(b => JSON.stringify({ variants: [...b.variantIds].sort(), artifacts: b.artifacts.map(a => a.digest).sort() })).sort();
+            const key = JSON.stringify([config, attempt.effectiveLabels.modelId, attempt.effectiveLabels.effortId, bindingKeys]);
+            groups.set(key, [...(groups.get(key) ?? []), attempt]);
+        }
+        const strongest = [...groups].sort(([ka, a], [kb, b]) => b.length - a.length || (ka < kb ? -1 : ka > kb ? 1 : 0))[0]?.[1] ?? [];
+        const ids = new Set(strongest.map(a => a.executionId));
+        if (ids.size >= options.minEquivalentAttempts) {
+            const refs = occurrences.filter(o => ids.has(o.payload.executionId) && o.payload.obligation.id === ref.id && o.payload.obligation.digest === ref.digest).map(o => o.event.digest);
+            add("repeat_without_progress", "candidate_defect", { equivalentAttempts: ids.size }, [...evidence, ...refs]);
+        }
+    }
+    return { version: "work-candidates-v1", cases: cases.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0), issues: [], expected: expected.sort() };
+}
+//# sourceMappingURL=work-candidates.js.map

package/dist/work-case-archive.d.ts

@@ -0,0 +1,25 @@
+import { type WorkCaptureCaseV2 } from "@skill-harness/core";
+import { type WorkDetectionOptions } from "./work-candidates.js";
+import type { WorkProjection } from "./generated/retention-v2-work-types.js";
+/** Explicit private archival, never promotion into a scored specification or automatic alert exposure. */
+export declare function retainWorkCandidate(root: string, candidate: WorkCaptureCaseV2): string;
+export declare function readWorkCandidate(root: string, manifestId: string): WorkCaptureCaseV2;
+/** Capture the actual trusted P01 projection before retaining advisory cases; never a worker callback. */
+export declare function captureWorkCandidates(root: string, work: WorkProjection, options: WorkDetectionOptions): {
+    batchId: string;
+    observationId: string;
+    candidateIds: string[];
+};
+/** Several observations/detector versions of the same scoped work are not independent incidents. */
+export declare function groupWorkIncidents(cases: readonly WorkCaptureCaseV2[]): {
+    key: string;
+    target: {
+        kind: "work";
+        snapshotDigest: string;
+        obligationId: string;
+        obligationDigest: string;
+    };
+    observations: WorkCaptureCaseV2[];
+    status: "unresolved";
+    visibility: "silent";
+}[];

package/dist/work-case-archive.js

@@ -0,0 +1,63 @@
+import { buildWorkCapture } from "@skill-harness/core";
+import { readArchiveSource, retainArchiveSource } from "./evidence-archive.js";
+import { detectWorkCandidates } from "./work-candidates.js";
+function validate(value) {
+    if (!value || value.capture_schema !== 2 || value.status !== "unresolved" || value.visibility !== "silent" || value.causalAttribution !== "not-established")
+        throw new Error("invalid work case state");
+    const built = buildWorkCapture({ detector: value.detector, target: value.target, classification: value.classification,
+        reason: value.reason, evidence: value.evidence, metrics: value.metrics });
+    if (built.id !== value.id || Object.keys(value).sort().join() !== Object.keys(built).sort().join())
+        throw new Error("invalid work case identity");
+    return built;
+}
+/** Explicit private archival, never promotion into a scored specification or automatic alert exposure. */
+export function retainWorkCandidate(root, candidate) {
+    const value = validate(candidate);
+    return retainArchiveSource(root, { sourceId: `work-case-${value.id}`, parser: { id: "work-capture", version: "2" }, retention: "exact", bytes: Buffer.from(JSON.stringify(value)) }).manifestId;
+}
+export function readWorkCandidate(root, manifestId) {
+    const source = readArchiveSource(root, manifestId);
+    if (source.status !== "available" || source.reference.retention !== "exact" || source.reference.parser.id !== "work-capture" || source.reference.parser.version !== "2")
+        throw new Error("work case missing or invalid");
+    const value = validate(JSON.parse(source.bytes.toString("utf8")));
+    if (source.reference.sourceId !== `work-case-${value.id}`)
+        throw new Error("work case source mismatch");
+    return value;
+}
+/** Capture the actual trusted P01 projection before retaining advisory cases; never a worker callback. */
+export function captureWorkCandidates(root, work, options) {
+    const detection = detectWorkCandidates(work, options);
+    const observation = retainArchiveSource(root, {
+        sourceId: `work-facts-${options.scopeDigest}`, parser: { id: "pi-daddy-work-projection", version: "1" },
+        retention: "exact", bytes: Buffer.from(JSON.stringify(work)),
+    });
+    const candidates = detection.cases.map(candidate => buildWorkCapture({
+        detector: candidate.detector, target: candidate.target, classification: candidate.classification,
+        reason: candidate.reason, metrics: candidate.metrics, evidence: [...candidate.evidence, observation.reference.sha256],
+    }));
+    const candidateIds = candidates.map(candidate => retainWorkCandidate(root, candidate));
+    const batch = { version: "work-candidate-batch-v1", observationId: observation.manifestId, candidateIds,
+        issues: detection.issues, expected: detection.expected, visibility: "silent", promotion: "not-authorized" };
+    const stored = retainArchiveSource(root, { sourceId: `case-batch-${options.scopeDigest}`, parser: { id: "work-candidate-batch", version: "1" },
+        retention: "exact", bytes: Buffer.from(JSON.stringify(batch)) });
+    return { batchId: stored.manifestId, observationId: observation.manifestId, candidateIds };
+}
+/** Several observations/detector versions of the same scoped work are not independent incidents. */
+export function groupWorkIncidents(cases) {
+    if (cases.length > 4096)
+        throw new Error("work incident snapshot exceeds bound");
+    const groups = new Map();
+    for (const raw of cases) {
+        const c = validate(raw);
+        const key = JSON.stringify([c.target.snapshotDigest, c.target.obligationId, c.target.obligationDigest, c.detector.population]);
+        const values = groups.get(key) ?? [];
+        if (!values.some(v => v.id === c.id && JSON.stringify(v) === JSON.stringify(c)))
+            values.push(c);
+        groups.set(key, values);
+    }
+    return [...groups].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, values]) => ({
+        key, target: values[0].target, observations: values.sort((a, b) => { const left = JSON.stringify(a), right = JSON.stringify(b); return left < right ? -1 : left > right ? 1 : 0; }),
+        status: "unresolved", visibility: "silent",
+    }));
+}
+//# sourceMappingURL=work-case-archive.js.map

package/dist/work-case-review.d.ts

@@ -0,0 +1,45 @@
+import { type WorkCaseDecision, type WorkCaseDisposition } from "@skill-harness/core";
+export interface WorkCaseReviewRequest {
+    caseManifestId: string;
+    priorDecisionId: string | null;
+    disposition: WorkCaseDisposition;
+    note: string;
+}
+/** Operator-selected batch/author capability. Not user authentication, worker authority or scenario promotion. */
+export declare function createWorkCaseReviewer(root: string, batchId: string, author: string): {
+    history: (caseManifestId: string) => WorkCaseDecision[];
+    list(offset?: number, limit?: number): {
+        total: number;
+        offset: number;
+        items: {
+            caseManifestId: string;
+            candidate: import("@skill-harness/core").WorkCaptureCaseV2;
+            priorDecisionId: string | null;
+            disposition: string;
+        }[];
+    };
+    decide(request: WorkCaseReviewRequest): {
+        current: WorkCaseDecision;
+        replayed: boolean;
+    };
+};
+/** Explicit new signal contract; the existing v2 entry point still refuses these batches. */
+export declare function createWorkSignalReviewer(root: string, batchId: string, author: string): {
+    list(offset?: number, limit?: number): {
+        observationId: string;
+        issues: string[];
+        total: number;
+        offset: number;
+        items: {
+            caseManifestId: string;
+            candidate: import("@skill-harness/core").WorkCaptureCaseV2 | import("@skill-harness/core").WorkCaptureCaseV3;
+            priorDecisionId: string | null;
+            disposition: string;
+        }[];
+    };
+    history: (caseManifestId: string) => WorkCaseDecision[];
+    decide(request: WorkCaseReviewRequest): {
+        current: WorkCaseDecision;
+        replayed: boolean;
+    };
+};