project-tiny-context-harness 0.2.81 → 0.2.83

package/dist/lib/superpowers-task-state-shape.js

@@ -0,0 +1,50 @@
+import { isRecord } from "./superpowers-task-state-schema.js";
+export 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",
+        "attempts",
+        "current_attempt_id",
+        "required_command_specs",
+        "command_runs",
+        "negative_evidence_records",
+        "slices",
+        "evidence",
+        "gates",
+        "progress",
+        "blockers",
+        "final"
+    ]) {
+        if (!(key in state)) {
+            errors.push(`task-state.json is missing section: ${key}`);
+        }
+    }
+}
+export 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.attempts) &&
+        typeof candidate.current_attempt_id === "string" &&
+        Array.isArray(candidate.required_command_specs) &&
+        Array.isArray(candidate.command_runs) &&
+        Array.isArray(candidate.negative_evidence_records) &&
+        Array.isArray(candidate.slices) &&
+        Array.isArray(candidate.evidence) &&
+        isRecord(candidate.gates) &&
+        isRecord(candidate.progress) &&
+        Array.isArray(candidate.blockers) &&
+        isRecord(candidate.final));
+}

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

@@ -1,8 +1,10 @@
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { ensureDir, pathExists, readText, writeTextIfChanged } from "./fs.js";
+import { normalizeProofLayerId } from "./superpowers-task-fields.js";
 import { appendSuperpowersEvent } from "./superpowers-task-events.js";
