project-tiny-context-harness 0.2.75 → 0.2.77

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

@@ -0,0 +1,223 @@
+import path from "node:path";
+import { readText } from "./fs.js";
+import { appendSuperpowersEvent } from "./superpowers-task-events.js";
+import { loadSuperpowersState, recomputeStatuses, saveSuperpowersState, refreshSourceHashes } from "./superpowers-task-state.js";
+import { asStringArray } from "./superpowers-task-state-schema.js";
+const DEFAULT_LAYERS = ["code", "test"];
+export async function compileSuperpowersTask(workdir) {
+    const state = await loadSuperpowersState(workdir);
+    await refreshSourceHashes(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),
+        scope_conflicts: []
+    };
+    const planItems = parsePlanItems(technicalPlan);
+    const acceptanceCriteria = parseAcceptanceCriteria(checklist);
+    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.delivery.scope_conflicts = computeScopeConflicts(state);
+    state.progress = compileProgress(state);
+    recomputeStatuses(state);
+    await saveSuperpowersState(workdir, state);
+    await appendSuperpowersEvent(workdir, "graph_compiled", {
+        plan_items: Object.keys(planItems).length,
+        acceptance_criteria: Object.keys(acceptanceCriteria).length
+    });
+    return state;
+}
+function parseProductArchitectureScope(content) {
+    return {
+        delivery_scope: fieldText(content, "delivery_scope"),
+        full_population_required: fieldBoolean(content, "full_population_required"),
+        representative_samples_validate: field(content, "representative_samples_validate"),
+        representative_samples_do_not_validate: field(content, "representative_samples_do_not_validate"),
+        out_of_scope_backlog: field(content, "out_of_scope_backlog")
+    };
+}
+function parsePlanItems(content) {
+    const items = {};
+    const matches = [...content.matchAll(/\b(PI-\d{3,})\b\s*[:.-]?\s*([^\n]*)/gi)];
+    for (const [index, match] of matches.entries()) {
+        const id = match[1].toUpperCase();
+        const block = blockAfter(content, match.index ?? 0, matches[index + 1]?.index);
+        items[id] = {
+            requirement: cleanText(match[2]) || firstLine(block) || id,
+            delivery_scope: fieldText(block, "delivery_scope"),
+            capability_target: fieldText(block, "capability_target"),
+            representative_samples: field(block, "representative_samples"),
+            full_population_boundary: fieldText(block, "full_population_boundary"),
+            non_required_population: field(block, "non_required_population"),
+            owner_surfaces: field(block, "owner_surfaces"),
+            forbidden_surfaces: field(block, "forbidden_surfaces"),
+            implementation_paths: field(block, "implementation_paths"),
+            required_tests: field(block, "required_tests"),
+            status: "not_started",
+            related_acs: field(block, "related_acs").map((item) => item.toUpperCase()),
+            required_proof_layers: []
+        };
+    }
+    if (Object.keys(items).length === 0) {
+        items["PI-001"] = {
+            requirement: firstLine(content) || "Implement technical realization plan",
+            delivery_scope: "",
+            capability_target: "",
+            representative_samples: [],
+            full_population_boundary: "",
+            non_required_population: [],
+            owner_surfaces: [],
+            forbidden_surfaces: [],
+            implementation_paths: [],
+            required_tests: [],
+            status: "not_started",
+            related_acs: [],
+            required_proof_layers: []
+        };
+    }
+    return items;
+}
+function parseAcceptanceCriteria(content) {
+    const items = {};
+    const matches = [...content.matchAll(/\b(AC-\d{3,})\b\s*[:.-]?\s*([^\n]*)/gi)];
+    for (const [index, match] of matches.entries()) {
+        const id = match[1].toUpperCase();
+        const block = blockAfter(content, match.index ?? 0, matches[index + 1]?.index);
+        const layers = field(block, "required_proof_layers").map(normalizeLayer).filter(Boolean);
+        items[id] = {
+            scope: cleanText(match[2]) || firstLine(block) || id,
+            acceptance_scope: fieldText(block, "acceptance_scope"),
+            ac_validates: field(block, "ac_validates"),
+            ac_does_not_validate: field(block, "ac_does_not_validate"),
+            sample_boundary: fieldText(block, "sample_boundary"),
+            full_population_required: fieldBoolean(block, "full_population_required"),
+            related_plan_items: field(block, "related_plan_items").map((item) => item.toUpperCase()),
+            required_proof_layers: layers.length > 0 ? layers : DEFAULT_LAYERS,
+            status: "not_run"
+        };
+    }
+    if (Object.keys(items).length === 0) {
+        items["AC-001"] = {
+            scope: firstLine(content) || "Acceptance checklist item",
+            acceptance_scope: "",
+            ac_validates: [],
+            ac_does_not_validate: [],
+            sample_boundary: "",
+            full_population_required: null,
+            related_plan_items: [],
+            required_proof_layers: DEFAULT_LAYERS,
+            status: "not_run"
+        };
+    }
+    return items;
+}
+export function computeScopeConflicts(state) {
+    const conflicts = [];
+    const product = state.delivery?.product_architecture_scope;
+    const productScope = product?.delivery_scope ?? "";
+    const productRequiresFullPopulation = productScope === "full_population_operation" || product?.full_population_required === true;
+    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"}`);
+        }
+        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`);
+        }
+    }
+    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`);
+        }
+        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`);
+        }
+    }
+    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 blockAfter(content, start, end) {
+    return content.slice(start, end ?? content.length);
+}
+function field(block, name) {
+    const text = fieldText(block, name);
+    return text ? asStringArray(text) : [];
+}
+function fieldText(block, name) {
+    const pattern = new RegExp(`${name}\\s*:\\s*([^\\n]+)`, "i");
+    const match = pattern.exec(block);
+    return match ? cleanText(match[1]) : "";
+}
+function fieldBoolean(block, name) {
+    const value = fieldText(block, name).toLowerCase();
+    if (value === "true") {
+        return true;
+    }
+    if (value === "false") {
+        return false;
+    }
+    return null;
+}
+function normalizeLayer(value) {
+    return value.trim().toLowerCase().replace(/[- ]+/g, "_");
+}
+function firstLine(content) {
+    return cleanText(content.split(/\r?\n/).find((line) => cleanText(line)) ?? "");
+}
+function cleanText(value) {
+    return value.replace(/^[-#*\s]+/, "").trim();
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}

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

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

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

@@ -0,0 +1,84 @@
+import { computeScopeConflicts } from "./superpowers-task-compile.js";
+import { isRecord } from "./superpowers-task-state-schema.js";
+const PRODUCT_DELIVERY_SCOPES = new Set([
+    "system_capability_build",
+    "representative_sample_validation",
+    "full_population_operation",
+    "mixed_scope_requires_boundary"
+]);
+const PLAN_DELIVERY_SCOPES = new Set([
+    "system_capability_build",
+    "representative_sample_validation",
+    "full_population_operation",
+    "out_of_scope_backlog"
+]);
+const ACCEPTANCE_SCOPES = new Set([
+    "system_capability_build",
+    "representative_sample_validation",
+    "full_population_operation",
+    "full_population_not_required"
+]);
+export function validateDeliveryContract(state, errors) {
+    const product = state.delivery?.product_architecture_scope;
+    if (!isRecord(product)) {
+        errors.push("Product / Architecture Source delivery scope is missing");
+    }
+    else {
+        requireEnum(errors, "Product / Architecture Source delivery_scope", product.delivery_scope, PRODUCT_DELIVERY_SCOPES);
+        requireBoolean(errors, "Product / Architecture Source full_population_required", product.full_population_required);
+        requireArray(errors, "Product / Architecture Source representative_samples_validate", product.representative_samples_validate);
+        requireArray(errors, "Product / Architecture Source representative_samples_do_not_validate", product.representative_samples_do_not_validate);
+        requireArray(errors, "Product / Architecture Source out_of_scope_backlog", product.out_of_scope_backlog);
+    }
+    for (const [planId, item] of Object.entries(state.graph?.plan_items ?? {})) {
+        requireEnum(errors, `${planId} delivery_scope`, item.delivery_scope, PLAN_DELIVERY_SCOPES);
+        requireText(errors, `${planId} capability_target`, item.capability_target);
+        requireArray(errors, `${planId} representative_samples`, item.representative_samples);
+        requireText(errors, `${planId} full_population_boundary`, item.full_population_boundary);
+        requireArray(errors, `${planId} non_required_population`, item.non_required_population);
+    }
+    for (const [acId, ac] of Object.entries(state.graph?.acceptance_criteria ?? {})) {
+        requireEnum(errors, `${acId} acceptance_scope`, ac.acceptance_scope, ACCEPTANCE_SCOPES);
+        requireArray(errors, `${acId} ac_validates`, ac.ac_validates);
+        requireArray(errors, `${acId} ac_does_not_validate`, ac.ac_does_not_validate);
+        requireText(errors, `${acId} sample_boundary`, ac.sample_boundary);
+        requireBoolean(errors, `${acId} full_population_required`, ac.full_population_required);
+    }
+}
+export function validateScopeConflicts(state, errors) {
+    const conflicts = [...new Set([...(state.delivery?.scope_conflicts ?? []), ...computeScopeConflicts(state)])].filter(Boolean);
+    for (const conflict of conflicts) {
+        if (/scope_conflict_requires_decision/i.test(conflict)) {
+            errors.push(conflict);
+        }
+    }
+}
+export function fullPopulationRequired(state) {
+    return (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));
+}
+function requireEnum(errors, label, value, allowed) {
+    if (typeof value !== "string" || value.trim() === "") {
+        errors.push(`${label} is missing`);
+        return;
+    }
+    if (!allowed.has(value)) {
+        errors.push(`${label} has unknown value: ${value}`);
+    }
+}
+function requireText(errors, label, value) {
+    if (typeof value !== "string" || value.trim() === "") {
+        errors.push(`${label} is missing`);
+    }
+}
+function requireBoolean(errors, label, value) {
+    if (typeof value !== "boolean") {
+        errors.push(`${label} must be true or false`);
+    }
+}
+function requireArray(errors, label, value) {
+    if (!Array.isArray(value)) {
+        errors.push(`${label} is missing`);
+    }
+}

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

@@ -0,0 +1,13 @@
+import { type SuperpowersTaskState } from "./superpowers-task-state-schema.js";
+export interface DerivedSuperpowersArtifacts {
+    matrix: Record<string, unknown>;
+    verdict: Record<string, unknown>;
+    files: string[];
+}
+export declare function deriveSuperpowersArtifacts(workdir: string): Promise<DerivedSuperpowersArtifacts>;
+export declare function deriveObjects(state: SuperpowersTaskState): {
+    matrix: Record<string, unknown>;
+    verdict: Record<string, unknown>;
+    progress: Record<string, unknown>;
+};
+export declare function derivedMatchesState(workdir: string, state: SuperpowersTaskState): Promise<string[]>;

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

@@ -0,0 +1,204 @@
+import path from "node:path";
+import { ensureDir, pathExists, readText, writeTextIfChanged } from "./fs.js";
+import { stableJson, loadSuperpowersState } from "./superpowers-task-state.js";
+export async function deriveSuperpowersArtifacts(workdir) {
+    const state = await loadSuperpowersState(workdir);
+    const derived = deriveObjects(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, "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));
+    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));
+    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 missingLayers = requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status !== "satisfied");
+        const evidenceIds = evidenceForLayers(state, requiredLayers);
+        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,
+            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,
+            evidence_ids: evidenceIds,
+            scope_assessment: missingLayers.length === 0 ? "full" : "partial",
+            drift: missingLayers.length === 0 ? "no drift detected" : "missing required proof layers"
+        };
+    });
+    const verdictRows = Object.entries(state.graph.acceptance_criteria).map(([acId, ac]) => {
+        const requiredLayers = ac.required_proof_layers.map((layer) => `${acId}.${layer}`);
+        const missingLayers = requiredLayers.filter((layerId) => state.graph.proof_layers[layerId]?.status !== "satisfied");
+        const evidenceIds = evidenceForLayers(state, requiredLayers);
+        const status = missingLayers.length === 0 && requiredLayers.length > 0 ? "complete" : evidenceIds.length > 0 ? "partial" : ac.status;
+        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",
+            required_evidence: requiredLayers,
+            required_proof_chain: requiredLayers,
+            fresh_evidence: evidenceText(state, evidenceIds),
+            missing_evidence: [],
+            missing_required_layers: missingLayers,
+            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,
+        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)
+    };
+    return {
+        matrix: { overall_status: allComplete ? "complete" : "partial", items: matrixRows },
+        verdict: { overall_status: allComplete ? "complete" : "partial", acceptance_items: verdictRows },
+        progress
+    };
+}
+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);
+    return errors;
+}
+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 superpowers derive`);
+    }
+}
+function evidenceForLayers(state, layerIds) {
+    return [...new Set(layerIds.flatMap((layerId) => state.graph.proof_layers[layerId]?.evidence_ids ?? []))];
+}
+function evidenceText(state, evidenceIds, type) {
+    return evidenceIds
+        .map((evidenceId) => state.evidence.find((item) => item.evidence_id === evidenceId))
+        .filter((item) => item && (!type || 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 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) {
+    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}
+`;
+}
+function progressMarkdown(progress) {
+    return `# Progress Ledger
+
+\`\`\`json
+${stableJson(progress)}
+\`\`\`
+`;
+}
+function evidenceMarkdown(state) {
+    return [
+        "# Evidence Index",
+        "",
+        ...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) {
+    return `# Final Summary
+
+overall_status: ${verdict.overall_status}
+product_goal_complete: ${state.final.product_goal_complete}
+`;
+}

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

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

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

@@ -0,0 +1,13 @@
+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-gates.d.ts

@@ -0,0 +1,12 @@
+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<{
+    product_goal_complete: boolean;
+    errors: string[];
+}>;

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

@@ -0,0 +1,47 @@
+import { appendSuperpowersEvent } from "./superpowers-task-events.js";
+import { deriveSuperpowersArtifacts } from "./superpowers-task-derive.js";
+import { loadSuperpowersState, recomputeStatuses, saveSuperpowersState } from "./superpowers-task-state.js";
+import { allCompletionConditionsSatisfied, 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);
+    recomputeStatuses(state);
+    state.final.audit_task_complete = true;
+    state.meta.audit_task_complete = true;
+    state.gates.validator = { status: "not_run" };
+    await saveSuperpowersState(workdir, state);
+    await deriveSuperpowersArtifacts(workdir);
+    const report = await validateSuperpowersState(workdir, [workdir]);
+    const latest = await loadSuperpowersState(workdir);
+    const complete = report.errors.length === 0 && allCompletionConditionsSatisfied(latest);
+    latest.final.product_goal_complete = complete;
+    latest.meta.product_goal_complete = complete;
+    latest.final.acceptance_target_status = complete ? "complete" : "partial";
+    latest.meta.acceptance_target_status = latest.final.acceptance_target_status;
+    latest.final.audit_task_complete = true;
+    latest.meta.audit_task_complete = true;
+    latest.final.completion_basis = complete ? ["all_required_acs_complete", "validator_passed", "auditor_no_blocker"] : [];
+    latest.gates.validator = { status: report.errors.length === 0 ? "pass" : "blocked", errors: report.errors };
+    await saveSuperpowersState(workdir, latest);
+    await deriveSuperpowersArtifacts(workdir);
+    await appendSuperpowersEvent(workdir, "final_gate", { product_goal_complete: complete });
+    return { product_goal_complete: complete, errors: report.errors };
+}

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

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

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

@@ -0,0 +1,12 @@
+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}`;
+    });
+}