project-tiny-context-harness 0.2.85 → 0.6.1

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,35 +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 triage = contract.blocker_triage;
-    const triageBlock = triage
-        ? `blocker_triage_category: ${triage.category}
-blocker_triage_self_recoverable: ${triage.self_recoverable}
-blocker_triage_recovery_attempted: ${triage.recovery_attempted}
-blocker_triage_next_action: ${triage.next_action}`
-        : `blocker_triage_category: none
-blocker_triage_self_recoverable: false
-blocker_triage_recovery_attempted: false
-blocker_triage_next_action: no blocker remains`;
-    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}
-${triageBlock}
-
-${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,267 +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, scanGeneratedCompletionOutputSurfacesDetailed, triageFinalGateBlockers } 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) {
-    return runFinalGateOnce(workdir, { recoveryAttempted: false, recoveryAction: "" });
-}
-async function runFinalGateOnce(workdir, options) {
-    const state = await loadSuperpowersState(workdir);
-    const previousTransientFindings = previousTransientBookkeepingFindings(state);
-    const kernel = await evaluateTrustedEvidenceKernel(workdir, state);
-    applyTrustedEvidenceKernelResult(state, kernel);
-    state.gates.validator = { status: "not_run", kernel: "trusted_evidence_kernel" };
-    const candidateContract = resolveCompletionOutputStatus({
-        final_gate_ran: true,
-        product_goal_complete: kernel.product_goal_complete && kernel.errors.length === 0,
-        acceptance_target_status: kernel.product_goal_complete && kernel.errors.length === 0 ? "complete" : kernel.acceptance_target_status,
-        audit_task_complete: true,
-        validator_errors: kernel.errors,
-        rejection_reasons: kernel.product_goal_complete ? [] : kernel.errors.slice(0, 12)
-    });
-    const candidateState = candidateStateFromContract(candidateContract);
-    candidateContract.candidate_state = candidateState;
-    applyCompletionOutputContract(state, candidateContract);
-    state.final.completion_basis = candidateContract.product_goal_complete
-        ? ["trusted_evidence_kernel", "current_attempt_evidence", "negative_evidence_scan_passed", "harness_drift_lock_passed"]
-        : [];
-    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
-    });
-    contract.candidate_state = candidateState;
-    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,
-        candidate_state: candidateState,
-        previous_bookkeeping_snapshot: previousTransientFindings
-    };
-    await saveSuperpowersState(workdir, latest);
-    await deriveSuperpowersArtifacts(workdir);
-    const outputFindings = await scanGeneratedCompletionOutputSurfacesDetailed(workdir, contract);
-    let triage = triageFinalGateBlockers({
-        errors,
-        output_findings: outputFindings,
-        previous_transient_findings: previousTransientFindings,
-        candidate_state: candidateState,
-        recovery_attempted: options.recoveryAttempted || previousTransientFindings.length > 0,
-        recovery_action: options.recoveryAction || (previousTransientFindings.length > 0 ? "cleared previous transient bookkeeping" : "")
-    });
-    if (outputFindings.length > 0 && triage.self_recoverable && !options.recoveryAttempted) {
-        await deriveSuperpowersArtifacts(workdir);
-        return runFinalGateOnce(workdir, { recoveryAttempted: true, recoveryAction: "regenerated_derived_outputs" });
-    }
-    if (outputFindings.length > 0) {
-        errors = [...new Set([...errors, ...completionPhraseFindingMessages(outputFindings)])];
-        complete = false;
-        triage = triageFinalGateBlockers({
-            errors,
-            output_findings: outputFindings,
-            previous_transient_findings: previousTransientFindings,
-            candidate_state: candidateState,
-            recovery_attempted: options.recoveryAttempted,
-            recovery_action: options.recoveryAction
-        });
-        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
-        });
-        contract.candidate_state = candidateState;
-        contract.blocker_triage = triage;
-        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,
-            candidate_state: candidateState,
-            blocker_triage: triage,
-            previous_bookkeeping_snapshot: previousTransientFindings
-        };
-        blockedLatest.final.false_completion_phrase_findings = outputFindings;
-        await saveSuperpowersState(workdir, blockedLatest);
-        await deriveSuperpowersArtifacts(workdir);
-    }
-    else {
-        if (triage.category === "environment_blocked" || triage.category === "contract_blocked" || triage.category === "harness_drift_blocked") {
-            contract = resolveCompletionOutputStatus({
-                final_gate_ran: true,
-                product_goal_complete: false,
-                acceptance_target_status: "blocked",
-                audit_task_complete: true,
-                validator_errors: errors,
-                blocked_reasons: [triage.category],
-                rejection_reasons: []
-            });
-            contract.candidate_state = candidateState;
-        }
-        contract.blocker_triage = triage;
-        const triagedLatest = await loadSuperpowersState(workdir);
-        applyCompletionOutputContract(triagedLatest, contract);
-        triagedLatest.final.next_required_actions = contract.completion_output_status === "accept" ? [] : nextActionsForErrors(errors);
-        triagedLatest.gates.final_gate = {
-            ...(isRecord(triagedLatest.gates.final_gate) ? triagedLatest.gates.final_gate : {}),
-            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,
-            candidate_state: candidateState,
-            blocker_triage: triage,
-            previous_bookkeeping_snapshot: previousTransientFindings
-        };
-        await saveSuperpowersState(workdir, triagedLatest);
-        await deriveSuperpowersArtifacts(workdir);
-    }
-    await appendSuperpowersEvent(workdir, "final_gate", {
-        product_goal_complete: contract.product_goal_complete,
-        completion_output_status: contract.completion_output_status,
-        blocker_triage: contract.blocker_triage
-    });
-    return { ...contract, blocker_triage: contract.blocker_triage ?? triage, 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;
-    });
-}
-function candidateStateFromContract(contract) {
-    return {
-        final_gate_ran: contract.final_gate_ran,
-        product_goal_complete: contract.product_goal_complete,
-        acceptance_target_status: contract.acceptance_target_status,
-        completion_output_status: contract.completion_output_status,
-        generated_output_mismatch: false,
-        source: "trusted_evidence_kernel"
-    };
-}
-function previousTransientBookkeepingFindings(state) {
-    const findings = [];
-    const finalRecord = state.final;
-    const metaRecord = state.meta;
-    const gate = isRecord(state.gates?.final_gate) ? state.gates.final_gate : {};
-    collectTransient(findings, "final", finalRecord);
-    collectTransient(findings, "meta", metaRecord);
-    collectTransient(findings, "gates.final_gate", gate);
-    return [...new Set(findings)];
-}
-function collectTransient(findings, label, record) {
-    const status = typeof record.completion_output_status === "string" ? record.completion_output_status : "";
-    if (status === "blocked" || status === "reject") {
-        findings.push(`${label}.completion_output_status=${status}`);
-    }
-    if (record.generated_output_mismatch === true) {
-        findings.push(`${label}.generated_output_mismatch=true`);
-    }
-    if (Array.isArray(record.false_completion_phrase_findings) && record.false_completion_phrase_findings.length > 0) {
-        findings.push(`${label}.false_completion_phrase_findings=${record.false_completion_phrase_findings.length}`);
-    }
-}

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;