project-tiny-context-harness 0.2.84 → 0.6.0

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

@@ -1,276 +0,0 @@
-export const PRODUCT_FIELDS = [
-    "delivery_scope",
-    "full_population_required",
-    "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",
-    "surface_ia_lock",
-    "decision_lock",
-    "context_delta",
-    "source_to_context_coverage",
-    "acceptance_semantics",
-    "impact"
-];
-export const PLAN_FIELDS = [
-    "delivery_scope",
-    "capability_target",
-    "representative_samples",
-    "full_population_boundary",
-    "non_required_population",
-    "owner_surfaces",
-    "forbidden_surfaces",
-    "owner_boundary",
-    "primary_capability_path",
-    "trigger_contract",
-    "state_transition_contract",
-    "observable_result_contract",
-    "assertion_support",
-    "required_assertion_commands",
-    "invalid_implementation_shortcuts",
-    "implementation_paths",
-    "required_tests",
-    "related_acs",
-    "requirement_ref",
-    "decision_id",
-    "proof_layer_ids",
-    "api_schema_changes",
-    "state_machine",
-    "data_flow",
-    "worker_runtime_behavior",
-    "ui_ia_changes",
-    "migration_plan",
-    "evidence_artifacts",
-    "explicit_no_test_scope",
-    "non_completing_shortcuts",
-    "substitution_policy",
-    "drift_severity",
-    "partial_conditions",
-    "blockers",
-    "context_fact_refs"
-];
-export const ACCEPTANCE_FIELDS = [
-    "acceptance_scope",
-    "ac_validates",
-    "ac_does_not_validate",
-    "sample_boundary",
-    "full_population_required",
-    "related_plan_items",
-    "required_proof_layers",
-    "assertion_command",
-    "assertion_artifacts",
-    "positive_assertions",
-    "negative_assertions",
-    "machine_blocking",
-    "invalid_completion_signals",
-    "assertion_result_required",
-    "ac_type",
-    "proof_chain",
-    "verification_method",
-    "fail_conditions",
-    "invalid_evidence",
-    "substitution_policy",
-    "missing_layer_downgrade",
-    "auditor_expectation",
-    "out_of_scope_na_approval_source",
-    "required_test_ids",
-    "explicit_no_test_scope",
-    "hard_blockers",
-    "validates_explanation",
-    "does_not_validate_explanation",
-    "final_evidence_expected",
-    "test_cases"
-];
-export const PRODUCT_REQUIRED_FIELDS = [
-    "delivery_scope",
-    "full_population_required",
-    "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"
-];
-export const PLAN_REQUIRED_FIELDS = [
-    "delivery_scope",
-    "capability_target",
-    "representative_samples",
-    "full_population_boundary",
-    "non_required_population",
-    "owner_boundary",
-    "primary_capability_path",
-    "trigger_contract",
-    "state_transition_contract",
-    "observable_result_contract",
-    "assertion_support",
-    "required_assertion_commands",
-    "invalid_implementation_shortcuts",
-    "implementation_paths"
-];
-export const ACCEPTANCE_REQUIRED_FIELDS = [
-    "acceptance_scope",
-    "ac_validates",
-    "ac_does_not_validate",
-    "sample_boundary",
-    "full_population_required",
-    "related_plan_items",
-    "required_proof_layers",
-    "assertion_command",
-    "assertion_artifacts",
-    "positive_assertions",
-    "negative_assertions",
-    "machine_blocking",
-    "invalid_completion_signals",
-    "assertion_result_required"
-];
-export const PRODUCT_FIELD_TYPES = {
-    delivery_scope: "enum",
-    full_population_required: "boolean",
-    representative_samples_validate: "array",
-    representative_samples_do_not_validate: "array",
-    out_of_scope_backlog: "array",
-    scope_fit_decision: "enum",
-    selected_scope_fit_slice: "text",
-    owner_boundary: "text",
-    primary_capability_path: "text",
-    non_completing_outcomes: "array",
-    assertion_policy: "text",
-    source_authority: "text",
-    product_goal: "text",
-    surface_ia_lock: "text",
-    decision_lock: "text",
-    context_delta: "text",
-    source_to_context_coverage: "text",
-    acceptance_semantics: "text",
-    impact: "text"
-};
-export const PLAN_FIELD_TYPES = {
-    delivery_scope: "enum",
-    capability_target: "text",
-    representative_samples: "array",
-    full_population_boundary: "text",
-    non_required_population: "array",
-    owner_surfaces: "array",
-    forbidden_surfaces: "array",
-    owner_boundary: "text",
-    primary_capability_path: "text",
-    trigger_contract: "text",
-    state_transition_contract: "text",
-    observable_result_contract: "text",
-    assertion_support: "text",
-    required_assertion_commands: "array",
-    invalid_implementation_shortcuts: "array",
-    implementation_paths: "array",
-    required_tests: "array",
-    related_acs: "array",
-    requirement_ref: "text",
-    decision_id: "text",
-    proof_layer_ids: "array",
-    api_schema_changes: "text",
-    state_machine: "text",
-    data_flow: "text",
-    worker_runtime_behavior: "text",
-    ui_ia_changes: "text",
-    migration_plan: "text",
-    evidence_artifacts: "array",
-    explicit_no_test_scope: "boolean",
-    non_completing_shortcuts: "array",
-    substitution_policy: "array",
-    drift_severity: "text",
-    partial_conditions: "array",
-    blockers: "array",
-    context_fact_refs: "array"
-};
-export const ACCEPTANCE_FIELD_TYPES = {
-    acceptance_scope: "enum",
-    ac_validates: "array",
-    ac_does_not_validate: "array",
-    sample_boundary: "text",
-    full_population_required: "boolean",
-    related_plan_items: "array",
-    required_proof_layers: "array",
-    assertion_command: "text",
-    assertion_artifacts: "array",
-    positive_assertions: "array",
-    negative_assertions: "array",
-    machine_blocking: "boolean",
-    invalid_completion_signals: "array",
-    assertion_result_required: "boolean",
-    ac_type: "text",
-    proof_chain: "array",
-    verification_method: "array",
-    fail_conditions: "array",
-    invalid_evidence: "array",
-    substitution_policy: "array",
-    missing_layer_downgrade: "text",
-    auditor_expectation: "text",
-    out_of_scope_na_approval_source: "text",
-    required_test_ids: "array",
-    explicit_no_test_scope: "boolean",
-    hard_blockers: "array",
-    validates_explanation: "text",
-    does_not_validate_explanation: "text",
-    final_evidence_expected: "array",
-    test_cases: "array"
-};
-export const PRODUCT_DELIVERY_SCOPES = new Set([
-    "system_capability_build", "representative_sample_validation", "full_population_operation", "mixed_scope_requires_boundary"
-]);
-export const PLAN_DELIVERY_SCOPES = new Set([
-    "system_capability_build", "representative_sample_validation", "full_population_operation", "out_of_scope_backlog"
-]);
-export const ACCEPTANCE_SCOPES = new Set([
-    "system_capability_build", "representative_sample_validation", "full_population_operation", "full_population_not_required"
-]);
-export const SCOPE_FIT_DECISIONS = new Set(["fit_for_three_inputs", "selected_from_split", "blocked_for_decision"]);
-export const CANONICAL_PROOF_LAYERS = [
-    "code",
-    "api_schema",
-    "worker_runtime",
-    "data_artifact",
-    "integration",
-    "ui_browser",
-    "security_redaction",
-    "all_provider_all_runner",
-    "cleanup_stale_scan",
-    "test"
-];
-export const LEGACY_PROOF_LAYER_ALIASES = {
-    runtime: "worker_runtime",
-    browser: "ui_browser",
-    api: "api_schema",
-    data: "data_artifact",
-    security: "security_redaction"
-};
-export const MACHINE_VERIFIABLE_LAYER_NAMES = new Set(CANONICAL_PROOF_LAYERS.filter((layer) => layer !== "code"));
-export function fieldSet(fields) {
-    return new Set(fields);
-}
-export function normalizeProofLayerName(layer) {
-    const normalized = layer.trim().toLowerCase().replace(/[- ]+/g, "_");
-    return LEGACY_PROOF_LAYER_ALIASES[normalized] ?? normalized;
-}
-export function normalizeProofLayerId(layerId) {
-    const value = layerId.trim();
-    if (!value.includes(".")) {
-        return normalizeProofLayerName(value);
-    }
-    const acId = value.slice(0, value.lastIndexOf("."));
-    const layer = value.slice(value.lastIndexOf(".") + 1);
-    return `${acId}.${normalizeProofLayerName(layer)}`;
-}
-export function isSelectedScopeFitSlice(value) {
-    return value === "none" || /^SFC-\d{3,}$/i.test(value);
-}

