project-tiny-context-harness 0.2.82 → 0.2.84

package/assets/skills/composite-long-task-workflow/references/composite-long-task-workflow-protocol.md

@@ -35,9 +35,11 @@ Implementation advances through coherent slices. Each slice selects related PI /
 
 ## Evidence Protocol
 
-Evidence is canonical state, not prose. Every proof record enters `task-state.evidence[]` with evidence id, slice id, type, command or artifact paths, command exit code when applicable, `proves`, `does_not_prove`, freshness, redaction, reviewability / reproduction data and, for machine-verifiable layers, an `assertion_result`. Evidence must be fresh, reviewable and free of secrets, raw credentials, tokens, cookies and long raw payloads.
+Evidence is canonical state, not prose. Every proof record enters `task-state.evidence[]` with evidence id, slice id, type, command or artifact paths, command exit code when applicable, `proves`, `does_not_prove`, freshness, redaction, reviewability / reproduction data and, for machine-verifiable layers, an `assertion_result`. Strict final completion uses EvidenceRecordV2 records bound to the current attempt, source bundle, product source hash, technical plan hash, acceptance checklist hash, git head, worktree fingerprint, command spec/run id, command line/exit code, artifact path/SHA/mtime, target AC ids, target PI ids, target proof layers, assertion status/exit code, positive assertions, negative assertions, invalid completion signals, negative evidence scan and required test ids. Evidence must be fresh, reviewable and free of secrets, raw credentials, tokens, cookies and long raw payloads.
 
-Canonical proof layers are `code`, `api_schema`, `worker_runtime`, `data_artifact`, `integration`, `ui_browser`, `security_redaction`, `all_provider_all_runner`, `cleanup_stale_scan` and `test`; legacy aliases map `runtime -> worker_runtime`, `browser -> ui_browser`, `api -> api_schema`, `data -> data_artifact` and `security -> security_redaction`. `code` cannot complete a machine-backed AC by itself. Machine-verifiable layers are not complete from descriptions, screenshots, final cards, validator passes, matrix rows or verdict rows. They require `assertion_result.schema_version=assertion-result-v1`, `assertion_result.status=passed`, assertion exit code `0`, command exit code `0` when present, target AC/layer coverage, passed positive and negative assertions and reviewable artifacts. UI/browser layers also require owner surface, route/path, user action, browser/playwright/UI assertion evidence and a passed `negative_evidence_scan` with matching target proof layers and checked invalid completion signals.
+Canonical proof layers are `code`, `api_schema`, `worker_runtime`, `data_artifact`, `integration`, `ui_browser`, `security_redaction`, `all_provider_all_runner`, `cleanup_stale_scan` and `test`; legacy aliases map `runtime -> worker_runtime`, `browser -> ui_browser`, `api -> api_schema`, `data -> data_artifact` and `security -> security_redaction`. `code` cannot complete a machine-backed AC by itself. Machine-verifiable layers are not complete from descriptions, screenshots, final cards, validator passes, matrix rows, verdict rows, evidence-index rows, final-summary text, historical `events.ndjson` complete events, auditor prose, summary-only AC proof or unregistered temporary JSON. They require current-attempt EvidenceRecordV2 plus `assertion_result.schema_version=assertion-result-v2`, `assertion_result.status=passed`, assertion exit code `0`, command exit code `0`, target AC/PI/layer coverage, passed positive and negative assertions, no invalid completion signal and reviewable artifacts. UI/browser layers also require owner surface, route/path, user action, browser/playwright/UI assertion evidence and a passed `negative_evidence_scan` with matching target proof layers and checked invalid completion signals.
+
+The Trusted Evidence Kernel marks a machine-blocking AC `under_specified` when it lacks an assertion command, assertion artifacts, positive assertions, negative assertions, invalid completion signals, required UI/browser proof, concrete assertion result production or any non-generated final evidence path. Under-specified ACs block related PIs and force `product_goal_complete=false`. AC-010 / final-gate summary proof only summarizes fresh current EvidenceRecordV2 proof for the other ACs; it cannot bootstrap missing, failed, stale or under-specified ACs and is invalidated with `final_gate_cannot_bootstrap_from_summary_only` when it tries.
 
 Strict V2 source fields are canonical. Product Source must carry Scope Fit, owner, primary capability and assertion policy fields. PI items must carry owner boundary, primary capability path, trigger/state/observable contracts, assertion support, required assertion commands and invalid implementation shortcuts. ACs must carry assertion command, artifacts, positive/negative assertions, machine-blocking flag, invalid completion signals and assertion-result requirement. Unknown, duplicate, table or missing canonical fields block compile; the workflow must not generate, infer, rewrite or repair the Technical Realization Plan or Acceptance Checklist.
 