-import { evaluateProofLayerAssertions, isMachineVerifiableLayer, normalizeAssertionResult, normalizeNegativeEvidenceScan } from "./superpowers-task-assertions.js";
+import { evaluateProofLayerAssertions, isMachineVerifiableLayer } from "./superpowers-task-assertions.js";
+import { readEvidenceRecords } from "./superpowers-task-evidence-records.js";
 import { SUPERPOWERS_TASK_STATE_JSON_SCHEMA, SUPERPOWERS_TASK_STATE_SCHEMA_VERSION, asStringArray, isRecord } from "./superpowers-task-state-schema.js";
 const SOURCE_FILES = {
     product_architecture_source: {
@@ -54,7 +56,15 @@ export async function initializeSuperpowersTask(workdir, options = {}) {
                 full_population_required: null,
                 representative_samples_validate: [],
                 representative_samples_do_not_validate: [],
-                out_of_scope_backlog: []
+                out_of_scope_backlog: [],
+                scope_fit_decision: "",
+                selected_scope_fit_slice: "",
+                owner_boundary: "",
+                primary_capability_path: "",
+                non_completing_outcomes: [],
+                assertion_policy: "",
+                source_authority: "",
+                product_goal: ""
             },
             scope_conflicts: []
         },
@@ -64,6 +74,11 @@ export async function initializeSuperpowersTask(workdir, options = {}) {
             proof_layers: {},
             edges: []
         },
+        attempts: [],
+        current_attempt_id: "",
+        required_command_specs: [],
+        command_runs: [],
+        negative_evidence_records: [],
         slices: [],
         evidence: [],
         gates: {},
@@ -121,8 +136,8 @@ export async function applySliceDelta(workdir, deltaFile) {
         missing_layer_classes: asStringArray(delta.missing_layer_classes),
         code_changes: asStringArray(delta.code_changes),
         evidence_records: evidenceRecords.map((item) => item.evidence_id),
-        closed_layers: asStringArray(delta.closed_layers),
-        remaining_layers: asStringArray(delta.remaining_layers),
+        closed_layers: asStringArray(delta.closed_layers).map(normalizeProofLayerId),
+        remaining_layers: asStringArray(delta.remaining_layers).map(normalizeProofLayerId),
         blockers: Array.isArray(delta.blockers) ? delta.blockers : [],
         cleanup_assertions: asStringArray(delta.cleanup_assertions),
         progress_value: {
@@ -205,41 +220,6 @@ export function sha256(value) {
 export function stableJson(value) {
     return JSON.stringify(sortJson(value), null, 2);
 }
-function readEvidenceRecords(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter(isRecord).map((item) => ({
-        evidence_id: String(item.evidence_id ?? item.evidenceId ?? ""),
-        slice_id: String(item.slice_id ?? item.sliceId ?? ""),
-        type: String(item.type ?? ""),
-        freshness: isRecord(item.freshness)
-            ? {
-                created_at: String(item.freshness.created_at ?? ""),
-                valid_for: String(item.freshness.valid_for ?? ""),
-                stale_after: item.freshness.stale_after === null ? null : item.freshness.stale_after === undefined ? null : String(item.freshness.stale_after)
-            }
-            : { created_at: "", valid_for: "", stale_after: null },
-        command: item.command === undefined ? undefined : String(item.command),
-        command_exit_code: item.command_exit_code === undefined ? undefined : Number(item.command_exit_code),
-        artifact_paths: asStringArray(item.artifact_paths),
-        proves: asStringArray(item.proves),
-        does_not_prove: asStringArray(item.does_not_prove),
-        redaction: isRecord(item.redaction)
-            ? { checked: item.redaction.checked === true, contains_secret: item.redaction.contains_secret === true }
-            : { checked: false, contains_secret: false },
-        reviewability: isRecord(item.reviewability)
-            ? {
-                external_reviewer_can_reproduce: item.reviewability.external_reviewer_can_reproduce === true,
-                reproduction_steps: String(item.reviewability.reproduction_steps ?? "")
-            }
-            : { external_reviewer_can_reproduce: false, reproduction_steps: "" },
-        assertion_result: normalizeAssertionResult(item.assertion_result),
-        negative_evidence_scan: normalizeNegativeEvidenceScan(item.negative_evidence_scan),
-        sibling_substitution_used: item.sibling_substitution_used === true,
-        sibling_substitution_approval_source: item.sibling_substitution_approval_source === undefined ? undefined : String(item.sibling_substitution_approval_source)
-    }));
-}
 function sortJson(value) {
     if (Array.isArray(value)) {
         return value.map(sortJson);

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

@@ -1,5 +1,15 @@
 const CANONICAL_PLAN_STATUSES = new Set(["not_started", "in_progress", "partial", "blocked", "invalidated", "complete", "out_of_scope_NA"]);
-const CANONICAL_AC_STATUSES = new Set(["not_started", "not_run", "in_progress", "partial", "blocked", "invalidated", "complete", "out_of_scope_NA"]);
+const CANONICAL_AC_STATUSES = new Set([
+    "not_started",
+    "not_run",
+    "in_progress",
+    "partial",
+    "blocked",
+    "invalidated",
+    "under_specified",
+    "complete",
+    "out_of_scope_NA"
+]);
 export function validateCanonicalStatuses(state, errors) {
     for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
         if (!CANONICAL_PLAN_STATUSES.has(item.status)) {

package/dist/lib/superpowers-task-under-specified.d.ts

@@ -0,0 +1,7 @@
+import type { SuperpowersAcceptanceCriterion, SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface UnderSpecifiedAc {
+    ac_id: string;
+    reasons: string[];
+}
+export declare function findUnderSpecifiedAcs(state: SuperpowersTaskState): UnderSpecifiedAc[];
+export declare function underSpecifiedReasons(acId: string, ac: SuperpowersAcceptanceCriterion): string[];

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,11 +4,14 @@ 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";
-import { evaluateProofLayerAssertions, isUiBrowserLayer } from "./superpowers-task-assertions.js";
+import { evaluateProofLayerAssertions, isUiBrowserLayer, proofLayerName } from "./superpowers-task-assertions.js";
 export async function validateSuperpowersState(projectRoot, args = []) {
     const info = [];
     const warnings = [];
@@ -24,12 +27,7 @@ export async function validateSuperpowersState(projectRoot, args = []) {
         state = await loadSuperpowersState(targetDir);
     }
     catch (error) {
-        return {
-            info,
-            warnings,
-            hygiene,
-            errors: [`${repoRelative(projectRoot, statePath)} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`]
-        };
+        return { info, warnings, hygiene, errors: [`${repoRelative(projectRoot, statePath)} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`] };
     }
     validateShape(state, errors);
     if (!hasUsableShape(state)) {
@@ -44,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)));
@@ -66,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 ?? {}));
@@ -165,10 +138,11 @@ function validateEvidenceRecords(state, errors) {
             errors.push(`${label} uses sibling substitution without approval`);
         }
         for (const proofLayer of evidence.proves ?? []) {
-            if (proofLayer.endsWith(".runtime") && /\b(mock|unit|viewmodel)\b/i.test(evidence.type)) {
-                errors.push(`${label} runtime proof cannot be mock/unit/viewmodel only`);
+            const layerName = proofLayerName(proofLayer);
+            if (layerName === "worker_runtime" && /\b(mock|unit|viewmodel)\b/i.test(evidence.type)) {
+                errors.push(`${label} worker_runtime proof cannot be mock/unit/viewmodel only`);
             }
-            if (proofLayer.endsWith(".ui_browser") && !/(browser|ui_browser|screenshot|playwright)/i.test(evidence.type)) {
+            if (layerName === "ui_browser" && !/(browser|ui_browser|screenshot|playwright)/i.test(evidence.type)) {
                 errors.push(`${label} UI proof must use browser owner surface evidence`);
             }
         }

package/package.json

@@ -1,69 +1,69 @@
-{
-  "name": "project-tiny-context-harness",
-  "version": "0.2.81",
-  "description": "Minimal project memory and validation harness for AI coding agents.",
-  "license": "MIT",
-  "author": "Seven128",
-  "homepage": "https://github.com/Seven128/project-tiny-context-harness#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Seven128/project-tiny-context-harness.git",
-    "directory": "packages/ty-context"
-  },
-  "bugs": {
-    "url": "https://github.com/Seven128/project-tiny-context-harness/issues"
-  },
-  "keywords": [
-    "ai-agents",
-    "coding-agent",
-    "codex",
-    "claude-code",
-    "cursor",
-    "gemini-cli",
-    "opencode",
-    "agent-context",
-    "context-engineering",
-    "context-management",
-    "agents-md",
-    "project-memory",
-    "agent-memory",
-    "ai-coding",
-    "multi-agent",
-    "llm",
-    "developer-tools",
-    "developer-productivity",
-    "cli",
-    "ty-context",
-    "workflow"
-  ],
-  "type": "module",
-  "bin": {
-    "ty-context": "dist/cli.js"
-  },
-  "files": [
-    "README.md",
-    "dist",
-    "assets",
-    "migrations",
-    "source-mappings.yaml"
-  ],
-  "scripts": {
-    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test:built": "node --test ../../tests/ty-context/*.test.mjs",
-    "test": "npm run build && node --test ../../tests/ty-context/*.test.mjs",
-    "prepack": "npm run build"
-  },
-  "engines": {
-    "node": ">=24"
-  },
-  "dependencies": {
-    "@google/design.md": "^0.3.0",
-    "impeccable": "^3.1.0",
-    "yaml": "^2.9.0"
-  },
-  "devDependencies": {
-    "@types/node": "^26.0.0",
-    "typescript": "^5.5.0"
-  }
-}
+{
+  "name": "project-tiny-context-harness",
+  "version": "0.2.83",
+  "description": "Minimal project memory and validation harness for AI coding agents.",
+  "license": "MIT",
+  "author": "Seven128",
+  "homepage": "https://github.com/Seven128/project-tiny-context-harness#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Seven128/project-tiny-context-harness.git",
+    "directory": "packages/ty-context"
+  },
+  "bugs": {
+    "url": "https://github.com/Seven128/project-tiny-context-harness/issues"
+  },
+  "keywords": [
+    "ai-agents",
+    "coding-agent",
+    "codex",
+    "claude-code",
+    "cursor",
+    "gemini-cli",
+    "opencode",
+    "agent-context",
+    "context-engineering",
+    "context-management",
+    "agents-md",
+    "project-memory",
+    "agent-memory",
+    "ai-coding",
+    "multi-agent",
+    "llm",
+    "developer-tools",
+    "developer-productivity",
+    "cli",
+    "ty-context",
+    "workflow"
+  ],
+  "type": "module",
+  "bin": {
+    "ty-context": "dist/cli.js"
+  },
+  "files": [
+    "README.md",
+    "dist",
+    "assets",
+    "migrations",
+    "source-mappings.yaml"
+  ],
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test:built": "node --test ../../tests/ty-context/*.test.mjs",
+    "test": "npm run build && node --test ../../tests/ty-context/*.test.mjs",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@google/design.md": "^0.3.0",
+    "impeccable": "^3.1.0",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.0",
+    "typescript": "^5.5.0"
+  }
+}

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"