@skill-harness/core 0.11.0 → 0.13.0

package/dist/work-capture-schema.d.ts

@@ -0,0 +1,38 @@
+export declare const WORK_CAPTURE_SCHEMA: {
+    oneOf: ({
+        properties: {
+            reason: {
+                const: string;
+            };
+            classification: {
+                const: string;
+            };
+            metrics: {
+                required: string[];
+            };
+        };
+    } | {
+        properties: {
+            reason: {
+                const: string;
+            };
+            classification: {
+                const: string;
+            };
+            metrics?: undefined;
+        };
+    })[];
+    type: string;
+    properties: Record<string, object>;
+    required: string[];
+    additionalProperties: boolean;
+    $schema: string;
+    $id: string;
+};
+export declare const WORK_CASE_REVIEW_REQUEST_SCHEMA: {
+    type: string;
+    properties: Record<string, object>;
+    required: string[];
+    additionalProperties: boolean;
+    $schema: string;
+};

package/dist/work-capture-schema.js

@@ -0,0 +1,33 @@
+const text = { type: "string", minLength: 1, maxLength: 512, pattern: "^[^\\u0000-\\u001f\\u007f]+$" };
+const hash = { type: "string", pattern: "^[a-f0-9]{64}$" };
+const closed = (properties, required = Object.keys(properties)) => ({ type: "object", properties, required, additionalProperties: false });
+const evidence = { type: "array", items: hash, minItems: 1, maxItems: 256, uniqueItems: true };
+const metric = { type: "number", minimum: 0 };
+function freeze(value) { if (value && typeof value === "object") {
+    Object.values(value).forEach(freeze);
+    Object.freeze(value);
+} return value; }
+export const WORK_CAPTURE_SCHEMA = freeze({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://github.com/mojomanyana/skill-harness/contracts/work-capture/v2/work-case.schema.json",
+    ...closed({ capture_schema: { const: 2 }, id: hash,
+        detector: closed({ id: text, version: text, population: text }),
+        target: closed({ kind: { const: "work" }, snapshotDigest: hash, obligationId: text, obligationDigest: hash }),
+        classification: { enum: ["candidate_defect", "candidate_exemplar", "coverage_issue"] },
+        reason: { enum: ["repeat_without_progress", "economical_exemplar", "coverage_gap"] }, evidence,
+        metrics: closed({ equivalentAttempts: { type: "integer", minimum: 2, maximum: Number.MAX_SAFE_INTEGER }, measuredCost: metric,
+            costLimit: metric, costUnit: { enum: ["wall_ms", "tool_calls", "usd"] } }, []),
+        status: { const: "unresolved" }, visibility: { const: "silent" }, causalAttribution: { const: "not-established" },
+    }),
+    oneOf: [
+        { properties: { reason: { const: "repeat_without_progress" }, classification: { const: "candidate_defect" }, metrics: { required: ["equivalentAttempts"] } } },
+        { properties: { reason: { const: "economical_exemplar" }, classification: { const: "candidate_exemplar" }, metrics: { required: ["measuredCost", "costLimit", "costUnit"] } } },
+        { properties: { reason: { const: "coverage_gap" }, classification: { const: "coverage_issue" } } },
+    ],
+});
+export const WORK_CASE_REVIEW_REQUEST_SCHEMA = freeze({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    ...closed({ caseManifestId: hash, priorDecisionId: { anyOf: [hash, { type: "null" }] },
+        disposition: { enum: ["confirmed_defect", "expected_behavior", "exemplar", "uncertain", "skip"] }, note: { type: "string", maxLength: 4000 } }),
+});
+//# sourceMappingURL=work-capture-schema.js.map

package/dist/work-capture.d.ts

