agentera 3.0.0-dev.7 → 3.0.0-dev.74

package/dist/hooks/compaction.js

@@ -1,935 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import YAML from "yaml";
-import { loadYamlMapping } from "../core/yaml.js";
-import { DEFAULT_ARTIFACT_PATHS, MAX_FULL_ENTRIES, MAX_ONELINE_ENTRIES, MAX_TOTAL_ENTRIES, applyRetentionCaps, parseDocsYamlMapping, } from "./common.js";
-// --- body field helpers ----------------------------------------------------
-function extractField(body, label) {
-    const pattern = new RegExp(`^\\*\\*${escapeRe(label)}\\*\\*:\\s*(.+?)$`, "m");
-    const m = pattern.exec(body);
-    return m ? m[1].trim() : "";
-}
-function escapeRe(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function firstNonEmpty(body) {
-    for (const line of body.split(/\r\n|\r|\n/)) {
-        if (line.trim())
-            return line.trim();
-    }
-    return "";
-}
-function truncateWords(text, limit = 15) {
-    const words = text.split(/\s+/).filter((w) => w.length > 0);
-    // Match Python str.split() token count but preserve original spacing on no-trunc.
-    const tokenCount = (text.match(/\S+/g) ?? []).length;
-    if (tokenCount <= limit)
-        return text;
-    return words.slice(0, limit).join(" ") + "...";
-}
-const HEADER_NUM_RE = /(?:Cycle|Decision|Audit|Experiment)\s+(\d+)/;
-const HEADER_DATE_RE = /(\d{4}-\d{2}-\d{2})/;
-const NUMBER_RE = /(?:Cycle|Decision|Audit|Experiment|EXP-)\s*(\d+)/;
-function parseHeader(header) {
-    const numMatch = HEADER_NUM_RE.exec(header);
-    const dateMatch = HEADER_DATE_RE.exec(header);
-    const number = numMatch ? numMatch[1] : "";
-    const date = dateMatch ? dateMatch[1] : "";
-    const parts = header.split(" · ");
-    let title = parts.length >= 2 ? parts[parts.length - 1].trim() : "";
-    if (title === date) {
-        title = parts.length >= 3 ? parts[parts.length - 2].trim() : "";
-    }
-    return [number, date, title];
-}
-// --- one-line formatters ---------------------------------------------------
-function formatProgressOneline(entry) {
-    let [number, date, title] = parseHeader(entry.header);
-    if (!title) {
-        title = extractField(entry.body, "What") || firstNonEmpty(entry.body);
-    }
-    title = truncateWords(title || "(no summary)", 20);
-    const numberPart = number ? `Cycle ${number}` : "Cycle ?";
-    const datePart = date ? ` (${date})` : "";
-    return `- ${numberPart}${datePart}: ${title}`;
-}
-function formatDecisionOneline(entry) {
-    const [number, date] = parseHeader(entry.header);
-    let chosen = extractField(entry.body, "Chosen alternative");
-    if (!chosen)
-        chosen = extractField(entry.body, "Chosen");
-    if (!chosen)
-        chosen = firstNonEmpty(entry.body);
-    chosen = truncateWords(chosen || "(no rationale)", 20);
-    const numberPart = number ? `Decision ${number}` : "Decision ?";
-    const datePart = date ? ` (${date})` : "";
-    return `- ${numberPart}${datePart}: ${chosen}`;
-}
-function formatHealthOneline(entry) {
-    const [number, date] = parseHeader(entry.header);
-    let grade = extractField(entry.body, "Overall");
-    if (!grade)
-        grade = extractField(entry.body, "Grade");
-    let trajectory = extractField(entry.body, "Overall trajectory");
-    if (!trajectory)
-        trajectory = "";
-    const summaryBits = [];
-    if (grade)
-        summaryBits.push(truncateWords(grade, 10));
-    if (trajectory && trajectory !== grade)
-        summaryBits.push(truncateWords(trajectory, 10));
-    const summary = summaryBits.length > 0 ? summaryBits.join(" | ") : "no summary";
-    const numberPart = number ? `Audit ${number}` : "Audit ?";
-    const datePart = date ? ` · ${date}` : "";
-    return `### ${numberPart}${datePart} (${summary})`;
-}
-function formatExperimentOneline(entry) {
-    const [number] = parseHeader(entry.header);
-    let summary = extractField(entry.body, "Metric");
-    if (!summary)
-        summary = extractField(entry.body, "Conclusion");
-    if (!summary)
-        summary = extractField(entry.body, "Result");
-    if (!summary)
-        summary = firstNonEmpty(entry.body);
-    summary = truncateWords(summary || "(no result)", 15);
-    const numberPart = number ? `EXP-${number}` : "EXP-?";
-    return `- ${numberPart}: ${summary}`;
-}
-const TODO_CHECKBOX_RE = /^-\s*\[x\]\s*/;
-const TODO_ISS_LABEL_RE = /ISS-\d+:?\s*/;
-function isTodoOnelinePassthrough(entry) {
-    return entry.kind === "oneline" && String(entry.header).includes("~~");
-}
-function stripTodoMetadata(header) {
-    let stripped = header.replace(TODO_CHECKBOX_RE, "");
-    stripped = stripped.replace(/~~/g, "").trim();
-    stripped = stripped.split(" · ")[0].trim();
-    stripped = stripped.replace(TODO_ISS_LABEL_RE, "").trim();
-    return stripped;
-}
-function formatTodoOneline(entry) {
-    const header = String(entry.header).trim();
-    if (isTodoOnelinePassthrough(entry)) {
-        return header.startsWith("- ") ? header : `- ${header}`;
-    }
-    const summary = truncateWords(stripTodoMetadata(header) || "(resolved)", 15);
-    return `- [x] ~~${summary}~~`;
-}
-export const SPECS = {
-    progress: {
-        name: "progress",
-        entryHeadingRe: /^■?\s*##\s+Cycle\s+\d+/m,
-        onelineHeadingRe: /^-\s+Cycle\s+\d+/m,
-        archiveHeading: "## Archived Cycles",
-        formatOneline: formatProgressOneline,
-        scopedSection: null,
-    },
-    decisions: {
-        name: "decisions",
-        entryHeadingRe: /^##\s+Decision\s+\d+/m,
-        onelineHeadingRe: /^-\s+Decision\s+\d+/m,
-        archiveHeading: "## Archived Decisions",
-        formatOneline: formatDecisionOneline,
-        scopedSection: null,
-    },
-    health: {
-        name: "health",
-        entryHeadingRe: /^##\s+Audit\s+\d+/m,
-        onelineHeadingRe: /^###\s+Audit\s+\d+/m,
-        archiveHeading: "## Archived Audits",
-        formatOneline: formatHealthOneline,
-        scopedSection: null,
-    },
-    experiments: {
-        name: "experiments",
-        entryHeadingRe: /^##\s+Experiment\s+\d+/m,
-        onelineHeadingRe: /^-\s+EXP-\d+/m,
-        archiveHeading: "## Archived Experiments",
-        formatOneline: formatExperimentOneline,
-        scopedSection: null,
-    },
-    "todo-resolved": {
-        name: "todo-resolved",
-        entryHeadingRe: /^-\s+\[x\]\s+/m,
-        onelineHeadingRe: null,
-        archiveHeading: null,
-        formatOneline: formatTodoOneline,
-        scopedSection: "## Resolved",
-    },
-};
-export const COMPACTABLE_YAML_ARTIFACTS = {
-    progress: ["cycles", "archive"],
-    decisions: ["decisions", "archive"],
-    health: ["audits", "archive"],
-};
-const YAML_SPEC_BY_ARTIFACT = {
-    progress: "progress",
-    decisions: "decisions",
-    health: "health",
-};
-const NON_COMPACTABLE_ARTIFACTS = {
-    changelog: ["exempt", "public release history is not compacted"],
-    plan: ["unsupported", "active plan is lifecycle state, not a uniform retained-entry log"],
-    docs: ["unsupported", "docs owns artifact mapping and schema metadata"],
-    vision: ["protected", "vision state is protected during execution cycles"],
-    design: ["unsupported", "design is a human-facing identity artifact, not a uniform retained-entry log"],
-};
-function overLimitCount(activeCount, archiveCount) {
-    const totalCount = activeCount + archiveCount;
-    return Math.max(Math.max(activeCount - MAX_FULL_ENTRIES, 0), Math.max(archiveCount - MAX_ONELINE_ENTRIES, 0), Math.max(totalCount - MAX_TOTAL_ENTRIES, 0));
-}
-function artifactPaths(projectRoot) {
-    const paths = { ...DEFAULT_ARTIFACT_PATHS };
-    const docsPath = path.join(projectRoot, ".agentera", "docs.yaml");
-    if (fs.existsSync(docsPath)) {
-        Object.assign(paths, parseDocsYamlMapping(fs.readFileSync(docsPath, "utf8")));
-    }
-    const resolved = {};
-    for (const [artifact, rel] of Object.entries(paths)) {
-        resolved[artifact] = path.join(projectRoot, rel);
-    }
-    return resolved;
-}
-function missingStatus(artifact, p, classification) {
-    return {
-        artifact,
-        path: p,
-        classification,
-        active_count: 0,
-        archive_count: 0,
-        total_count: 0,
-        over_limit_count: 0,
-        reason: "artifact path is not present",
-        protected_overflow_count: 0,
-        exists: false,
-    };
-}
-function yamlErrorStatus(artifact, p, message) {
-    return {
-        artifact,
-        path: p,
-        classification: "error",
-        active_count: null,
-        archive_count: null,
-        total_count: null,
-        over_limit_count: null,
-        reason: message.trim() || "invalid YAML mapping root",
-        protected_overflow_count: 0,
-        exists: true,
-    };
-}
-function yamlCounts(p, activeKey, archiveKey) {
-    const data = loadYamlMapping(fs.readFileSync(p, "utf8"));
-    if (!data || typeof data !== "object" || Array.isArray(data))
-        return [0, 0];
-    const active = data[activeKey] || [];
-    const archive = data[archiveKey] || [];
-    return [Array.isArray(active) ? active.length : 0, Array.isArray(archive) ? archive.length : 0];
-}
-function yamlLists(p, activeKey, archiveKey) {
-    const data = loadYamlMapping(fs.readFileSync(p, "utf8"));
-    if (!data || typeof data !== "object" || Array.isArray(data))
-        return [[], []];
-    const active = data[activeKey] || [];
-    const archive = data[archiveKey] || [];
-    return [Array.isArray(active) ? active : [], Array.isArray(archive) ? archive : []];
-}
-function yamlEntryNumber(entry) {
-    let summary;
-    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
-        const number = entry.number;
-        if (typeof number === "number" && Number.isInteger(number))
-            return number;
-        if (typeof number === "string" && /^\d+$/.test(number))
-            return parseInt(number, 10);
-        summary = String(entry.summary ?? "");
-    }
-    else {
-        summary = String(entry);
-    }
-    const match = NUMBER_RE.exec(summary);
-    return match ? parseInt(match[1], 10) : 0;
-}
-function yamlEntryTimestamp(entry) {
-    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
-        return String(entry.timestamp || entry.date || "");
-    }
-    return "";
-}
-function yamlSummaryText(entry, ...fields) {
-    for (const field of fields) {
-        const value = entry[field];
-        if (typeof value === "string" && value.trim()) {
-            return truncateWords(value.trim(), 15);
-        }
-        if (value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0) {
-            return truncateWords(Object.entries(value).map(([k, v]) => `${k}: ${v}`).join(", "), 15);
-        }
-    }
-    return "no summary";
-}
-function isEmptyish(v) {
-    return (v === null ||
-        v === undefined ||
-        v === "" ||
-        (Array.isArray(v) && v.length === 0) ||
-        (typeof v === "object" && v !== null && !Array.isArray(v) && Object.keys(v).length === 0));
-}
-function yamlArchiveEntry(specName, entry) {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-        return { summary: String(entry) };
-    }
-    const e = entry;
-    if (specName === "progress") {
-        const number = e.number ?? "?";
-        const date = String(e.timestamp ?? "").split(/\s+/)[0] || "";
-        const datePart = date ? ` (${date})` : "";
-        const summary = yamlSummaryText(e, "what", "type");
-        return { summary: `Cycle ${number}${datePart}: ${summary}` };
-    }
-    if (specName === "decisions") {
-        const number = e.number ?? "?";
-        const date = String(e.date ?? "");
-        const datePart = date ? ` (${date})` : "";
-        const choice = yamlSummaryText(e, "choice", "question");
-        const archiveEntry = { summary: `Decision ${number}${datePart}: ${choice}` };
-        for (const field of ["number", "date", "choice", "outcome", "feeds_into", "satisfaction"]) {
-            const value = e[field];
-            if (!isEmptyish(value))
-                archiveEntry[field] = value;
-        }
-        if (!("outcome" in archiveEntry) && !isEmptyish(archiveEntry.choice)) {
-            archiveEntry.outcome = archiveEntry.choice;
-        }
-        return archiveEntry;
-    }
-    if (specName === "health") {
-        const number = e.number ?? "?";
-        const date = String(e.date ?? "");
-        const datePart = date ? ` (${date})` : "";
-        const summary = yamlSummaryText(e, "trajectory", "grades");
-        return { summary: `Audit ${number}${datePart}: ${summary}` };
-    }
-    if (specName === "session") {
-        return { timestamp: String(e.timestamp ?? ""), summary: yamlSummaryText(e, "summary") };
-    }
-    return { summary: yamlSummaryText(e, "summary") };
-}
-function stableSortBy(arr, key, reverse = false) {
-    return arr
-        .map((x, i) => [x, i])
-        .sort((a, b) => {
-        const ka = key(a[0]);
-        const kb = key(b[0]);
-        let cmp = ka < kb ? -1 : ka > kb ? 1 : 0;
-        if (reverse)
-            cmp = -cmp;
-        return cmp !== 0 ? cmp : a[1] - b[1];
-    })
-        .map(([x]) => x);
-}
-function yamlSortEntries(entries, specName) {
-    if (specName === "decisions" || specName === "health") {
-        return stableSortBy(entries, yamlEntryNumber);
-    }
-    if (specName === "session") {
-        return stableSortBy(entries, yamlEntryTimestamp, true);
-    }
-    return stableSortBy(entries, yamlEntryNumber, true);
-}
-function yamlRecentFullAndOlder(entries, specName) {
-    const newestFirst = specName === "session"
-        ? stableSortBy(entries, yamlEntryTimestamp, true)
-        : stableSortBy(entries, yamlEntryNumber, true);
-    const recent = newestFirst.slice(0, MAX_FULL_ENTRIES);
-    const older = newestFirst.slice(MAX_FULL_ENTRIES);
-    return [yamlSortEntries(recent, specName), older];
-}
-function yamlArchiveSortKey(entry) {
-    const timestamp = yamlEntryTimestamp(entry);
-    if (timestamp)
-        return ["timestamp", timestamp];
-    return ["number", yamlEntryNumber(entry)];
-}
-function yamlArchiveEntries(entries) {
-    // Sort by (tag, value) descending, mirroring Python tuple comparison.
-    return entries
-        .map((x, i) => [x, i])
-        .sort((a, b) => {
-        const ka = yamlArchiveSortKey(a[0]);
-        const kb = yamlArchiveSortKey(b[0]);
-        let cmp = 0;
-        if (ka[0] !== kb[0])
-            cmp = ka[0] < kb[0] ? -1 : 1;
-        else
-            cmp = ka[1] < kb[1] ? -1 : ka[1] > kb[1] ? 1 : 0;
-        cmp = -cmp;
-        return cmp !== 0 ? cmp : a[1] - b[1];
-    })
-        .map(([x]) => x);
-}
-function decisionSatisfactionState(entry) {
-    if (!entry || typeof entry !== "object")
-        return null;
-    const satisfaction = entry.satisfaction;
-    if (!satisfaction || typeof satisfaction !== "object")
-        return null;
-    const state = satisfaction.state;
-    return typeof state === "string" ? state : null;
-}
-function decisionRequiresUserReview(entry) {
-    if (!entry || typeof entry !== "object")
-        return true;
-    const satisfaction = entry.satisfaction;
-    if (!satisfaction || typeof satisfaction !== "object")
-        return true;
-    const confirmation = satisfaction.user_confirmation;
-    return (decisionSatisfactionState(entry) !== "user_confirmed_satisfied" ||
-        !confirmation ||
-        typeof confirmation !== "object" ||
-        Object.keys(confirmation).length === 0);
-}
-function decisionProtectedOverflowCount(active, archive) {
-    const protectedActive = active.filter((e) => decisionRequiresUserReview(e)).length;
-    const protectedArchive = archive.filter((e) => decisionRequiresUserReview(e)).length;
-    return Math.max(protectedActive - MAX_FULL_ENTRIES, protectedArchive - MAX_ONELINE_ENTRIES, protectedActive + protectedArchive - MAX_TOTAL_ENTRIES, 0);
-}
-function selectDecisionActiveEntries(active) {
-    const protectedEntries = active.filter((e) => decisionRequiresUserReview(e));
-    if (protectedEntries.length > MAX_FULL_ENTRIES) {
-        throw new Error("decisions: protected-overflow review pressure; " +
-            `${protectedEntries.length} protected active decision(s) exceed ${MAX_FULL_ENTRIES} full-detail slots`);
-    }
-    const satisfied = active.filter((e) => !decisionRequiresUserReview(e));
-    const newestSatisfied = stableSortBy(satisfied, yamlEntryNumber, true);
-    const keepSatisfied = newestSatisfied.slice(0, MAX_FULL_ENTRIES - protectedEntries.length);
-    const compactSatisfied = newestSatisfied.slice(MAX_FULL_ENTRIES - protectedEntries.length);
-    return [yamlSortEntries([...protectedEntries, ...keepSatisfied], "decisions"), compactSatisfied];
-}
-function selectDecisionArchiveEntries(archiveCandidates) {
-    const protectedEntries = archiveCandidates.filter((e) => decisionRequiresUserReview(e));
-    if (protectedEntries.length > MAX_ONELINE_ENTRIES) {
-        throw new Error("decisions: protected-overflow review pressure; " +
-            `${protectedEntries.length} protected archived decision(s) exceed ${MAX_ONELINE_ENTRIES} archive slots`);
-    }
-    const satisfied = archiveCandidates.filter((e) => !decisionRequiresUserReview(e));
-    const keepSatisfied = yamlArchiveEntries(satisfied).slice(0, MAX_ONELINE_ENTRIES - protectedEntries.length);
-    return yamlArchiveEntries([...protectedEntries, ...keepSatisfied]);
-}
-export function compactYamlFile(p, artifact) {
-    if (!(artifact in COMPACTABLE_YAML_ARTIFACTS)) {
-        throw new Error(`unsupported YAML artifact: ${artifact}`);
-    }
-    if (!fs.existsSync(p)) {
-        throw new Error(p);
-    }
-    const [activeKey, archiveKey] = COMPACTABLE_YAML_ARTIFACTS[artifact];
-    const specName = YAML_SPEC_BY_ARTIFACT[artifact];
-    const data = loadYamlMapping(fs.readFileSync(p, "utf8"));
-    let active = data[activeKey] || [];
-    let archive = data[archiveKey] || [];
-    if (!Array.isArray(active))
-        active = [];
-    if (!Array.isArray(archive))
-        archive = [];
-    const fullBefore = active.length;
-    const onelineBefore = archive.length;
-    if (overLimitCount(fullBefore, onelineBefore) === 0) {
-        return { full_before: fullBefore, oneline_before: onelineBefore, full_after: fullBefore, oneline_after: onelineBefore, dropped: 0, changed: false };
-    }
-    let recentFull;
-    let olderActive;
-    if (specName === "decisions") {
-        [recentFull, olderActive] = selectDecisionActiveEntries(active);
-    }
-    else {
-        [recentFull, olderActive] = yamlRecentFullAndOlder(active, specName);
-    }
-    const compactedFromActive = olderActive.map((entry) => yamlArchiveEntry(specName, entry));
-    const archiveCandidates = yamlArchiveEntries([...compactedFromActive, ...archive]);
-    let archiveAfter;
-    if (specName === "decisions") {
-        archiveAfter = selectDecisionArchiveEntries(archiveCandidates);
-    }
-    else {
-        const merged = applyRetentionCaps(recentFull, archiveCandidates);
-        archiveAfter = merged.slice(recentFull.length);
-    }
-    data[activeKey] = recentFull;
-    data[archiveKey] = archiveAfter;
-    fs.writeFileSync(p, YAML.stringify(data));
-    const fullAfter = recentFull.length;
-    const onelineAfter = archiveAfter.length;
-    const dropped = fullBefore + onelineBefore - fullAfter - onelineAfter;
-    return { full_before: fullBefore, oneline_before: onelineBefore, full_after: fullAfter, oneline_after: onelineAfter, dropped, changed: true };
-}
-function countStatus(artifact, p, activeCount, archiveCount, protectedOverflowCount = 0) {
-    const totalCount = activeCount + archiveCount;
-    return {
-        artifact,
-        path: p,
-        classification: "compactable",
-        active_count: activeCount,
-        archive_count: archiveCount,
-        total_count: totalCount,
-        over_limit_count: overLimitCount(activeCount, archiveCount),
-        reason: protectedOverflowCount ? "protected-overflow review pressure" : "uniform_10_40_50",
-        protected_overflow_count: protectedOverflowCount,
-        exists: true,
-    };
-}
-export function computeCompactionStatus(projectRoot) {
-    const paths = artifactPaths(projectRoot);
-    const statuses = [];
-    const todoPath = paths.todo;
-    if (fs.existsSync(todoPath)) {
-        const entries = parseEntries(fs.readFileSync(todoPath, "utf8"), "todo-resolved");
-        const activeCount = entries.filter((e) => e.kind === "full").length;
-        const archiveCount = entries.filter((e) => e.kind === "oneline").length;
-        statuses.push(countStatus("todo#Resolved", todoPath, activeCount, archiveCount));
-    }
-    else {
-        statuses.push(missingStatus("todo#Resolved", todoPath, "compactable"));
-    }
-    for (const [artifact, [activeKey, archiveKey]] of Object.entries(COMPACTABLE_YAML_ARTIFACTS)) {
-        const p = paths[artifact];
-        if (fs.existsSync(p)) {
-            let active;
-            let archive;
-            try {
-                [active, archive] = yamlLists(p, activeKey, archiveKey);
-            }
-            catch (exc) {
-                statuses.push(yamlErrorStatus(artifact, p, exc.message));
-                continue;
-            }
-            const protectedOverflowCount = artifact === "decisions" ? decisionProtectedOverflowCount(active, archive) : 0;
-            statuses.push(countStatus(artifact, p, active.length, archive.length, protectedOverflowCount));
-        }
-        else {
-            statuses.push(missingStatus(artifact, p, "compactable"));
-        }
-    }
-    for (const [artifact, [classification, reason]] of Object.entries(NON_COMPACTABLE_ARTIFACTS)) {
-        const p = paths[artifact];
-        statuses.push({
-            artifact,
-            path: p,
-            classification,
-            active_count: null,
-            archive_count: null,
-            total_count: null,
-            over_limit_count: null,
-            reason,
-            protected_overflow_count: 0,
-            exists: fs.existsSync(p),
-        });
-    }
-    const optimeraDir = path.join(projectRoot, ".agentera", "optimera");
-    if (fs.existsSync(optimeraDir) && fs.statSync(optimeraDir).isDirectory()) {
-        const experimentPaths = [];
-        for (const sub of fs.readdirSync(optimeraDir).sort()) {
-            const expPath = path.join(optimeraDir, sub, "experiments.yaml");
-            if (fs.existsSync(expPath))
-                experimentPaths.push(expPath);
-        }
-        for (const expPath of experimentPaths) {
-            let activeCount;
-            let archiveCount;
-            try {
-                [activeCount, archiveCount] = yamlCounts(expPath, "experiments", "archive");
-            }
-            catch (exc) {
-                statuses.push(yamlErrorStatus("experiments", expPath, exc.message));
-                continue;
-            }
-            statuses.push({
-                artifact: "experiments",
-                path: expPath,
-                classification: "protected",
-                active_count: activeCount,
-                archive_count: archiveCount,
-                total_count: activeCount + archiveCount,
-                over_limit_count: overLimitCount(activeCount, archiveCount),
-                reason: "objective-state experiment files are classified but skipped by default",
-                protected_overflow_count: 0,
-                exists: true,
-            });
-        }
-    }
-    return statuses;
-}
-function operationForStatus(status, mode) {
-    const base = (action, message) => ({
-        status,
-        mode,
-        action,
-        changed: false,
-        result: null,
-        message,
-    });
-    if (!status.exists)
-        return base("missing", status.reason);
-    if (status.classification === "error")
-        return base("error", status.reason);
-    if (status.classification !== "compactable")
-        return base("skipped", status.reason);
-    if (status.protected_overflow_count) {
-        return base("protected_overflow", `protected-overflow review pressure by ${status.protected_overflow_count}`);
-    }
-    if (!status.over_limit_count)
-        return base("ok", "within uniform_10_40_50 limits");
-    return base(mode === "check" ? "over_limit" : "pending_fix", `over uniform_10_40_50 limit by ${status.over_limit_count}`);
-}
-export function checkCompaction(projectRoot) {
-    return computeCompactionStatus(projectRoot).map((status) => operationForStatus(status, "check"));
-}
-export function fixCompaction(projectRoot) {
-    const operations = [];
-    for (const status of computeCompactionStatus(projectRoot)) {
-        const baseline = operationForStatus(status, "fix");
-        if (baseline.action !== "pending_fix") {
-            operations.push(baseline);
-            continue;
-        }
-        const p = status.path;
-        let result;
-        try {
-            if (status.artifact === "todo#Resolved") {
-                result = compactFile(p, "todo-resolved");
-            }
-            else if (status.artifact in YAML_SPEC_BY_ARTIFACT) {
-                result = compactYamlFile(p, status.artifact);
-            }
-            else {
-                operations.push({ status, mode: "fix", action: "skipped", changed: false, result: null, message: `no fixer registered for ${status.artifact}` });
-                continue;
-            }
-        }
-        catch (exc) {
-            operations.push({ status, mode: "fix", action: "error", changed: false, result: null, message: exc.message });
-            continue;
-        }
-        operations.push({
-            status,
-            mode: "fix",
-            action: result.changed ? "compacted" : "ok",
-            changed: result.changed,
-            result,
-            message: `full ${result.full_before}->${result.full_after}; ` +
-                `archive ${result.oneline_before}->${result.oneline_after}; ` +
-                `dropped ${result.dropped}`,
-        });
-    }
-    return operations;
-}
-export function runCompaction(projectRoot, mode = "check") {
-    if (mode === "check")
-        return checkCompaction(projectRoot);
-    if (mode === "fix")
-        return fixCompaction(projectRoot);
-    throw new Error(`unknown compaction mode: ${mode}`);
-}
-// --- markdown parse + compaction -------------------------------------------
-function splitArchive(text, archiveHeading) {
-    if (!archiveHeading)
-        return [text, ""];
-    const pattern = new RegExp(`^${escapeRe(archiveHeading)}\\s*$`, "m");
-    const match = pattern.exec(text);
-    if (!match)
-        return [text, ""];
-    const pre = text.slice(0, match.index).replace(/\s+$/, "");
-    const after = text.slice(match.index + match[0].length);
-    const nextSection = /^##\s/m.exec(after);
-    if (nextSection) {
-        const archiveBody = after.slice(0, nextSection.index);
-        const trailing = after.slice(nextSection.index);
-        return [pre, archiveBody.trim() + (trailing ? "\n\n" + trailing : "")];
-    }
-    return [pre, after.trim()];
-}
-function parseFullEntries(text, spec) {
-    const entries = [];
-    const re = new RegExp(spec.entryHeadingRe.source, "gm");
-    const matches = [...text.matchAll(re)];
-    for (let i = 0; i < matches.length; i++) {
-        const m = matches[i];
-        const lineStart = text.lastIndexOf("\n", m.index - 1) + 1;
-        let lineEnd = text.indexOf("\n", m.index);
-        if (lineEnd === -1)
-            lineEnd = text.length;
-        const headerLine = text.slice(lineStart, lineEnd).trim();
-        const glyphMatch = /^(■)\s*/.exec(headerLine);
-        const glyph = glyphMatch ? glyphMatch[1] + " " : "";
-        const remainder = glyphMatch ? headerLine.slice(glyphMatch[0].length) : headerLine;
-        const header = glyph + remainder.replace(/^#+/, "").trim();
-        const bodyStart = lineEnd + 1;
-        let bodyEnd;
-        if (i + 1 < matches.length) {
-            bodyEnd = text.lastIndexOf("\n", matches[i + 1].index - 1) + 1;
-        }
-        else {
-            bodyEnd = text.length;
-        }
-        const body = text.slice(bodyStart, bodyEnd).trim();
-        entries.push({ header, body, kind: "full" });
-    }
-    return entries;
-}
-function parseOnelineEntries(text, spec) {
-    if (spec.onelineHeadingRe === null)
-        return [];
-    const entries = [];
-    const re = new RegExp(spec.onelineHeadingRe.source);
-    for (const line of text.split(/\r\n|\r|\n/)) {
-        if (re.test(line)) {
-            entries.push({ header: line.replace(/\s+$/, ""), body: "", kind: "oneline" });
-        }
-    }
-    return entries;
-}
-export function parseEntries(text, specName) {
-    const spec = SPECS[specName];
-    if (spec.name === "todo-resolved") {
-        return parseTodoResolved(text, spec);
-    }
-    const [pre, archiveBody] = splitArchive(text, spec.archiveHeading || "");
-    const fullEntries = parseFullEntries(pre, spec);
-    const onelineEntries = parseOnelineEntries(archiveBody, spec);
-    return [...fullEntries, ...onelineEntries];
-}
-function extractResolvedSection(text) {
-    const m = /^##\s+(?:✓\s+)?Resolved\s*$/m.exec(text);
-    if (!m)
-        return [-1, -1, ""];
-    const bodyStart = m.index + m[0].length + 1;
-    const nextSection = /^##\s/m.exec(text.slice(bodyStart));
-    const bodyEnd = nextSection ? bodyStart + nextSection.index : text.length;
-    return [m.index, bodyEnd, text.slice(bodyStart, bodyEnd)];
-}
-function parseTodoResolved(text, spec) {
-    const [, , body] = extractResolvedSection(text);
-    if (!body)
-        return [];
-    const entries = [];
-    const lines = body.split(/\r\n|\r|\n/);
-    const headRe = new RegExp(spec.entryHeadingRe.source);
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        if (headRe.test(line)) {
-            const detailLines = [];
-            let j = i + 1;
-            while (j < lines.length) {
-                const nxt = lines[j];
-                if (nxt.startsWith(" ") || nxt.startsWith("\t")) {
-                    detailLines.push(nxt);
-                    j += 1;
-                }
-                else if (nxt.trim() === "") {
-                    if (j + 1 < lines.length && (lines[j + 1].startsWith(" ") || lines[j + 1].startsWith("\t"))) {
-                        detailLines.push(nxt);
-                        j += 1;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                else {
-                    break;
-                }
-            }
-            const bodyText = detailLines.join("\n").trim();
-            entries.push({ header: line.replace(/\s+$/, ""), body: bodyText, kind: bodyText ? "full" : "oneline" });
-            i = j;
-        }
-        else {
-            i += 1;
-        }
-    }
-    return entries;
-}
-function entryNumber(entry) {
-    const m = NUMBER_RE.exec(entry.header);
-    return m ? parseInt(m[1], 10) : 0;
-}
-function detectDirection(entries) {
-    let asc = 0;
-    let desc = 0;
-    for (let i = 0; i < entries.length - 1; i++) {
-        const a = entryNumber(entries[i]);
-        const b = entryNumber(entries[i + 1]);
-        if (a === 0 || b === 0 || a === b)
-            continue;
-        if (a < b)
-            asc += 1;
-        else
-            desc += 1;
-    }
-    if (asc === 0 && desc === 0)
-        return "descending";
-    return asc > desc ? "ascending" : "descending";
-}
-export function compactEntries(entries, maxFull = MAX_FULL_ENTRIES, maxOneline = MAX_ONELINE_ENTRIES, formatOneline = null) {
-    const maxTotal = maxFull + maxOneline;
-    if (entries.length === 0)
-        return [];
-    const ascending = detectDirection(entries) === "ascending";
-    const newestFirst = stableSortBy(entries, entryNumber, true);
-    const full = [];
-    const archive = [];
-    newestFirst.forEach((entry, i) => {
-        if (i < maxFull) {
-            full.push(entry);
-        }
-        else if (i < maxTotal) {
-            if (entry.kind === "full" && formatOneline !== null) {
-                archive.push({ header: formatOneline(entry), body: "", kind: "oneline" });
-            }
-            else {
-                archive.push(entry);
-            }
-        }
-    });
-    const result = applyRetentionCaps(full, archive, { maxFull, maxOneline, maxTotal });
-    if (ascending)
-        result.reverse();
-    return result;
-}
-function compactTodoEntries(entries) {
-    const result = [];
-    let fullCount = 0;
-    let onelineCount = 0;
-    for (const entry of entries) {
-        if (entry.kind === "full" && fullCount < MAX_FULL_ENTRIES) {
-            result.push(entry);
-            fullCount += 1;
-            continue;
-        }
-        if (onelineCount < MAX_ONELINE_ENTRIES) {
-            if (entry.kind === "full") {
-                result.push({ header: formatTodoOneline(entry), body: "", kind: "oneline" });
-            }
-            else {
-                result.push(entry);
-            }
-            onelineCount += 1;
-        }
-    }
-    return result;
-}
-function formatProgressLike(headerPrefix, entries, spec) {
-    const lines = [];
-    if (headerPrefix.trim()) {
-        lines.push(headerPrefix.replace(/\s+$/, ""));
-        lines.push("");
-    }
-    const fullEntries = entries.filter((e) => e.kind === "full");
-    const onelineEntries = entries.filter((e) => e.kind === "oneline");
-    for (const entry of fullEntries) {
-        const header = entry.header;
-        const glyphMatch = /^(■)\s+(.*)$/.exec(header);
-        if (glyphMatch) {
-            lines.push(`${glyphMatch[1]} ## ${glyphMatch[2]}`);
-        }
-        else {
-            lines.push(`## ${header}`);
-        }
-        if (entry.body) {
-            lines.push("");
-            lines.push(entry.body);
-        }
-        lines.push("");
-    }
-    if (onelineEntries.length > 0 && spec.archiveHeading) {
-        lines.push(spec.archiveHeading);
-        lines.push("");
-        for (const entry of onelineEntries) {
-            lines.push(entry.header);
-        }
-        lines.push("");
-    }
-    return lines.join("\n").replace(/\s+$/, "") + "\n";
-}
-function extractHeaderPrefix(text, spec) {
-    const firstEntry = new RegExp(spec.entryHeadingRe.source, "m").exec(text);
-    let firstArchiveIdx = -1;
-    if (spec.archiveHeading) {
-        const archiveMatch = new RegExp(`^${escapeRe(spec.archiveHeading)}\\s*$`, "m").exec(text);
-        if (archiveMatch)
-            firstArchiveIdx = archiveMatch.index;
-    }
-    const candidates = [firstEntry ? firstEntry.index : -1, firstArchiveIdx].filter((c) => c >= 0);
-    if (candidates.length === 0)
-        return text.replace(/\s+$/, "");
-    return text.slice(0, Math.min(...candidates)).replace(/\s+$/, "");
-}
-function compactTodoResolved(p) {
-    const spec = SPECS["todo-resolved"];
-    const text = fs.readFileSync(p, "utf8");
-    const [start, end, body] = extractResolvedSection(text);
-    if (start < 0)
-        return { full_before: 0, oneline_before: 0, full_after: 0, oneline_after: 0, dropped: 0, changed: false };
-    const entries = parseTodoResolved(text, spec);
-    const fullBefore = entries.filter((e) => e.kind === "full").length;
-    const onelineBefore = entries.filter((e) => e.kind === "oneline").length;
-    const totalBefore = entries.length;
-    if (totalBefore <= MAX_TOTAL_ENTRIES && fullBefore <= MAX_FULL_ENTRIES && onelineBefore <= MAX_ONELINE_ENTRIES) {
-        return { full_before: fullBefore, oneline_before: onelineBefore, full_after: fullBefore, oneline_after: onelineBefore, dropped: 0, changed: false };
-    }
-    const compacted = compactTodoEntries(entries);
-    const fullAfter = compacted.filter((e) => e.kind === "full").length;
-    const onelineAfter = compacted.filter((e) => e.kind === "oneline").length;
-    const dropped = totalBefore - compacted.length;
-    const newLines = [];
-    for (const entry of compacted) {
-        if (entry.kind === "full") {
-            newLines.push(entry.header);
-            if (entry.body)
-                newLines.push(entry.body);
-        }
-        else {
-            newLines.push(spec.formatOneline(entry));
-        }
-    }
-    const newBody = newLines.join("\n") + "\n";
-    const headingEnd = text.indexOf("\n", start) + 1;
-    const newText = text.slice(0, headingEnd) + "\n" + newBody + text.slice(end);
-    fs.writeFileSync(p, newText);
-    return { full_before: fullBefore, oneline_before: onelineBefore, full_after: fullAfter, oneline_after: onelineAfter, dropped, changed: true };
-}
-export function compactFile(p, specName) {
-    if (!(specName in SPECS))
-        throw new Error(`unknown spec: ${specName}`);
-    if (!fs.existsSync(p))
-        throw new Error(p);
-    const spec = SPECS[specName];
-    if (spec.name === "todo-resolved") {
-        return compactTodoResolved(p);
-    }
-    const text = fs.readFileSync(p, "utf8");
-    const entries = parseEntries(text, specName);
-    const fullBefore = entries.filter((e) => e.kind === "full").length;
-    const onelineBefore = entries.filter((e) => e.kind === "oneline").length;
-    const totalBefore = fullBefore + onelineBefore;
-    const needsCompact = fullBefore > MAX_FULL_ENTRIES || onelineBefore > MAX_ONELINE_ENTRIES || totalBefore > MAX_FULL_ENTRIES + MAX_ONELINE_ENTRIES;
-    if (!needsCompact) {
-        return { full_before: fullBefore, oneline_before: onelineBefore, full_after: fullBefore, oneline_after: onelineBefore, dropped: 0, changed: false };
-    }
-    const compacted = compactEntries(entries, MAX_FULL_ENTRIES, MAX_ONELINE_ENTRIES, spec.formatOneline);
-    const fullAfter = compacted.filter((e) => e.kind === "full").length;
-    const onelineAfter = compacted.filter((e) => e.kind === "oneline").length;
-    const dropped = totalBefore - compacted.length;
-    const headerPrefix = extractHeaderPrefix(text, spec);
-    const newText = formatProgressLike(headerPrefix, compacted, spec);
-    fs.writeFileSync(p, newText);
-    return { full_before: fullBefore, oneline_before: onelineBefore, full_after: fullAfter, oneline_after: onelineAfter, dropped, changed: true };
-}
-export function detectOverflow(text, specName) {
-    const entries = parseEntries(text, specName);
-    const fullCount = entries.filter((e) => e.kind === "full").length;
-    const onelineCount = entries.filter((e) => e.kind === "oneline").length;
-    return [fullCount, onelineCount];
-}
-//# sourceMappingURL=compaction.js.map