package/dist/lib/superpowers-task-final-card.d.ts

@@ -1,3 +0,0 @@
-import { type CompletionOutputContract } from "./superpowers-task-completion-output.js";
-import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export declare function renderFinalCard(contract: CompletionOutputContract, state: SuperpowersTaskState): string;

package/dist/lib/superpowers-task-final-card.js

@@ -1,24 +0,0 @@
-export function renderFinalCard(contract, state) {
-    const reasons = contract.completion_output_status === "blocked" ? contract.blocked_reasons : contract.rejection_reasons;
-    const reasonBlock = reasons.length > 0 ? reasons.map((reason) => `- ${reason}`).join("\n") : "- none";
-    const gate = contract.completion_output_status === "accept" ? "Final answer: accept" : `Final answer: ${contract.completion_output_status}`;
-    const auditLine = contract.completion_output_status === "accept"
-        ? "Final-gate accepted the current attempt."
-        : "Audit workflow completed; acceptance target not complete.";
-    return `# Final Card
-
-completion_output_status: ${contract.completion_output_status}
-${gate}
-required_user_visible_status: ${contract.required_user_visible_status}
-final_answer_allowed: ${contract.final_answer_allowed}
-exit_code: ${contract.exit_code}
-product_goal_complete: ${contract.product_goal_complete}
-acceptance_target_status: ${contract.acceptance_target_status}
-audit_task_complete: ${state.final.audit_task_complete}
-
-${auditLine}
-
-Reasons:
-${reasonBlock}
-`;
-}

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

