project-tiny-context-harness 0.2.82 → 0.2.84

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

@@ -3,7 +3,8 @@ 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: {
@@ -40,7 +41,8 @@ export async function initializeSuperpowersTask(workdir, options = {}) {
             goal_type: options.goalType ?? "implementation",
             product_goal_complete: false,
             acceptance_target_status: "not_run",
-            audit_task_complete: false
+            audit_task_complete: false,
+            completion_output_status: "blocked"
         },
         sources: await sourceRecords(workdir),
         context: {
@@ -73,6 +75,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: {},
@@ -82,6 +89,14 @@ export async function initializeSuperpowersTask(workdir, options = {}) {
             product_goal_complete: false,
             acceptance_target_status: "not_run",
             audit_task_complete: false,
+            completion_output_status: "blocked",
+            final_answer_allowed: false,
+            required_user_visible_status: "blocked",
+            final_answer: "blocked",
+            exit_code: 2,
+            blocked_reasons: ["final_gate_not_run"],
+            rejection_reasons: [],
+            generated_output_mismatch: false,
             completion_basis: [],
             next_required_actions: []
         }
@@ -214,41 +229,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).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 },
-        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-unregistered-evidence.d.ts

@@ -0,0 +1,11 @@
+import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface IgnoredUnregisteredEvidence {
+    path: string;
+    status: string;
+    target_ac_ids: string[];
+    target_proof_layers: string[];
+}
+export declare function scanUnregisteredAssertionEvidence(workdir: string, state: SuperpowersTaskState): Promise<{
+    ignored: IgnoredUnregisteredEvidence[];
+    errors: string[];
+}>;

package/dist/lib/superpowers-task-unregistered-evidence.js

@@ -0,0 +1,72 @@
+import path from "node:path";
+import { listFiles, readText } from "./fs.js";
+import { isRecord } from "./superpowers-task-state-schema.js";
+export async function scanUnregisteredAssertionEvidence(workdir, state) {
+    const registeredPaths = new Set();
+    for (const evidence of state.evidence ?? []) {
+        for (const candidate of [evidence.artifact_path, ...(evidence.artifact_paths ?? []), ...(evidence.assertion_result?.artifacts ?? [])]) {
+            if (candidate) {
+                registeredPaths.add(slash(candidate));
+                registeredPaths.add(slash(path.join(workdir, candidate)));
+            }
+        }
+    }
+    const ignored = [];
+    for (const file of await listFiles(workdir)) {
+        if (!/\.json$/i.test(file)) {
+            continue;
+        }
+        const relative = slash(path.relative(workdir, file));
+        if (registeredPaths.has(relative) || registeredPaths.has(slash(file))) {
+            continue;
+        }
+        const parsed = await readJson(file);
+        const assertion = assertionRecord(parsed);
+        if (!assertion) {
+            continue;
+        }
+        const status = String(assertion.status ?? "");
+        if (status !== "passed") {
+            continue;
+        }
+        ignored.push({
+            path: relative,
+            status,
+            target_ac_ids: asStringArray(assertion.target_ac_ids),
+            target_proof_layers: asStringArray(assertion.target_proof_layers)
+        });
+    }
+    return {
+        ignored,
+        errors: ignored.map((item) => `ignored_unregistered_evidence: unregistered assertion JSON ${item.path} status=passed is not proof`)
+    };
+}
+async function readJson(file) {
+    try {
+        return JSON.parse(await readText(file));
+    }
+    catch {
+        return undefined;
+    }
+}
+function assertionRecord(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    if (looksLikeAssertion(value)) {
+        return value;
+    }
+    if (isRecord(value.assertion_result) && looksLikeAssertion(value.assertion_result)) {
+        return value.assertion_result;
+    }
+    return undefined;
+}
+function looksLikeAssertion(value) {
+    return /assertion-result-v\d+/i.test(String(value.schema_version ?? "")) || (typeof value.status === "string" && Array.isArray(value.target_ac_ids));
+}
+function asStringArray(value) {
+    return Array.isArray(value) ? value.map(String).filter(Boolean) : [];
+}
+function slash(value) {
+    return value.replace(/\\/g, "/");
+}

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

