project-tiny-context-harness 0.2.85 → 0.6.0

package/dist/lib/superpowers-task-compile-guards.d.ts

@@ -1,2 +0,0 @@
-import { type SuperpowersAcceptanceCriterion, type SuperpowersPlanItem, type SuperpowersProductArchitectureScope } from "./superpowers-task-state-schema.js";
-export declare function validateCompiledSources(product: SuperpowersProductArchitectureScope, planItems: Record<string, SuperpowersPlanItem>, acceptanceCriteria: Record<string, SuperpowersAcceptanceCriterion>): void;

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

@@ -1,66 +0,0 @@
-import { MACHINE_VERIFIABLE_PROOF_LAYERS } from "./superpowers-task-assertions.js";
-import { compileError, throwCompileErrors } from "./superpowers-task-compile-diagnostics.js";
-const ALLOWED_PROOF_LAYERS = new Set(["code", ...MACHINE_VERIFIABLE_PROOF_LAYERS]);
-export function validateCompiledSources(product, planItems, acceptanceCriteria) {
-    const errors = [];
-    const planIds = new Set(Object.keys(planItems));
-    const acIds = new Set(Object.keys(acceptanceCriteria));
-    for (const [planId, item] of Object.entries(planItems)) {
-        validatePlanItem(planId, item, acIds, acceptanceCriteria, errors);
-    }
-    for (const [acId, ac] of Object.entries(acceptanceCriteria)) {
-        validateAcceptanceCriterion(product, acId, ac, planIds, planItems, errors);
-    }
-    throwCompileErrors(errors);
-}
-function validatePlanItem(planId, item, acIds, acceptanceCriteria, errors) {
-    for (const acId of item.related_acs) {
-        if (!acIds.has(acId)) {
-            errors.push(compileError(`${planId} references unknown related_acs ${acId}`, "blocking_unparseable_object", item.source_file, item.source_start_line, "related_acs", "dangling plan-to-AC references make the graph ambiguous", "fix related_acs to existing AC ids"));
-        }
-    }
-    if (item.delivery_scope !== "out_of_scope_backlog" && item.implementation_paths.length === 0) {
-        errors.push(compileError(`${planId} missing implementation_paths`, "blocking_missing_primary_path", item.source_file, item.source_start_line, "implementation_paths", "plan conformance needs an implementation owner path", "add implementation_paths or mark the item out_of_scope_backlog"));
-    }
-    if (item.owner_surfaces.length > 0) {
-        const related = item.related_acs.length > 0 ? item.related_acs : Object.keys(acceptanceCriteria);
-        const hasUiLayer = related.some((acId) => acceptanceCriteria[acId]?.required_proof_layers.includes("ui_browser"));
-        if (!hasUiLayer) {
-            errors.push(compileError(`${planId} owner_surfaces requires a ui_browser proof layer`, "blocking_missing_owner_boundary", item.source_file, item.source_start_line, "owner_surfaces", "owner-surface work must have browser proof on the owner route", "add ui_browser to a related AC required_proof_layers"));
-        }
-    }
-}
-function validateAcceptanceCriterion(product, acId, ac, planIds, planItems, errors) {
-    for (const planId of ac.related_plan_items) {
-        if (!planIds.has(planId)) {
-            errors.push(compileError(`${acId} references unknown related_plan_items ${planId}`, "blocking_unparseable_object", ac.source_file, ac.source_start_line, "related_plan_items", "dangling AC-to-plan references make the graph ambiguous", "fix related_plan_items to existing PI ids"));
-        }
-    }
-    for (const layer of ac.required_proof_layers) {
-        if (!ALLOWED_PROOF_LAYERS.has(layer)) {
-            errors.push(compileError(`${acId} has invalid required_proof_layers ${layer}`, "blocking_unparseable_object", ac.source_file, ac.source_start_line, "required_proof_layers", "unknown proof layers cannot be evaluated", "use code or a supported machine-verifiable proof layer"));
-        }
-    }
-    if (ac.ac_validates.length === 0) {
-        errors.push(compileError(`${acId} missing observable acceptance result`, "blocking_missing_observable_result", ac.source_file, ac.source_start_line, "ac_validates", "ACs need an observable result before evidence can prove completion", "add concrete ac_validates outcomes"));
-    }
-    const machineRequirements = (ac.assertion_requirements ?? []).filter((item) => item.machine_blocking);
-    if (machineRequirements.some((item) => item.positive_assertions.length === 0)) {
-        errors.push(compileError(`${acId} machine-verifiable proof layer lacks positive assertion requirements`, "blocking_missing_assertion_spec", ac.source_file, ac.source_start_line, "assertion_requirements", "machine-verifiable ACs need observable positive assertions", "add ac_validates, required_test_ids, test_cases or final_evidence_expected"));
-    }
-    if (machineRequirements.some((item) => item.negative_assertions.length === 0)) {
-        errors.push(compileError(`${acId} machine-verifiable proof layer lacks negative assertion requirements`, "blocking_missing_invalid_evidence", ac.source_file, ac.source_start_line, "invalid_evidence", "negative assertions prevent forbidden completion shortcuts", "add ac_does_not_validate, fail_conditions or invalid_evidence"));
-    }
-    const relatedPlans = ac.related_plan_items.map((planId) => planItems[planId]).filter(Boolean);
-    if (ac.full_population_required === true && relatedPlans.length > 0 && relatedPlans.every((item) => item.delivery_scope === "representative_sample_validation")) {
-        errors.push(compileError(`${acId} full-population AC is backed only by representative sample plan items`, "blocking_scope_conflict", ac.source_file, ac.source_start_line, "full_population_required", "sample-only plan items cannot prove full-population acceptance", "add a full_population_operation plan item or change the AC boundary"));
-    }
-    const productNonCompleting = product.representative_samples_do_not_validate.join("\n");
-    if (productNonCompleting && !containsAny(ac.ac_does_not_validate, product.representative_samples_do_not_validate)) {
-        errors.push(compileError(`${acId} does not represent Product non-completing outcomes`, "blocking_missing_invalid_evidence", ac.source_file, ac.source_start_line, "ac_does_not_validate", "Product non-completing outcomes must remain visible in AC invalid evidence", "add matching ac_does_not_validate or invalid_evidence entries"));
-    }
-}
-function containsAny(values, needles) {
-    const text = values.join("\n").toLowerCase();
-    return needles.some((needle) => text.includes(needle.toLowerCase()));
-}

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