@@ -1,12 +0,0 @@
-import { type CompletionOutputContract } from "./superpowers-task-completion-output.js";
-export declare function runSliceGate(workdir: string, sliceId: string): Promise<{
-    passed: boolean;
-    messages: string[];
-}>;
-export declare function runEpochGate(workdir: string, epochId: string): Promise<{
-    passed: boolean;
-    messages: string[];
-}>;
-export declare function runFinalGate(workdir: string): Promise<CompletionOutputContract & {
-    errors: string[];
-}>;

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

@@ -1,155 +0,0 @@
-import { appendSuperpowersEvent } from "./superpowers-task-events.js";
-import { deriveSuperpowersArtifacts } from "./superpowers-task-derive.js";
-import { validatePlanAcceptance } from "./plan-acceptance-validator.js";
-import { loadSuperpowersState, saveSuperpowersState } from "./superpowers-task-state.js";
-import { applyCompletionOutputContract, completionPhraseFindingMessages, resolveCompletionOutputStatus, scanGeneratedCompletionOutputSurfaces } from "./superpowers-task-completion-output.js";
-import { applyTrustedEvidenceKernelResult, evaluateTrustedEvidenceKernel } from "./superpowers-task-evidence-kernel.js";
-import { isRecord } from "./superpowers-task-state-schema.js";
-import { validateSuperpowersState } from "./superpowers-task-validator.js";
-export async function runSliceGate(workdir, sliceId) {
-    const state = await loadSuperpowersState(workdir);
-    const slice = state.slices.find((item) => item.slice_id === sliceId);
-    const messages = [];
-    if (!slice) {
-        messages.push(`slice not found: ${sliceId}`);
-    }
-    else if (!slice.progress_value?.type || slice.progress_value.closed_items.length === 0) {
-        messages.push(`slice ${sliceId} has no progress_value`);
-    }
-    await deriveSuperpowersArtifacts(workdir);
-    await appendSuperpowersEvent(workdir, "slice_gate", { slice_id: sliceId, passed: messages.length === 0 });
-    return { passed: messages.length === 0, messages };
-}
-export async function runEpochGate(workdir, epochId) {
-    await deriveSuperpowersArtifacts(workdir);
-    await appendSuperpowersEvent(workdir, "epoch_gate", { epoch_id: epochId, passed: true });
-    return { passed: true, messages: ["epoch derived artifacts refreshed"] };
-}
-export async function runFinalGate(workdir) {
-    const state = await loadSuperpowersState(workdir);
-    const kernel = await evaluateTrustedEvidenceKernel(workdir, state);
-    applyTrustedEvidenceKernelResult(state, kernel);
-    state.gates.validator = { status: "not_run", kernel: "trusted_evidence_kernel" };
-    await saveSuperpowersState(workdir, state);
-    await deriveSuperpowersArtifacts(workdir);
-    const report = await validateSuperpowersState(workdir, [workdir]);
-    const acceptanceReport = await validatePlanAcceptance(workdir, [workdir]);
-    const latest = await loadSuperpowersState(workdir);
-    let errors = [...new Set([...kernel.errors, ...report.errors, ...acceptanceReport.errors])];
-    let complete = kernel.product_goal_complete && errors.length === 0;
-    const acceptanceStatus = complete ? "complete" : acceptanceStatusForErrors(errors, kernel);
-    const nextRequiredActions = complete ? [] : nextActionsForErrors(errors);
-    let contract = resolveCompletionOutputStatus({
-        final_gate_ran: true,
-        product_goal_complete: complete,
-        acceptance_target_status: acceptanceStatus,
-        audit_task_complete: true,
-        validator_errors: report.errors,
-        acceptance_validator_errors: acceptanceReport.errors,
-        rejection_reasons: complete ? [] : nextRequiredActions
-    });
-    applyCompletionOutputContract(latest, contract);
-    latest.final.completion_basis = complete
-        ? ["trusted_evidence_kernel", "current_attempt_evidence", "negative_evidence_scan_passed", "harness_drift_lock_passed"]
-        : [];
-    latest.final.next_required_actions = nextRequiredActions;
-    latest.gates.validator = { status: errors.length === 0 ? "pass" : "blocked", errors };
-    latest.gates.final_gate = {
-        status: complete ? "pass" : acceptanceStatus,
-        kernel: "trusted_evidence_kernel",
-        order: kernel.kernel_order,
-        errors,
-        stale_evidence_ids: kernel.stale_evidence_ids,
-        ignored_unregistered_evidence: kernel.ignored_unregistered_evidence,
-        invalidated_evidence_ids: kernel.invalidated_evidence_ids,
-        ac_findings: kernel.ac_findings,
-        pi_findings: kernel.pi_findings,
-        harness_task_final_verdict: kernel.harness_task_final_verdict,
-        next_required_actions: nextRequiredActions,
-        completion_output_status: contract.completion_output_status,
-        final_answer_allowed: contract.final_answer_allowed,
-        required_user_visible_status: contract.required_user_visible_status,
-        exit_code: contract.exit_code,
-        blocked_reasons: contract.blocked_reasons,
-        rejection_reasons: contract.rejection_reasons,
-        generated_output_mismatch: contract.generated_output_mismatch
-    };
-    await saveSuperpowersState(workdir, latest);
-    await deriveSuperpowersArtifacts(workdir);
-    const outputFindings = await scanGeneratedCompletionOutputSurfaces(workdir, contract);
-    if (outputFindings.length > 0) {
-        errors = [...new Set([...errors, ...completionPhraseFindingMessages(outputFindings)])];
-        complete = false;
-        contract = resolveCompletionOutputStatus({
-            final_gate_ran: true,
-            product_goal_complete: false,
-            acceptance_target_status: acceptanceStatusForErrors(errors, kernel),
-            audit_task_complete: true,
-            validator_errors: errors,
-            generated_output_mismatch: true
-        });
-        const blockedLatest = await loadSuperpowersState(workdir);
-        applyCompletionOutputContract(blockedLatest, contract);
-        blockedLatest.final.completion_basis = [];
-        blockedLatest.final.next_required_actions = nextActionsForErrors(errors);
-        blockedLatest.gates.validator = { status: "blocked", errors };
-        blockedLatest.gates.final_gate = {
-            ...(isRecord(blockedLatest.gates.final_gate) ? blockedLatest.gates.final_gate : {}),
-            status: contract.completion_output_status,
-            errors,
-            next_required_actions: blockedLatest.final.next_required_actions,
-            completion_output_status: contract.completion_output_status,
-            final_answer_allowed: contract.final_answer_allowed,
-            required_user_visible_status: contract.required_user_visible_status,
-            exit_code: contract.exit_code,
-            blocked_reasons: contract.blocked_reasons,
-            rejection_reasons: contract.rejection_reasons,
-            generated_output_mismatch: contract.generated_output_mismatch,
-            false_completion_phrase_findings: outputFindings
-        };
-        blockedLatest.final.false_completion_phrase_findings = outputFindings;
-        await saveSuperpowersState(workdir, blockedLatest);
-        await deriveSuperpowersArtifacts(workdir);
-    }
-    await appendSuperpowersEvent(workdir, "final_gate", {
-        product_goal_complete: contract.product_goal_complete,
-        completion_output_status: contract.completion_output_status
-    });
-    return { ...contract, errors };
-}
-function acceptanceStatusForErrors(errors, kernel) {
-    const text = errors.join("\n");
-    if (kernel?.acceptance_target_status === "under_specified" || /under_specified/i.test(text)) {
-        return "under_specified";
-    }
-    if (/source hash mismatch|source_changed_requires_recompile|scope_conflict_requires_decision|auditor blocker|Context Delta coverage is unresolved|harness_drift|protected_baseline|harness_task_missing|required_command_specs_hash/i.test(text)) {
-        return "blocked";
-    }
-    if (/invalid evidence|forbidden shortcut|negative evidence|stale evidence|raw secret|contains_secret|sibling substitution|assertion_result\.status=failed|assertion exit_code=|command_exit_code=|forbidden text|current contradiction|workflow_gate_bug_prevented|playwright_last_run_failed|owner_dom_forbidden_state|failed_test_result_artifact/i.test(text)) {
-        return "invalidated";
-    }
-    return "partial";
-}
-function nextActionsForErrors(errors) {
-    return errors.slice(0, 12).map((error) => {
-        if (/source hash mismatch/i.test(error)) {
-            return `${error}; rerun ty-context composite-long-task compile <workdir> after approving source changes`;
-        }
-        if (/scope_conflict_requires_decision/i.test(error)) {
-            return `${error}; clarify Product / Plan / Checklist delivery scope before more implementation`;
-        }
-        if (/missing assertion result|not machine-backed/i.test(error)) {
-            return `${error}; add assertion_result evidence for the target AC/proof layer`;
-        }
-        if (/negative evidence|forbidden/i.test(error)) {
-            return `${error}; rerun the negative evidence scan and fix the contradictory owner-surface state`;
-        }
-        if (/current contradiction|playwright_last_run_failed|owner_dom_forbidden_state|failed_test_result_artifact/i.test(error)) {
-            return `${error}; rerun the required current assertion command after fixing the current failure`;
-        }
-        if (/derived\/.*does not match/i.test(error)) {
-            return `${error}; rerun ty-context composite-long-task derive <workdir>`;
-        }
-        return error;
-    });
-}

