project-tiny-context-harness 0.2.82 → 0.2.84

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

@@ -0,0 +1,176 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { pathExists, readText } from "./fs.js";
+import { normalizeProofLayerName } from "./superpowers-task-fields.js";
+export function evaluateCurrentAttemptEvidence(state, evidence, layerId) {
+    if (!state.current_attempt_id) {
+        return [];
+    }
+    const failures = [];
+    const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
+    if (evidence.schema_version !== "evidence-record-v2") {
+        failures.push(`${label} must be EvidenceRecordV2 for current-attempt machine completion`);
+    }
+    if (evidence.task_attempt_id !== state.current_attempt_id) {
+        failures.push(`${label} stale evidence from old attempt ${evidence.task_attempt_id || "(missing)"}; expected current attempt ${state.current_attempt_id}`);
+    }
+    for (const field of [
+        "generated_at",
+        "source_bundle_hash",
+        "product_source_hash",
+        "technical_plan_hash",
+        "acceptance_checklist_hash",
+        "git_head",
+        "git_status_short",
+        "tracked_diff_hash",
+        "relevant_untracked_hash",
+        "worktree_fingerprint",
+        "command_spec_id",
+        "command_run_id",
+        "command_line",
+        "artifact_path",
+        "artifact_sha256",
+        "artifact_mtime"
+    ]) {
+        if (!evidence[field]) {
+            failures.push(`${label} EvidenceRecordV2 missing ${field}`);
+        }
+    }
+    const attempt = state.attempts?.find((item) => item.task_attempt_id === state.current_attempt_id);
+    if (attempt && evidence.source_bundle_hash && evidence.source_bundle_hash !== attempt.source_bundle_hash) {
+        failures.push(`${label} stale evidence source_bundle_hash mismatch for current attempt`);
+    }
+    if (attempt && evidence.product_source_hash && evidence.product_source_hash !== attempt.product_source_hash) {
+        failures.push(`${label} stale evidence product_source_hash mismatch for current attempt`);
+    }
+    if (attempt && evidence.technical_plan_hash && evidence.technical_plan_hash !== attempt.technical_plan_hash) {
+        failures.push(`${label} stale evidence technical_plan_hash mismatch for current attempt`);
+    }
+    if (attempt && evidence.acceptance_checklist_hash && evidence.acceptance_checklist_hash !== attempt.acceptance_checklist_hash) {
+        failures.push(`${label} stale evidence acceptance_checklist_hash mismatch for current attempt`);
+    }
+    if (attempt && evidence.git_head && evidence.git_head !== attempt.git_head) {
+        failures.push(`${label} stale evidence git_head mismatch for current attempt`);
+    }
+    if (attempt && evidence.git_status_short !== undefined && evidence.git_status_short !== attempt.git_status_short) {
+        failures.push(`${label} stale evidence git_status_short mismatch for current attempt`);
+    }
+    if (attempt && evidence.tracked_diff_hash !== undefined && evidence.tracked_diff_hash !== attempt.tracked_diff_hash) {
+        failures.push(`${label} stale evidence tracked_diff_hash mismatch for current attempt`);
+    }
+    if (attempt && evidence.relevant_untracked_hash !== undefined && evidence.relevant_untracked_hash !== attempt.relevant_untracked_hash) {
+        failures.push(`${label} stale evidence relevant_untracked_hash mismatch for current attempt`);
+    }
+    if (attempt && evidence.worktree_fingerprint && evidence.worktree_fingerprint !== attempt.worktree_fingerprint) {
+        failures.push(`${label} stale evidence worktree_fingerprint mismatch for current attempt`);
+    }
+    if (attempt && (attempt.git_status_short || attempt.relevant_untracked_hash !== "none") && evidence.covers_dirty_worktree !== true) {
+        failures.push(`${label} dirty worktree evidence must set covers_dirty_worktree=true for current attempt`);
+    }
+    if (attempt && evidence.generated_at && Date.parse(evidence.generated_at) < Date.parse(attempt.started_at)) {
+        failures.push(`${label} stale evidence generated_at predates current attempt`);
+    }
+    if (attempt && evidence.artifact_mtime && Date.parse(evidence.artifact_mtime) < Date.parse(attempt.started_at)) {
+        failures.push(`${label} stale evidence artifact_mtime predates current attempt`);
+    }
+    const commandRun = state.command_runs?.find((item) => item.command_run_id === evidence.command_run_id);
+    if (!commandRun) {
+        failures.push(`${label} missing command run ${evidence.command_run_id || "(missing)"}`);
+    }
+    else {
+        if (commandRun.task_attempt_id !== state.current_attempt_id) {
+            failures.push(`${label} command run ${commandRun.command_run_id} is from old attempt ${commandRun.task_attempt_id}`);
+        }
+        if (commandRun.exit_code !== 0) {
+            failures.push(`${label} command run ${commandRun.command_run_id} exit_code=${commandRun.exit_code}; expected 0`);
+        }
+        if (!commandRun.completed_at) {
+            failures.push(`${label} command run ${commandRun.command_run_id} missing completed_at`);
+        }
+        if (commandRun.command_spec_id !== evidence.command_spec_id) {
+            failures.push(`${label} command_spec_id mismatch between evidence and command run`);
+        }
+    }
+    const commandSpec = state.required_command_specs?.find((item) => item.command_spec_id === evidence.command_spec_id);
+    if (!commandSpec) {
+        failures.push(`${label} missing required command spec ${evidence.command_spec_id || "(missing)"}`);
+    }
+    else if (commandSpec.ac_id !== proofLayerAcId(layerId) || !commandSpec.proof_layers.map(normalizeProofLayerName).includes(proofLayerName(layerId))) {
+        failures.push(`${label} command spec does not cover ${layerId}`);
+    }
+    const ac = state.graph.acceptance_criteria?.[proofLayerAcId(layerId)];
+    const targetAcIds = evidence.target_ac_ids ?? evidence.assertion_result?.target_ac_ids ?? [];
+    if (!targetAcIds.includes(proofLayerAcId(layerId))) {
+        failures.push(`${label} target_ac_ids ${targetAcIds.join(", ") || "(none)"} do not include ${proofLayerAcId(layerId)}`);
+    }
+    const expectedPiIds = ac?.related_plan_items ?? [];
+    const targetPiIds = evidence.target_pi_ids ?? evidence.assertion_result?.target_pi_ids ?? [];
+    for (const piId of expectedPiIds) {
+        if (!targetPiIds.includes(piId)) {
+            failures.push(`${label} target_pi_ids ${targetPiIds.join(", ") || "(none)"} do not include related plan item ${piId}`);
+        }
+    }
+    const targetLayers = (evidence.target_proof_layers ?? evidence.assertion_result?.target_proof_layers ?? []).map(normalizeLayerId);
+    if (!targetLayers.includes(normalizeLayerId(layerId)) && !targetLayers.includes(proofLayerName(layerId))) {
+        failures.push(`${label} target_proof_layers ${targetLayers.join(", ") || "(none)"} do not include ${layerId}`);
+    }
+    if (evidence.assertion_result?.schema_version !== "assertion-result-v2") {
+        failures.push(`${label} assertion_result.schema_version must be assertion-result-v2 for current-attempt machine completion`);
+    }
+    return failures;
+}
+export async function evaluateCurrentAttemptArtifact(workdir, evidence, layerId) {
+    const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
+    return validateArtifact(workdir, evidence, label);
+}
+async function validateArtifact(workdir, evidence, label) {
+    const failures = [];
+    if (!evidence.artifact_path) {
+        failures.push(`${label} EvidenceRecordV2 missing artifact_path`);
+        return failures;
+    }
+    const artifact = await resolveArtifactPath(workdir, evidence.artifact_path);
+    if (!artifact) {
+        failures.push(`${label} artifact_path does not exist: ${evidence.artifact_path}`);
+        return failures;
+    }
+    if (evidence.artifact_sha256) {
+        const actual = createHash("sha256").update(await readText(artifact)).digest("hex");
+        if (actual !== evidence.artifact_sha256) {
+            failures.push(`${label} stale evidence artifact_sha256 mismatch for ${evidence.artifact_path}`);
+        }
+    }
+    return failures;
+}
+async function resolveArtifactPath(workdir, artifactPath) {
+    const candidates = path.isAbsolute(artifactPath) ? [artifactPath] : [path.join(workdir, artifactPath), path.join(projectRootFromWorkdir(workdir), artifactPath)];
+    for (const candidate of candidates) {
+        if (await pathExists(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function proofLayerName(layerId) {
+    const raw = layerId.includes(".") ? layerId.slice(layerId.lastIndexOf(".") + 1) : layerId;
+    return normalizeProofLayerName(raw);
+}
+function proofLayerAcId(layerId) {
+    return layerId.includes(".") ? layerId.slice(0, layerId.lastIndexOf(".")) : "";
+}
+function normalizeLayerId(layerId) {
+    if (!layerId.includes(".")) {
+        return normalizeProofLayerName(layerId);
+    }
+    const acId = proofLayerAcId(layerId);
+    return `${acId}.${proofLayerName(layerId)}`;
+}
+function projectRootFromWorkdir(workdir) {
+    const normalized = workdir.replace(/\\/g, "/");
+    const marker = "/tmp/ty-context/plan-acceptance/";
+    const index = normalized.lastIndexOf(marker);
+    if (index < 0) {
+        return workdir;
+    }
+    return normalized.slice(0, index);
+}

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

@@ -2,9 +2,12 @@ import path from "node:path";
 import { ensureDir, pathExists, readText, writeTextIfChanged } from "./fs.js";
 import { stableJson, loadSuperpowersState } from "./superpowers-task-state.js";
 import { evaluateProofLayerAssertions } from "./superpowers-task-assertions.js";
+import { completionOutputContractFromState } from "./superpowers-task-completion-output.js";
+import { renderFinalCard } from "./superpowers-task-final-card.js";
 export async function deriveSuperpowersArtifacts(workdir) {
     const state = await loadSuperpowersState(workdir);
     const derived = deriveObjects(state);
+    const contract = completionOutputContractFromState(state);
     const derivedDir = path.join(workdir, "derived");
     await ensureDir(derivedDir);
     const files = [];
@@ -14,11 +17,12 @@ export async function deriveSuperpowersArtifacts(workdir) {
     await writeDerived(files, path.join(derivedDir, "evidence-index.json"), stableJson(deriveEvidenceIndex(state)));
     await writeDerived(files, path.join(derivedDir, "plan-conformance-matrix.md"), matrixMarkdown(derived.matrix));
     await writeDerived(files, path.join(derivedDir, "final-acceptance-verdict.md"), verdictMarkdown(derived.verdict));
-    await writeDerived(files, path.join(derivedDir, "local-audit.md"), localAuditMarkdown(state));
+    await writeDerived(files, path.join(derivedDir, "local-audit.md"), localAuditMarkdown(state, contract));
     await writeDerived(files, path.join(derivedDir, "progress-ledger.md"), progressMarkdown(derived.progress));
     await writeDerived(files, path.join(derivedDir, "evidence-index.md"), evidenceMarkdown(state));
     await writeDerived(files, path.join(derivedDir, "context-alignment.md"), contextMarkdown(state));
-    await writeDerived(files, path.join(derivedDir, "final-summary.md"), finalSummaryMarkdown(state, derived.verdict));
+    await writeDerived(files, path.join(derivedDir, "final-summary.md"), finalSummaryMarkdown(state, derived.verdict, contract));
+    await writeDerived(files, path.join(derivedDir, "final-card.md"), renderFinalCard(contract, state));
     return { matrix: derived.matrix, verdict: derived.verdict, files };
 }
 export function deriveObjects(state) {
@@ -140,9 +144,28 @@ export function deriveObjects(state) {
             .slice(0, 5)
             .map(([layerId]) => layerId)
     };
+    const contract = completionOutputContractFromState(state);
+    const completionMetadata = {
+        completion_output_status: contract.completion_output_status,
+        final_answer_allowed: contract.final_answer_allowed,
+        required_user_visible_status: contract.required_user_visible_status,
+        product_goal_complete: contract.product_goal_complete,
+        acceptance_target_status: contract.acceptance_target_status,
+        audit_task_complete: contract.audit_task_complete
+    };
     return {
-        matrix: { overall_status: allComplete ? "complete" : "partial", items: matrixRows },
-        verdict: { overall_status: allComplete ? "complete" : "partial", acceptance_items: verdictRows },
+        matrix: {
+            diagnostic_scope: "plan_conformance_rows_only",
+            overall_status: allComplete ? "complete" : "partial",
+            ...completionMetadata,
+            items: matrixRows
+        },
+        verdict: {
+            diagnostic_scope: "acceptance_evidence_rows_only",
+            overall_status: allComplete ? "complete" : "partial",
+            ...completionMetadata,
+            acceptance_items: verdictRows
+        },
         progress
     };
 }
@@ -169,10 +192,24 @@ export function deriveEvidenceIndex(state) {
         evidence.evidence_id,
         {
             evidence_id: evidence.evidence_id,
+            schema_version: evidence.schema_version ?? "",
+            task_attempt_id: evidence.task_attempt_id ?? "",
+            source_bundle_hash: evidence.source_bundle_hash ?? "",
+            product_source_hash: evidence.product_source_hash ?? "",
+            technical_plan_hash: evidence.technical_plan_hash ?? "",
+            acceptance_checklist_hash: evidence.acceptance_checklist_hash ?? "",
             type: evidence.type,
+            command_spec_id: evidence.command_spec_id ?? "",
+            command_run_id: evidence.command_run_id ?? "",
             command: evidence.command ?? "",
             command_exit_code: evidence.command_exit_code,
+            artifact_path: evidence.artifact_path ?? "",
+            artifact_sha256: evidence.artifact_sha256 ?? "",
+            artifact_mtime: evidence.artifact_mtime ?? "",
             artifact_paths: evidence.artifact_paths,
+            target_ac_ids: evidence.target_ac_ids ?? evidence.assertion_result?.target_ac_ids ?? [],
+            target_pi_ids: evidence.target_pi_ids ?? evidence.assertion_result?.target_pi_ids ?? [],
+            target_proof_layers: evidence.target_proof_layers ?? evidence.assertion_result?.target_proof_layers ?? [],
             proves: evidence.proves,
             does_not_prove: evidence.does_not_prove,
             assertion_result: evidence.assertion_result ?? null,
@@ -275,12 +312,19 @@ missing_layer_count: ${missing}
 ${rows.map((row) => `- ${row.ac_id}: ${row.status}`).join("\n")}
 `;
 }
-function localAuditMarkdown(state) {
+function localAuditMarkdown(state, contract) {
+    const auditLine = contract.completion_output_status === "accept"
+        ? "Final-gate accepted the current attempt."
+        : "Audit workflow completed; acceptance target not complete.";
     return `# Local Audit
 
 audit_task_complete: ${state.final.audit_task_complete}
 acceptance_target_status: ${state.final.acceptance_target_status}
 product_goal_complete: ${state.final.product_goal_complete}
+completion_output_status: ${contract.completion_output_status}
+final_answer_allowed: ${contract.final_answer_allowed}
+
+${auditLine}
 `;
 }
 function progressMarkdown(progress) {
@@ -312,10 +356,27 @@ Product Context Delta: ${state.context.product_context_delta}
 Technical Context Delta: ${state.context.technical_context_delta}
 `;
 }
-function finalSummaryMarkdown(state, verdict) {
+function finalSummaryMarkdown(state, verdict, contract) {
+    const reasons = contract.completion_output_status === "blocked" ? contract.blocked_reasons : contract.rejection_reasons;
+    const reasonBlock = reasons.length > 0 ? reasons.map((reason) => `- ${reason}`).join("\n") : "- none";
+    const auditLine = contract.completion_output_status === "accept"
+        ? "Final-gate accepted the current attempt."
+        : "Audit workflow completed; acceptance target not complete.";
     return `# Final Summary
 
-overall_status: ${verdict.overall_status}
-product_goal_complete: ${state.final.product_goal_complete}
+diagnostic_overall_status: ${verdict.overall_status}
+product_goal_complete: ${contract.product_goal_complete}
+acceptance_target_status: ${contract.acceptance_target_status}
+completion_output_status: ${contract.completion_output_status}
+final_answer_allowed: ${contract.final_answer_allowed}
+required_user_visible_status: ${contract.required_user_visible_status}
+exit_code: ${contract.exit_code}
+
+Final answer: ${contract.final_answer}
+
+${auditLine}
+
+Reasons:
+${reasonBlock}
 `;
 }

package/dist/lib/superpowers-task-evidence-kernel.d.ts

@@ -0,0 +1,19 @@
+import { type IgnoredUnregisteredEvidence } from "./superpowers-task-unregistered-evidence.js";
+import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface TrustedEvidenceKernelResult {
+    product_goal_complete: boolean;
+    acceptance_target_status: "complete" | "partial" | "blocked" | "invalidated" | "under_specified";
+    errors: string[];
+    ac_statuses: Record<string, string>;
+    pi_statuses: Record<string, string>;
+    stale_evidence_ids: string[];
+    ignored_unregistered_evidence: IgnoredUnregisteredEvidence[];
+    invalidated_evidence_ids: string[];
+    kernel_order: string[];
+    ac_findings: Record<string, string[]>;
+    pi_findings: Record<string, string[]>;
+    harness_task_final_verdict?: "passed" | "failed";
+}
+export declare const TRUSTED_EVIDENCE_KERNEL_ORDER: readonly ["load_three_inputs", "recompute_source_hashes", "load_task_state", "resolve_current_attempt", "load_required_command_specs", "load_command_run_records", "load_registered_evidence_records", "discard_stale_evidence", "scan_unregistered_assertion_json", "scan_contradictions", "run_ac010_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", "regenerate_derived", "append_final_gate_event"];
+export declare function evaluateTrustedEvidenceKernel(workdir: string, providedState?: SuperpowersTaskState): Promise<TrustedEvidenceKernelResult>;
+export declare function applyTrustedEvidenceKernelResult(state: SuperpowersTaskState, result: TrustedEvidenceKernelResult): void;