@@ -1,6 +0,0 @@
-import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-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

@@ -1,133 +0,0 @@
-import path from "node:path";
-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, options = {}) {
-    const state = await loadSuperpowersState(workdir);
-    await refreshSourceHashes(workdir, state);
-    await assertRequiredSourcesExist(workdir, state);
-    const productSource = await readText(path.join(workdir, state.sources.product_architecture_source.path));
-    const technicalPlan = await readText(path.join(workdir, state.sources.technical_realization_plan.path));
-    const checklist = await readText(path.join(workdir, state.sources.acceptance_checklist.path));
-    state.delivery = {
-        product_architecture_scope: parseProductArchitectureScope(productSource, state.sources.product_architecture_source.path),
-        scope_conflicts: []
-    };
-    const planItems = parsePlanItems(technicalPlan, state.sources.technical_realization_plan.path);
-    const acceptanceCriteria = parseAcceptanceCriteria(checklist, state.sources.acceptance_checklist.path);
-    validateCompiledSources(state.delivery.product_architecture_scope, planItems, acceptanceCriteria);
-    const acIds = Object.keys(acceptanceCriteria);
-    for (const [planId, item] of Object.entries(planItems)) {
-        if (item.related_acs.length === 0) {
-            item.related_acs = acIds;
-        }
-        item.required_proof_layers = item.related_acs.flatMap((acId) => (acceptanceCriteria[acId]?.required_proof_layers ?? DEFAULT_LAYERS).map((layer) => `${acId}.${layer}`));
-    }
-    for (const [acId, ac] of Object.entries(acceptanceCriteria)) {
-        if (ac.related_plan_items.length === 0) {
-            ac.related_plan_items = Object.keys(planItems);
-        }
-    }
-    state.graph.plan_items = planItems;
-    state.graph.acceptance_criteria = acceptanceCriteria;
-    state.graph.proof_layers = {};
-    for (const [acId, ac] of Object.entries(acceptanceCriteria)) {
-        for (const layer of ac.required_proof_layers) {
-            state.graph.proof_layers[`${acId}.${layer}`] = { required: true, status: "missing", evidence_ids: [] };
-        }
-    }
-    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,
-        acceptance_criteria: Object.keys(acceptanceCriteria).length
-    });
-    return state;
-}
-async function assertRequiredSourcesExist(workdir, state) {
-    const errors = [];
-    const checks = [
-        ["product_architecture_source", "blocking_missing_source", "Product / Architecture Source"],
-        ["technical_realization_plan", "blocking_missing_plan", "Technical Realization Plan"],
-        ["acceptance_checklist", "blocking_missing_checklist", "Acceptance Checklist"]
-    ];
-    for (const [key, category, label] of checks) {
-        const source = state.sources[key];
-        const file = source?.path ?? `${key}.md`;
-        if (!source || !(await pathExists(path.join(workdir, file)))) {
-            errors.push(compileError(`${label} input is missing: ${file}`, category, file, 1, key, "all three authority inputs are required", "restore the missing source file and rerun compile"));
-        }
-    }
-    throwCompileErrors(errors);
-}
-export function computeScopeConflicts(state) {
-    const conflicts = [];
-    const product = state.delivery?.product_architecture_scope;
-    const productScope = product?.delivery_scope ?? "";
-    const productRequiresFullPopulation = productScope === "full_population_operation";
-    const productIsCapabilityOnly = productScope === "system_capability_build" ||
-        productScope === "representative_sample_validation" ||
-        product?.full_population_required === false;
-    for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
-        if (productRequiresFullPopulation && item.delivery_scope !== "full_population_operation" && item.delivery_scope !== "out_of_scope_backlog") {
-            conflicts.push(`scope_conflict_requires_decision: Product / Architecture Source requires full_population_operation but ${planId} delivery_scope=${item.delivery_scope || "missing"}${compileReportSuffix("blocking_scope_conflict", item.source_file, item.source_start_line, "delivery_scope", "Product source and plan delivery scopes disagree", "align the source, plan and checklist delivery scope")}`);
-        }
-        if (productIsCapabilityOnly && item.delivery_scope === "full_population_operation" && productScope !== "mixed_scope_requires_boundary") {
-            conflicts.push(`scope_conflict_requires_decision: Product / Architecture Source delivery_scope=${productScope || "missing"} but ${planId} delivery_scope=full_population_operation${compileReportSuffix("blocking_scope_conflict", item.source_file, item.source_start_line, "delivery_scope", "Product source and plan delivery scopes disagree", "align the source, plan and checklist delivery scope")}`);
-        }
-    }
-    for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
-        if (productRequiresFullPopulation && (ac.acceptance_scope === "full_population_not_required" || ac.full_population_required === false)) {
-            conflicts.push(`scope_conflict_requires_decision: Product / Architecture Source requires full_population_operation but ${acId} full_population_required=false${compileReportSuffix("blocking_scope_conflict", ac.source_file, ac.source_start_line, "full_population_required", "Product source and checklist full-population requirements disagree", "align the source, plan and checklist delivery scope")}`);
-        }
-        if (productIsCapabilityOnly && (ac.acceptance_scope === "full_population_operation" || ac.full_population_required === true) && productScope !== "mixed_scope_requires_boundary") {
-            conflicts.push(`scope_conflict_requires_decision: Product / Architecture Source delivery_scope=${productScope || "missing"} but ${acId} acceptance_scope=full_population_operation${compileReportSuffix("blocking_scope_conflict", ac.source_file, ac.source_start_line, "acceptance_scope", "Product source and checklist delivery scopes disagree", "align the source, plan and checklist delivery scope")}`);
-        }
-    }
-    return [...new Set(conflicts)];
-}
-function compileProgress(state) {
-    const planEntries = Object.entries(state.graph.plan_items);
-    const sampleNames = unique([
-        ...state.delivery.product_architecture_scope.representative_samples_validate,
-        ...planEntries.flatMap(([, item]) => item.representative_samples)
-    ]);
-    const systemPlanIds = planEntries.filter(([, item]) => item.delivery_scope === "system_capability_build").map(([planId]) => planId);
-    const representativePlanIds = planEntries.filter(([, item]) => item.delivery_scope === "representative_sample_validation").map(([planId]) => planId);
-    const fullPopulationRequired = state.delivery.product_architecture_scope.delivery_scope === "full_population_operation" ||
-        state.delivery.product_architecture_scope.full_population_required === true ||
-        Object.values(state.graph.acceptance_criteria).some((ac) => ac.acceptance_scope === "full_population_operation" || ac.full_population_required === true);
-    return {
-        system_capability_progress: {
-            status: systemPlanIds.length > 0 ? "not_started" : "not_in_scope",
-            plan_items: systemPlanIds
-        },
-        representative_sample_progress: {
-            status: sampleNames.length > 0 || representativePlanIds.length > 0 ? "not_started" : "not_in_scope",
-            plan_items: representativePlanIds,
-            samples: sampleNames
-        },
-        real_object_coverage: {
-            status: sampleNames.length > 0 ? "sampled_only" : "unknown",
-            covered_objects: sampleNames
-        },
-        full_population_operation_progress: {
-            status: fullPopulationRequired ? "not_started" : "not_in_scope"
-        }
-    };
-}
-function unique(values) {
-    return [...new Set(values.filter(Boolean))];
-}

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