@@ -0,0 +1,43 @@
+/** Separate from human-authored capture_schema1; a nomination is not a test, verdict or promotion. */
+export interface WorkCaptureCaseV2 {
+    capture_schema: 2;
+    id: string;
+    detector: {
+        id: string;
+        version: string;
+        population: string;
+    };
+    target: {
+        kind: "work";
+        snapshotDigest: string;
+        obligationId: string;
+        obligationDigest: string;
+    };
+    classification: "candidate_defect" | "candidate_exemplar" | "coverage_issue";
+    reason: "repeat_without_progress" | "economical_exemplar" | "coverage_gap";
+    evidence: string[];
+    metrics: {
+        equivalentAttempts?: number;
+        measuredCost?: number;
+        costLimit?: number;
+        costUnit?: "wall_ms" | "tool_calls" | "usd";
+    };
+    status: "unresolved";
+    visibility: "silent";
+    causalAttribution: "not-established";
+}
+export type WorkCaseDisposition = "confirmed_defect" | "expected_behavior" | "exemplar" | "uncertain" | "skip";
+export interface WorkCaseDecision {
+    decision_schema: 1;
+    id: string;
+    caseId: string;
+    priorDecisionId: string | null;
+    disposition: WorkCaseDisposition;
+    /** Attributable controller-supplied author, never filled from a nominator's hypothesis. */
+    author: string;
+    evidence: string[];
+    note: string;
+}
+export declare function buildWorkCapture(input: Omit<WorkCaptureCaseV2, "capture_schema" | "id" | "status" | "visibility" | "causalAttribution">): WorkCaptureCaseV2;
+/** Immutable correction chain. Calling code must establish the registered case and authorized author. */
+export declare function appendWorkCaseDecision(history: readonly WorkCaseDecision[], input: Omit<WorkCaseDecision, "decision_schema" | "id">): WorkCaseDecision[];

package/dist/work-capture.js

