project-tiny-context-harness 0.2.80 → 0.2.82

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

@@ -1,7 +1,9 @@
 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 { SUPERPOWERS_TASK_STATE_JSON_SCHEMA, SUPERPOWERS_TASK_STATE_SCHEMA_VERSION, asStringArray, isRecord } from "./superpowers-task-state-schema.js";
 const SOURCE_FILES = {
     product_architecture_source: {
@@ -17,6 +19,7 @@ const SOURCE_FILES = {
         authority: "acs_completion_semantics_proof_layers"
     }
 };
+const SLICE_PROGRESS_TYPES = new Set(["functional_gap_closed", "proof_gap_closed", "blocker_resolved", "invalid_evidence_removed"]);
 export async function initializeSuperpowersTask(workdir, options = {}) {
     await ensureDir(path.join(workdir, "derived"));
     await writeTextIfChanged(path.join(workdir, "task-state.schema.json"), `${stableJson(SUPERPOWERS_TASK_STATE_JSON_SCHEMA)}\n`);
@@ -52,7 +55,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: []
         },
@@ -71,7 +82,8 @@ export async function initializeSuperpowersTask(workdir, options = {}) {
             product_goal_complete: false,
             acceptance_target_status: "not_run",
             audit_task_complete: false,
-            completion_basis: []
+            completion_basis: [],
+            next_required_actions: []
         }
     };
     await saveSuperpowersState(workdir, state);
@@ -96,6 +108,10 @@ export async function applySliceDelta(workdir, deltaFile) {
     if (!progressValue || !String(progressValue.type ?? "").trim() || asStringArray(progressValue.closed_items).length === 0) {
         throw new Error("slice_delta must include progress_value with type and closed_items");
     }
+    const progressType = String(progressValue.type);
+    if (!SLICE_PROGRESS_TYPES.has(progressType)) {
+        throw new Error(`slice_delta progress_value.type must be one of ${[...SLICE_PROGRESS_TYPES].join(", ")}; got ${progressType || "(missing)"}`);
+    }
     const evidenceRecords = readEvidenceRecords(delta.evidence_records);
     for (const evidence of evidenceRecords) {
         const existingIndex = state.evidence.findIndex((item) => item.evidence_id === evidence.evidence_id);
@@ -114,12 +130,12 @@ 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: {
-            type: String(progressValue.type),
+            type: progressType,
             closed_items: asStringArray(progressValue.closed_items),
             why_it_reduces_rework: String(progressValue.why_it_reduces_rework ?? "")
         }
@@ -147,7 +163,7 @@ export function recomputeStatuses(state) {
         if (layerIds.length === 0) {
             ac.status = "not_run";
         }
-        else if (layerIds.every((layerId) => state.graph.proof_layers[layerId]?.status === "satisfied")) {
+        else if (layerIds.every((layerId) => layerSatisfiedForCompletion(state, layerId))) {
             ac.status = "complete";
         }
         else if (layerIds.some((layerId) => state.graph.proof_layers[layerId]?.status === "satisfied")) {
@@ -169,6 +185,12 @@ export function recomputeStatuses(state) {
         }
     }
 }
+function layerSatisfiedForCompletion(state, layerId) {
+    if (state.graph.proof_layers[layerId]?.status !== "satisfied") {
+        return false;
+    }
+    return !isMachineVerifiableLayer(layerId) || evaluateProofLayerAssertions(state, layerId).assertion_status === "passed";
+}
 export function emptyProgressState() {
     return {
         system_capability_progress: { status: "not_started" },
@@ -208,9 +230,10 @@ function readEvidenceRecords(value) {
             }
             : { 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),
+        proves: asStringArray(item.proves).map(normalizeProofLayerId),
+        does_not_prove: asStringArray(item.does_not_prove).map((value) => (value.includes(".") ? normalizeProofLayerId(value) : value)),
         redaction: isRecord(item.redaction)
             ? { checked: item.redaction.checked === true, contains_secret: item.redaction.contains_secret === true }
             : { checked: false, contains_secret: false },
@@ -220,6 +243,8 @@ function readEvidenceRecords(value) {
                 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)
     }));

package/dist/lib/superpowers-task-status.d.ts

@@ -0,0 +1,2 @@
+import type { SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export declare function validateCanonicalStatuses(state: SuperpowersTaskState, errors: string[]): void;

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

@@ -0,0 +1,14 @@
+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"]);
+export function validateCanonicalStatuses(state, errors) {
+    for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
+        if (!CANONICAL_PLAN_STATUSES.has(item.status)) {
+            errors.push(`plan item ${planId} has non-canonical status: ${item.status}`);
+        }
+    }
+    for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
+        if (!CANONICAL_AC_STATUSES.has(ac.status)) {
+            errors.push(`AC ${acId} has non-canonical status: ${ac.status}`);
+        }
+    }
+}

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

@@ -3,9 +3,12 @@ import { pathExists, readText } from "./fs.js";
 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 { fullPopulationRequired, validateDeliveryContract, validateScopeConflicts } from "./superpowers-task-delivery.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, proofLayerName } from "./superpowers-task-assertions.js";
 export async function validateSuperpowersState(projectRoot, args = []) {
     const info = [];
     const warnings = [];
@@ -21,12 +24,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)) {
@@ -35,7 +33,9 @@ export async function validateSuperpowersState(projectRoot, args = []) {
     }
     await validateSourceHashes(targetDir, state, errors);
     validateDeliveryContract(state, errors);
+    validateCanonicalStatuses(state, errors);
     validateGraphReferences(state, errors);
+    validatePlanCompletionConformance(state, errors);
     validateScopeConflicts(state, errors);
     validateEvidenceRecords(state, errors);
     validateProofLayers(state, errors);
@@ -160,10 +160,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") && !/\b(browser|ui_browser|screenshot)\b/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`);
             }
         }
@@ -185,6 +186,13 @@ function validateProofLayers(state, errors) {
                 errors.push(`proof layer ${layerId} references ${evidenceId} but that evidence does not prove it`);
             }
         }
+        if (layer.status === "satisfied") {
+            const evaluation = evaluateProofLayerAssertions(state, layerId);
+            errors.push(...evaluation.blocking_assertion_failures, ...evaluation.negative_evidence_findings);
+            if (isUiBrowserLayer(layerId) && evaluation.assertion_status !== "passed") {
+                errors.push(`proof layer ${layerId} ui_browser proof not machine-backed`);
+            }
+        }
     }
 }
 function validateAuditor(state, errors) {
@@ -242,6 +250,7 @@ export function completionConditionErrors(state) {
     validateDeliveryContract(state, errors);
     validateScopeConflicts(state, errors);
     validateGraphReferences(state, errors);
+    validatePlanCompletionConformance(state, errors);
     validateEvidenceRecords(state, errors);
     validateProofLayers(state, errors);
     validateAuditor(state, errors);

package/package.json

@@ -1,69 +1,69 @@
-{
-  "name": "project-tiny-context-harness",
-  "version": "0.2.80",
-  "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": ">=20"
-  },
-  "dependencies": {
-    "@google/design.md": "^0.2.0",
-    "impeccable": "^2.3.2",
-    "yaml": "^2.9.0"
-  },
-  "devDependencies": {
-    "@types/node": "^24.0.0",
-    "typescript": "^5.5.0"
-  }
-}
+{
+  "name": "project-tiny-context-harness",
+  "version": "0.2.82",
+  "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"
+  }
+}