project-tiny-context-harness 0.2.85 → 0.6.1

package/dist/lib/superpowers-task-state-schema.js

@@ -1,66 +0,0 @@
-export const SUPERPOWERS_TASK_STATE_SCHEMA_VERSION = "superpowers-task-state-v1";
-export const SUPERPOWERS_TASK_STATE_JSON_SCHEMA = {
-    $schema: "https://json-schema.org/draft/2020-12/schema",
-    $id: "https://project-tiny-context-harness.local/superpowers-task-state.schema.json",
-    title: "Superpowers Long-Task State",
-    type: "object",
-    required: [
-        "meta",
-        "sources",
-        "context",
-        "delivery",
-        "graph",
-        "attempts",
-        "current_attempt_id",
-        "required_command_specs",
-        "command_runs",
-        "negative_evidence_records",
-        "slices",
-        "evidence",
-        "gates",
-        "progress",
-        "blockers",
-        "final"
-    ],
-    properties: {
-        meta: {
-            type: "object",
-            required: ["task_id", "plan_slug", "created_at", "updated_at", "schema_version", "product_goal_complete", "acceptance_target_status"],
-            properties: {
-                schema_version: { const: SUPERPOWERS_TASK_STATE_SCHEMA_VERSION },
-                product_goal_complete: { type: "boolean" },
-                acceptance_target_status: { type: "string" }
-            }
-        },
-        sources: { type: "object" },
-        context: { type: "object" },
-        delivery: { type: "object" },
-        graph: { type: "object" },
-        attempts: { type: "array" },
-        current_attempt_id: { type: "string" },
-        required_command_specs: { type: "array" },
-        command_runs: { type: "array" },
-        negative_evidence_records: { type: "array" },
-        slices: { type: "array" },
-        evidence: { type: "array" },
-        gates: { type: "object" },
-        progress: { type: "object" },
-        blockers: { type: "array" },
-        final: { type: "object" }
-    }
-};
-export function isRecord(value) {
-    return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-export function asStringArray(value) {
-    if (Array.isArray(value)) {
-        return value.flatMap(asStringArray);
-    }
-    if (value === undefined || value === null) {
-        return [];
-    }
-    return String(value)
-        .split(/[,;\n]/)
-        .map((item) => item.trim())
-        .filter(Boolean);
-}

package/dist/lib/superpowers-task-state-shape.d.ts

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

package/dist/lib/superpowers-task-state-shape.js

@@ -1,50 +0,0 @@
-import { isRecord } from "./superpowers-task-state-schema.js";
-export function validateShape(state, errors) {
-    if (state.meta?.schema_version !== "superpowers-task-state-v1") {
-        errors.push("task-state.json schema_version must be superpowers-task-state-v1");
-    }
-    for (const key of [
-        "meta",
-        "sources",
-        "context",
-        "delivery",
-        "graph",
-        "attempts",
-        "current_attempt_id",
-        "required_command_specs",
-        "command_runs",
-        "negative_evidence_records",
-        "slices",
-        "evidence",
-        "gates",
-        "progress",
-        "blockers",
-        "final"
-    ]) {
-        if (!(key in state)) {
-            errors.push(`task-state.json is missing section: ${key}`);
-        }
-    }
-}
-export function hasUsableShape(state) {
-    const candidate = state;
-    return (isRecord(candidate.meta) &&
-        isRecord(candidate.sources) &&
-        isRecord(candidate.context) &&
-        isRecord(candidate.delivery) &&
-        isRecord(candidate.graph) &&
-        isRecord(candidate.graph.plan_items) &&
-        isRecord(candidate.graph.acceptance_criteria) &&
-        isRecord(candidate.graph.proof_layers) &&
-        Array.isArray(candidate.attempts) &&
-        typeof candidate.current_attempt_id === "string" &&
-        Array.isArray(candidate.required_command_specs) &&
-        Array.isArray(candidate.command_runs) &&
-        Array.isArray(candidate.negative_evidence_records) &&
-        Array.isArray(candidate.slices) &&
-        Array.isArray(candidate.evidence) &&
-        isRecord(candidate.gates) &&
-        isRecord(candidate.progress) &&
-        Array.isArray(candidate.blockers) &&
-        isRecord(candidate.final));
-}

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

@@ -1,16 +0,0 @@
-import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export interface InitializeSuperpowersTaskOptions {
-    taskId?: string;
-    planSlug?: string;
-    goalType?: string;
-}
-export declare function initializeSuperpowersTask(workdir: string, options?: InitializeSuperpowersTaskOptions): Promise<SuperpowersTaskState>;
-export declare function loadSuperpowersState(workdir: string): Promise<SuperpowersTaskState>;
-export declare function saveSuperpowersState(workdir: string, state: SuperpowersTaskState): Promise<void>;
-export declare function applySliceDelta(workdir: string, deltaFile: string): Promise<SuperpowersTaskState>;
-export declare function refreshSourceHashes(workdir: string, state: SuperpowersTaskState): Promise<void>;
-export declare function recomputeStatuses(state: SuperpowersTaskState): void;
-export declare function emptyProgressState(): SuperpowersTaskState["progress"];
-export declare function sourceRecords(workdir: string): Promise<SuperpowersTaskState["sources"]>;
-export declare function sha256(value: string): string;
-export declare function stableJson(value: unknown): string;

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

@@ -1,246 +0,0 @@
-import { createHash } from "node:crypto";
-import path from "node:path";
-import { ensureDir, pathExists, readText, writeTextIfChanged } from "./fs.js";
-import { normalizeProofLayerId } from "./superpowers-task-fields.js";
-import { appendSuperpowersEvent } from "./superpowers-task-events.js";
-import { evaluateProofLayerAssertions, isMachineVerifiableLayer } from "./superpowers-task-assertions.js";
-import { readEvidenceRecords } from "./superpowers-task-evidence-records.js";
-import { SUPERPOWERS_TASK_STATE_JSON_SCHEMA, SUPERPOWERS_TASK_STATE_SCHEMA_VERSION, asStringArray, isRecord } from "./superpowers-task-state-schema.js";
-const SOURCE_FILES = {
-    product_architecture_source: {
-        path: "product-architecture-source.md",
-        authority: "intent_scope_boundaries"
-    },
-    technical_realization_plan: {
-        path: "technical-realization-plan.md",
-        authority: "plan_items_execution_blueprint_conformance"
-    },
-    acceptance_checklist: {
-        path: "acceptance-checklist.md",
-        authority: "acs_completion_semantics_proof_layers"
-    }
-};
-const SLICE_PROGRESS_TYPES = new Set(["functional_gap_closed", "proof_gap_closed", "blocker_resolved", "invalid_evidence_removed"]);
-export async function initializeSuperpowersTask(workdir, options = {}) {
-    await ensureDir(path.join(workdir, "derived"));
-    await writeTextIfChanged(path.join(workdir, "task-state.schema.json"), `${stableJson(SUPERPOWERS_TASK_STATE_JSON_SCHEMA)}\n`);
-    for (const source of Object.values(SOURCE_FILES)) {
-        const target = path.join(workdir, source.path);
-        if (!(await pathExists(target))) {
-            await writeTextIfChanged(target, `# ${source.path.replace(/\.md$/, "").replace(/-/g, " ")}\n`);
-        }
-    }
-    const now = new Date().toISOString();
-    const state = {
-        meta: {
-            task_id: options.taskId ?? `SP-${compactDate(now)}-001`,
-            plan_slug: options.planSlug ?? path.basename(workdir),
-            created_at: now,
-            updated_at: now,
-            schema_version: SUPERPOWERS_TASK_STATE_SCHEMA_VERSION,
-            goal_type: options.goalType ?? "implementation",
-            product_goal_complete: false,
-            acceptance_target_status: "not_run",
-            audit_task_complete: false,
-            completion_output_status: "blocked"
-        },
-        sources: await sourceRecords(workdir),
-        context: {
-            product_context_delta: "none",
-            technical_context_delta: "none",
-            source_to_context_coverage: [],
-            context_to_implementation_binding: []
-        },
-        delivery: {
-            product_architecture_scope: {
-                delivery_scope: "",
-                full_population_required: null,
-                representative_samples_validate: [],
-                representative_samples_do_not_validate: [],
-                out_of_scope_backlog: [],
-                scope_fit_decision: "",
-                selected_scope_fit_slice: "",
-                owner_boundary: "",
-                primary_capability_path: "",
-                non_completing_outcomes: [],
-                assertion_policy: "",
-                source_authority: "",
-                product_goal: ""
-            },
-            scope_conflicts: []
-        },
-        graph: {
-            plan_items: {},
-            acceptance_criteria: {},
-            proof_layers: {},
-            edges: []
-        },
-        attempts: [],
-        current_attempt_id: "",
-        required_command_specs: [],
-        command_runs: [],
-        negative_evidence_records: [],
-        slices: [],
-        evidence: [],
-        gates: {},
-        progress: emptyProgressState(),
-        blockers: [],
-        final: {
-            product_goal_complete: false,
-            acceptance_target_status: "not_run",
-            audit_task_complete: false,
-            completion_output_status: "blocked",
-            final_answer_allowed: false,
-            required_user_visible_status: "blocked",
-            final_answer: "blocked",
-            exit_code: 2,
-            blocked_reasons: ["final_gate_not_run"],
-            rejection_reasons: [],
-            generated_output_mismatch: false,
-            completion_basis: [],
-            next_required_actions: []
-        }
-    };
-    await saveSuperpowersState(workdir, state);
-    await appendSuperpowersEvent(workdir, "task_initialized", { task_id: state.meta.task_id });
-    return state;
-}
-export async function loadSuperpowersState(workdir) {
-    return JSON.parse(await readText(path.join(workdir, "task-state.json")));
-}
-export async function saveSuperpowersState(workdir, state) {
-    state.meta.updated_at = new Date().toISOString();
-    await writeTextIfChanged(path.join(workdir, "task-state.json"), `${stableJson(state)}\n`);
-}
-export async function applySliceDelta(workdir, deltaFile) {
-    const state = await loadSuperpowersState(workdir);
-    const delta = JSON.parse(await readText(deltaFile));
-    const sliceId = String(delta.slice_id ?? "");
-    const progressValue = isRecord(delta.progress_value) ? delta.progress_value : undefined;
-    if (!sliceId) {
-        throw new Error("slice_delta must include slice_id");
-    }
-    if (!progressValue || !String(progressValue.type ?? "").trim() || asStringArray(progressValue.closed_items).length === 0) {
-        throw new Error("slice_delta must include progress_value with type and closed_items");
-    }
-    const progressType = String(progressValue.type);
-    if (!SLICE_PROGRESS_TYPES.has(progressType)) {
-        throw new Error(`slice_delta progress_value.type must be one of ${[...SLICE_PROGRESS_TYPES].join(", ")}; got ${progressType || "(missing)"}`);
-    }
-    const evidenceRecords = readEvidenceRecords(delta.evidence_records);
-    for (const evidence of evidenceRecords) {
-        const existingIndex = state.evidence.findIndex((item) => item.evidence_id === evidence.evidence_id);
-        if (existingIndex >= 0) {
-            state.evidence[existingIndex] = evidence;
-        }
-        else {
-            state.evidence.push(evidence);
-        }
-    }
-    const slice = {
-        slice_id: sliceId,
-        slice_goal: String(delta.slice_goal ?? ""),
-        touched_plan_items: asStringArray(delta.touched_plan_items),
-        touched_acs: asStringArray(delta.touched_acs),
-        missing_layer_classes: asStringArray(delta.missing_layer_classes),
-        code_changes: asStringArray(delta.code_changes),
-        evidence_records: evidenceRecords.map((item) => item.evidence_id),
-        closed_layers: asStringArray(delta.closed_layers).map(normalizeProofLayerId),
-        remaining_layers: asStringArray(delta.remaining_layers).map(normalizeProofLayerId),
-        blockers: Array.isArray(delta.blockers) ? delta.blockers : [],
-        cleanup_assertions: asStringArray(delta.cleanup_assertions),
-        progress_value: {
-            type: progressType,
-            closed_items: asStringArray(progressValue.closed_items),
-            why_it_reduces_rework: String(progressValue.why_it_reduces_rework ?? "")
-        }
-    };
-    state.slices.push(slice);
-    for (const layerId of slice.closed_layers) {
-        const layer = state.graph.proof_layers[layerId];
-        if (!layer) {
-            continue;
-        }
-        layer.status = "satisfied";
-        layer.evidence_ids = unique([...layer.evidence_ids, ...evidenceRecords.filter((item) => item.proves.includes(layerId)).map((item) => item.evidence_id)]);
-    }
-    recomputeStatuses(state);
-    await saveSuperpowersState(workdir, state);
-    await appendSuperpowersEvent(workdir, "slice_delta_applied", { slice_id: sliceId });
-    return state;
-}
-export async function refreshSourceHashes(workdir, state) {
-    state.sources = await sourceRecords(workdir);
-}
-export function recomputeStatuses(state) {
-    for (const [acId, ac] of Object.entries(state.graph.acceptance_criteria)) {
-        const layerIds = ac.required_proof_layers.map((layer) => `${acId}.${layer}`);
-        if (layerIds.length === 0) {
-            ac.status = "not_run";
-        }
-        else if (layerIds.every((layerId) => layerSatisfiedForCompletion(state, layerId))) {
-            ac.status = "complete";
-        }
-        else if (layerIds.some((layerId) => state.graph.proof_layers[layerId]?.status === "satisfied")) {
-            ac.status = "partial";
-        }
-        else {
-            ac.status = "not_run";
-        }
-    }
-    for (const item of Object.values(state.graph.plan_items)) {
-        if (item.related_acs.length > 0 && item.related_acs.every((acId) => state.graph.acceptance_criteria[acId]?.status === "complete")) {
-            item.status = "complete";
-        }
-        else if (item.related_acs.some((acId) => state.graph.acceptance_criteria[acId]?.status === "partial")) {
-            item.status = "partial";
-        }
-        else if (item.status === "complete") {
-            item.status = "not_started";
-        }
-    }
-}
-function layerSatisfiedForCompletion(state, layerId) {
-    if (state.graph.proof_layers[layerId]?.status !== "satisfied") {
-        return false;
-    }
-    return !isMachineVerifiableLayer(layerId) || evaluateProofLayerAssertions(state, layerId).assertion_status === "passed";
-}
-export function emptyProgressState() {
-    return {
-        system_capability_progress: { status: "not_started" },
-        representative_sample_progress: { status: "not_started" },
-        real_object_coverage: { status: "unknown" },
-        full_population_operation_progress: { status: "not_in_scope" }
-    };
-}
-export async function sourceRecords(workdir) {
-    const sources = {};
-    for (const [key, source] of Object.entries(SOURCE_FILES)) {
-        const file = path.join(workdir, source.path);
-        const content = (await pathExists(file)) ? await readText(file) : "";
-        sources[key] = { path: source.path, sha256: sha256(content), authority: source.authority };
-    }
-    return sources;
-}
-export function sha256(value) {
-    return createHash("sha256").update(value).digest("hex");
-}
-export function stableJson(value) {
-    return JSON.stringify(sortJson(value), null, 2);
-}
-function sortJson(value) {
-    if (Array.isArray(value)) {
-        return value.map(sortJson);
-    }
-    if (!isRecord(value)) {
-        return value;
-    }
-    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortJson(value[key])]));
-}
-function unique(values) {
-    return [...new Set(values.filter(Boolean))];
-}
-function compactDate(value) {
-    return value.slice(0, 10).replace(/-/g, "");
-}

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

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

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