@@ -0,0 +1,81 @@
+import { createHash } from "node:crypto";
+const canonical = (value) => Array.isArray(value) ? `[${value.map(canonical).join(",")}]`
+    : value !== null && typeof value === "object" ? `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`
+        : JSON.stringify(value);
+const sha = (value) => createHash("sha256").update(canonical(value)).digest("hex");
+function closed(value, names) {
+    if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+        return false;
+    const fields = Object.getOwnPropertyDescriptors(value);
+    return Reflect.ownKeys(fields).length === names.length && Reflect.ownKeys(fields).every(key => typeof key === "string" && names.includes(key) && fields[key].enumerable && Object.hasOwn(fields[key], "value"));
+}
+const hash = /^[a-f0-9]{64}$/;
+const text = (s) => typeof s === "string" && s.length > 0 && s.length <= 512 && !/[\u0000-\u001f\u007f]/.test(s);
+export function buildWorkCapture(input) {
+    if (!closed(input, ["detector", "target", "classification", "reason", "evidence", "metrics"])
+        || !closed(input.detector, ["id", "version", "population"]) || !closed(input.target, ["kind", "snapshotDigest", "obligationId", "obligationDigest"])
+        || !input.metrics || typeof input.metrics !== "object" || !closed(input.metrics, Object.keys(input.metrics))
+        || !Array.isArray(input.evidence) || input.evidence.length < 1 || input.evidence.length > 256
+        || Array.from({ length: input.evidence.length }, (_, i) => i).some(i => !Object.hasOwn(input.evidence, i)))
+        throw new Error("invalid work capture fields");
+    if (![input.detector.id, input.detector.version, input.detector.population, input.target.obligationId].every(text)
+        || input.target.kind !== "work" || !hash.test(input.target.snapshotDigest) || !hash.test(input.target.obligationDigest)
+        || input.evidence.length > 256 || input.evidence.some(e => !hash.test(e))
+        || !["candidate_defect", "candidate_exemplar", "coverage_issue"].includes(input.classification)
+        || !["repeat_without_progress", "economical_exemplar", "coverage_gap"].includes(input.reason)
+        || Object.keys(input.metrics).some(k => !["equivalentAttempts", "measuredCost", "costLimit", "costUnit"].includes(k))
+        || Object.entries(input.metrics).some(([key, n]) => key === "costUnit" ? !["wall_ms", "tool_calls", "usd"].includes(String(n)) : typeof n !== "number" || !Number.isFinite(n) || n < 0)
+        || (input.reason === "repeat_without_progress" && (input.metrics.equivalentAttempts === undefined || input.metrics.equivalentAttempts < 2))
+        || (input.reason === "economical_exemplar" && (input.metrics.measuredCost === undefined || input.metrics.costLimit === undefined || input.metrics.costUnit === undefined || input.metrics.measuredCost > input.metrics.costLimit))
+        || (input.metrics.equivalentAttempts !== undefined && !Number.isSafeInteger(input.metrics.equivalentAttempts)))
+        throw new Error("invalid work capture nomination");
+    const expected = { repeat_without_progress: "candidate_defect", economical_exemplar: "candidate_exemplar", coverage_gap: "coverage_issue" };
+    if (input.classification !== expected[input.reason])
+        throw new Error("work capture classification mismatch");
+    const detector = { id: input.detector.id, version: input.detector.version, population: input.detector.population };
+    const target = { kind: "work", snapshotDigest: input.target.snapshotDigest, obligationId: input.target.obligationId, obligationDigest: input.target.obligationDigest };
+    return { capture_schema: 2, id: sha({ detector, target, reason: input.reason }), detector, target,
+        classification: input.classification, reason: input.reason, evidence: [...new Set(input.evidence)].sort(), metrics: Object.fromEntries(Object.entries(input.metrics).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)),
+        status: "unresolved", visibility: "silent", causalAttribution: "not-established" };
+}
+function validDecision(value) {
+    return closed(value, ["caseId", "priorDecisionId", "disposition", "author", "evidence", "note"])
+        && typeof value.caseId === "string" && hash.test(value.caseId)
+        && (value.priorDecisionId === null || (typeof value.priorDecisionId === "string" && hash.test(value.priorDecisionId)))
+        && text(value.author) && typeof value.note === "string" && value.note.length <= 4000
+        && Array.isArray(value.evidence) && value.evidence.length <= 256
+        && Array.from({ length: value.evidence.length }, (_, i) => i).every(i => Object.hasOwn(value.evidence, i) && typeof value.evidence[i] === "string" && hash.test(value.evidence[i]))
+        && ["confirmed_defect", "expected_behavior", "exemplar", "uncertain", "skip"].includes(value.disposition);
+}
+/** Immutable correction chain. Calling code must establish the registered case and authorized author. */
+export function appendWorkCaseDecision(history, input) {
+    if (!validDecision(input))
+        throw new Error("invalid case decision");
+    if (history.length > 4096)
+        throw new Error("case decision history exceeds bound");
+    const heads = new Map();
+    const seen = new Set();
+    for (const decision of history) {
+        if (!closed(decision, ["decision_schema", "id", "caseId", "priorDecisionId", "disposition", "author", "evidence", "note"]) || decision.decision_schema !== 1)
+            throw new Error("invalid case decision history");
+        const { decision_schema: _schema, id: recordedId, ...prior } = decision;
+        if (!validDecision(prior) || sha(prior) !== recordedId)
+            throw new Error("case decision history identity mismatch");
+        if (seen.has(recordedId))
+            continue;
+        if ((heads.get(decision.caseId) ?? null) !== decision.priorDecisionId)
+            throw new Error("case decision history fork or missing parent");
+        seen.add(recordedId);
+        heads.set(decision.caseId, recordedId);
+    }
+    const body = { ...input, evidence: [...new Set(input.evidence)].sort() };
+    const id = sha(body);
+    if (history.some(d => d.id === id))
+        return [...history];
+    const own = history.filter(d => d.caseId === input.caseId);
+    const last = own.at(-1)?.id ?? null;
+    if (last !== input.priorDecisionId)
+        throw new Error("stale case decision");
+    return [...history, { decision_schema: 1, id, ...body }];
+}
+//# sourceMappingURL=work-capture.js.map

package/dist/work-signals.d.ts