package/dist/lib/superpowers-task-harness-drift.d.ts

@@ -1,11 +0,0 @@
-import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export interface HarnessDriftResult {
-    harness_drift_detected: boolean;
-    acceptance_target_status: "complete" | "partial" | "blocked";
-    product_goal_complete: boolean;
-    harness_task_final_verdict?: "passed" | "failed";
-    changed_files: string[];
-    errors: string[];
-}
-export declare function detectHarnessDrift(state: SuperpowersTaskState): HarnessDriftResult;
-export declare function isHarnessPath(file: string): boolean;

package/dist/lib/superpowers-task-harness-drift.js

@@ -1,90 +0,0 @@
-import { isRecord } from "./superpowers-task-state-schema.js";
-const HARNESS_PATH_PATTERNS = [
-    /(^|\/)tests\/.*\.(spec|test)\.[cm]?[jt]sx?$/i,
-    /(^|\/)playwright\.config\./i,
-    /(^|\/).*\.spec\.[cm]?[jt]sx?$/i,
-    /(^|\/).*\.test\.[cm]?[jt]sx?$/i,
-    /(^|\/)tests\/ty-context\/fixtures\/composite-long-task\//i,
-    /superpowers-task-(assertions|evidence|evidence-kernel|current-evidence|command-specs|command-run-correlation|unregistered-evidence|completion-output|final-card|ac010|gates|validator|derive|state|state-schema|state-shape|under-specified|protected-baseline|harness-drift)\.ts$/i,
-    /(^|\/)(\.codex\/ty-context-managed|packages\/ty-context\/assets)\/skills\/composite-long-task-workflow\//i,
-    /composite-long-task-workflow-protocol\.md$/i,
-    /(^|\/)Makefile$/i,
-    /(^|\/)package\.json$/i
-];
-const REQUIRED_NEGATIVE_FIXTURES = [
-    "stale_evidence",
-    "historical_complete",
-    "derived_contradiction",
-    "ac010_summary_only",
-    "target_mismatch",
-    "api_only_for_ui",
-    "negative_evidence_after_pass",
-    "source_hash_mismatch",
-    "dirty_worktree_mismatch",
-    "missing_assertion_result",
-    "test_weakening"
-];
-export function detectHarnessDrift(state) {
-    const attempt = currentAttempt(state);
-    const changedFiles = changedFilesFor(attempt);
-    const harnessFiles = changedFiles.filter(isHarnessPath);
-    const mode = attempt?.mode ?? "product_task";
-    if (mode === "product_task" && harnessFiles.length > 0) {
-        return {
-            harness_drift_detected: true,
-            acceptance_target_status: "blocked",
-            product_goal_complete: false,
-            changed_files: harnessFiles,
-            errors: [
-                `harness_drift_detected: ${harnessFiles.join(", ")}`,
-                "本轮修改了验收工具链或测试本身，不能用被修改后的验收证明同一轮产品完成。请拆成独立 harness_task。"
-            ]
-        };
-    }
-    if (mode === "harness_task") {
-        return harnessTaskFixtureVerdict(state, changedFiles);
-    }
-    return { harness_drift_detected: false, acceptance_target_status: "complete", product_goal_complete: true, changed_files: [], errors: [] };
-}
-export function isHarnessPath(file) {
-    const normalized = file.replace(/\\/g, "/");
-    return HARNESS_PATH_PATTERNS.some((pattern) => pattern.test(normalized));
-}
-function harnessTaskFixtureVerdict(state, changedFiles) {
-    const fixtureState = isRecord(state.gates?.harness_task_fixtures) ? state.gates.harness_task_fixtures : undefined;
-    const errors = [];
-    if (!fixtureState) {
-        errors.push("harness_task_missing_adversarial_fixtures: harness_task must declare adversarial fixture outcomes");
-    }
-    else {
-        for (const fixture of REQUIRED_NEGATIVE_FIXTURES) {
-            if (fixtureState[fixture] !== false) {
-                errors.push(`harness_task_missing_adversarial_fixtures: ${fixture} must have expected product_goal_complete=false`);
-            }
-        }
-        if (fixtureState.happy_path !== true) {
-            errors.push("harness_task_missing_happy_path_fixture: happy_path must have expected product_goal_complete=true");
-        }
-    }
-    const fixtureChanges = changedFiles.filter((file) => /(^|\/)tests\/ty-context\/.*fixture/i.test(file.replace(/\\/g, "/")));
-    if (fixtureChanges.length > 0) {
-        errors.push(`fixture_changed_requires_review: ${fixtureChanges.join(", ")}`);
-    }
-    return {
-        harness_drift_detected: false,
-        acceptance_target_status: errors.length > 0 ? "blocked" : "complete",
-        product_goal_complete: false,
-        harness_task_final_verdict: errors.length > 0 ? "failed" : "passed",
-        changed_files: changedFiles,
-        errors
-    };
-}
-function currentAttempt(state) {
-    if (!state.current_attempt_id) {
-        return undefined;
-    }
-    return (state.attempts ?? []).find((item) => item.task_attempt_id === state.current_attempt_id);
-}
-function changedFilesFor(attempt) {
-    return [...new Set((attempt?.changed_files ?? []).map((file) => file.replace(/\\/g, "/")).filter(Boolean))];
-}