@@ -63,19 +65,23 @@ Superpowers remains the execution layer: prefer `superpowers:subagent-driven-dev
 
 ## Final Gate Protocol
 
-Final completion always runs in fixed order: derive all views, run `superpowers:verification-before-completion`, validate canonical state, validate plan acceptance artifacts, run auditor and stale-overclaim checks when applicable, rederive/revalidate if fixes changed state or evidence, then let `ty-context composite-long-task final-gate <workdir>` compute `product_goal_complete`.
+Final completion always runs through the Trusted Evidence Kernel, then through the completion-output resolver. Final gate, `validate-superpowers-state`, state-backed `validate-plan-acceptance` and derived completion views use the same kernel and resolver result. Superpowers verification, validators, auditor checks and generated views are useful execution checks, but they are not proof authority or completion-output authority. The AC Evidence Assertion Gate and Negative Evidence Scan Gate are enforced inside the kernel, not by trusting generated matrix or verdict text. The final gate itself runs in fixed order: load the three inputs, recompute source hashes, load task state, resolve the current attempt, load required command specs, load command-run records, load registered EvidenceRecords, discard stale evidence, scan unregistered assertion JSON, run contradiction scan, run AC-010 bootstrap prevention, run under-specified AC checks, run Harness Drift Lock, run protected baseline guard, validate scope conflicts, recompute every AC, recompute every PI, recompute `acceptance_target_status`, recompute `product_goal_complete`, resolve `completion_output_status`, regenerate `derived/**` and append an event.
+
+The final gate recomputes from current source hashes, current attempt, required command specs/runs, registered EvidenceRecordV2 records, contradiction scan, Harness Drift Lock and protected baseline state. It ignores stale passed artifacts, historical complete events, stale derived complete views, matrix/verdict/evidence-index/final-summary rows, validator passes, final cards, auditor prose, AC summary-only proof, unregistered temporary JSON and hand-written status files as proof. The completion-output resolver ignores those same surfaces as authority and emits only `accept`, `reject` or `blocked`. Newer failed commands, Playwright `.last-run.json`, `test-results/**/error-context.md`, JUnit/JSON reporter failures, negative evidence artifacts, owner DOM forbidden states, task-state false/partial values and derived/state mismatch block completion for the affected AC/layer. If historical completion conflicts with current recompute, report `Historical stale completion event detected and ignored.` and `Current recomputed product_goal_complete=false.`
+
+Harness Drift Lock: `product_task` is blocked when the current attempt changed Playwright specs, tests, assertion generators, AC010 helpers, evidence writers, final-gate, validator, derive, task-state reducer, this workflow Skill/protocol or related Makefile/package test targets. The output must include `harness_drift_detected`, `acceptance_target_status=blocked`, `product_goal_complete=false` and `本轮修改了验收工具链或测试本身，不能用被修改后的验收证明同一轮产品完成。请拆成独立 harness_task。` A `harness_task` must include adversarial fixtures with expected final-gate outcomes for stale evidence, historical complete, derived contradiction, AC010 summary-only, target mismatch, API-only-for-UI, negative evidence after pass, source hash mismatch, dirty worktree mismatch, missing assertion_result, test weakening, scope leakage, missing UI/browser owner-surface proof, missing negative semantic proof and one happy path; it never proves product completion. HFC-003 is the durable false-completion regression suite: 35 committed mini workdirs plus one runner cover the Trusted Evidence Kernel, completion-output resolver, generated-output scanner, selected CLI smoke paths and one happy path. `protected-harness-baseline.json` blocks product-task changes to protected harness surfaces and requires a baseline reason plus fixtures for harness-task changes.
 
 ## Completion State Machine
 
-`audit_task_complete` means the workflow or audit pass finished. `acceptance_target_status` is the acceptance verdict. `product_goal_complete` is computed only by final-gate and is the only implementation/execution Goal completion condition. A read-only audit goal may finish at audit completion only while saying `Audit workflow completed; acceptance target not complete.` for non-accepted targets.
+`audit_task_complete` means the workflow or audit pass finished. `acceptance_target_status` is the acceptance verdict. `product_goal_complete` is computed only by final-gate. `completion_output_status` is computed only by the final-gate completion-output resolver and is the only official generated final-answer status. Implementation/execution Goal completion requires both `product_goal_complete=true` and `completion_output_status=accept`. A read-only audit goal may finish at audit completion only while saying `Audit workflow completed; acceptance target not complete.` for non-accepted targets.
 
 ## Forbidden Shortcuts
 
-Tests alone do not prove plan conformance. Superpowers review does not prove AC acceptance. Sample evidence does not prove full population unless the AC allows it. Browser screenshots, final cards, validator passes, matrix/verdict rows and prose evidence are auxiliary only for machine-verifiable ACs unless a passed assertion report is bound to the target AC/layer. Derived files, local audit, validator output and auditor reports cannot rewrite Product / Plan / Checklist. Local audit cannot mark product completion. Agents must not handwrite `product_goal_complete`.
+Tests alone do not prove plan conformance. Superpowers review does not prove AC acceptance. Sample evidence does not prove full population unless the AC allows it. Browser screenshots, final cards, validator passes, matrix/verdict rows, evidence-index/final-summary rows, unregistered JSON and prose evidence are auxiliary only for machine-verifiable ACs unless a passed assertion report is bound to the target AC/layer. Derived files, local audit, validator output and auditor reports cannot rewrite Product / Plan / Checklist. Local audit cannot mark product completion. Agents must not handwrite `product_goal_complete`.
 
 ## Hallucination Guard
 
-The protocol must prevent false fusion: do not interpret the composite workflow as the Tiny Context Workflow Contract itself; do not register `workflow-protocol.md` in `project_context/context.toml`; do not treat it as a business fact source; do not use local audit, tests, Superpowers review, sampled evidence, screenshots, final cards, matrix/verdict rows, validator passes or final-gate failure as product completion; do not claim full alignment with unresolved Source-to-Context Coverage or Context-to-Implementation Binding gaps; and do not call a Codex implementation Goal complete before final-gate passes.
+The protocol must prevent false fusion: do not interpret the composite workflow as the Tiny Context Workflow Contract itself; do not register `workflow-protocol.md` in `project_context/context.toml`; do not treat it as a business fact source; do not use local audit, tests, Superpowers review, sampled evidence, screenshots, final cards, matrix/verdict rows, validator passes, stale generated output or final-gate failure as product completion; do not let those surfaces promote `completion_output_status` to `accept`; do not claim full alignment with unresolved Source-to-Context Coverage or Context-to-Implementation Binding gaps; and do not call a Codex implementation Goal complete before final-gate passes and resolver status is `accept`.
 
 ## Blocker Protocol
 
@@ -498,17 +504,30 @@ Completion is blocked until the source conflict is resolved. Validators inspect
 
 ## 13. Phase Twelve: Fixed Final Gate Order
 
-Before final completion, the order is fixed:
-
-```text
-1. derive all views
-2. superpowers:verification-before-completion
-3. ty-context validate-superpowers-state <workdir>
-4. ty-context validate-plan-acceptance <workdir>
-5. read-only auditor / stale-overclaim scan when applicable
-6. if auditor findings changed state/evidence, derive and validate again
-7. AC Evidence Assertion Gate and Negative Evidence Scan Gate
-8. ty-context composite-long-task final-gate <workdir>
+Before final completion, the kernel order is fixed:
+
+```text
+1. load product-architecture-source.md, technical-realization-plan.md, acceptance-checklist.md
+2. recompute source hashes
+3. load task-state.json
+4. resolve current_attempt
+5. load required command specs
+6. load command-run records
+7. load registered EvidenceRecordV2 records
+8. discard stale evidence
+9. scan unregistered assertion JSON
+10. contradiction scan
+11. run AC-010 bootstrap prevention
+12. run under-specified AC checks
+13. run Harness Drift Lock
+14. run protected baseline guard
+15. recompute every AC
+16. recompute every PI
+17. recompute acceptance_target_status
+18. recompute product_goal_complete
+19. resolve completion_output_status
+20. regenerate derived/**
+21. append event
 ```
 
 Legacy/internal compatibility may exist as:
@@ -521,9 +540,10 @@ Only final-gate computes:
 
 ```text
 product_goal_complete=true
+completion_output_status=accept
 ```
 
-Implementation / execution Goals complete only after that computed state.
+Implementation / execution Goals complete only after both computed values are present.
 
 ## 14. Completion Semantics
 
@@ -538,6 +558,9 @@ acceptance_target_status
 
 product_goal_complete
 = whether implementation/execution is truly complete.
+
+completion_output_status
+= official generated final-answer status: accept, reject or blocked.
 ```
 
 Rules:
@@ -545,11 +568,13 @@ Rules:
 ```text
 1. Do not handwrite product_goal_complete.
 2. product_goal_complete is computed only by final-gate.
-3. audit_task_complete=true is not product completion.
-4. If acceptance_target_status is not complete, do not say Goal achieved.
-5. A read-only audit task may end, but must say:
+3. Do not handwrite completion_output_status.
+4. completion_output_status=accept requires product_goal_complete=true and accepted target status.
+5. audit_task_complete=true is not product completion.
+6. If completion_output_status is reject or blocked, do not say Goal achieved, completed, accepted or done.
+7. A read-only audit task may end, but must say:
    Audit workflow completed; acceptance target not complete.
-6. Implementation / execution Goal mode can call update_goal complete only when product_goal_complete=true.
+8. Implementation / execution Goal mode can call update_goal complete only when product_goal_complete=true and completion_output_status=accept.
 ```
 
 This must stay visible in Skill and Goal objective because Codex Goal mode can otherwise confuse "audit workflow ended" with "product target accepted."
@@ -621,13 +646,13 @@ Final
   -> Acceptance Evidence Gate
   -> External Reviewer / stale-overclaim scan
   -> final-gate
-  -> product_goal_complete=true before Codex Goal completion
+  -> product_goal_complete=true and completion_output_status=accept before Codex Goal completion
 ```
 
 One-sentence definition:
 
 ```text
-The expected runtime effect of the composite long-task workflow is to make a Codex agent fuse Tiny Context fact/process constraints, three upstream task authorities, Superpowers long-task execution and a task-state evidence state machine in one context; execution goes Context first, then Plan, then Superpowers slices, and completion is judged by state-backed gates for plan conformance, AC evidence and product_goal_complete so long tasks do not drift in implementation, acceptance or completion claims.
+The expected runtime effect of the composite long-task workflow is to make a Codex agent fuse Tiny Context fact/process constraints, three upstream task authorities, Superpowers long-task execution and a task-state evidence state machine in one context; execution goes Context first, then Plan, then Superpowers slices, and completion is judged by state-backed gates for plan conformance, AC evidence, product_goal_complete and completion_output_status so long tasks do not drift in implementation, acceptance or completion claims.
 ```
 
 ## 17. Forbidden Wrong Fusion / 不允许的错误融合
