project-tiny-context-harness 0.2.85 → 0.6.1

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

@@ -1,74 +0,0 @@
-import { normalizeProofLayerId } from "./superpowers-task-fields.js";
-import { isRecord } from "./superpowers-task-state-schema.js";
-export function normalizeAssertionResult(value) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    return {
-        schema_version: String(value.schema_version ?? ""),
-        status: String(value.status ?? ""),
-        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)
-    };
-}
-export function normalizeNegativeEvidenceScan(value) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    return {
-        schema_version: String(value.schema_version ?? ""),
-        status: String(value.status ?? ""),
-        target_ac_ids: stringArray(value.target_ac_ids),
-        target_proof_layers: stringArray(value.target_proof_layers).map(normalizeProofLayerId),
-        invalid_completion_signals_checked: stringArray(value.invalid_completion_signals_checked),
-        owner_surface: value.owner_surface === undefined ? undefined : String(value.owner_surface),
-        route: value.route === undefined ? undefined : String(value.route),
-        forbidden_findings: findingArray(value.forbidden_findings),
-        required_findings: checkArray(value.required_findings),
-        artifacts: stringArray(value.artifacts)
-    };
-}
-function checkArray(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter(isRecord).map((item) => ({
-        id: String(item.id ?? ""),
-        status: String(item.status ?? ""),
-        actual: item.actual === undefined ? undefined : String(item.actual),
-        expected: item.expected === undefined ? undefined : String(item.expected),
-        forbidden_text: item.forbidden_text === undefined ? undefined : String(item.forbidden_text)
-    }));
-}
-function findingArray(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter(isRecord).map((item) => ({
-        id: String(item.id ?? ""),
-        status: String(item.status ?? ""),
-        forbidden_text: item.forbidden_text === undefined ? undefined : String(item.forbidden_text),
-        actual: item.actual === undefined ? undefined : String(item.actual)
-    }));
-}
-function stringArray(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.map((item) => String(item)).filter(Boolean);
-}
-function numberValue(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : Number.NaN;
-}

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