@@ -4,11 +4,15 @@ 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, proofLayerName } from "./superpowers-task-assertions.js";
+import { completionOutputContractFromState, completionPhraseFindingMessages, scanGeneratedCompletionOutputSurfaces } from "./superpowers-task-completion-output.js";
 export async function validateSuperpowersState(projectRoot, args = []) {
     const info = [];
     const warnings = [];
@@ -39,15 +43,54 @@ 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)));
+    await validateCompletionOutputConsistency(targetDir, state, errors);
     info.push(`checked superpowers task state ${repoRelative(projectRoot, targetDir)} plan_items=${Object.keys(state.graph?.plan_items ?? {}).length} acs=${Object.keys(state.graph?.acceptance_criteria ?? {}).length} evidence=${state.evidence?.length ?? 0}`);
     if (errors.length === 0) {
         info.push("Superpowers task state validation passed");
     }
     return { info, warnings, hygiene, errors };
 }
+async function validateCompletionOutputConsistency(workdir, state, errors) {
+    const contract = completionOutputContractFromState(state);
+    const finalRecord = state.final;
+    const gate = isRecord(state.gates?.final_gate) ? state.gates.final_gate : {};
+    const storedStatus = finalRecord.completion_output_status ?? (typeof gate.completion_output_status === "string" ? gate.completion_output_status : undefined);
+    if (storedStatus && storedStatus !== contract.completion_output_status) {
+        errors.push(`completion_output_status mismatch: expected ${contract.completion_output_status}, found ${storedStatus}`);
+    }
+    if (contract.completion_output_status === "accept" && state.final.product_goal_complete !== true) {
+        errors.push("completion_output_status=accept but product_goal_complete is not true");
+    }
+    if (finalRecord.final_answer_allowed !== undefined && finalRecord.final_answer_allowed !== contract.final_answer_allowed) {
+        errors.push(`final_answer_allowed mismatch: expected ${contract.final_answer_allowed}, found ${finalRecord.final_answer_allowed}`);
+    }
+    if (finalRecord.required_user_visible_status && finalRecord.required_user_visible_status !== contract.required_user_visible_status) {
+        errors.push(`required_user_visible_status mismatch: expected ${contract.required_user_visible_status}, found ${finalRecord.required_user_visible_status}`);
+    }
+    if (finalRecord.exit_code !== undefined && finalRecord.exit_code !== contract.exit_code) {
+        errors.push(`completion output exit_code mismatch: expected ${contract.exit_code}, found ${finalRecord.exit_code}`);
+    }
+    errors.push(...completionPhraseFindingMessages(await scanGeneratedCompletionOutputSurfaces(workdir, contract)));
+    await validateMarkdownCompletionStatus(workdir, contract.completion_output_status, errors);
+}
+async function validateMarkdownCompletionStatus(workdir, expectedStatus, errors) {
+    for (const relative of ["derived/final-summary.md", "derived/final-card.md", "derived/local-audit.md"]) {
+        const file = path.join(workdir, ...relative.split("/"));
+        if (!(await pathExists(file))) {
+            continue;
+        }
+        const text = await readText(file);
+        const match = /^completion_output_status:\s*(\S+)\s*$/im.exec(text);
+        if (match && match[1] !== expectedStatus) {
+            errors.push(`${relative} completion_output_status mismatch: expected ${expectedStatus}, found ${match[1]}`);
+        }
+    }
+}
 async function validateSourceHashes(workdir, state, errors) {
     for (const [key, source] of Object.entries(state.sources ?? {})) {
         const file = path.join(workdir, source.path);
@@ -61,33 +104,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,69 +1,69 @@
-{
-  "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"
-  }
-}
+{
+  "name": "project-tiny-context-harness",
+  "version": "0.2.84",
+  "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"