@@ -1,24 +0,0 @@
-const CANONICAL_PLAN_STATUSES = new Set(["not_started", "in_progress", "partial", "blocked", "invalidated", "complete", "out_of_scope_NA"]);
-const CANONICAL_AC_STATUSES = new Set([
-    "not_started",
-    "not_run",
-    "in_progress",
-    "partial",
-    "blocked",
-    "invalidated",
-    "under_specified",
-    "complete",
-    "out_of_scope_NA"
-]);
-export function validateCanonicalStatuses(state, errors) {
-    for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
-        if (!CANONICAL_PLAN_STATUSES.has(item.status)) {
-            errors.push(`plan item ${planId} has non-canonical status: ${item.status}`);
-        }
-    }
-    for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
-        if (!CANONICAL_AC_STATUSES.has(ac.status)) {
-            errors.push(`AC ${acId} has non-canonical status: ${ac.status}`);
-        }
-    }
-}

package/dist/lib/superpowers-task-under-specified.d.ts

@@ -1,7 +0,0 @@
-import type { SuperpowersAcceptanceCriterion, SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export interface UnderSpecifiedAc {
-    ac_id: string;
-    reasons: string[];
-}
-export declare function findUnderSpecifiedAcs(state: SuperpowersTaskState): UnderSpecifiedAc[];
-export declare function underSpecifiedReasons(acId: string, ac: SuperpowersAcceptanceCriterion): string[];

package/dist/lib/superpowers-task-under-specified.js

@@ -1,61 +0,0 @@
-import { isMachineVerifiableLayer } from "./superpowers-task-assertions.js";
-const GENERATED_ONLY_EVIDENCE = /\b(matrix|verdict|validator|final[-_ ]?card|final[-_ ]?summary|evidence[-_ ]?index|derived\/)/i;
-const MACHINE_UI_PROOF = /\b(browser|ui_browser|e2e|smoke|trace|playwright|route|owner surface)\b/i;
-const MANUAL_ONLY_TEST = /\b(查看页面|人工确认|manual confirm|manually inspect|visual check only)\b/i;
-export function findUnderSpecifiedAcs(state) {
-    return Object.entries(state.graph?.acceptance_criteria ?? {})
-        .map(([acId, ac]) => ({ ac_id: acId, reasons: underSpecifiedReasons(acId, ac) }))
-        .filter((item) => item.reasons.length > 0);
-}
-export function underSpecifiedReasons(acId, ac) {
-    if (ac.machine_blocking !== true && ac.assertion_result_required !== true) {
-        return [];
-    }
-    const reasons = [];
-    if (!trimmed(ac.assertion_command)) {
-        reasons.push(`${acId} under_specified: assertion_command is required for machine_blocking AC`);
-    }
-    if ((ac.assertion_artifacts ?? []).length === 0) {
-        reasons.push(`${acId} under_specified: assertion_artifacts are required for machine_blocking AC`);
-    }
-    if ((ac.positive_assertions ?? []).length === 0) {
-        reasons.push(`${acId} under_specified: positive_assertions are required for machine_blocking AC`);
-    }
-    if ((ac.negative_assertions ?? []).length === 0) {
-        reasons.push(`${acId} under_specified: negative_assertions are required for machine_blocking AC`);
-    }
-    if ((ac.invalid_completion_signals ?? []).length === 0) {
-        reasons.push(`${acId} under_specified: invalid_completion_signals are required for machine_blocking AC`);
-    }
-    if (ac.assertion_result_required !== true) {
-        reasons.push(`${acId} under_specified: machine_blocking AC must require assertion_result`);
-    }
-    const requiredLayers = ac.required_proof_layers ?? [];
-    if (requiredLayers.some((layer) => isMachineVerifiableLayer(`${acId}.${layer}`)) && !trimmed(ac.assertion_command)) {
-        reasons.push(`${acId} under_specified: machine proof layers cannot produce assertion_result without assertion_command`);
-    }
-    if (requiredLayers.includes("ui_browser") && !MACHINE_UI_PROOF.test(acEvidenceText(ac))) {
-        reasons.push(`${acId} under_specified: ui_browser AC requires browser/e2e/smoke/trace-backed proof`);
-    }
-    const finalEvidence = ac.final_evidence_expected ?? [];
-    if (finalEvidence.length > 0 && finalEvidence.every((item) => GENERATED_ONLY_EVIDENCE.test(item))) {
-        reasons.push(`${acId} under_specified: final_evidence_expected only names generated summary artifacts`);
-    }
-    const testCases = ac.test_cases ?? [];
-    if (testCases.length > 0 && testCases.every((item) => MANUAL_ONLY_TEST.test(item))) {
-        reasons.push(`${acId} under_specified: test_cases are manual-only`);
-    }
-    return reasons;
-}
-function acEvidenceText(ac) {
-    return [
-        ac.assertion_command ?? "",
-        ...(ac.assertion_artifacts ?? []),
-        ...(ac.verification_method ?? []),
-        ...(ac.test_cases ?? []),
-        ...(ac.final_evidence_expected ?? [])
-    ].join("\n");
-}
-function trimmed(value) {
-    return Boolean(value && value.trim());
-}

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

@@ -1,11 +0,0 @@
-import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export interface IgnoredUnregisteredEvidence {
-    path: string;
-    status: string;
-    target_ac_ids: string[];
-    target_proof_layers: string[];
-}
-export declare function scanUnregisteredAssertionEvidence(workdir: string, state: SuperpowersTaskState): Promise<{
-    ignored: IgnoredUnregisteredEvidence[];
-    errors: string[];
-}>;

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

@@ -1,72 +0,0 @@
-import path from "node:path";
-import { listFiles, readText } from "./fs.js";
-import { isRecord } from "./superpowers-task-state-schema.js";
-export async function scanUnregisteredAssertionEvidence(workdir, state) {
-    const registeredPaths = new Set();
-    for (const evidence of state.evidence ?? []) {
-        for (const candidate of [evidence.artifact_path, ...(evidence.artifact_paths ?? []), ...(evidence.assertion_result?.artifacts ?? [])]) {
-            if (candidate) {
-                registeredPaths.add(slash(candidate));
-                registeredPaths.add(slash(path.join(workdir, candidate)));
-            }
-        }
-    }
-    const ignored = [];
-    for (const file of await listFiles(workdir)) {
-        if (!/\.json$/i.test(file)) {
-            continue;
-        }
-        const relative = slash(path.relative(workdir, file));
-        if (registeredPaths.has(relative) || registeredPaths.has(slash(file))) {
-            continue;
-        }
-        const parsed = await readJson(file);
-        const assertion = assertionRecord(parsed);
-        if (!assertion) {
-            continue;
-        }
-        const status = String(assertion.status ?? "");
-        if (status !== "passed") {
-            continue;
-        }
-        ignored.push({
-            path: relative,
-            status,
-            target_ac_ids: asStringArray(assertion.target_ac_ids),
-            target_proof_layers: asStringArray(assertion.target_proof_layers)
-        });
-    }
-    return {
-        ignored,
-        errors: ignored.map((item) => `ignored_unregistered_evidence: unregistered assertion JSON ${item.path} status=passed is not proof`)
-    };
-}
-async function readJson(file) {
-    try {
-        return JSON.parse(await readText(file));
-    }
-    catch {
-        return undefined;
-    }
-}
-function assertionRecord(value) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    if (looksLikeAssertion(value)) {
-        return value;
-    }
-    if (isRecord(value.assertion_result) && looksLikeAssertion(value.assertion_result)) {
-        return value.assertion_result;
-    }
-    return undefined;
-}
-function looksLikeAssertion(value) {
-    return /assertion-result-v\d+/i.test(String(value.schema_version ?? "")) || (typeof value.status === "string" && Array.isArray(value.target_ac_ids));
-}
-function asStringArray(value) {
-    return Array.isArray(value) ? value.map(String).filter(Boolean) : [];
-}
-function slash(value) {
-    return value.replace(/\\/g, "/");
-}

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

@@ -1,5 +0,0 @@
-import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-import type { ValidatorReport } from "./validators.js";
-export declare function validateSuperpowersState(projectRoot: string, args?: string[]): Promise<ValidatorReport>;
-export declare function completionConditionErrors(state: SuperpowersTaskState): string[];
-export declare function allCompletionConditionsSatisfied(state: SuperpowersTaskState): boolean;