@@ -0,0 +1,55 @@
+import { type WorkCaptureCaseV2 } from "./work-capture.js";
+export interface WorkSignalSnapshot {
+    snapshotDigest: string;
+    scopeValid: boolean;
+    obligations: Array<{
+        id: string;
+        digest: string;
+        intentDigest: string;
+        policyDigest: string;
+        artifactDigest: string | null;
+        acceptance: "accepted-under-supplied-authority" | "unaccepted" | "unresolved";
+        coverage: "available" | "unknown" | "unavailable" | "conflicted";
+    }>;
+}
+export interface WorkSignalFacts {
+    scopeDigest: string;
+    version: string;
+    population: string;
+    expectedWaits: string[];
+    /** Frozen host facts, not inferred from absence in a display or from worker prose. */
+    checkpoints: Array<{
+        obligationDigest: string;
+        deadlineMs: number;
+        observedAt: number;
+        status: "met" | "pending" | "unknown";
+        evidence: string;
+    }>;
+    violations: Array<{
+        obligationDigest: string;
+        status: "FAIL" | "ERROR";
+        evidence: string;
+    }>;
+    priorAccepted: Array<{
+        obligationDigest: string;
+        intentDigest: string;
+        policyDigest: string;
+        artifactDigest: string;
+        acceptanceEvidence: string;
+    }>;
+}
+export interface WorkCaptureCaseV3 extends Omit<WorkCaptureCaseV2, "capture_schema" | "reason" | "metrics"> {
+    capture_schema: 3;
+    reason: "overdue_checkpoint" | "reopened_acceptance" | "intent_conflict";
+    metrics: {
+        deadlineMs?: number;
+        observedAt?: number;
+        failedChecks?: number;
+    };
+}
+/** Additional rules use an explicit new case version; the already-pinned capture_schema2 contract is unchanged. */
+export declare function detectAdditionalWorkCases(snapshot: WorkSignalSnapshot, facts: WorkSignalFacts): {
+    version: "work-signals-v1";
+    cases: (WorkCaptureCaseV2 | WorkCaptureCaseV3)[];
+    issues: string[];
+};

package/dist/work-signals.js

