project-tiny-context-harness 0.2.84 → 0.6.0

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

@@ -1,382 +0,0 @@
-import path from "node:path";
-import { ensureDir, pathExists, readText, writeTextIfChanged } from "./fs.js";
-import { stableJson, loadSuperpowersState } from "./superpowers-task-state.js";
-import { evaluateProofLayerAssertions } from "./superpowers-task-assertions.js";
-import { completionOutputContractFromState } from "./superpowers-task-completion-output.js";
-import { renderFinalCard } from "./superpowers-task-final-card.js";
-export async function deriveSuperpowersArtifacts(workdir) {
-    const state = await loadSuperpowersState(workdir);
-    const derived = deriveObjects(state);
-    const contract = completionOutputContractFromState(state);
-    const derivedDir = path.join(workdir, "derived");
-    await ensureDir(derivedDir);
-    const files = [];
-    await writeDerived(files, path.join(derivedDir, "plan-conformance-matrix.json"), stableJson(derived.matrix));
-    await writeDerived(files, path.join(derivedDir, "final-acceptance-verdict.json"), stableJson(derived.verdict));
-    await writeDerived(files, path.join(derivedDir, "progress-ledger.json"), stableJson(derived.progress));
-    await writeDerived(files, path.join(derivedDir, "evidence-index.json"), stableJson(deriveEvidenceIndex(state)));
-    await writeDerived(files, path.join(derivedDir, "plan-conformance-matrix.md"), matrixMarkdown(derived.matrix));
-    await writeDerived(files, path.join(derivedDir, "final-acceptance-verdict.md"), verdictMarkdown(derived.verdict));
-    await writeDerived(files, path.join(derivedDir, "local-audit.md"), localAuditMarkdown(state, contract));
-    await writeDerived(files, path.join(derivedDir, "progress-ledger.md"), progressMarkdown(derived.progress));
-    await writeDerived(files, path.join(derivedDir, "evidence-index.md"), evidenceMarkdown(state));
-    await writeDerived(files, path.join(derivedDir, "context-alignment.md"), contextMarkdown(state));
-    await writeDerived(files, path.join(derivedDir, "final-summary.md"), finalSummaryMarkdown(state, derived.verdict, contract));
-    await writeDerived(files, path.join(derivedDir, "final-card.md"), renderFinalCard(contract, state));
-    return { matrix: derived.matrix, verdict: derived.verdict, files };
-}
-export function deriveObjects(state) {
-    const matrixRows = Object.entries(state.graph.plan_items).map(([planItemId, item]) => {
-        const relatedAcs = item.related_acs;
-        const requiredLayers = item.required_proof_layers;
-        const assertionSummary = assertionSummaryForLayers(state, requiredLayers);
-        const missingLayers = requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status !== "satisfied" || evaluateProofLayerAssertions(state, layerId).assertion_status === "failed" || evaluateProofLayerAssertions(state, layerId).assertion_status === "missing" || evaluateProofLayerAssertions(state, layerId).assertion_status === "stale");
-        const evidenceIds = evidenceForLayers(state, requiredLayers);
-        const invalidEvidence = invalidEvidenceSignals(assertionSummary);
-        return {
-            plan_item_id: planItemId,
-            plan_requirement: item.requirement,
-            acceptance_ids: relatedAcs,
-            status: missingLayers.length === 0 && requiredLayers.length > 0 ? "complete" : evidenceIds.length > 0 ? "partial" : item.status,
-            delivery_scope: item.delivery_scope,
-            capability_target: item.capability_target,
-            representative_samples: item.representative_samples,
-            full_population_boundary: item.full_population_boundary,
-            non_required_population: item.non_required_population,
-            owner_boundary: item.owner_boundary,
-            primary_capability_path: item.primary_capability_path,
-            trigger_contract: item.trigger_contract,
-            state_transition_contract: item.state_transition_contract,
-            observable_result_contract: item.observable_result_contract,
-            assertion_support: item.assertion_support,
-            required_assertion_commands: item.required_assertion_commands,
-            invalid_implementation_shortcuts: item.invalid_implementation_shortcuts,
-            blockers: item.blockers ?? [],
-            conformance_type: item.owner_surfaces.length > 0 ? "product_surface" : "implementation",
-            owner_surface: item.owner_surfaces[0] ?? "",
-            forbidden_primary_surfaces: item.forbidden_surfaces,
-            negative_surface_checks: item.forbidden_surfaces.map((surface) => `confirmed ${surface} is not the owner surface`),
-            default_visibility_required: item.owner_surfaces.length > 0,
-            real_page_evidence: evidenceText(state, evidenceIds, "browser"),
-            context_fact_refs: [],
-            expected_surfaces: item.owner_surfaces.length > 0 ? ["ui", "runtime"] : ["code"],
-            implemented_paths: item.implementation_paths,
-            missing_paths: [],
-            tests: item.required_tests,
-            runtime_evidence: evidenceText(state, evidenceIds, "runtime"),
-            artifact_evidence: evidenceText(state, evidenceIds, "artifact"),
-            required_proof_layers: requiredLayers,
-            satisfied_proof_layers: requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status === "satisfied"),
-            missing_required_layers: missingLayers,
-            assertion_status: assertionSummary.assertion_status,
-            blocking_assertion_failures: assertionSummary.blocking_assertion_failures,
-            negative_evidence_findings: assertionSummary.negative_evidence_findings,
-            invalid_evidence: invalidEvidence,
-            forbidden_shortcuts_hit: invalidEvidence.filter((item) => /forbidden shortcut|cannot satisfy/i.test(item)),
-            evidence_ids: evidenceIds,
-            scope_assessment: missingLayers.length === 0 ? "full" : "partial",
-            drift: missingLayers.length === 0 ? "no drift detected" : "missing required proof layers",
-            decision: missingLayers.length === 0 ? "accept" : "continue"
-        };
-    });
-    const verdictRows = Object.entries(state.graph.acceptance_criteria).map(([acId, ac]) => {
-        const requiredLayers = ac.required_proof_layers.map((layer) => `${acId}.${layer}`);
-        const assertionSummary = assertionSummaryForLayers(state, requiredLayers);
-        const missingLayers = requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status !== "satisfied" || evaluateProofLayerAssertions(state, layerId).assertion_status === "failed" || evaluateProofLayerAssertions(state, layerId).assertion_status === "missing" || evaluateProofLayerAssertions(state, layerId).assertion_status === "stale");
-        const evidenceIds = evidenceForLayers(state, requiredLayers);
-        const status = missingLayers.length === 0 && requiredLayers.length > 0 ? "complete" : evidenceIds.length > 0 ? "partial" : ac.status;
-        const invalidCompletionSignals = invalidEvidenceSignals(assertionSummary);
-        return {
-            ac_id: acId,
-            related_plan_item_ids: ac.related_plan_items,
-            status,
-            acceptance_scope: ac.acceptance_scope,
-            ac_validates: ac.ac_validates,
-            ac_does_not_validate: ac.ac_does_not_validate,
-            sample_boundary: ac.sample_boundary,
-            full_population_required: ac.full_population_required,
-            full_population_status: ac.full_population_required === true || ac.acceptance_scope === "full_population_operation" ? status : "not_in_scope",
-            assertion_command: ac.assertion_command ?? "",
-            assertion_artifacts: ac.assertion_artifacts ?? [],
-            positive_assertions: ac.positive_assertions ?? [],
-            negative_assertions: ac.negative_assertions ?? [],
-            machine_blocking: ac.machine_blocking ?? false,
-            invalid_completion_signals: ac.invalid_completion_signals ?? [],
-            assertion_result_required: ac.assertion_result_required ?? false,
-            required_evidence: requiredLayers,
-            required_proof_chain: requiredLayers,
-            fresh_evidence: evidenceText(state, evidenceIds),
-            missing_evidence: [],
-            missing_required_layers: missingLayers,
-            assertion_status: assertionSummary.assertion_status,
-            blocking_assertion_failures: assertionSummary.blocking_assertion_failures,
-            negative_evidence_findings: assertionSummary.negative_evidence_findings,
-            invalid_evidence_findings: invalidCompletionSignals,
-            required_next_evidence: requiredNextEvidence(missingLayers, assertionSummary),
-            contradictions: [],
-            context_fact_refs: [],
-            evidence_ids: evidenceIds,
-            drift_severity: "none",
-            sibling_substitution_used: false,
-            auditor_status: auditorStatus(state),
-            decision: status === "complete" ? "accept" : "continue"
-        };
-    });
-    const allComplete = verdictRows.length > 0 && verdictRows.every((row) => row.status === "complete");
-    const progress = {
-        ...state.progress,
-        acceptance_progress: {
-            status: allComplete ? "complete" : "partial",
-            complete_count: verdictRows.filter((row) => row.status === "complete").length,
-            required_count: verdictRows.filter((row) => row.status !== "out_of_scope_NA").length
-        },
-        engineering_implementation_progress: progressStatus(Object.values(state.graph.plan_items).map((item) => item.status)),
-        runtime_proof_progress: progressStatus(Object.values(state.graph.proof_layers).map((layer) => layer.status)),
-        proof_layer_milestones: Object.entries(state.graph.proof_layers).map(([layerId, layer]) => ({ layer_id: layerId, status: layer.status, evidence_ids: layer.evidence_ids })),
-        artifact_budget: { evidence_records: state.evidence.length, artifact_count: state.evidence.reduce((sum, item) => sum + item.artifact_paths.length, 0) },
-        workflow_overhead: { slices: state.slices.length, blockers: state.blockers.length },
-        complete_count: verdictRows.filter((row) => row.status === "complete").length,
-        partial_count: verdictRows.filter((row) => row.status === "partial").length,
-        acceptance_required_count: verdictRows.filter((row) => row.status !== "out_of_scope_NA").length,
-        missing_layer_count: verdictRows.reduce((sum, row) => sum + row.missing_required_layers.length, 0),
-        next_clusters: Object.entries(state.graph.proof_layers)
-            .filter(([, layer]) => layer.status !== "satisfied")
-            .slice(0, 5)
-            .map(([layerId]) => layerId)
-    };
-    const contract = completionOutputContractFromState(state);
-    const completionMetadata = {
-        completion_output_status: contract.completion_output_status,
-        final_answer_allowed: contract.final_answer_allowed,
-        required_user_visible_status: contract.required_user_visible_status,
-        product_goal_complete: contract.product_goal_complete,
-        acceptance_target_status: contract.acceptance_target_status,
-        audit_task_complete: contract.audit_task_complete
-    };
-    return {
-        matrix: {
-            diagnostic_scope: "plan_conformance_rows_only",
-            overall_status: allComplete ? "complete" : "partial",
-            ...completionMetadata,
-            items: matrixRows
-        },
-        verdict: {
-            diagnostic_scope: "acceptance_evidence_rows_only",
-            overall_status: allComplete ? "complete" : "partial",
-            ...completionMetadata,
-            acceptance_items: verdictRows
-        },
-        progress
-    };
-}
-function invalidEvidenceSignals(summary) {
-    return [...summary.blocking_assertion_failures, ...summary.negative_evidence_findings].filter((item) => /invalid evidence|forbidden shortcut|cannot satisfy|negative evidence|forbidden text/i.test(item));
-}
-function requiredNextEvidence(missingLayers, summary) {
-    return [...missingLayers.map((layerId) => `fresh assertion-backed evidence for ${layerId}`), ...summary.blocking_assertion_failures, ...summary.negative_evidence_findings];
-}
-function progressStatus(statuses) {
-    const complete = statuses.filter((status) => status === "complete" || status === "satisfied").length;
-    return { status: statuses.length > 0 && complete === statuses.length ? "complete" : complete > 0 ? "partial" : "not_started", complete, total: statuses.length };
-}
-export async function derivedMatchesState(workdir, state) {
-    const errors = [];
-    const expected = deriveObjects(state);
-    await assertDerivedJson(workdir, "plan-conformance-matrix", expected.matrix, errors);
-    await assertDerivedJson(workdir, "final-acceptance-verdict", expected.verdict, errors);
-    await assertDerivedJson(workdir, "evidence-index", deriveEvidenceIndex(state), errors);
-    return errors;
-}
-export function deriveEvidenceIndex(state) {
-    const evidenceById = Object.fromEntries((state.evidence ?? []).map((evidence) => [
-        evidence.evidence_id,
-        {
-            evidence_id: evidence.evidence_id,
-            schema_version: evidence.schema_version ?? "",
-            task_attempt_id: evidence.task_attempt_id ?? "",
-            source_bundle_hash: evidence.source_bundle_hash ?? "",
-            product_source_hash: evidence.product_source_hash ?? "",
-            technical_plan_hash: evidence.technical_plan_hash ?? "",
-            acceptance_checklist_hash: evidence.acceptance_checklist_hash ?? "",
-            type: evidence.type,
-            command_spec_id: evidence.command_spec_id ?? "",
-            command_run_id: evidence.command_run_id ?? "",
-            command: evidence.command ?? "",
-            command_exit_code: evidence.command_exit_code,
-            artifact_path: evidence.artifact_path ?? "",
-            artifact_sha256: evidence.artifact_sha256 ?? "",
-            artifact_mtime: evidence.artifact_mtime ?? "",
-            artifact_paths: evidence.artifact_paths,
-            target_ac_ids: evidence.target_ac_ids ?? evidence.assertion_result?.target_ac_ids ?? [],
-            target_pi_ids: evidence.target_pi_ids ?? evidence.assertion_result?.target_pi_ids ?? [],
-            target_proof_layers: evidence.target_proof_layers ?? evidence.assertion_result?.target_proof_layers ?? [],
-            proves: evidence.proves,
-            does_not_prove: evidence.does_not_prove,
-            assertion_result: evidence.assertion_result ?? null,
-            negative_evidence_scan: evidence.negative_evidence_scan ?? null,
-            freshness: evidence.freshness,
-            reviewability: evidence.reviewability,
-            redaction: evidence.redaction
-        }
-    ]));
-    const proofLayers = Object.fromEntries(Object.entries(state.graph.proof_layers ?? {}).map(([layerId, layer]) => {
-        const evaluation = evaluateProofLayerAssertions(state, layerId);
-        return [
-            layerId,
-            {
-                layer_id: layerId,
-                status: layer.status,
-                required: layer.required,
-                evidence_ids: layer.evidence_ids,
-                assertion_status: evaluation.assertion_status,
-                blocking_assertion_failures: evaluation.blocking_assertion_failures,
-                negative_evidence_findings: evaluation.negative_evidence_findings,
-                evidence: layer.evidence_ids.map((evidenceId) => evidenceById[evidenceId]).filter(Boolean)
-            }
-        ];
-    }));
-    return { proof_layers: proofLayers, evidence: evidenceById };
-}
-async function assertDerivedJson(workdir, basename, expected, errors) {
-    const file = path.join(workdir, "derived", `${basename}.json`);
-    if (!(await pathExists(file))) {
-        return;
-    }
-    const actual = JSON.parse(await readText(file));
-    if (stableJson(actual) !== stableJson(expected)) {
-        errors.push(`derived/${basename}.json does not match task-state.json; rerun ty-context composite-long-task derive`);
-    }
-}
-function evidenceForLayers(state, layerIds) {
-    return [...new Set(layerIds.flatMap((layerId) => state.graph.proof_layers[layerId]?.evidence_ids ?? []))];
-}
-function assertionSummaryForLayers(state, layerIds) {
-    const evaluations = layerIds.map((layerId) => evaluateProofLayerAssertions(state, layerId));
-    const applicable = evaluations.filter((item) => item.assertion_status !== "not_applicable");
-    const blocking_assertion_failures = applicable.flatMap((item) => item.blocking_assertion_failures);
-    const negative_evidence_findings = applicable.flatMap((item) => item.negative_evidence_findings);
-    const statuses = applicable.map((item) => item.assertion_status);
-    const assertion_status = applicable.length === 0
-        ? "not_applicable"
-        : statuses.includes("failed")
-            ? "failed"
-            : statuses.includes("stale")
-                ? "stale"
-                : statuses.includes("missing")
-                    ? "missing"
-                    : "passed";
-    return { assertion_status, blocking_assertion_failures, negative_evidence_findings };
-}
-function evidenceText(state, evidenceIds, type) {
-    return evidenceIds
-        .map((evidenceId) => state.evidence.find((item) => item.evidence_id === evidenceId))
-        .filter((item) => item && (!type || evidenceTypeMatches(item.type, type) || (type === "artifact" && item.artifact_paths.length > 0)))
-        .map((item) => {
-        const artifacts = item?.artifact_paths.join(", ");
-        return `${item?.type} ${item?.command ?? ""} ${artifacts}`.trim();
-    });
-}
-function evidenceTypeMatches(actual, expected) {
-    return actual === expected || actual.includes(expected) || (expected === "browser" && /\b(playwright|ui_browser|browser)_assertion\b/.test(actual));
-}
-function auditorStatus(state) {
-    const auditor = state.gates.auditor;
-    if (auditor && typeof auditor === "object" && !Array.isArray(auditor) && typeof auditor.auditor_status === "string") {
-        return String(auditor.auditor_status);
-    }
-    return "not_run";
-}
-async function writeDerived(files, file, content) {
-    await writeTextIfChanged(file, `${content.trimEnd()}\n`);
-    files.push(file.split(path.sep).join("/"));
-}
-function matrixMarkdown(matrix) {
-    const rows = matrix.items ?? [];
-    return ["# Plan Conformance Matrix", "", ...rows.map((row) => `- ${row.plan_item_id}: ${row.status}`)].join("\n");
-}
-function verdictMarkdown(verdict) {
-    const rows = verdict.acceptance_items ?? [];
-    const complete = rows.filter((row) => row.status === "complete").length;
-    const partial = rows.filter((row) => row.status === "partial").length;
-    const required = rows.filter((row) => row.status !== "out_of_scope_NA").length;
-    const missing = rows.reduce((sum, row) => sum + ((row.missing_required_layers ?? []).length), 0);
-    return `# Final Acceptance Verdict
-
-<!-- generated:active-counts:start -->
-complete_count: ${complete}
-partial_count: ${partial}
-acceptance_required_count: ${required}
-missing_layer_count: ${missing}
-<!-- generated:active-counts:end -->
-
-${rows.map((row) => `- ${row.ac_id}: ${row.status}`).join("\n")}
-`;
-}
-function localAuditMarkdown(state, contract) {
-    const auditLine = contract.completion_output_status === "accept"
-        ? "Final-gate accepted the current attempt."
-        : "Audit workflow completed; acceptance target not complete.";
-    return `# Local Audit
-
-audit_task_complete: ${state.final.audit_task_complete}
-acceptance_target_status: ${state.final.acceptance_target_status}
-product_goal_complete: ${state.final.product_goal_complete}
-completion_output_status: ${contract.completion_output_status}
-final_answer_allowed: ${contract.final_answer_allowed}
-
-${auditLine}
-`;
-}
-function progressMarkdown(progress) {
-    return `# Progress Ledger
-
-\`\`\`json
-${stableJson(progress)}
-\`\`\`
-`;
-}
-function evidenceMarkdown(state) {
-    const index = deriveEvidenceIndex(state);
-    const layers = Object.values(index.proof_layers);
-    return [
-        "# Evidence Index",
-        "",
-        ...layers.map((item) => {
-            const evidenceIds = item.evidence_ids ?? [];
-            return `- ${item.layer_id}: ${item.assertion_status}; evidence ${evidenceIds.join(", ") || "(none)"}`;
-        }),
-        "",
-        ...state.evidence.map((item) => `- ${item.evidence_id}: proves ${item.proves.join(", ")}; does_not_prove ${item.does_not_prove.join(", ")}`)
-    ].join("\n");
-}
-function contextMarkdown(state) {
-    return `# Context Alignment
-
-Product Context Delta: ${state.context.product_context_delta}
-Technical Context Delta: ${state.context.technical_context_delta}
-`;
-}
-function finalSummaryMarkdown(state, verdict, contract) {
-    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 auditLine = contract.completion_output_status === "accept"
-        ? "Final-gate accepted the current attempt."
-        : "Audit workflow completed; acceptance target not complete.";
-    return `# Final Summary
-
-diagnostic_overall_status: ${verdict.overall_status}
-product_goal_complete: ${contract.product_goal_complete}
-acceptance_target_status: ${contract.acceptance_target_status}
-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}
-
-Final answer: ${contract.final_answer}
-
-${auditLine}
-
-Reasons:
-${reasonBlock}
-`;
-}

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