@@ -645,5 +670,6 @@ Do not treat sample evidence as full-population proof.
 Do not claim full implementation when Context Delta is required but Context is not updated.
 Do not claim full alignment while Source-to-Context Coverage / Context-to-Implementation Binding has unresolved gaps.
 Do not handwrite product_goal_complete.
-Do not call update_goal complete before final-gate passes.
+Do not handwrite completion_output_status.
+Do not call update_goal complete before final-gate passes and completion_output_status=accept.
 ```

package/dist/commands/composite-long-task.js

@@ -1,6 +1,8 @@
 import path from "node:path";
 import { applySliceDelta, initializeSuperpowersTask } from "../lib/superpowers-task-state.js";
 import { compileSuperpowersTask } from "../lib/superpowers-task-compile.js";
+import { startAndSaveSuperpowersAttempt } from "../lib/superpowers-task-attempt.js";
+import { recordSuperpowersEvidence, runSuperpowersAssertion } from "../lib/superpowers-task-evidence.js";
 import { deriveSuperpowersArtifacts } from "../lib/superpowers-task-derive.js";
 import { runEpochGate, runFinalGate, runSliceGate } from "../lib/superpowers-task-gates.js";
 import { nextSuperpowersSlices } from "../lib/superpowers-task-next-slices.js";
@@ -26,10 +28,37 @@ export async function runCompositeLongTaskCommand(args, options) {
         return;
     }
     if (subcommand === "compile") {
-        const state = await compileSuperpowersTask(workdir);
+        const state = await compileSuperpowersTask(workdir, { mode: attemptMode(args) });
         console.log(`compiled ${options.label} graph plan_items=${Object.keys(state.graph.plan_items).length} acs=${Object.keys(state.graph.acceptance_criteria).length}`);
         return;
     }
+    if (subcommand === "start-attempt") {
+        const attempt = await startAndSaveSuperpowersAttempt(workdir, attemptMode(args));
+        console.log(`started attempt ${attempt.task_attempt_id}`);
+        return;
+    }
+    if (subcommand === "run-assertion") {
+        const separator = args.indexOf("--");
+        const commandArgs = separator >= 0 ? args.slice(separator + 1) : [];
+        const run = await runSuperpowersAssertion(workdir, {
+            acId: optionValue(args, "--ac") ?? "",
+            proofLayer: optionValue(args, "--proof-layer") ?? "",
+            commandArgs
+        });
+        console.log(`recorded assertion command_run_id=${run.command_run_id} exit_code=${run.exit_code}`);
+        if (run.exit_code !== 0) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (subcommand === "record-evidence") {
+        const evidence = await recordSuperpowersEvidence(workdir, {
+            artifactPath: path.resolve(process.cwd(), optionValue(args, "--from") ?? ""),
+            commandRunId: optionValue(args, "--command-run-id") ?? ""
+        });
+        console.log(`registered evidence ${evidence.evidence_id}`);
+        return;
+    }
     if (subcommand === "apply-slice-delta") {
         const delta = args[2];
         if (!delta) {
@@ -63,8 +92,20 @@ export async function runCompositeLongTaskCommand(args, options) {
     if (subcommand === "final-gate") {
         const result = await runFinalGate(workdir);
         console.log(`final gate product_goal_complete=${result.product_goal_complete}`);
-        if (!result.product_goal_complete) {
-            process.exitCode = 1;
+        console.log(`acceptance_target_status=${result.acceptance_target_status}`);
+        console.log(`completion_output_status=${result.completion_output_status}`);
+        console.log(`final_answer_allowed=${result.final_answer_allowed}`);
+        console.log(`required_user_visible_status=${result.required_user_visible_status}`);
+        console.log(`exit_code=${result.exit_code}`);
+        console.log(`audit_task_complete=${result.audit_task_complete}`);
+        if (result.blocked_reasons.length > 0) {
+            console.log(`blocked_reasons=${result.blocked_reasons.join("; ")}`);
+        }
+        if (result.rejection_reasons.length > 0) {
+            console.log(`rejection_reasons=${result.rejection_reasons.join("; ")}`);
+        }
+        if (!result.final_answer_allowed) {
+            process.exitCode = result.exit_code;
             for (const error of result.errors) {
                 console.error(`error: ${error}`);
             }
@@ -89,15 +130,29 @@ function help(commandName, showRenderGoal) {
     const renderGoal = showRenderGoal ? "\n  render-goal <workdir>                  Render workflow-protocol.md, execution-binding.md and goal-objective.txt" : "";
     console.log(`${commandName} commands:
   init <workdir>                         Initialize task-state.json and events.ndjson