package/dist/lib/superpowers-task-next-slices.d.ts

@@ -1 +0,0 @@
-export declare function nextSuperpowersSlices(workdir: string, limit?: number): Promise<string[]>;

package/dist/lib/superpowers-task-next-slices.js

@@ -1,12 +0,0 @@
-import { loadSuperpowersState } from "./superpowers-task-state.js";
-export async function nextSuperpowersSlices(workdir, limit = 5) {
-    const state = await loadSuperpowersState(workdir);
-    return Object.entries(state.graph.proof_layers)
-        .filter(([, layer]) => layer.required && layer.status !== "satisfied")
-        .slice(0, limit)
-        .map(([layerId], index) => {
-        const acId = layerId.split(".")[0];
-        const planId = Object.entries(state.graph.plan_items).find(([, item]) => item.related_acs.includes(acId))?.[0] ?? "PI";
-        return `${index + 1}. ${planId}/${acId}: close ${layerId}`;
-    });
-}

package/dist/lib/superpowers-task-protected-baseline.d.ts

@@ -1,10 +0,0 @@
-import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export interface ProtectedBaselineResult {
-    protected_baseline_changed: boolean;
-    product_goal_complete: boolean;
-    changed_files: string[];
-    errors: string[];
-}
-export declare const PROTECTED_BASELINE_PATHS: string[];
-export declare function evaluateProtectedBaseline(state: SuperpowersTaskState): ProtectedBaselineResult;
-export declare function isProtectedBaselinePath(file: string): boolean;