project-tiny-context-harness 0.2.82 → 0.2.83

package/dist/lib/superpowers-task-under-specified.js

@@ -0,0 +1,61 @@
+import { isMachineVerifiableLayer } from "./superpowers-task-assertions.js";
+const GENERATED_ONLY_EVIDENCE = /\b(matrix|verdict|validator|final[-_ ]?card|final[-_ ]?summary|evidence[-_ ]?index|derived\/)/i;
+const MACHINE_UI_PROOF = /\b(browser|ui_browser|e2e|smoke|trace|playwright|route|owner surface)\b/i;
+const MANUAL_ONLY_TEST = /\b(查看页面|人工确认|manual confirm|manually inspect|visual check only)\b/i;
+export function findUnderSpecifiedAcs(state) {
+    return Object.entries(state.graph?.acceptance_criteria ?? {})
+        .map(([acId, ac]) => ({ ac_id: acId, reasons: underSpecifiedReasons(acId, ac) }))
+        .filter((item) => item.reasons.length > 0);
+}
+export function underSpecifiedReasons(acId, ac) {
+    if (ac.machine_blocking !== true && ac.assertion_result_required !== true) {
+        return [];
+    }
+    const reasons = [];
+    if (!trimmed(ac.assertion_command)) {
+        reasons.push(`${acId} under_specified: assertion_command is required for machine_blocking AC`);
+    }
+    if ((ac.assertion_artifacts ?? []).length === 0) {
+        reasons.push(`${acId} under_specified: assertion_artifacts are required for machine_blocking AC`);
+    }
+    if ((ac.positive_assertions ?? []).length === 0) {
+        reasons.push(`${acId} under_specified: positive_assertions are required for machine_blocking AC`);
+    }
+    if ((ac.negative_assertions ?? []).length === 0) {
+        reasons.push(`${acId} under_specified: negative_assertions are required for machine_blocking AC`);
+    }
+    if ((ac.invalid_completion_signals ?? []).length === 0) {
+        reasons.push(`${acId} under_specified: invalid_completion_signals are required for machine_blocking AC`);
+    }
+    if (ac.assertion_result_required !== true) {
+        reasons.push(`${acId} under_specified: machine_blocking AC must require assertion_result`);
+    }
+    const requiredLayers = ac.required_proof_layers ?? [];
+    if (requiredLayers.some((layer) => isMachineVerifiableLayer(`${acId}.${layer}`)) && !trimmed(ac.assertion_command)) {
+        reasons.push(`${acId} under_specified: machine proof layers cannot produce assertion_result without assertion_command`);
+    }
+    if (requiredLayers.includes("ui_browser") && !MACHINE_UI_PROOF.test(acEvidenceText(ac))) {
+        reasons.push(`${acId} under_specified: ui_browser AC requires browser/e2e/smoke/trace-backed proof`);
+    }
+    const finalEvidence = ac.final_evidence_expected ?? [];
+    if (finalEvidence.length > 0 && finalEvidence.every((item) => GENERATED_ONLY_EVIDENCE.test(item))) {
+        reasons.push(`${acId} under_specified: final_evidence_expected only names generated summary artifacts`);
+    }
+    const testCases = ac.test_cases ?? [];
+    if (testCases.length > 0 && testCases.every((item) => MANUAL_ONLY_TEST.test(item))) {
+        reasons.push(`${acId} under_specified: test_cases are manual-only`);
+    }
+    return reasons;
+}
+function acEvidenceText(ac) {
+    return [
+        ac.assertion_command ?? "",
+        ...(ac.assertion_artifacts ?? []),
+        ...(ac.verification_method ?? []),
+        ...(ac.test_cases ?? []),
+        ...(ac.final_evidence_expected ?? [])
+    ].join("\n");
+}
+function trimmed(value) {
+    return Boolean(value && value.trim());
+}

package/dist/lib/superpowers-task-validator.js