@@ -1,91 +0,0 @@
-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;
-    blocker_triage?: FinalGateBlockerTriage;
-    candidate_state?: FinalGateCandidateState;
-}
-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 type CompletionOutputSurfaceType = "user_visible_final_summary" | "final_card" | "agent_final_answer" | "generated_summary" | "machine_readable_json_status" | "derived_diagnostic_json" | "matrix_diagnostic" | "verdict_diagnostic" | "workflow_protocol_text" | "execution_binding_text" | "rule_explanation_text" | "local_audit_diagnostic" | "unknown";
-export type CompletionPhraseClassification = "true_false_completion_claim" | "allowed_protocol_reserved_word" | "allowed_machine_status_field" | "allowed_diagnostic_status" | "allowed_rule_explanation";
-export interface CompletionPhraseFinding {
-    surface: string;
-    surface_type?: CompletionOutputSurfaceType;
-    classification?: CompletionPhraseClassification;
-    phrase: string;
-    line: number;
-    text: string;
-    self_recoverable?: boolean;
-}
-export interface FinalGateCandidateState {
-    final_gate_ran: boolean;
-    product_goal_complete: boolean;
-    acceptance_target_status: string;
-    completion_output_status: CompletionOutputStatus;
-    generated_output_mismatch: boolean;
-    source: "trusted_evidence_kernel";
-}
-export type FinalGateBlockerCategory = "none" | "product_evidence_failed" | "missing_current_evidence" | "stale_or_contradictory_evidence" | "generated_output_mismatch" | "self_recoverable_generated_output_mismatch" | "transient_state_bookkeeping" | "environment_blocked" | "contract_blocked" | "harness_drift_blocked";
-export interface FinalGateBlockerTriage {
-    category: FinalGateBlockerCategory;
-    self_recoverable: boolean;
-    recovery_attempted: boolean;
-    recovery_action: string;
-    next_action: string;
-    details: string[];
-    blocker_count: number;
-}
-export interface FinalGateBlockerTriageInput {
-    errors: string[];
-    output_findings: CompletionPhraseFinding[];
-    previous_transient_findings?: string[];
-    candidate_state?: FinalGateCandidateState;
-    recovery_attempted?: boolean;
-    recovery_action?: 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 scanFalseCompletionPhrasesDetailed(input: {
-    completion_output_status: CompletionOutputStatus;
-    surfaces: CompletionOutputSurface[] | string;
-}): CompletionPhraseFinding[];
-export declare function scanGeneratedCompletionOutputSurfaces(workdir: string, contract: CompletionOutputContract): Promise<CompletionPhraseFinding[]>;
-export declare function scanGeneratedCompletionOutputSurfacesDetailed(workdir: string, contract: CompletionOutputContract): Promise<CompletionPhraseFinding[]>;
-export declare function completionPhraseFindingMessages(findings: CompletionPhraseFinding[]): string[];
-export declare function triageFinalGateBlockers(input: FinalGateBlockerTriageInput): FinalGateBlockerTriage;