project-tiny-context-harness 0.2.82 → 0.2.84

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

@@ -0,0 +1,52 @@
+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.d.ts

@@ -1,3 +1,6 @@
 import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export declare function compileSuperpowersTask(workdir: string): Promise<SuperpowersTaskState>;
+import type { SuperpowersAttemptMode } from "./superpowers-task-state-schema.js";
+export declare function compileSuperpowersTask(workdir: string, options?: {
+    mode?: SuperpowersAttemptMode;
+}): Promise<SuperpowersTaskState>;
 export declare function computeScopeConflicts(state: SuperpowersTaskState): string[];

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

@@ -3,9 +3,11 @@ import { pathExists, readText } from "./fs.js";
 import { appendSuperpowersEvent } from "./superpowers-task-events.js";
 import { compileError, compileReportSuffix, throwCompileErrors } from "./superpowers-task-compile-diagnostics.js";
 import { validateCompiledSources } from "./superpowers-task-compile-guards.js";
+import { startSuperpowersAttempt } from "./superpowers-task-attempt.js";
+import { deriveRequiredCommandSpecs } from "./superpowers-task-command-specs.js";
 import { loadSuperpowersState, recomputeStatuses, saveSuperpowersState, refreshSourceHashes } from "./superpowers-task-state.js";
 import { DEFAULT_LAYERS, parseAcceptanceCriteria, parsePlanItems, parseProductArchitectureScope } from "./superpowers-task-source-compile.js";
-export async function compileSuperpowersTask(workdir) {
+export async function compileSuperpowersTask(workdir, options = {}) {
     const state = await loadSuperpowersState(workdir);
     await refreshSourceHashes(workdir, state);
     await assertRequiredSourcesExist(workdir, state);
@@ -40,9 +42,13 @@ export async function compileSuperpowersTask(workdir) {
         }
     }
     state.graph.edges = Object.entries(planItems).flatMap(([planId, item]) => item.related_acs.map((acId) => ({ from: planId, to: acId, type: "supports" })));
+    state.required_command_specs = deriveRequiredCommandSpecs(state);
+    state.command_runs = [];
+    state.negative_evidence_records = [];
     state.delivery.scope_conflicts = computeScopeConflicts(state);
     state.progress = compileProgress(state);
     recomputeStatuses(state);
+    await startSuperpowersAttempt(workdir, state, options.mode ?? "product_task");
     await saveSuperpowersState(workdir, state);
     await appendSuperpowersEvent(workdir, "graph_compiled", {
         plan_items: Object.keys(planItems).length,

package/dist/lib/superpowers-task-completion-output.d.ts

@@ -0,0 +1,52 @@
+import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export type CompletionOutputStatus = "accept" | "reject" | "blocked";
+export interface CompletionOutputContract {
+    product_goal_complete: boolean;
+    acceptance_target_status: string;
+    completion_output_status: CompletionOutputStatus;
+    final_answer_allowed: boolean;
+    required_user_visible_status: "accepted" | "rejected" | "blocked";
+    final_answer: CompletionOutputStatus;
+    exit_code: 0 | 1 | 2;
+    blocked_reasons: string[];
+    rejection_reasons: string[];
+    audit_task_complete: boolean;
+    final_gate_ran: boolean;
+    generated_output_mismatch: boolean;
+}
+export interface CompletionOutputResolveInput {
+    final_gate_ran?: boolean;
+    product_goal_complete?: boolean;
+    acceptance_target_status?: string;
+    audit_task_complete?: boolean;
+    validator_errors?: string[];
+    acceptance_validator_errors?: string[];
+    blocked_reasons?: string[];
+    rejection_reasons?: string[];
+    generated_output_mismatch?: boolean;
+    required_command_not_run?: boolean;
+    environment_unknown?: boolean;
+    state_unreadable?: boolean;
+    source_unreadable?: boolean;
+    kernel_invalid?: boolean;
+    required_validator_unavailable?: boolean;
+}
+export interface CompletionOutputSurface {
+    surface: string;
+    text: string;
+}
+export interface CompletionPhraseFinding {
+    surface: string;
+    phrase: string;
+    line: number;
+    text: string;
+}
+export declare function resolveCompletionOutputStatus(input: CompletionOutputResolveInput): CompletionOutputContract;
+export declare function completionOutputContractFromState(state: SuperpowersTaskState): CompletionOutputContract;
+export declare function applyCompletionOutputContract(state: SuperpowersTaskState, contract: CompletionOutputContract): void;
+export declare function scanFalseCompletionPhrases(input: {
+    completion_output_status: CompletionOutputStatus;
+    surfaces: CompletionOutputSurface[] | string;
+}): CompletionPhraseFinding[];
+export declare function scanGeneratedCompletionOutputSurfaces(workdir: string, contract: CompletionOutputContract): Promise<CompletionPhraseFinding[]>;
+export declare function completionPhraseFindingMessages(findings: CompletionPhraseFinding[]): string[];

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

@@ -0,0 +1,228 @@
+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";
+    return 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
+    });
+}
+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;
+    metaRecord.completion_output_status = contract.completion_output_status;
+}
+export function scanFalseCompletionPhrases(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()) {
+            if (lineAllowedForNonAccept(line)) {
+                continue;
+            }
+            for (const item of FORBIDDEN_PHRASES) {
+                if (item.pattern.test(line)) {
+                    findings.push({ surface: surface.surface, phrase: item.phrase, line: index + 1, text: line.trim() });
+                    break;
+                }
+            }
+        }
+    }
+    return findings;
+}
+export async function scanGeneratedCompletionOutputSurfaces(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 scanFalseCompletionPhrases({ completion_output_status: contract.completion_output_status, surfaces });
+}
+export function completionPhraseFindingMessages(findings) {
+    return findings.map((finding) => `false completion phrase in ${finding.surface}:${finding.line}: ${finding.phrase}`);
+}
+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 lineAllowedForNonAccept(line) {
+    const text = line.trim();
+    if (!text) {
+        return true;
+    }
+    if (/Audit workflow completed; acceptance target not complete\./i.test(text)) {
+        return true;
+    }
+    if (/^Product goal complete:\s*false$/i.test(text)) {
+        return true;
+    }
+    if (/^(?:complete|partial|acceptance_required|missing_layer)_count:\s*\d+$/i.test(text)) {
+        return true;
+    }
+    if (/^-\s+[A-Z]+-\d+:\s*(?:complete|accepted|accept)\s*$/i.test(text)) {
+        return true;
+    }
+    const jsonField = /^"([^"]+)"\s*:\s*/.exec(text);
+    if (jsonField && !/^(final_answer|final_conclusion|conclusion|summary|message|required_user_visible_status)$/i.test(jsonField[1])) {
+        return true;
+    }
+    if (/\b(product_goal_complete|completion_output_status|acceptance_target_status|audit_task_complete)\b/i.test(text)) {
+        return true;
+    }
+    if (/["']?(overall_)?status["']?\s*:\s*["']?(complete|accepted|accept)["']?/i.test(text)) {
+        return true;
+    }
+    if (/diagnostic|row-level|row status|not[_ -]?in[_ -]?scope/i.test(text)) {
+        return true;
+    }
+    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 true;
+    }
+    if (/\bnot\s+(?:complete|completed|accepted|accept|done|successful)\b/i.test(text)) {
+        return true;
+    }
+    if (/不得|不能|禁止|仅当|不是|不等于/.test(text)) {
+        return true;
+    }
+    return false;
+}
+function unique(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}

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

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

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

@@ -0,0 +1,3 @@
+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[]>;