@@ -1,20 +0,0 @@
-import { type SuperpowersEvidenceRecord, type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export { normalizeAssertionResult, normalizeNegativeEvidenceScan } from "./superpowers-task-assertion-normalizers.js";
-export type AssertionStatus = "passed" | "failed" | "missing" | "stale" | "not_applicable";
-export interface ProofLayerAssertionEvaluation {
-    assertion_status: AssertionStatus;
-    blocking_assertion_failures: string[];
-    negative_evidence_findings: string[];
-}
-export declare const MACHINE_VERIFIABLE_PROOF_LAYERS: Set<string>;
-export declare const UI_BROWSER_ASSERTION_TYPES: Set<string>;
-export declare function proofLayerName(layerId: string): string;
-export declare function proofLayerAcId(layerId: string): string;
-export declare function isMachineVerifiableLayer(layerId: string): boolean;
-export declare function isUiBrowserLayer(layerId: string): boolean;
-export declare function evaluateAcEvidence(state: SuperpowersTaskState, acId: string): ProofLayerAssertionEvaluation;
-export declare function evaluateProofLayer(state: SuperpowersTaskState, layerId: string): ProofLayerAssertionEvaluation;
-export declare function evaluateProofLayerAssertions(state: SuperpowersTaskState, layerId: string): ProofLayerAssertionEvaluation;
-export declare function assertionFailuresForState(state: SuperpowersTaskState): string[];
-export declare function evaluateAssertionEvidence(evidence: SuperpowersEvidenceRecord, layerId: string): string[];
-export declare function evaluateNegativeEvidence(evidence: SuperpowersEvidenceRecord, layerId: string): string[];

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

@@ -1,257 +0,0 @@
-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);
-export const UI_BROWSER_ASSERTION_TYPES = new Set(["browser_assertion", "playwright_assertion", "ui_browser_assertion"]);
-const DEFAULT_UI_FORBIDDEN_FINAL_STATES = ["未验证", "不可用", "暂不可用", "页面无明显变化"];
-const GENERIC_INVALID_EVIDENCE_TYPE_PATTERNS = [
-    /\bfinal[-_ ]?(?:result[-_ ]?)?card\b/i,
-    /\b(?:plan[-_ ]?conformance[-_ ]?)?matrix\b/i,
-    /\b(?:final[-_ ]?acceptance[-_ ]?)?verdict\b/i,
-    /\bvalidator[-_ ]?pass\b/i,
-    /\bauditor[-_ ]?pass\b/i,
-    /\bsubagent[-_ ]?summary\b/i,
-    /\bagent[-_ ]?summary\b/i,
-    /\bprose[-_ ]?summary\b/i,
-    /\bfile[-_ ]?exists\b/i,
-    /\bartifact[-_ ]?exists\b/i,
-    /\btest[-_ ]?name[-_ ]?only\b/i,
-    /\bdiagnostic[-_ ]?(?:surface|page)?\b/i,
-    /\blocal[-_ ]?audit\b/i,
-    /\bcomponent[-_ ]?screenshot\b/i,
-    /\bstorybook\b/i,
-    /\bdom[-_ ]?snippet\b/i,
-    /\bsample[-_ ]?for[-_ ]?full[-_ ]?population\b/i
-];
-export function proofLayerName(layerId) {
-    const raw = layerId.includes(".") ? layerId.slice(layerId.lastIndexOf(".") + 1) : layerId;
-    return normalizeProofLayerName(raw);
-}
-export function proofLayerAcId(layerId) {
-    return layerId.includes(".") ? layerId.slice(0, layerId.lastIndexOf(".")) : "";
-}
-export function isMachineVerifiableLayer(layerId) {
-    return MACHINE_VERIFIABLE_PROOF_LAYERS.has(proofLayerName(layerId));
-}
-export function isUiBrowserLayer(layerId) {
-    return proofLayerName(layerId) === "ui_browser";
-}
-export function evaluateAcEvidence(state, acId) {
-    const ac = state.graph.acceptance_criteria[acId];
-    if (!ac) {
-        return {
-            assertion_status: "missing",
-            blocking_assertion_failures: [`AC ${acId} missing from task graph`],
-            negative_evidence_findings: []
-        };
-    }
-    const evaluations = ac.required_proof_layers.map((layer) => evaluateProofLayer(state, `${acId}.${layer}`));
-    const applicable = evaluations.filter((item) => item.assertion_status !== "not_applicable");
-    const blocking_assertion_failures = applicable.flatMap((item) => item.blocking_assertion_failures);
-    const negative_evidence_findings = applicable.flatMap((item) => item.negative_evidence_findings);
-    const statuses = applicable.map((item) => item.assertion_status);
-    const assertion_status = applicable.length === 0
-        ? "not_applicable"
-        : statuses.includes("failed")
-            ? "failed"
-            : statuses.includes("stale")
-                ? "stale"
-                : statuses.includes("missing")
-                    ? "missing"
-                    : "passed";
-    return { assertion_status, blocking_assertion_failures, negative_evidence_findings };
-}
-export function evaluateProofLayer(state, layerId) {
-    return evaluateProofLayerAssertions(state, layerId);
-}
-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));
-    if (!layer || evidenceRecords.length === 0) {
-        return {
-            assertion_status: "missing",
-            blocking_assertion_failures: [`proof layer ${layerId} missing assertion result`],
-            negative_evidence_findings: []
-        };
-    }
-    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));
-    }
-    const combined = [...blocking, ...negative];
-    if (combined.length === 0) {
-        return { assertion_status: "passed", blocking_assertion_failures: [], negative_evidence_findings: [] };
-    }
-    const text = combined.join("\n");
-    const status = /missing assertion result/i.test(text)
-        ? "missing"
-        : /\bstale\b/i.test(text)
-            ? "stale"
-            : "failed";
-    return { assertion_status: status, blocking_assertion_failures: blocking, negative_evidence_findings: negative };
-}
-export function assertionFailuresForState(state) {
-    return Object.keys(state.graph?.proof_layers ?? {}).flatMap((layerId) => {
-        const evaluation = evaluateProofLayerAssertions(state, layerId);
-        return [...evaluation.blocking_assertion_failures, ...evaluation.negative_evidence_findings];
-    });
-}
-export function evaluateAssertionEvidence(evidence, layerId) {
-    const failures = [];
-    const acId = proofLayerAcId(layerId);
-    const layerName = proofLayerName(layerId);
-    const assertion = evidence.assertion_result;
-    const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
-    const invalidEvidence = invalidEvidenceReason(evidence, layerName);
-    if (invalidEvidence) {
-        failures.push(`${label} invalid evidence forbidden shortcut ${evidence.type || "(missing)"} cannot satisfy ${layerName}: ${invalidEvidence}`);
-    }
-    if (!assertion) {
-        failures.push(`${label} missing assertion result; ${layerName} proof not machine-backed`);
-        return failures;
-    }
-    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`);
-    }
-    if (assertion.exit_code !== 0) {
-        failures.push(`${label} assertion exit_code=${assertion.exit_code}; expected 0`);
-    }
-    if (evidence.command_exit_code !== undefined && evidence.command_exit_code !== 0) {
-        failures.push(`${label} command_exit_code=${evidence.command_exit_code}; expected 0`);
-    }
-    if (!assertion.target_ac_ids.includes(acId)) {
-        failures.push(`${label} assertion target ACs ${assertion.target_ac_ids.join(", ") || "(none)"} do not include ${acId}`);
-    }
-    const assertionTargetLayers = assertion.target_proof_layers.map(normalizeProofLayerId);
-    const normalizedLayerId = normalizeProofLayerId(layerId);
-    if (!assertionTargetLayers.includes(normalizedLayerId) && !assertionTargetLayers.includes(layerName)) {
-        failures.push(`${label} assertion target_proof_layers ${assertion.target_proof_layers.join(", ") || "(none)"} do not include ${layerId} or ${layerName}`);
-    }
-    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`);
-    }
-    if (isUiBrowserLayer(layerId)) {
-        failures.push(...validateUiBrowserAssertion(evidence, assertion, layerId));
-    }
-    return failures;
-}
-function validateUiBrowserAssertion(evidence, assertion, layerId) {
-    const failures = [];
-    const label = `proof layer ${layerId} evidence ${evidence.evidence_id}`;
-    if (!UI_BROWSER_ASSERTION_TYPES.has(evidence.type)) {
-        const apiOnly = /\bapi\b/i.test(evidence.type) ? "; API-only cannot satisfy UI Path AC" : "";
-        failures.push(`${label} ui_browser evidence type ${evidence.type || "(missing)"} is not allowed${apiOnly}`);
-    }
-    if (!assertion.owner_surface) {
-        failures.push(`${label} missing owner_surface`);
-    }
-    if (!assertion.route) {
-        failures.push(`${label} missing route`);
-    }
-    if (!assertion.action) {
-        failures.push(`${label} missing action-level UI proof`);
-    }
-    const artifacts = [...(assertion.artifacts ?? []), ...evidence.artifact_paths];
-    if (!artifacts.some((artifact) => /\.(png|jpe?g|zip|json)$/i.test(artifact) || /\b(trace|screenshot|report)\b/i.test(artifact))) {
-        failures.push(`${label} ui_browser assertion must include screenshot, trace or report artifact`);
-    }
-    const negativeCoverage = assertion.negative_assertions.map((item) => `${item.id} ${item.forbidden_text ?? ""}`).join("\n");
-    for (const forbidden of DEFAULT_UI_FORBIDDEN_FINAL_STATES) {
-        if (!negativeCoverage.includes(forbidden)) {
-            failures.push(`${label} missing negative assertion coverage for forbidden final state ${forbidden}`);
-        }
-    }
-    if (!evidence.negative_evidence_scan) {
-        failures.push(`${label} missing negative_evidence_scan for ui_browser layer`);
-    }
-    return failures;
-}
-function checkAssertions(prefix, checks) {
-    return checks
-        .filter((check) => check.status !== "passed")
-        .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.assertion_result?.negative_evidence_scan ?? evidence.negative_evidence_scan;
-    if (!scan) {
-        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}`;
-    const findings = [];
-    if (scan.schema_version !== "negative-evidence-scan-v1") {
-        findings.push(`${label} negative_evidence_scan.schema_version must be negative-evidence-scan-v1`);
-    }
-    if (scan.status !== "passed") {
-        findings.push(`${label} negative evidence scan status=${scan.status}; expected passed`);
-    }
-    if (!scan.target_ac_ids.includes(acId)) {
-        findings.push(`${label} negative evidence scan target ACs ${scan.target_ac_ids.join(", ") || "(none)"} do not include ${acId}`);
-    }
-    const targetLayers = (scan.target_proof_layers ?? []).map(normalizeProofLayerId);
-    const normalizedLayerId = normalizeProofLayerId(layerId);
-    if (targetLayers.length === 0) {
-        findings.push(`${label} negative evidence scan target proof layers are missing; expected ${normalizedLayerId}`);
-    }
-    else if (!targetLayers.includes(normalizedLayerId) && !targetLayers.includes(proofLayerName(layerId))) {
-        findings.push(`${label} negative evidence scan target proof layers ${targetLayers.join(", ") || "(none)"} do not include ${normalizedLayerId}`);
-    }
-    for (const finding of scan.forbidden_findings ?? []) {
-        if (finding.status === "found") {
-            findings.push(`${label} negative evidence found forbidden text ${finding.forbidden_text ?? finding.id}: ${finding.actual ?? ""}`.trim());
-        }
-    }
-    for (const required of scan.required_findings ?? []) {
-        if (required.status !== "passed") {
-            findings.push(`${label} negative evidence required finding ${required.id} status=${required.status}; expected passed`);
-        }
-    }
-    if ((scan.artifacts ?? []).length === 0) {
-        findings.push(`${label} negative evidence scan must include artifacts`);
-    }
-    return findings;
-}
-function invalidEvidenceReason(evidence, layerName) {
-    const evidenceText = [evidence.type, evidence.command, ...evidence.artifact_paths, ...evidence.proves, ...evidence.does_not_prove].join("\n");
-    const genericShortcut = GENERIC_INVALID_EVIDENCE_TYPE_PATTERNS.find((pattern) => pattern.test(evidenceText));
-    if (genericShortcut) {
-        return `matches invalid completion evidence ${genericShortcut}`;
-    }
-    if ((layerName === "worker_runtime" || layerName === "integration" || layerName === "ui_browser") && /\b(unit|mock|viewmodel)\b/i.test(evidence.type)) {
-        return "unit, mock or viewmodel evidence is auxiliary only for runtime, worker, integration and UI layers";
-    }
-    if (layerName === "ui_browser" && /\b(api|schema)\b/i.test(evidence.type)) {
-        return "API-only evidence cannot satisfy UI Path AC";
-    }
-    if (layerName === "ui_browser" && /^screenshot$/i.test(evidence.type)) {
-        return "screenshot-only evidence cannot satisfy UI Path AC";
-    }
-    if ((layerName === "worker_runtime" || layerName === "data_artifact" || layerName === "security_redaction") && /\b(ui|browser|playwright|screenshot)\b/i.test(evidence.type)) {
-        return "UI-only evidence cannot satisfy runtime, data or security proof layers";
-    }
-    return undefined;
-}

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

@@ -1,4 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

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

package/dist/lib/superpowers-task-command-specs.js

@@ -1,52 +0,0 @@
-import { createHash } from "node:crypto";
-import { stableJson } from "./superpowers-task-state.js";
-export function deriveRequiredCommandSpecs(state) {
-    return Object.entries(state.graph.acceptance_criteria).flatMap(([acId, ac]) => {
-        const proofLayers = [...new Set((ac.required_proof_layers ?? []).filter(Boolean))];
-        if (proofLayers.length === 0) {
-            return [];
-        }
-        const spec = {
-            ac_id: acId,
-            proof_layers: proofLayers,
-            command: ac.assertion_command ?? "",
-            assertion_artifacts: ac.assertion_artifacts ?? [],
-            required_test_ids: ac.required_test_ids ?? [],
-            machine_blocking: ac.machine_blocking !== false,
-            assertion_result_required: ac.assertion_result_required !== false,
-            positive_assertions: ac.positive_assertions ?? [],
-            negative_assertions: ac.negative_assertions ?? [],
-            invalid_completion_signals: ac.invalid_completion_signals ?? [],
-            final_evidence_expected: ac.final_evidence_expected ?? []
-        };
-        return [{ command_spec_id: commandSpecId(spec), ...spec }];
-    });
-}
-export function requiredCommandSpecsHash(specs) {
-    return sha256(stableJson(specs.map((spec) => ({
-        ...spec,
-        proof_layers: [...(spec.proof_layers ?? [])].sort(),
-        assertion_artifacts: [...(spec.assertion_artifacts ?? [])].sort(),
-        required_test_ids: [...(spec.required_test_ids ?? [])].sort(),
-        positive_assertions: [...(spec.positive_assertions ?? [])].sort(),
-        negative_assertions: [...(spec.negative_assertions ?? [])].sort(),
-        invalid_completion_signals: [...(spec.invalid_completion_signals ?? [])].sort(),
-        final_evidence_expected: [...(spec.final_evidence_expected ?? [])].sort()
-    }))));
-}
-function commandSpecId(spec) {
-    return sha256([
-        spec.ac_id,
-        spec.proof_layers.join(","),
-        spec.command,
-        spec.assertion_artifacts.join(","),
-        spec.required_test_ids.join(","),
-        spec.positive_assertions.join(","),
-        spec.negative_assertions.join(","),
-        spec.invalid_completion_signals.join(","),
-        spec.final_evidence_expected.join(",")
-    ].join("\n"));
-}
-function sha256(value) {
-    return createHash("sha256").update(value).digest("hex");
-}

package/dist/lib/superpowers-task-compile-diagnostics.d.ts

@@ -1,5 +0,0 @@
-export type CompileReportCategory = "blocking_missing_source" | "blocking_missing_plan" | "blocking_missing_checklist" | "blocking_unparseable_object" | "blocking_scope_conflict" | "blocking_missing_assertion_spec" | "blocking_missing_owner_boundary" | "blocking_missing_primary_path" | "blocking_missing_observable_result" | "blocking_missing_invalid_evidence" | "warning_weak_acceptance_wording" | "hygiene_non_canonical_field_order";
-export declare function compileError(message: string, category: CompileReportCategory, file: string, line: number, field: string, whyBlocking: string, requiredFix: string): string;
-export declare function compileReportSuffix(category: CompileReportCategory, file: string, line: number, field: string, whyBlocking: string, requiredFix: string): string;
-export declare function missingCategory(label: string): CompileReportCategory;
-export declare function throwCompileErrors(errors: string[]): void;

package/dist/lib/superpowers-task-compile-diagnostics.js

@@ -1,20 +0,0 @@
-export function compileError(message, category, file, line, field, whyBlocking, requiredFix) {
-    return `${message}${compileReportSuffix(category, file, line, field, whyBlocking, requiredFix)}`;
-}
-export function compileReportSuffix(category, file, line, field, whyBlocking, requiredFix) {
-    return ` [category=${category}; file=${file}; line=${line}; invalid_or_missing_field=${field}; why_blocking=${whyBlocking}; required_fix=${requiredFix}; rerun_compile_enough=true]`;
-}
-export function missingCategory(label) {
-    if (/^PI-\d+/i.test(label)) {
-        return "blocking_missing_plan";
-    }
-    if (/^AC-\d+/i.test(label)) {
-        return "blocking_missing_checklist";
-    }
-    return "blocking_missing_source";
-}
-export function throwCompileErrors(errors) {
-    if (errors.length > 0) {
-        throw new Error(`Superpowers source compile failed:\n- ${errors.join("\n- ")}`);
-    }
-}