@@ -1 +0,0 @@
-export declare function appendSuperpowersEvent(workdir: string, eventType: string, payload?: Record<string, unknown>): Promise<void>;

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

@@ -1,13 +0,0 @@
-import path from "node:path";
-import { ensureDir, readText, writeTextIfChanged, pathExists } from "./fs.js";
-export async function appendSuperpowersEvent(workdir, eventType, payload = {}) {
-    const eventsPath = path.join(workdir, "events.ndjson");
-    await ensureDir(workdir);
-    const event = {
-        event_type: eventType,
-        created_at: new Date().toISOString(),
-        ...payload
-    };
-    const previous = (await pathExists(eventsPath)) ? await readText(eventsPath) : "";
-    await writeTextIfChanged(eventsPath, `${previous}${JSON.stringify(event)}\n`);
-}

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

@@ -1,19 +0,0 @@
-import { type IgnoredUnregisteredEvidence } from "./superpowers-task-unregistered-evidence.js";
-import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
-export interface TrustedEvidenceKernelResult {
-    product_goal_complete: boolean;
-    acceptance_target_status: "complete" | "partial" | "blocked" | "invalidated" | "under_specified";
-    errors: string[];
-    ac_statuses: Record<string, string>;
-    pi_statuses: Record<string, string>;
-    stale_evidence_ids: string[];
-    ignored_unregistered_evidence: IgnoredUnregisteredEvidence[];
-    invalidated_evidence_ids: string[];
-    kernel_order: string[];
-    ac_findings: Record<string, string[]>;
-    pi_findings: Record<string, string[]>;
-    harness_task_final_verdict?: "passed" | "failed";
-}
-export declare const TRUSTED_EVIDENCE_KERNEL_ORDER: readonly ["load_three_inputs", "recompute_source_hashes", "load_task_state", "resolve_current_attempt", "load_required_command_specs", "load_command_run_records", "load_registered_evidence_records", "discard_stale_evidence", "scan_unregistered_assertion_json", "scan_contradictions", "run_ac010_bootstrap_prevention", "run_under_specified_ac_checks", "run_harness_drift_lock", "run_protected_baseline_guard", "validate_scope_conflicts", "recompute_every_ac", "recompute_every_pi", "recompute_acceptance_target_status", "recompute_product_goal_complete", "regenerate_derived", "append_final_gate_event"];
-export declare function evaluateTrustedEvidenceKernel(workdir: string, providedState?: SuperpowersTaskState): Promise<TrustedEvidenceKernelResult>;
-export declare function applyTrustedEvidenceKernelResult(state: SuperpowersTaskState, result: TrustedEvidenceKernelResult): void;