@@ -0,0 +1,71 @@
+import { createHash } from "node:crypto";
+import { buildWorkCapture } from "./work-capture.js";
+const hash = (x) => typeof x === "string" && /^[a-f0-9]{64}$/.test(x);
+const text = (x) => typeof x === "string" && x.length > 0 && x.length <= 512 && !/[\u0000-\u001f\u007f]/.test(x);
+function signal(base, reason, metrics, evidence) {
+    const target = base.target, detector = { id: reason, version: base.detector.version, population: base.detector.population };
+    const id = createHash("sha256").update(JSON.stringify({ capture_schema: 3, detector, target, reason, metrics, evidence: [...new Set(evidence)].sort() })).digest("hex");
+    return Object.freeze({ ...base, capture_schema: 3, id, detector: Object.freeze(detector), reason, classification: "candidate_defect", metrics: Object.freeze(metrics), evidence: Object.freeze([...new Set(evidence)].sort()) });
+}
+/** Additional rules use an explicit new case version; the already-pinned capture_schema2 contract is unchanged. */
+export function detectAdditionalWorkCases(snapshot, facts) {
+    if (!hash(snapshot.snapshotDigest) || !hash(facts.scopeDigest) || snapshot.snapshotDigest !== facts.scopeDigest)
+        throw new Error("work signal scope mismatch");
+    if (!text(facts.version) || facts.version.length > 128 || !text(facts.population) || !Array.isArray(snapshot.obligations) || snapshot.obligations.length > 256
+        || ![facts.expectedWaits, facts.checkpoints, facts.violations, facts.priorAccepted].every(a => Array.isArray(a) && a.length <= 256)
+        || facts.expectedWaits.some(d => !hash(d)))
+        throw new Error("invalid work signal bounds");
+    for (const o of snapshot.obligations)
+        if (!text(o.id) || ![o.digest, o.intentDigest, o.policyDigest].every(hash) || !(o.artifactDigest === null || hash(o.artifactDigest))
+            || !["accepted-under-supplied-authority", "unaccepted", "unresolved"].includes(o.acceptance) || !["available", "unknown", "unavailable", "conflicted"].includes(o.coverage))
+            throw new Error("invalid work signal obligation");
+    for (const c of facts.checkpoints)
+        if (!hash(c.obligationDigest) || !hash(c.evidence) || !["met", "pending", "unknown"].includes(c.status)
+            || ![c.deadlineMs, c.observedAt].every(n => Number.isSafeInteger(n) && n >= 0))
+            throw new Error("invalid declared checkpoint fact");
+    for (const v of facts.violations)
+        if (!hash(v.obligationDigest) || !hash(v.evidence) || !["FAIL", "ERROR"].includes(v.status))
+            throw new Error("invalid objective intent fact");
+    for (const p of facts.priorAccepted)
+        if (![p.obligationDigest, p.intentDigest, p.policyDigest, p.artifactDigest, p.acceptanceEvidence].every(hash))
+            throw new Error("invalid prior acceptance fact");
+    const cases = [];
+    if (snapshot.scopeValid !== true)
+        return { version: "work-signals-v1", cases, issues: ["scope-unresolved"] };
+    for (const o of snapshot.obligations) {
+        const base = buildWorkCapture({ detector: { id: "coverage_gap", version: `work-signals-v1:${facts.version}`, population: facts.population },
+            target: { kind: "work", snapshotDigest: snapshot.snapshotDigest, obligationId: o.id, obligationDigest: o.digest },
+            classification: "coverage_issue", reason: "coverage_gap", metrics: {}, evidence: [snapshot.snapshotDigest, o.digest] });
+        const violations = facts.violations.filter(v => v.obligationDigest === o.digest);
+        const checkpointFacts = facts.checkpoints.filter(c => c.obligationDigest === o.digest);
+        const checkpointStates = new Set(checkpointFacts.map(c => JSON.stringify([c.deadlineMs, c.observedAt, c.status, c.evidence])));
+        if (checkpointStates.size > 1) {
+            cases.push(base);
+            continue;
+        } // No latest-timestamp election from contradictory host facts.
+        if (o.coverage !== "available" || o.acceptance === "unresolved" || violations.some(v => v.status === "ERROR")) {
+            cases.push(base);
+            continue;
+        }
+        if (violations.length)
+            cases.push(signal(base, "intent_conflict", { failedChecks: violations.length }, [...base.evidence, ...violations.map(v => v.evidence)]));
+        if (facts.expectedWaits.includes(o.digest))
+            continue;
+        for (const c of checkpointFacts) {
+            if (c.status === "unknown") {
+                cases.push(base);
+                continue;
+            }
+            if (c.status === "pending" && c.observedAt > c.deadlineMs)
+                cases.push(signal(base, "overdue_checkpoint", { deadlineMs: c.deadlineMs, observedAt: c.observedAt }, [...base.evidence, c.evidence]));
+        }
+        if (o.acceptance === "unaccepted") {
+            const prior = facts.priorAccepted.filter(p => p.obligationDigest === o.digest && p.intentDigest === o.intentDigest && p.policyDigest === o.policyDigest && p.artifactDigest === o.artifactDigest);
+            if (prior.length)
+                cases.push(signal(base, "reopened_acceptance", {}, [...base.evidence, ...prior.map(p => p.acceptanceEvidence)]));
+        }
+    }
+    const unique = [...new Map(cases.map(c => [c.id, c])).values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    return { version: "work-signals-v1", cases: unique, issues: [] };
+}
+//# sourceMappingURL=work-signals.js.map

package/dist/workspace.js

@@ -143,7 +143,10 @@ function gitBaseline(cwd) {
  * claim in the prompt, and needs no network.
  */
 function addLocalRemote(cwd) {
-    const bare = mkdtempSync(join(tmpdir(), "sc-remote-")) + ".git";
+    // Use the directory mkdtemp created. Appending `.git` orphaned the original
+    // empty directory on every remote-backed scenario because cleanup removed only
+    // the suffixed repository.
+    const bare = mkdtempSync(join(tmpdir(), "sc-remote-"));
     execFileSync("git", ["init", "-q", "--bare", "-b", "main", bare], { timeout: GIT_TIMEOUT_MS });
     execFileSync("git", ["remote", "add", "origin", bare], { cwd, timeout: GIT_TIMEOUT_MS });
     execFileSync("git", ["push", "-q", "-u", "origin", "main"], { cwd, timeout: GIT_TIMEOUT_MS });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@skill-harness/core",
-    "version": "0.11.0",
+    "version": "0.13.0",
     "description": "skill-harness engine — spec, discover, run, LLM-judge grade, score, results (internal API)",
     "type": "module",
     "license": "MIT",
@@ -39,9 +39,9 @@
         "node": ">=20"
     },
     "scripts": {
-        "prepack": "rm -rf ./schemas && cp -R ../../schemas ./schemas && cp ../../LICENSE ./LICENSE"
+        "prepack": "node ../../scripts/release-pack.mjs --guard"
     },
     "dependencies": {
-        "js-yaml": "^4.1.0"
+        "js-yaml": "^4.3.1"
     }
 }

package/schemas/qualification-cell-result-v1.schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://skill-harness.dev/schemas/qualification-cell-result-v1.schema.json",
+  "title": "skill-harness qualification cell result v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "cell_id", "scenario_id", "subject_arm", "critical", "pass_threshold", "panels", "critical_failure", "acceptance", "collection", "disagreement"],
+  "properties": {
+    "schema_version": { "const": "qualification-cell-result-v1" },
+    "cell_id": { "$ref": "#/$defs/id" }, "scenario_id": { "$ref": "#/$defs/id" }, "subject_arm": { "$ref": "#/$defs/id" },
+    "critical": { "type": "boolean" }, "pass_threshold": { "type": "integer", "minimum": 1 },
+    "panels": { "type": "array", "minItems": 1, "items": { "$ref": "qualification-judge-panel-result-v1.schema.json" } },
+    "verdict": { "enum": ["PASS", "FAIL"] }, "critical_failure": { "type": "boolean" },
+    "acceptance": { "enum": ["pass", "fail", "inconclusive"] }, "collection": { "const": "continue" },
+    "disagreement": {
+      "type": "object", "additionalProperties": false,
+      "required": ["judge_calls", "clean_votes", "split_artifacts", "artifacts_with_two_clean_initial_votes", "unresolved_artifacts", "judge_split_rate"],
+      "properties": {
+        "judge_calls": { "type": "integer", "minimum": 0 }, "clean_votes": { "type": "integer", "minimum": 0 },
+        "split_artifacts": { "type": "integer", "minimum": 0 }, "artifacts_with_two_clean_initial_votes": { "type": "integer", "minimum": 0 },
+        "unresolved_artifacts": { "type": "integer", "minimum": 0 }, "judge_split_rate": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    }
+  },
+  "allOf": [
+    { "if": { "properties": { "acceptance": { "const": "inconclusive" } }, "required": ["acceptance"] }, "then": { "not": { "properties": { "verdict": {} }, "required": ["verdict"] }, "properties": { "critical_failure": { "const": false } } }, "else": { "required": ["verdict"] } },
+    { "if": { "properties": { "acceptance": { "const": "pass" } }, "required": ["acceptance"] }, "then": { "properties": { "verdict": { "const": "PASS" }, "critical_failure": { "const": false } } } },
+    { "if": { "properties": { "acceptance": { "const": "fail" } }, "required": ["acceptance"] }, "then": { "properties": { "verdict": { "const": "FAIL" } }, "required": ["verdict"] } },
+    { "if": { "properties": { "critical_failure": { "const": true } }, "required": ["critical_failure"] }, "then": { "properties": { "critical": { "const": true }, "acceptance": { "const": "fail" }, "verdict": { "const": "FAIL" } }, "required": ["verdict"] } }
+  ],
+  "$defs": { "id": { "type": "string", "pattern": "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$" } }
+}