-  compile <workdir>                      Compile sources into task graph
+  compile <workdir> [--mode product_task|harness_task]
+                                         Compile sources into task graph
+  start-attempt <workdir> [--mode product_task|harness_task]
+                                         Start a fresh current attempt
+  run-assertion <workdir> --ac <id> --proof-layer <layer> -- <command>
+                                         Run and record an assertion command
+  record-evidence <workdir> --from <artifact> --command-run-id <id>
+                                         Register current-attempt EvidenceRecordV2
   apply-slice-delta <workdir> <delta>    Apply structured slice delta, evidence and derived views
   derive <workdir>                       Generate derived/** views
   slice-gate <workdir> --slice <id>      Validate one slice has real progress
   epoch-gate <workdir> --epoch <id>      Refresh shared epoch evidence views
-  final-gate <workdir>                   Compute product_goal_complete
+  final-gate <workdir>                   Compute product_goal_complete and completion_output_status
   next-slices <workdir> --limit 5        Recommend next proof clusters${renderGoal}`);
 }
 function optionValue(args, name) {
     const index = args.indexOf(name);
     return index >= 0 ? args[index + 1] : undefined;
 }
+function attemptMode(args) {
+    const value = optionValue(args, "--mode");
+    if (value === "harness_task") {
+        return "harness_task";
+    }
+    return "product_task";
+}

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

@@ -0,0 +1,6 @@
+import type { SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface Ac010BootstrapResult {
+    invalidated_ac_ids: string[];
+    errors: string[];
+}
+export declare function evaluateAc010Bootstrap(state: SuperpowersTaskState, acStatuses: Record<string, string>): Ac010BootstrapResult;

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

@@ -0,0 +1,26 @@
+const SUMMARY_ONLY = /\b(AC[-_ ]?010|final[-_ ]?gate|summary|final[-_ ]?acceptance[-_ ]?verdict|final[-_ ]?summary|matrix|validator)\b/i;
+export function evaluateAc010Bootstrap(state, acStatuses) {
+    const invalidated = [];
+    const errors = [];
+    for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
+        if (!isSummaryAc(acId, ac)) {
+            continue;
+        }
+        if (acStatuses[acId] !== "complete" && ac.status !== "complete") {
+            continue;
+        }
+        const incomplete = Object.keys(state.graph.acceptance_criteria).filter((otherId) => otherId !== acId && acIsRequired(otherId) && acStatuses[otherId] !== "complete" && acStatuses[otherId] !== "out_of_scope_NA");
+        if (incomplete.length === 0) {
+            continue;
+        }
+        invalidated.push(acId);
+        errors.push(`${acId} final_gate_cannot_bootstrap_from_summary_only: summary AC cannot prove incomplete ACs ${incomplete.join(", ")}`);
+    }
+    return { invalidated_ac_ids: invalidated, errors };
+}
+function isSummaryAc(acId, ac) {
+    return /^AC-?0?10$/i.test(acId) || SUMMARY_ONLY.test([ac.scope ?? "", ac.assertion_command ?? "", ...(ac.final_evidence_expected ?? [])].join("\n"));
+}
+function acIsRequired(acId) {
+    return !/^AC-?0?10$/i.test(acId);
+}

package/dist/lib/superpowers-task-assertion-normalizers.js

@@ -10,12 +10,16 @@ export function normalizeAssertionResult(value) {
         runner: String(value.runner ?? ""),
         exit_code: numberValue(value.exit_code),
         target_ac_ids: stringArray(value.target_ac_ids),
+        target_pi_ids: stringArray(value.target_pi_ids),
         target_proof_layers: stringArray(value.target_proof_layers).map(normalizeProofLayerId),
         owner_surface: value.owner_surface === undefined ? undefined : String(value.owner_surface),
         route: value.route === undefined ? undefined : String(value.route),
         action: value.action === undefined ? undefined : String(value.action),
         positive_assertions: checkArray(value.positive_assertions),
         negative_assertions: checkArray(value.negative_assertions),
+        invalid_completion_signals: checkArray(value.invalid_completion_signals),
+        negative_evidence_scan: normalizeNegativeEvidenceScan(value.negative_evidence_scan),
+        required_test_ids: stringArray(value.required_test_ids),
         artifacts: stringArray(value.artifacts)
     };
 }

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

@@ -1,3 +1,4 @@
+import { evaluateCurrentAttemptEvidence } from "./superpowers-task-current-evidence.js";
 import { MACHINE_VERIFIABLE_LAYER_NAMES, normalizeProofLayerId, normalizeProofLayerName } from "./superpowers-task-fields.js";
 export { normalizeAssertionResult, normalizeNegativeEvidenceScan } from "./superpowers-task-assertion-normalizers.js";
 export const MACHINE_VERIFIABLE_PROOF_LAYERS = new Set(MACHINE_VERIFIABLE_LAYER_NAMES);
@@ -67,6 +68,13 @@ export function evaluateProofLayerAssertions(state, layerId) {
     if (!isMachineVerifiableLayer(layerId)) {
         return { assertion_status: "not_applicable", blocking_assertion_failures: [], negative_evidence_findings: [] };
     }
+    if (!state.current_attempt_id) {
+        return {
+            assertion_status: "missing",
+            blocking_assertion_failures: [`proof layer ${layerId} missing current attempt; current attempt is required for machine-backed completion`],
+            negative_evidence_findings: []
+        };
+    }
     const layer = state.graph.proof_layers[layerId];
     const evidenceById = new Map((state.evidence ?? []).map((item) => [item.evidence_id, item]));
     const evidenceRecords = (layer?.evidence_ids ?? []).map((id) => evidenceById.get(id)).filter((item) => Boolean(item));
@@ -80,6 +88,7 @@ export function evaluateProofLayerAssertions(state, layerId) {
     const blocking = [];
     const negative = [];
     for (const evidence of evidenceRecords) {
+        blocking.push(...evaluateCurrentAttemptEvidence(state, evidence, layerId));
         blocking.push(...evaluateAssertionEvidence(evidence, layerId));
         negative.push(...evaluateNegativeEvidence(evidence, layerId));
     }
@@ -115,8 +124,8 @@ export function evaluateAssertionEvidence(evidence, layerId) {
         failures.push(`${label} missing assertion result; ${layerName} proof not machine-backed`);
         return failures;
     }
-    if (assertion.schema_version !== "assertion-result-v1") {
-        failures.push(`${label} assertion_result.schema_version must be assertion-result-v1`);
+    if (assertion.schema_version !== "assertion-result-v1" && assertion.schema_version !== "assertion-result-v2") {
+        failures.push(`${label} assertion_result.schema_version must be assertion-result-v1 or assertion-result-v2`);
     }
     if (assertion.status !== "passed") {
         failures.push(`${label} assertion_result.status=${assertion.status}; expected passed`);
@@ -137,6 +146,11 @@ export function evaluateAssertionEvidence(evidence, layerId) {
     }
     failures.push(...checkAssertions(`${label} positive assertion`, assertion.positive_assertions));
     failures.push(...checkAssertions(`${label} negative assertion`, assertion.negative_assertions));
+    failures.push(...checkAssertions(`${label} invalid completion signal`, assertion.invalid_completion_signals ?? []));
+    const missingRequiredTests = (assertion.required_test_ids ?? []).filter((testId) => !testId);
+    if (missingRequiredTests.length > 0) {
+        failures.push(`${label} assertion_result.required_test_ids contains empty test ids`);
+    }
     if ((assertion.artifacts?.length ?? 0) === 0 && evidence.artifact_paths.length === 0) {
         failures.push(`${label} assertion-backed evidence must include artifacts`);
     }
@@ -182,9 +196,9 @@ function checkAssertions(prefix, checks) {
         .map((check) => `${prefix} ${check.id || "(unnamed)"} status=${check.status}; expected passed${check.forbidden_text ? ` forbidden_text=${check.forbidden_text}` : ""}`);
 }
 export function evaluateNegativeEvidence(evidence, layerId) {
-    const scan = evidence.negative_evidence_scan;
+    const scan = evidence.assertion_result?.negative_evidence_scan ?? evidence.negative_evidence_scan;
     if (!scan) {
-        return [];
+        return [`proof layer ${layerId} evidence ${evidence.evidence_id} missing negative_evidence_scan`];
     }
     const acId = proofLayerAcId(layerId);
     const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;

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

@@ -0,0 +1,4 @@
+import type { ExecutionAttempt, SuperpowersAttemptMode, SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export declare function startSuperpowersAttempt(workdir: string, state: SuperpowersTaskState, mode?: SuperpowersAttemptMode): Promise<ExecutionAttempt>;
+export declare function startAndSaveSuperpowersAttempt(workdir: string, mode?: SuperpowersAttemptMode): Promise<ExecutionAttempt>;
+export declare function computeSourceBundleHash(state: SuperpowersTaskState, specsHash?: string): string;

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

@@ -0,0 +1,102 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { appendSuperpowersEvent } from "./superpowers-task-events.js";
+import { requiredCommandSpecsHash } from "./superpowers-task-command-specs.js";
+import { loadSuperpowersState, saveSuperpowersState, sha256, stableJson } from "./superpowers-task-state.js";
+const execFileAsync = promisify(execFile);
+export async function startSuperpowersAttempt(workdir, state, mode = "product_task") {
+    const now = new Date().toISOString();
+    const specsHash = requiredCommandSpecsHash(state.required_command_specs ?? []);
+    const sourceBundleHash = computeSourceBundleHash(state, specsHash);
+    const git = await readGitIdentity(workdir);
+    const worktreeFingerprint = sha256(stableJson(git));
+    const attemptOrdinal = (state.attempts ?? []).length + 1;
+    const attempt = {
+        task_attempt_id: `ATT-${compactDate(now)}-${attemptOrdinal}-${sourceBundleHash.slice(0, 8)}`,
+        source_bundle_hash: sourceBundleHash,
+        product_source_hash: state.sources.product_architecture_source?.sha256 ?? "",
+        technical_plan_hash: state.sources.technical_realization_plan?.sha256 ?? "",
+        acceptance_checklist_hash: state.sources.acceptance_checklist?.sha256 ?? "",
+        git_head: git.git_head,
+        git_status_short: git.git_status_short,
+        tracked_diff_hash: git.tracked_diff_hash,
+        relevant_untracked_hash: git.relevant_untracked_hash,
+        untracked_relevant_hash: git.relevant_untracked_hash,
+        worktree_fingerprint: worktreeFingerprint,
+        started_at: now,
+        ended_at: null,
+        finalized_at: null,
+        required_command_specs_hash: specsHash,
+        mode,
+        changed_files: git.changed_files
+    };
+    state.attempts = [...(state.attempts ?? []).filter((item) => item.task_attempt_id !== attempt.task_attempt_id), attempt];
+    state.current_attempt_id = attempt.task_attempt_id;
+    return attempt;
+}
+export async function startAndSaveSuperpowersAttempt(workdir, mode = "product_task") {
+    const state = await loadSuperpowersState(workdir);
+    const attempt = await startSuperpowersAttempt(workdir, state, mode);
+    await saveSuperpowersState(workdir, state);
+    await appendSuperpowersEvent(workdir, "attempt_started", { task_attempt_id: attempt.task_attempt_id });
+    return attempt;
+}
+export function computeSourceBundleHash(state, specsHash = requiredCommandSpecsHash(state.required_command_specs ?? [])) {
+    return sha256(stableJson({
+        product_source_hash: state.sources.product_architecture_source?.sha256 ?? "",
+        technical_plan_hash: state.sources.technical_realization_plan?.sha256 ?? "",
+        acceptance_checklist_hash: state.sources.acceptance_checklist?.sha256 ?? "",
+        required_command_specs_hash: specsHash
+    }));
+}
+async function readGitIdentity(workdir) {
+    const head = await git(workdir, ["rev-parse", "HEAD"]);
+    if (!head.ok) {
+        return {
+            git_head: "no-git",
+            git_status_short: "no-git",
+            tracked_diff_hash: sha256("no-git-tracked-diff"),
+            relevant_untracked_hash: "ignored:no-git",
+            changed_files: []
+        };
+    }
+    const status = await git(workdir, ["status", "--short"]);
+    const diff = await git(workdir, ["diff", "--binary"]);
+    const stagedDiff = await git(workdir, ["diff", "--cached", "--binary"]);
+    const untracked = await git(workdir, ["ls-files", "--others", "--exclude-standard"]);
+    const trackedNames = await git(workdir, ["diff", "--name-only"]);
+    const stagedNames = await git(workdir, ["diff", "--cached", "--name-only"]);
+    const changedFiles = unique([
+        ...lines(trackedNames.ok ? trackedNames.stdout : ""),
+        ...lines(stagedNames.ok ? stagedNames.stdout : ""),
+        ...lines(untracked.ok ? untracked.stdout : "")
+    ]);
+    return {
+        git_head: head.stdout.trim(),
+        git_status_short: status.ok ? status.stdout.trim() : "git-status-unavailable",
+        tracked_diff_hash: sha256(`${diff.ok ? diff.stdout : "git-diff-unavailable"}\n${stagedDiff.ok ? stagedDiff.stdout : ""}`),
+        relevant_untracked_hash: untracked.ok && untracked.stdout.trim() ? sha256(untracked.stdout.trim()) : "none",
+        changed_files: changedFiles
+    };
+}
+async function git(workdir, args) {
+    try {
+        const result = await execFileAsync("git", args, { cwd: workdir, windowsHide: true, timeout: 10000 });
+        return { ok: true, stdout: result.stdout };
+    }
+    catch {
+        return { ok: false, stdout: "" };
+    }
+}
+function compactDate(value) {
+    return value.replace(/[-:.TZ]/g, "").slice(0, 14);
+}
+function lines(value) {
+    return value
+        .split(/\r?\n/)
+        .map((item) => item.trim().replace(/\\/g, "/"))
+        .filter(Boolean);
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}

package/dist/lib/superpowers-task-command-run-correlation.d.ts

@@ -0,0 +1,8 @@
+import type { CommandRunRecord, ExecutionAttempt, RequiredCommandSpec, SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface CommandRunCorrelationResult {
+    errors: string[];
+    invalidated_evidence_ids: string[];
+}
+export declare function validateRequiredCommandCorrelation(state: SuperpowersTaskState, attempt: ExecutionAttempt | undefined, expectedSpecs: RequiredCommandSpec[]): CommandRunCorrelationResult;
+export declare function validateCommandRunsForSpec(state: SuperpowersTaskState, attempt: ExecutionAttempt | undefined, spec: RequiredCommandSpec): string[];
+export declare function validateCommandRun(run: CommandRunRecord, attempt: ExecutionAttempt | undefined): string[];

package/dist/lib/superpowers-task-command-run-correlation.js

@@ -0,0 +1,103 @@
+import { isMachineVerifiableLayer } from "./superpowers-task-assertions.js";
+import { normalizeProofLayerName } from "./superpowers-task-fields.js";
+import { requiredCommandSpecsHash } from "./superpowers-task-command-specs.js";
+export function validateRequiredCommandCorrelation(state, attempt, expectedSpecs) {
+    const errors = [];
+    const invalidated = new Set();
+    const expectedByAc = new Map(expectedSpecs.map((spec) => [spec.ac_id, spec]));
+    for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
+        if (ac.machine_blocking !== true && ac.assertion_result_required !== true) {
+            continue;
+        }
+        const expected = expectedByAc.get(acId);
+        const actual = (state.required_command_specs ?? []).find((spec) => spec.ac_id === acId);
+        if (!expected || !actual) {
+            errors.push(`${acId} missing required_command_spec`);
+            continue;
+        }
+        if (actual.command_spec_id !== expected.command_spec_id) {
+            errors.push(`${acId} command_spec_id mismatch; required command specs must be recompiled from Acceptance Checklist`);
+        }
+    }
+    if (attempt) {
+        const specsHash = requiredCommandSpecsHash(state.required_command_specs ?? []);
+        if (attempt.required_command_specs_hash !== specsHash) {
+            errors.push("required_command_specs_hash mismatch for current attempt");
+        }
+    }
+    for (const spec of expectedSpecs) {
+        errors.push(...validateCommandRunsForSpec(state, attempt, spec));
+    }
+    for (const finding of findFailedCommandInvalidations(state)) {
+        invalidated.add(finding.evidence_id);
+        errors.push(`${finding.evidence_id} newer failed command invalidates older passed evidence for ${finding.ac_id}.${finding.proof_layer}: ${finding.command_run_id}`);
+    }
+    return { errors: unique(errors), invalidated_evidence_ids: [...invalidated] };
+}
+export function validateCommandRunsForSpec(state, attempt, spec) {
+    const errors = [];
+    for (const proofLayer of spec.proof_layers.filter((layer) => isMachineVerifiableLayer(`${spec.ac_id}.${layer}`))) {
+        const run = (state.command_runs ?? []).find((item) => item.task_attempt_id === state.current_attempt_id &&
+            item.command_spec_id === spec.command_spec_id &&
+            item.ac_id === spec.ac_id &&
+            normalizeProofLayerName(item.proof_layer) === normalizeProofLayerName(proofLayer));
+        if (!run) {
+            errors.push(`${spec.ac_id}.${proofLayer} missing current attempt command-run record for command_spec_id ${spec.command_spec_id}`);
+            continue;
+        }
+        errors.push(...validateCommandRun(run, attempt));
+    }
+    return errors;
+}
+export function validateCommandRun(run, attempt) {
+    const errors = [];
+    if (attempt && run.task_attempt_id !== attempt.task_attempt_id) {
+        errors.push(`${run.command_run_id} stale command run from ${run.task_attempt_id}; expected ${attempt.task_attempt_id}`);
+    }
+    if (run.exit_code !== 0) {
+        errors.push(`${run.command_run_id} command_exit_code=${run.exit_code}; expected 0`);
+    }
+    if (!run.command_line.trim()) {
+        errors.push(`${run.command_run_id} missing command_line`);
+    }
+    if (!run.started_at) {
+        errors.push(`${run.command_run_id} missing started_at`);
+    }
+    if (!run.completed_at) {
+        errors.push(`${run.command_run_id} missing completed_at`);
+    }
+    if (!run.task_attempt_id) {
+        errors.push(`${run.command_run_id} missing attempt_id`);
+    }
+    return errors;
+}
+function findFailedCommandInvalidations(state) {
+    const evidence = state.evidence ?? [];
+    const failedRuns = (state.command_runs ?? []).filter((run) => run.task_attempt_id === state.current_attempt_id && Number(run.exit_code) !== 0);
+    return failedRuns.flatMap((run) => evidence
+        .filter((item) => evidenceTargetsRunLayer(item, run) && evidencePredatesRun(item, run))
+        .map((item) => ({
+        evidence_id: item.evidence_id,
+        command_run_id: run.command_run_id,
+        ac_id: run.ac_id,
+        proof_layer: run.proof_layer
+    })));
+}
+function evidenceTargetsRunLayer(evidence, run) {
+    const layerId = `${run.ac_id}.${normalizeProofLayerName(run.proof_layer)}`;
+    const targetLayers = (evidence.target_proof_layers ?? evidence.assertion_result?.target_proof_layers ?? []).map((item) => item.includes(".") ? item : `${run.ac_id}.${normalizeProofLayerName(item)}`);
+    return (evidence.task_attempt_id === run.task_attempt_id &&
+        (evidence.target_ac_ids ?? evidence.assertion_result?.target_ac_ids ?? []).includes(run.ac_id) &&
+        (targetLayers.includes(layerId) || evidence.proves.includes(layerId)));
+}
+function evidencePredatesRun(evidence, run) {
+    const evidenceTime = Date.parse(evidence.generated_at ?? evidence.freshness?.created_at ?? evidence.artifact_mtime ?? "");
+    const runTime = Date.parse(run.started_at || run.completed_at || run.ended_at || "");
+    if (Number.isNaN(evidenceTime) || Number.isNaN(runTime)) {
+        return true;
+    }
+    return evidenceTime <= runTime;
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}

package/dist/lib/superpowers-task-command-specs.d.ts

@@ -0,0 +1,3 @@
+import type { RequiredCommandSpec, SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export declare function deriveRequiredCommandSpecs(state: SuperpowersTaskState): RequiredCommandSpec[];
+export declare function requiredCommandSpecsHash(specs: RequiredCommandSpec[]): string;