project-tiny-context-harness 0.2.85 → 0.6.1

package/dist/lib/superpowers-task-completion-output.js

@@ -1,374 +0,0 @@
-import path from "node:path";
-import { pathExists, readText } from "./fs.js";
-import { asStringArray, isRecord } from "./superpowers-task-state-schema.js";
-const BLOCKING_TARGET_STATUSES = new Set(["not_run", "blocked", "under_specified", "unknown"]);
-const REJECTING_TARGET_STATUSES = new Set(["partial", "failed", "rejected", "invalidated", "not_accepted"]);
-const GENERATED_COMPLETION_SURFACES = [
-    "derived/final-summary.md",
-    "derived/final-card.md",
-    "derived/final-acceptance-verdict.json",
-    "derived/final-acceptance-verdict.md",
-    "derived/plan-conformance-matrix.json",
-    "derived/plan-conformance-matrix.md",
-    "derived/local-audit.md",
-    "goal-objective.txt",
-    "execution-binding.md",
-    "workflow-protocol.md"
-];
-const FORBIDDEN_PHRASES = [
-    { phrase: "update_goal(status=\"complete\")", pattern: /update_goal\s*\(\s*status\s*=\s*["']complete["']\s*\)/i },
-    { phrase: "goal achieved", pattern: /\bgoal achieved\b/i },
-    { phrase: "ready to merge", pattern: /\bready to merge\b/i },
-    { phrase: "implementation complete", pattern: /\bimplementation complete\b/i },
-    { phrase: "all passed", pattern: /\ball (?:acs?|acceptance criteria|checks|tests)?\s*passed\b/i },
-    { phrase: "product complete", pattern: /\bproduct complete\b/i },
-    { phrase: "completed", pattern: /\bcompleted\b/i },
-    { phrase: "complete", pattern: /\bcomplete\b/i },
-    { phrase: "accepted", pattern: /\baccepted\b/i },
-    { phrase: "accept", pattern: /\baccept\b/i },
-    { phrase: "done", pattern: /\bdone\b/i },
-    { phrase: "success", pattern: /\bsuccess(?:ful)?\b/i },
-    { phrase: "任务完成", pattern: /任务完成/ },
-    { phrase: "已完成", pattern: /已完成/ },
-    { phrase: "验收通过", pattern: /验收通过/ },
-    { phrase: "目标完成", pattern: /目标完成/ },
-    { phrase: "全部通过", pattern: /全部通过/ },
-    { phrase: "可以合并", pattern: /可以合并/ }
-];
-export function resolveCompletionOutputStatus(input) {
-    const finalGateRan = input.final_gate_ran === true;
-    const productGoalComplete = input.product_goal_complete === true;
-    const acceptanceTargetStatus = normalizeAcceptanceTargetStatus(input.acceptance_target_status);
-    const validatorErrors = [...(input.validator_errors ?? []), ...(input.acceptance_validator_errors ?? [])].filter(Boolean);
-    const blockedReasons = [...(input.blocked_reasons ?? [])];
-    const rejectionReasons = [...(input.rejection_reasons ?? [])];
-    if (!finalGateRan) {
-        blockedReasons.push("final_gate_not_run");
-    }
-    if (input.required_command_not_run === true) {
-        blockedReasons.push("required_command_not_run");
-    }
-    if (input.environment_unknown === true) {
-        blockedReasons.push("environment_unknown");
-    }
-    if (input.state_unreadable === true) {
-        blockedReasons.push("state_unreadable");
-    }
-    if (input.source_unreadable === true) {
-        blockedReasons.push("source_unreadable");
-    }
-    if (input.kernel_invalid === true) {
-        blockedReasons.push("kernel_invalid");
-    }
-    if (input.required_validator_unavailable === true) {
-        blockedReasons.push("required_validator_unavailable");
-    }
-    if (input.generated_output_mismatch === true) {
-        blockedReasons.push("generated_output_mismatch");
-    }
-    if (BLOCKING_TARGET_STATUSES.has(acceptanceTargetStatus)) {
-        blockedReasons.push(`acceptance_target_status=${acceptanceTargetStatus}`);
-    }
-    if (REJECTING_TARGET_STATUSES.has(acceptanceTargetStatus)) {
-        rejectionReasons.push(`acceptance_target_status=${acceptanceTargetStatus}`);
-    }
-    if (finalGateRan && !productGoalComplete && !BLOCKING_TARGET_STATUSES.has(acceptanceTargetStatus)) {
-        rejectionReasons.push("product_goal_complete=false");
-    }
-    if (validatorErrors.length > 0) {
-        rejectionReasons.push(...validatorErrors);
-    }
-    const accept = finalGateRan &&
-        productGoalComplete &&
-        isAcceptedStatus(acceptanceTargetStatus) &&
-        validatorErrors.length === 0 &&
-        blockedReasons.length === 0 &&
-        rejectionReasons.length === 0;
-    const completionOutputStatus = accept ? "accept" : blockedReasons.length > 0 ? "blocked" : "reject";
-    const exitCode = completionOutputStatus === "accept" ? 0 : completionOutputStatus === "reject" ? 1 : 2;
-    return {
-        product_goal_complete: productGoalComplete && accept,
-        acceptance_target_status: acceptanceTargetStatus,
-        completion_output_status: completionOutputStatus,
-        final_answer_allowed: completionOutputStatus === "accept",
-        required_user_visible_status: completionOutputStatus === "accept" ? "accepted" : completionOutputStatus === "reject" ? "rejected" : "blocked",
-        final_answer: completionOutputStatus,
-        exit_code: exitCode,
-        blocked_reasons: unique(blockedReasons),
-        rejection_reasons: unique(rejectionReasons),
-        audit_task_complete: input.audit_task_complete === true,
-        final_gate_ran: finalGateRan,
-        generated_output_mismatch: input.generated_output_mismatch === true
-    };
-}
-export function completionOutputContractFromState(state) {
-    const finalRecord = state.final;
-    const gate = isRecord(state.gates?.final_gate) ? state.gates.final_gate : {};
-    const hasStoredOutput = typeof finalRecord.completion_output_status === "string" || typeof gate.completion_output_status === "string";
-    const contract = resolveCompletionOutputStatus({
-        final_gate_ran: hasStoredOutput || isRecord(state.gates?.final_gate),
-        product_goal_complete: state.final.product_goal_complete,
-        acceptance_target_status: state.final.acceptance_target_status,
-        audit_task_complete: state.final.audit_task_complete,
-        blocked_reasons: asStringArray(finalRecord.blocked_reasons ?? gate.blocked_reasons),
-        rejection_reasons: asStringArray(finalRecord.rejection_reasons ?? gate.rejection_reasons),
-        generated_output_mismatch: finalRecord.generated_output_mismatch === true || gate.generated_output_mismatch === true
-    });
-    const triage = isRecord(finalRecord.blocker_triage)
-        ? finalRecord.blocker_triage
-        : isRecord(gate.blocker_triage)
-            ? gate.blocker_triage
-            : undefined;
-    const candidate = isRecord(finalRecord.candidate_state)
-        ? finalRecord.candidate_state
-        : isRecord(gate.candidate_state)
-            ? gate.candidate_state
-            : undefined;
-    if (triage) {
-        contract.blocker_triage = triage;
-    }
-    if (candidate) {
-        contract.candidate_state = candidate;
-    }
-    return contract;
-}
-export function applyCompletionOutputContract(state, contract) {
-    const finalRecord = state.final;
-    const metaRecord = state.meta;
-    finalRecord.product_goal_complete = contract.product_goal_complete;
-    state.meta.product_goal_complete = contract.product_goal_complete;
-    finalRecord.acceptance_target_status = contract.acceptance_target_status;
-    state.meta.acceptance_target_status = contract.acceptance_target_status;
-    finalRecord.audit_task_complete = contract.audit_task_complete;
-    state.meta.audit_task_complete = contract.audit_task_complete;
-    finalRecord.completion_output_status = contract.completion_output_status;
-    finalRecord.final_answer_allowed = contract.final_answer_allowed;
-    finalRecord.required_user_visible_status = contract.required_user_visible_status;
-    finalRecord.final_answer = contract.final_answer;
-    finalRecord.exit_code = contract.exit_code;
-    finalRecord.blocked_reasons = contract.blocked_reasons;
-    finalRecord.rejection_reasons = contract.rejection_reasons;
-    finalRecord.generated_output_mismatch = contract.generated_output_mismatch;
-    if (contract.blocker_triage) {
-        finalRecord.blocker_triage = contract.blocker_triage;
-    }
-    if (contract.candidate_state) {
-        finalRecord.candidate_state = contract.candidate_state;
-    }
-    metaRecord.completion_output_status = contract.completion_output_status;
-}
-export function scanFalseCompletionPhrases(input) {
-    return scanFalseCompletionPhrasesDetailed(input);
-}
-export function scanFalseCompletionPhrasesDetailed(input) {
-    if (input.completion_output_status === "accept") {
-        return [];
-    }
-    const surfaces = typeof input.surfaces === "string" ? [{ surface: "inline", text: input.surfaces }] : input.surfaces;
-    const findings = [];
-    for (const surface of surfaces) {
-        const lines = surface.text.split(/\r?\n/);
-        for (const [index, line] of lines.entries()) {
-            const allowed = classifyAllowedCompletionLine(surface.surface, line);
-            if (allowed) {
-                continue;
-            }
-            for (const item of FORBIDDEN_PHRASES) {
-                if (item.pattern.test(line)) {
-                    findings.push({
-                        surface: surface.surface,
-                        surface_type: classifySurfaceLine(surface.surface, line),
-                        classification: "true_false_completion_claim",
-                        phrase: item.phrase,
-                        line: index + 1,
-                        text: line.trim(),
-                        self_recoverable: isSelfRecoverableSurface(surface.surface)
-                    });
-                    break;
-                }
-            }
-        }
-    }
-    return findings;
-}
-export async function scanGeneratedCompletionOutputSurfaces(workdir, contract) {
-    return scanGeneratedCompletionOutputSurfacesDetailed(workdir, contract);
-}
-export async function scanGeneratedCompletionOutputSurfacesDetailed(workdir, contract) {
-    const surfaces = [];
-    for (const relative of GENERATED_COMPLETION_SURFACES) {
-        const file = path.join(workdir, ...relative.split("/"));
-        if (await pathExists(file)) {
-            surfaces.push({ surface: relative, text: await readText(file) });
-        }
-    }
-    return scanFalseCompletionPhrasesDetailed({ completion_output_status: contract.completion_output_status, surfaces });
-}
-export function completionPhraseFindingMessages(findings) {
-    return findings.map((finding) => {
-        const kind = finding.classification ? ` ${finding.classification}` : "";
-        return `false completion phrase${kind} in ${finding.surface}:${finding.line}: ${finding.phrase}`;
-    });
-}
-export function triageFinalGateBlockers(input) {
-    const errors = unique(input.errors);
-    const findings = input.output_findings ?? [];
-    const previous = unique(input.previous_transient_findings ?? []);
-    const details = unique([...errors, ...findings.map((finding) => `${finding.surface}:${finding.line}:${finding.phrase}`), ...previous]);
-    const recoveryAttempted = input.recovery_attempted === true;
-    const recoveryAction = input.recovery_action ?? "";
-    if (findings.length > 0) {
-        const selfRecoverable = findings.every((finding) => finding.self_recoverable === true);
-        return {
-            category: selfRecoverable ? "self_recoverable_generated_output_mismatch" : "generated_output_mismatch",
-            self_recoverable: selfRecoverable,
-            recovery_attempted: recoveryAttempted,
-            recovery_action: recoveryAction,
-            next_action: selfRecoverable
-                ? "regenerate derived generated-output surfaces and rerun final-gate once"
-                : "remove or regenerate the user-visible false completion wording before final-gate can accept",
-            details,
-            blocker_count: findings.length
-        };
-    }
-    const text = errors.join("\n");
-    if (/harness_drift|protected_baseline|product task modified|harness task missing/i.test(text)) {
-        return blocker("harness_drift_blocked", false, recoveryAttempted, recoveryAction, "split harness changes into a harness_task with adversarial fixtures before proving product completion", details);
-    }
-    if (/source file is missing|source_unreadable|scope_conflict_requires_decision|three[- ]input|Product \/ Plan \/ Checklist|Context Delta coverage is unresolved/i.test(text)) {
-        return blocker("contract_blocked", false, recoveryAttempted, recoveryAction, "clarify or restore the source contract before rerunning final-gate", details);
-    }
-    if (/required command not_run|command not_run|browser unavailable|playwright unavailable|dependency unavailable|environment_unknown|required_validator_unavailable|permission|MFA/i.test(text)) {
-        return blocker("environment_blocked", false, recoveryAttempted, recoveryAction, "restore the unavailable command, browser, dependency or permission and rerun final-gate", details);
-    }
-    if (/stale evidence|negative evidence|current contradiction|source hash mismatch|dirty worktree|failed_test_result_artifact|owner_dom_forbidden_state|playwright_last_run_failed/i.test(text)) {
-        return blocker("stale_or_contradictory_evidence", false, recoveryAttempted, recoveryAction, "replace stale or contradictory evidence with fresh current-attempt evidence", details);
-    }
-    if (/missing current|missing assertion result|not machine-backed|missing required proof layer|proof layer .*missing|requires all required plan items|incomplete|no evidence_ids|unknown evidence_id/i.test(text)) {
-        return blocker("missing_current_evidence", false, recoveryAttempted, recoveryAction, "add fresh current-attempt evidence for the missing AC, PI or proof layer", details);
-    }
-    if (previous.length > 0 && errors.length === 0) {
-        return blocker("transient_state_bookkeeping", true, recoveryAttempted, recoveryAction || "cleared previous transient bookkeeping before current candidate scan", "cleared previous transient bookkeeping; no user action required", details);
-    }
-    if (errors.length > 0) {
-        return blocker("product_evidence_failed", false, recoveryAttempted, recoveryAction, "fix the current product evidence failure and rerun final-gate", details);
-    }
-    return blocker("none", false, recoveryAttempted, recoveryAction, "no blocker remains", details);
-}
-function normalizeAcceptanceTargetStatus(value) {
-    const normalized = String(value ?? "not_run").trim().toLowerCase();
-    if (normalized === "accepted") {
-        return "complete";
-    }
-    if (normalized === "not accepted") {
-        return "not_accepted";
-    }
-    return normalized || "not_run";
-}
-function isAcceptedStatus(value) {
-    return value === "complete" || value === "accepted";
-}
-function classifyAllowedCompletionLine(surface, line) {
-    const text = line.trim();
-    if (!text) {
-        return "allowed_rule_explanation";
-    }
-    if (/Audit workflow completed; acceptance target not complete\./i.test(text)) {
-        return "allowed_rule_explanation";
-    }
-    if (/^Product goal complete:\s*false$/i.test(text)) {
-        return "allowed_diagnostic_status";
-    }
-    if (/^(?:complete|partial|acceptance_required|missing_layer)_count:\s*\d+$/i.test(text)) {
-        return "allowed_diagnostic_status";
-    }
-    if (/^-\s+[A-Z]+-\d+:\s*(?:complete|accepted|accept)\s*$/i.test(text)) {
-        return "allowed_diagnostic_status";
-    }
-    const jsonField = /^"([^"]+)"\s*:\s*/.exec(text);
-    if (jsonField && !/^(final_answer|final_conclusion|conclusion|summary|message|required_user_visible_status)$/i.test(jsonField[1])) {
-        return "allowed_machine_status_field";
-    }
-    if (/\b(product_goal_complete|completion_output_status|acceptance_target_status|audit_task_complete)\b/i.test(text)) {
-        return "allowed_diagnostic_status";
-    }
-    if (isDiagnosticSurface(surface) && /["']?(overall_)?status["']?\s*:\s*["']?(complete|accepted|accept)["']?/i.test(text)) {
-        return "allowed_diagnostic_status";
-    }
-    if (/diagnostic|row-level|row status|not[_ -]?in[_ -]?scope/i.test(text)) {
-        return "allowed_diagnostic_status";
-    }
-    if (/\b(do not|must not|cannot|never|unless|only when|forbid|forbidden|invalid|false[- ]completion|does not mean|cannot authorize|cannot imply)\b/i.test(text)) {
-        return "allowed_rule_explanation";
-    }
-    if (/\bnot\s+(?:complete|completed|accepted|accept|done|successful)\b/i.test(text)) {
-        return "allowed_rule_explanation";
-    }
-    if (/不得|不能|禁止|仅当|不是|不等于/.test(text)) {
-        return "allowed_rule_explanation";
-    }
-    return undefined;
-}
-function classifySurfaceLine(surface, line) {
-    const normalized = surface.split(path.sep).join("/");
-    if (/^Final answer:|Goal achieved|ready to merge|implementation complete/i.test(line)) {
-        return "agent_final_answer";
-    }
-    if (normalized.endsWith("derived/final-summary.md")) {
-        return "user_visible_final_summary";
-    }
-    if (normalized.endsWith("derived/final-card.md")) {
-        return "final_card";
-    }
-    if (normalized.endsWith("goal-objective.txt")) {
-        return "agent_final_answer";
-    }
-    if (normalized.endsWith("execution-binding.md")) {
-        return "execution_binding_text";
-    }
-    if (normalized.endsWith("workflow-protocol.md")) {
-        return "workflow_protocol_text";
-    }
-    if (/final-acceptance-verdict\.json$/.test(normalized)) {
-        return "verdict_diagnostic";
-    }
-    if (/plan-conformance-matrix\.json$/.test(normalized)) {
-        return "matrix_diagnostic";
-    }
-    if (/\.json$/.test(normalized)) {
-        return "machine_readable_json_status";
-    }
-    if (/local-audit/.test(normalized)) {
-        return "local_audit_diagnostic";
-    }
-    if (/derived\//.test(normalized)) {
-        return "generated_summary";
-    }
-    return "unknown";
-}
-function isSelfRecoverableSurface(surface) {
-    const normalized = surface.split(path.sep).join("/");
-    return /^derived\/(?:final-summary|final-card|final-acceptance-verdict|plan-conformance-matrix|local-audit)\.(?:md|json)$/.test(normalized);
-}
-function isDiagnosticSurface(surface) {
-    const type = classifySurfaceLine(surface, "");
-    return (type === "machine_readable_json_status" ||
-        type === "derived_diagnostic_json" ||
-        type === "matrix_diagnostic" ||
-        type === "verdict_diagnostic" ||
-        type === "local_audit_diagnostic");
-}
-function blocker(category, selfRecoverable, recoveryAttempted, recoveryAction, nextAction, details) {
-    return {
-        category,
-        self_recoverable: selfRecoverable,
-        recovery_attempted: recoveryAttempted,
-        recovery_action: recoveryAction,
-        next_action: nextAction,
-        details,
-        blocker_count: category === "none" ? 0 : Math.max(1, details.length)
-    };
-}
-function unique(values) {
-    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
-}

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

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

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

@@ -1,24 +0,0 @@
-import { primitiveText } from "./plan-validator-common.js";
-export function validatePlanCompletionConformance(state, errors) {
-    for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
-        if (item.status !== "complete") {
-            continue;
-        }
-        if (item.implementation_paths.length === 0 && item.delivery_scope !== "out_of_scope_backlog") {
-            errors.push(`plan item ${planId} is complete but has no implementation_paths`);
-        }
-        if ((item.owner_surfaces ?? []).length > 0 && !item.required_proof_layers.some((layer) => layer.endsWith(".ui_browser"))) {
-            errors.push(`plan item ${planId} is complete but owner_surfaces has no related ui_browser proof layer`);
-        }
-        if ((item.required_tests ?? []).length === 0 && item.explicit_no_test_scope !== true) {
-            errors.push(`plan item ${planId} is complete but required_tests is empty and no explicit_no_test_scope is recorded`);
-        }
-        const shortcuts = item.non_completing_shortcuts ?? [];
-        const evidenceText = primitiveText(state.evidence.filter((evidence) => evidence.proves.some((layer) => item.required_proof_layers.includes(layer))));
-        for (const shortcut of shortcuts) {
-            if (shortcut && evidenceText.toLowerCase().includes(shortcut.toLowerCase())) {
-                errors.push(`plan item ${planId} is complete but evidence uses forbidden shortcut: ${shortcut}`);
-            }
-        }
-    }
-}

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

@@ -1,6 +0,0 @@
-import type { SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export interface SuperpowersContradictionScan {
-    errors: string[];
-    historicalCompleteIgnored: boolean;
-}
-export declare function scanSuperpowersContradictions(workdir: string, state: SuperpowersTaskState): Promise<SuperpowersContradictionScan>;

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

@@ -1,126 +0,0 @@
-import path from "node:path";
-import { listFiles, pathExists, readText } from "./fs.js";
-const OWNER_SURFACE_FORBIDDEN_STATES = ["尚未运行自测", "运行未记录", "未验证", "不可用", "暂不可用", "页面无明显变化"];
-export async function scanSuperpowersContradictions(workdir, state) {
-    const files = await listFiles(workdir);
-    const errors = [
-        ...scanFinalStateContradictions(state),
-        ...(await scanCurrentFailureArtifacts(workdir, files))
-    ];
-    const historicalCompleteIgnored = errors.length > 0 && (await hasHistoricalCompleteEvent(workdir));
-    if (historicalCompleteIgnored) {
-        errors.push("historical_complete_ignored: Historical stale completion event detected and ignored. Current recomputed product_goal_complete=false.");
-    }
-    if (errors.length > 0) {
-        errors.push("workflow_gate_bug_prevented: current contradiction scan prevents product_goal_complete=true.");
-    }
-    return { errors: unique(errors), historicalCompleteIgnored };
-}
-function scanFinalStateContradictions(state) {
-    const errors = [];
-    if (state.meta?.product_goal_complete === false && state.final?.product_goal_complete === true) {
-        errors.push("current contradiction task_state_product_goal_mismatch: meta product_goal_complete=false but final product_goal_complete=true.");
-    }
-    if (state.meta?.acceptance_target_status && state.final?.acceptance_target_status && state.meta.acceptance_target_status !== state.final.acceptance_target_status) {
-        errors.push(`current contradiction task_state_acceptance_status_mismatch: meta=${state.meta.acceptance_target_status} final=${state.final.acceptance_target_status}.`);
-    }
-    for (const commandRun of state.command_runs ?? []) {
-        if (Number(commandRun.exit_code) !== 0) {
-            errors.push(`current contradiction command_run_failed: ${commandRun.command_run_id} ac=${commandRun.ac_id} proof_layer=${commandRun.proof_layer} exit_code=${commandRun.exit_code}.`);
-        }
-    }
-    return errors;
-}
-async function scanCurrentFailureArtifacts(workdir, files) {
-    const errors = [];
-    for (const file of files) {
-        const relative = slash(path.relative(workdir, file));
-        if (relative.endsWith(".last-run.json")) {
-            errors.push(...(await scanPlaywrightLastRun(file, relative)));
-            continue;
-        }
-        if (/test-results\/.*error-context\.md$/i.test(relative)) {
-            errors.push(...(await scanOwnerDomErrorContext(file, relative)));
-            continue;
-        }
-        if (isFailureJsonCandidate(relative)) {
-            errors.push(...(await scanFailedJsonArtifact(file, relative)));
-        }
-    }
-    return errors;
-}
-async function scanPlaywrightLastRun(file, relative) {
-    const parsed = await readJsonRecord(file);
-    if (!parsed) {
-        return [];
-    }
-    const status = String(parsed.status ?? parsed.outcome ?? "").toLowerCase();
-    const failedTests = Array.isArray(parsed.failedTests) ? parsed.failedTests : Array.isArray(parsed.failed_tests) ? parsed.failed_tests : [];
-    if (status !== "failed" && failedTests.length === 0) {
-        return [];
-    }
-    return [
-        `current contradiction playwright_last_run_failed: ${relative} status=${status || "unknown"} failed_tests=${failedTests
-            .map(String)
-            .join(", ") || "(unspecified)"}.`
-    ];
-}
-async function scanOwnerDomErrorContext(file, relative) {
-    const text = await readText(file);
-    const findings = OWNER_SURFACE_FORBIDDEN_STATES.filter((state) => text.includes(state));
-    if (findings.length === 0) {
-        return [];
-    }
-    return [`current contradiction owner_dom_forbidden_state: ${relative} contains ${findings.join(", ")}.`];
-}
-async function scanFailedJsonArtifact(file, relative) {
-    const parsed = await readJsonRecord(file);
-    if (!parsed) {
-        return [];
-    }
-    const text = JSON.stringify(parsed);
-    const status = String(parsed.status ?? parsed.outcome ?? parsed.result ?? "").toLowerCase();
-    const failures = Number(parsed.failures ?? parsed.failed ?? parsed.failed_count ?? 0);
-    if (status !== "failed" && failures <= 0 && !/"failed"/i.test(text)) {
-        return [];
-    }
-    return [`current contradiction failed_test_result_artifact: ${relative} reports failed status.`];
-}
-function isFailureJsonCandidate(relative) {
-    return (/\.json$/i.test(relative) &&
-        /(^|\/)(test-results|playwright-report|junit|command-runs|negative-evidence|negative_evidence)(\/|$)/i.test(relative));
-}
-async function hasHistoricalCompleteEvent(workdir) {
-    const eventsPath = path.join(workdir, "events.ndjson");
-    if (!(await pathExists(eventsPath))) {
-        return false;
-    }
-    const content = await readText(eventsPath);
-    return content
-        .split(/\r?\n/)
-        .filter(Boolean)
-        .some((line) => {
-        try {
-            const event = JSON.parse(line);
-            return String(event.event ?? event.event_type ?? event.type ?? "") === "final_gate" && event.product_goal_complete === true;
-        }
-        catch {
-            return /final_gate/.test(line) && /product_goal_complete["']?\s*:\s*true/.test(line);
-        }
-    });
-}
-async function readJsonRecord(file) {
-    try {
-        const parsed = JSON.parse(await readText(file));
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function slash(value) {
-    return value.split(path.sep).join("/");
-}
-function unique(values) {
-    return [...new Set(values.filter(Boolean))];
-}

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

@@ -1,3 +0,0 @@
-import type { SuperpowersEvidenceRecord, SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export declare function evaluateCurrentAttemptEvidence(state: SuperpowersTaskState, evidence: SuperpowersEvidenceRecord, layerId: string): string[];
-export declare function evaluateCurrentAttemptArtifact(workdir: string, evidence: SuperpowersEvidenceRecord, layerId: string): Promise<string[]>;