@@ -4,7 +4,10 @@ import { findSensitiveEvidence } from "./plan-acceptance-evidence.js";
 import { primitiveText, repoRelative, resolveInputDir } from "./plan-validator-common.js";
 import { derivedMatchesState } from "./superpowers-task-derive.js";
 import { validatePlanCompletionConformance } from "./superpowers-task-conformance.js";
+import { scanSuperpowersContradictions } from "./superpowers-task-contradictions.js";
+import { evaluateTrustedEvidenceKernel } from "./superpowers-task-evidence-kernel.js";
 import { fullPopulationRequired, validateDeliveryContract, validateScopeConflicts } from "./superpowers-task-delivery.js";
+import { hasUsableShape, validateShape } from "./superpowers-task-state-shape.js";
 import { loadSuperpowersState, sha256 } from "./superpowers-task-state.js";
 import { validateCanonicalStatuses } from "./superpowers-task-status.js";
 import { isRecord } from "./superpowers-task-state-schema.js";
@@ -39,6 +42,8 @@ export async function validateSuperpowersState(projectRoot, args = []) {
     validateScopeConflicts(state, errors);
     validateEvidenceRecords(state, errors);
     validateProofLayers(state, errors);
+    errors.push(...(await evaluateTrustedEvidenceKernel(targetDir, state)).errors);
+    errors.push(...(await scanSuperpowersContradictions(targetDir, state)).errors);
     validateAuditor(state, errors);
     validateFinalCompletion(state, errors);
     errors.push(...(await derivedMatchesState(targetDir, state)));
@@ -61,33 +66,6 @@ async function validateSourceHashes(workdir, state, errors) {
         }
     }
 }
-function validateShape(state, errors) {
-    if (state.meta?.schema_version !== "superpowers-task-state-v1") {
-        errors.push("task-state.json schema_version must be superpowers-task-state-v1");
-    }
-    for (const key of ["meta", "sources", "context", "delivery", "graph", "slices", "evidence", "gates", "progress", "blockers", "final"]) {
-        if (!(key in state)) {
-            errors.push(`task-state.json is missing section: ${key}`);
-        }
-    }
-}
-function hasUsableShape(state) {
-    const candidate = state;
-    return (isRecord(candidate.meta) &&
-        isRecord(candidate.sources) &&
-        isRecord(candidate.context) &&
-        isRecord(candidate.delivery) &&
-        isRecord(candidate.graph) &&
-        isRecord(candidate.graph.plan_items) &&
-        isRecord(candidate.graph.acceptance_criteria) &&
-        isRecord(candidate.graph.proof_layers) &&
-        Array.isArray(candidate.slices) &&
-        Array.isArray(candidate.evidence) &&
-        isRecord(candidate.gates) &&
-        isRecord(candidate.progress) &&
-        Array.isArray(candidate.blockers) &&
-        isRecord(candidate.final));
-}
 function validateGraphReferences(state, errors) {
     const planIds = new Set(Object.keys(state.graph?.plan_items ?? {}));
     const acIds = new Set(Object.keys(state.graph?.acceptance_criteria ?? {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "project-tiny-context-harness",
-  "version": "0.2.82",
+  "version": "0.2.83",
   "description": "Minimal project memory and validation harness for AI coding agents.",
   "license": "MIT",
   "author": "Seven128",

package/source-mappings.yaml

@@ -17,6 +17,9 @@ source_mappings:
   - source: ".codex/ty-context-managed/make/ty-context.mk"
     target: "packages/ty-context/assets/make/ty-context.mk"
     mode: "copy-file"
+  - source: ".codex/ty-context-managed/protected-harness-baseline.json"
+    target: "packages/ty-context/assets/protected-harness-baseline.json"
+    mode: "copy-file"
   - source: ".codex/ty-context-managed/minimal_tools"
     target: "packages/ty-context/assets/tools"
     mode: "copy-tree"