agentera 3.0.0-dev.8 → 3.0.0-dev.81

package/dist/hooks/compaction/apply.js

@@ -11,58 +11,202 @@
  * runtime these fields are always strings.
  */
 import fs from "node:fs";
+import path from "node:path";
 import YAML from "yaml";
 import { loadYamlMapping } from "../../core/yaml.js";
 import { MAX_FULL_ENTRIES, MAX_ONELINE_ENTRIES, MAX_TOTAL_ENTRIES, applyRetentionCaps } from "../common.js";
 import { COMPACTABLE_YAML_ARTIFACTS, SPECS, YAML_SPEC_BY_ARTIFACT, formatTodoOneline } from "./dryRun.js";
-import { applyRetentionCaps as _applyRetentionCaps, overLimitCount, selectDecisionActiveEntries, selectDecisionArchiveEntries, stableSortBy, yamlArchiveEntries, yamlArchiveEntry, yamlEntryNumber, yamlRecentFullAndOlder, yamlSortEntries, } from "./retention.js";
-import { normalizeTodoResolvedLayout, parseEntries, parseTodoResolved, extractResolvedSection } from "./parse.js";
-export function compactYamlFile(p, artifact) {
+import { decisionRequiresUserReview, selectDecisionActiveEntries, selectDecisionArchiveEntries, stableSortBy, yamlArchiveEntry, yamlEntryNumber, yamlRecentFullAndOlder, yamlSortEntries, } from "./retention.js";
+import { normalizeTodoResolvedLayout, parseEntries, parseTodoResolved, extractResolvedSection, countTodoResolvedSectionHeadings, countTodoPendingSummarization, TODO_DROPPED_RECOVERY_GUIDANCE } from "./parse.js";
+import { hydrateDecisionRecords } from "../../state/decisionOverlay.js";
+import { gateProjectionEntries } from "../../state/archiveRecovery.js";
+import { loadProjectionPolicy, projectionOmission, } from "../../state/projectionPolicy.js";
+function restoreRawSatisfaction(selected, rawEntries) {
+    return selected.map((entry) => {
+        const raw = rawEntries.find((candidate) => yamlEntryNumber(candidate) === yamlEntryNumber(entry));
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            return entry;
+        const restored = { ...entry };
+        if ("satisfaction" in raw)
+            restored.satisfaction = raw.satisfaction;
+        else
+            delete restored.satisfaction;
+        return restored;
+    });
+}
+function existingOmissionCount(data) {
+    const count = data.omitted_count;
+    return typeof count === "number" && Number.isSafeInteger(count) && count > 0 ? count : 0;
+}
+function archiveProjectionCandidates(specName, rawArchive, generatedArchive, summaryCapacity) {
+    // Inline summaries have no independently verified complete record. They
+    // participate in the same bounded projection as verified summaries, but
+    // their omission explicitly remains degraded legacy history.
+    const candidates = [
+        ...rawArchive.map((entry) => ({ entry, source: "legacy_summary", index: 0 })),
+        ...generatedArchive.map((entry) => ({ entry, source: "archive", index: 1 })),
+    ];
+    const ordered = candidates.sort((left, right) => {
+        const leftTimestamp = String(left.entry?.timestamp ?? left.entry?.date ?? "");
+        const rightTimestamp = String(right.entry?.timestamp ?? right.entry?.date ?? "");
+        if (leftTimestamp !== rightTimestamp)
+            return leftTimestamp < rightTimestamp ? 1 : -1;
+        const leftNumber = yamlEntryNumber(left.entry);
+        const rightNumber = yamlEntryNumber(right.entry);
+        if (leftNumber !== rightNumber)
+            return rightNumber - leftNumber;
+        return left.index - right.index;
+    });
+    const reviewFirst = specName === "decisions"
+        ? [
+            ...ordered.filter((candidate) => decisionRequiresUserReview(candidate.entry)),
+            ...ordered.filter((candidate) => !decisionRequiresUserReview(candidate.entry)),
+        ]
+        : ordered;
+    const retained = reviewFirst.slice(0, summaryCapacity);
+    const omitted = reviewFirst.slice(summaryCapacity);
+    const provenance = [];
+    for (const source of ["legacy_summary", "archive"]) {
+        const omittedCount = omitted.filter((candidate) => candidate.source === source).length;
+        if (omittedCount === 0)
+            continue;
+        provenance.push({
+            source,
+            detail_availability: source === "legacy_summary" ? "unavailable" : "full",
+            compatibility: source === "legacy_summary" ? "degraded" : "complete",
+            archive_verified: source === "archive",
+            omitted_count: omittedCount,
+        });
+    }
+    return {
+        archive: yamlSortEntries(retained.map((candidate) => candidate.entry), specName),
+        omitted: omitted.length,
+        provenance,
+    };
+}
+function existingOmissionProvenance(data) {
+    const raw = data.omission_provenance;
+    const values = Array.isArray(raw) ? raw : raw && typeof raw === "object" ? [raw] : [];
+    return values.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+}
+export function compactYamlBytes(bytes, artifact, projectRoot) {
     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"));
+    const data = loadYamlMapping(bytes);
     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 };
+    const rawActive = active;
+    const rawArchive = archive;
+    const policy = loadProjectionPolicy();
+    const selectionActive = specName === "decisions" && projectRoot
+        ? hydrateDecisionRecords(rawActive, projectRoot)
+        : rawActive;
+    const fullBefore = rawActive.length;
+    const onelineBefore = rawArchive.length;
+    if (fullBefore <= policy.activeEntries && onelineBefore <= policy.summaryEntries && fullBefore + onelineBefore <= policy.totalEntries) {
+        return {
+            bytes,
+            result: {
+                full_before: fullBefore,
+                oneline_before: onelineBefore,
+                full_after: fullBefore,
+                oneline_after: onelineBefore,
+                dropped: 0,
+                omitted_count: 0,
+                changed: false,
+            },
+        };
     }
     let recentFull;
     let olderActive;
     if (specName === "decisions") {
-        [recentFull, olderActive] = selectDecisionActiveEntries(active);
+        const [selectedRecent, selectedOlder] = selectDecisionActiveEntries(selectionActive, policy.activeEntries);
+        recentFull = restoreRawSatisfaction(selectedRecent, rawActive);
+        olderActive = restoreRawSatisfaction(selectedOlder, rawActive);
     }
     else {
-        [recentFull, olderActive] = yamlRecentFullAndOlder(active, specName);
+        [recentFull, olderActive] = yamlRecentFullAndOlder(rawActive, specName, policy.activeEntries);
     }
-    const compactedFromActive = olderActive.map((entry) => yamlArchiveEntry(specName, entry));
-    const archiveCandidates = yamlArchiveEntries([...compactedFromActive, ...archive]);
-    let archiveAfter;
+    const projectionRoot = projectRoot ?? process.cwd();
+    // Experiment summaries are the pre-existing 10/40/50 projection itself.
+    // Durable experiment archives are introduced separately; publication must
+    // not silently disable the current projection while that policy is pending.
+    const gated = specName === "experiments"
+        ? {
+            verified: olderActive,
+            refused: [],
+            recovery: {
+                status: "unsupported",
+                attempted: olderActive.length,
+                verified: 0,
+                retained_full: 0,
+                refused_count: 0,
+                refusals: [],
+            },
+        }
+        : gateProjectionEntries(projectionRoot, specName, olderActive);
+    const compactedFromActive = gated.verified.map((entry) => yamlArchiveEntry(specName, entry));
+    const retainedFull = gated.refused.map(({ entry }) => entry);
+    recentFull = yamlSortEntries([...recentFull, ...retainedFull], specName);
+    const archiveProjection = archiveProjectionCandidates(specName, rawArchive, compactedFromActive, policy.summaryEntries);
+    let archiveAfter = archiveProjection.archive;
     if (specName === "decisions") {
-        archiveAfter = selectDecisionArchiveEntries(archiveCandidates);
+        const selectionArchiveCandidates = projectRoot
+            ? hydrateDecisionRecords(archiveAfter, projectRoot)
+            : archiveAfter;
+        archiveAfter = restoreRawSatisfaction(selectDecisionArchiveEntries(selectionArchiveCandidates), archiveAfter);
     }
-    else {
-        const merged = applyRetentionCaps(recentFull, archiveCandidates);
-        archiveAfter = merged.slice(recentFull.length);
+    const omittedCount = existingOmissionCount(data) + archiveProjection.omitted;
+    if (omittedCount > 0) {
+        Object.assign(data, projectionOmission(specName, omittedCount, "projection_capacity", {
+            forceOmitted: true,
+            provenance: [...existingOmissionProvenance(data), ...archiveProjection.provenance],
+        }));
     }
     data[activeKey] = recentFull;
-    data[archiveKey] = archiveAfter;
-    fs.writeFileSync(p, YAML.stringify(data));
+    if (archiveAfter.length > 0 || archiveKey in data || compactedFromActive.length > 0) {
+        data[archiveKey] = archiveAfter;
+    }
+    else {
+        delete data[archiveKey];
+    }
+    const compactedBytes = 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 };
+    // A projection may omit detail only after its complete numbered archive is
+    // verified. Omission is reported separately; logical entries are never
+    // counted as dropped.
+    const dropped = 0;
+    return {
+        bytes: compactedBytes,
+        result: {
+            full_before: fullBefore,
+            oneline_before: onelineBefore,
+            full_after: fullAfter,
+            oneline_after: onelineAfter,
+            dropped,
+            omitted_count: omittedCount,
+            ...(omittedCount > 0 ? { omission_reason: "projection_capacity" } : {}),
+            changed: true,
+            recovery: gated.recovery,
+        },
+    };
+}
+export function compactYamlFile(p, artifact, projectRoot) {
+    if (!fs.existsSync(p))
+        throw new Error(p);
+    const inferredProjectRoot = path.basename(path.dirname(p)) === ".agentera" ? path.dirname(path.dirname(p)) : path.dirname(p);
+    const compacted = compactYamlBytes(fs.readFileSync(p, "utf8"), artifact, projectRoot ?? inferredProjectRoot);
+    if (compacted.result.changed)
+        fs.writeFileSync(p, compacted.bytes);
+    return compacted.result;
 }
 function detectDirection(entries) {
     let asc = 0;
@@ -108,24 +252,32 @@ export function compactEntries(entries, maxFull = MAX_FULL_ENTRIES, maxOneline =
     return result;
 }
 function compactTodoEntries(entries) {
+    // Positional tiering per TC9: the first ten resolved rows are the
+    // recent/full-detail tier even when they have no indented body; rows
+    // 11-50 are the summary tier; rows beyond 50 are dropped. Using
+    // position (not body presence) ensures: (1) a TODO with 55 bodyless
+    // one-liners retains 50 (10 promoted to full + 40 summary), not 40;
+    // (2) a second compaction is idempotent because a compacted file
+    // with 0 body + 50 headers still reports total=50 (not oneline=50>40).
     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;
+    for (let i = 0; i < entries.length; i++) {
+        if (i < MAX_FULL_ENTRIES) {
+            // First 10: full-detail tier — preserve body if present, promote
+            // kind to "full" so the writer keeps the header (not formatOneline).
+            result.push(entries[i].kind === "oneline"
+                ? { ...entries[i], kind: "full" }
+                : entries[i]);
         }
-        if (onelineCount < MAX_ONELINE_ENTRIES) {
-            if (entry.kind === "full") {
-                result.push({ header: formatTodoOneline(entry), body: "", kind: "oneline" });
-            }
-            else {
-                result.push(entry);
-            }
-            onelineCount += 1;
+        else if (i < MAX_TOTAL_ENTRIES) {
+            // Items 11-50: summary tier — force ≤15-word summary formatting
+            // by passing kind="full" to formatTodoOneline so it goes through
+            // the truncation path (strip metadata + truncateWords). This must
+            // NOT use kind="oneline" (passthrough), which preserves long
+            // verbatim headers unchanged.
+            const summary = formatTodoOneline({ ...entries[i], kind: "full" });
+            result.push({ header: summary, body: "", kind: "oneline" });
         }
+        // Items 51+: dropped entirely.
     }
     return result;
 }
@@ -180,19 +332,39 @@ function extractHeaderPrefix(text, spec) {
 function compactTodoResolved(p) {
     const spec = SPECS["todo-resolved"];
     let text = fs.readFileSync(p, "utf8");
+    // Enforce exactly one `## ✓ Resolved` heading. Multiple headings hide
+    // trailing entries from parsing; zero headings leave placement ambiguous.
+    // The check-mode status path emits the error before reaching here; this
+    // guard protects direct callers (e.g. validate-artifact auto-compact).
+    const headingCount = countTodoResolvedSectionHeadings(text);
+    if (headingCount > 1) {
+        throw new Error(`TODO.md has ${headingCount} '## ✓ Resolved' sections; merge into exactly one before compacting. ` +
+            `Compaction drops oldest resolved entries and is destructive (no lossless archive); ` +
+            TODO_DROPPED_RECOVERY_GUIDANCE);
+    }
+    if (headingCount === 0) {
+        throw new Error("TODO.md has no required '## ✓ Resolved' section; add exactly one before compacting.");
+    }
+    // headingCount === 1: normalize (migrate misplaced items into existing heading)
     const normalized = normalizeTodoResolvedLayout(text);
     if (normalized.changed) {
         fs.writeFileSync(p, normalized.text);
         text = normalized.text;
     }
-    const [start, end] = extractResolvedSection(text);
+    const [start, end, currentBody] = extractResolvedSection(text);
     if (start < 0)
         return { full_before: 0, oneline_before: 0, full_after: 0, oneline_after: 0, dropped: 0, changed: normalized.changed };
     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) {
+    // Positional tiering per TC9 (consistent with countTodoResolvedEntries and
+    // compactTodoEntries): first min(N,10) = full tier, rest = oneline tier.
+    const fullBefore = Math.min(totalBefore, MAX_FULL_ENTRIES);
+    const onelineBefore = Math.max(0, totalBefore - MAX_FULL_ENTRIES);
+    // Skip the rewrite when within budget AND no rows 11-50 need reformatting.
+    // This preserves idempotency: a fully-compacted file (10 verbatim + 40
+    // summaries) reports pendingSummarization=0 and returns changed=false.
+    const pendingSummarization = countTodoPendingSummarization(text);
+    if (totalBefore <= MAX_TOTAL_ENTRIES && pendingSummarization === 0) {
         return {
             full_before: fullBefore,
             oneline_before: onelineBefore,
@@ -202,6 +374,9 @@ function compactTodoResolved(p) {
             changed: normalized.changed,
         };
     }
+    // Either total > 50 (entries to drop) or pendingSummarization > 0 (rows
+    // 11-50 need ≤15-word summary formatting). Run compactTodoEntries and
+    // rewrite the Resolved section body.
     const compacted = compactTodoEntries(entries);
     const fullAfter = compacted.filter((e) => e.kind === "full").length;
     const onelineAfter = compacted.filter((e) => e.kind === "oneline").length;
@@ -227,7 +402,12 @@ function compactTodoResolved(p) {
         full_after: fullAfter,
         oneline_after: onelineAfter,
         dropped,
-        changed: normalized.changed || true,
+        // TODO has no lossless numbered archive: dropped resolved entries are
+        // recoverable only via project history (Git), and only if previously
+        // committed. Surface this honestly in the JSON result rather than
+        // implying a lossless projection.
+        ...(dropped > 0 ? { omission_reason: TODO_DROPPED_RECOVERY_GUIDANCE } : {}),
+        changed: true,
     };
 }
 export function compactFile(p, specName) {
@@ -263,7 +443,4 @@ export function detectOverflow(text, specName) {
     const onelineCount = entries.filter((e) => e.kind === "oneline").length;
     return [fullCount, onelineCount];
 }
-// Silence the re-export-only `_applyRetentionCaps` alias used by status.ts.
-void _applyRetentionCaps;
 void yamlSortEntries;
-//# sourceMappingURL=apply.js.map

package/dist/hooks/compaction/dryRun.js

@@ -167,11 +167,13 @@ export const COMPACTABLE_YAML_ARTIFACTS = {
     progress: ["cycles", "archive"],
     decisions: ["decisions", "archive"],
     health: ["audits", "archive"],
+    experiments: ["experiments", "archive"],
 };
 export const YAML_SPEC_BY_ARTIFACT = {
     progress: "progress",
     decisions: "decisions",
     health: "health",
+    experiments: "experiments",
 };
 export const NON_COMPACTABLE_ARTIFACTS = {
     changelog: ["exempt", "public release history is not compacted"],
@@ -180,4 +182,3 @@ export const NON_COMPACTABLE_ARTIFACTS = {
     vision: ["protected", "vision state is protected during execution cycles"],
     design: ["unsupported", "design is a human-facing identity artifact, not a uniform retained-entry log"],
 };
-//# sourceMappingURL=dryRun.js.map

package/dist/hooks/compaction/index.js

@@ -1,5 +1,5 @@
 /**
- * Public surface for the compaction hook.
+ * Public surface for the compaction engine.
  *
  * Re-exports the API consumed by `cli/commands/compact.ts` and the
  * test suite. The actual implementation lives in the per-
@@ -13,11 +13,10 @@
  *                 checkCompaction, fixCompaction, runCompaction)
  */
 import { applyRetentionCaps as _applyRetentionCaps } from "../common.js";
-import { compactFile, compactYamlFile, detectOverflow, compactEntries } from "./apply.js";
+import { compactFile, compactYamlBytes, compactYamlFile, detectOverflow, compactEntries, } from "./apply.js";
 import { checkCompaction, computeCompactionStatus, fixCompaction, runCompaction } from "./status.js";
-import { parseEntries, parseFullEntries, parseOnelineEntries, splitArchive, extractResolvedSection, parseTodoResolved, countTodoResolvedEntries, normalizeTodoResolvedLayout, } from "./parse.js";
+import { parseEntries, parseFullEntries, parseOnelineEntries, splitArchive, extractResolvedSection, parseTodoResolved, countTodoResolvedEntries, countTodoResolvedSectionHeadings, countTodoPendingSummarization, normalizeTodoResolvedLayout, TODO_DROPPED_RECOVERY_GUIDANCE, } from "./parse.js";
 import { SPECS, COMPACTABLE_YAML_ARTIFACTS, NON_COMPACTABLE_ARTIFACTS, YAML_SPEC_BY_ARTIFACT, formatTodoOneline } from "./dryRun.js";
-import { overLimitCount, stableSortBy, yamlArchiveEntry, yamlArchiveEntries, yamlRecentFullAndOlder, yamlSortEntries, decisionProtectedOverflowCount, selectDecisionActiveEntries, selectDecisionArchiveEntries, } from "./retention.js";
-export { compactFile, compactYamlFile, detectOverflow, compactEntries, checkCompaction, computeCompactionStatus, fixCompaction, runCompaction, parseEntries, parseFullEntries, parseOnelineEntries, splitArchive, extractResolvedSection, parseTodoResolved, SPECS, COMPACTABLE_YAML_ARTIFACTS, NON_COMPACTABLE_ARTIFACTS, YAML_SPEC_BY_ARTIFACT, formatTodoOneline, countTodoResolvedEntries, normalizeTodoResolvedLayout, overLimitCount, stableSortBy, yamlArchiveEntry, yamlArchiveEntries, yamlRecentFullAndOlder, yamlSortEntries, decisionProtectedOverflowCount, selectDecisionActiveEntries, selectDecisionArchiveEntries, };
+import { overLimitCount, stableSortBy, yamlArchiveEntry, yamlArchiveEntries, yamlRecentFullAndOlder, yamlSortEntries, yamlEntryNumber, decisionProtectedOverflowCount, decisionRequiresUserReview, selectDecisionActiveEntries, selectDecisionArchiveEntries, } from "./retention.js";
+export { compactFile, compactYamlBytes, compactYamlFile, detectOverflow, compactEntries, checkCompaction, computeCompactionStatus, fixCompaction, runCompaction, parseEntries, parseFullEntries, parseOnelineEntries, splitArchive, extractResolvedSection, parseTodoResolved, SPECS, COMPACTABLE_YAML_ARTIFACTS, NON_COMPACTABLE_ARTIFACTS, YAML_SPEC_BY_ARTIFACT, formatTodoOneline, countTodoResolvedEntries, countTodoResolvedSectionHeadings, countTodoPendingSummarization, TODO_DROPPED_RECOVERY_GUIDANCE, normalizeTodoResolvedLayout, overLimitCount, stableSortBy, yamlArchiveEntry, yamlArchiveEntries, yamlRecentFullAndOlder, yamlSortEntries, yamlEntryNumber, decisionProtectedOverflowCount, decisionRequiresUserReview, selectDecisionActiveEntries, selectDecisionArchiveEntries, };
 void _applyRetentionCaps;
-//# sourceMappingURL=index.js.map

package/dist/hooks/compaction/parse.js

@@ -9,9 +9,24 @@
  * `## ✓ Resolved`.
  */
 import { parseTodoMarkdownListItem } from "../../cli/todoMarkdown.js";
-import { SPECS, escapeRe } from "./dryRun.js";
+import { MAX_FULL_ENTRIES, MAX_TOTAL_ENTRIES } from "../common.js";
+import { SPECS, escapeRe, formatTodoOneline } from "./dryRun.js";
 const SEVERITY_HEADING_RE = /^##\s*(⇶|⇉|→|⇢)\s/m;
 const STRIKETHROUGH_ITEM_RE = /^(\s*)-\s+~~(.+?)~~\s*(.*)$/;
+// Shared case-insensitive resolved-heading matcher. Duplicate detection
+// (countTodoResolvedSectionHeadings), validation (markdown.ts), classification
+// (isTodoResolvedSectionHeading), and extraction (extractResolvedSection) all
+// use these so they accept the same variants: `## ✓ Resolved`, `## Resolved`,
+// `## resolved`, `## RESOLVED`. Formerly extractResolvedSection used `\s+`
+// (requiring a space after ##) without the `i` flag, silently rejecting
+// case variants and `##Resolved`; now unified.
+const TODO_RESOLVED_HEADING_RE = /^##\s*(?:✓\s+)?Resolved\s*$/im;
+const TODO_RESOLVED_HEADING_GLOBAL_RE = /^##\s*(?:✓\s+)?Resolved\s*$/gim;
+// TODO.md is a bounded human-facing queue, not a lossless numbered archive:
+// dropped resolved entries are recoverable only via project history (Git),
+// and only if previously committed. Surfaced in compaction diagnostics
+// alongside the `dropped` count.
+export const TODO_DROPPED_RECOVERY_GUIDANCE = "dropped resolved entries are not retained in a lossless archive; recover previously committed content via Git: `git log -p -- :/TODO.md` (non-Git projects have no historical recovery)";
 export function splitArchive(text, archiveHeading) {
     if (!archiveHeading)
         return [text, ""];
@@ -70,7 +85,7 @@ export function parseOnelineEntries(text, spec) {
     return entries;
 }
 export function extractResolvedSection(text) {
-    const m = /^##\s+(?:✓\s+)?Resolved\s*$/m.exec(text);
+    const m = TODO_RESOLVED_HEADING_RE.exec(text);
     if (!m)
         return [-1, -1, ""];
     const bodyStart = m.index + m[0].length + 1;
@@ -124,7 +139,17 @@ export function isTodoSeveritySectionHeading(line) {
     return SEVERITY_HEADING_RE.test(line.trim());
 }
 export function isTodoResolvedSectionHeading(line) {
-    return /^##\s*(?:✓\s+)?Resolved\s*$/im.test(line.trim());
+    return TODO_RESOLVED_HEADING_RE.test(line.trim());
+}
+/**
+ * Count `## ✓ Resolved` section headings in a TODO.md. A well-formed queue has
+ * exactly one; duplicates make parsing silently process only the first and
+ * hide the remaining entries from the compaction budget. Callers (validation,
+ * compaction status, compaction apply) refuse when this returns a value > 1.
+ */
+export function countTodoResolvedSectionHeadings(text) {
+    const matches = text.match(TODO_RESOLVED_HEADING_GLOBAL_RE);
+    return matches ? matches.length : 0;
 }
 export function classifyTodoSectionHeading(line) {
     if (isTodoSeveritySectionHeading(line))
@@ -171,11 +196,54 @@ export function countTodoResolvedEntries(content) {
     const spec = SPECS["todo-resolved"];
     const resolvedSection = parseTodoResolved(content, spec);
     const misplaced = countTodoResolvedInSeverityBands(content);
+    const total = resolvedSection.length + misplaced;
+    // Positional tiering per TC9: the first ten resolved rows are the
+    // recent/full-detail tier even when they have no indented body; rows
+    // 11+ are the summary tier. This keeps status reporting consistent
+    // with how compactTodoEntries assigns tiers (positional, not
+    // body-presence-based), so a compacted file with 10 header-only rows
+    // + 40 summaries reports 10/40 (not 0/50).
     return {
-        full: resolvedSection.filter((e) => e.kind === "full").length,
-        oneline: resolvedSection.filter((e) => e.kind === "oneline").length + misplaced,
+        full: Math.min(total, MAX_FULL_ENTRIES),
+        oneline: Math.max(0, total - MAX_FULL_ENTRIES),
     };
 }
+/**
+ * Count resolved entries in positions 11-50 that need ≤15-word summarization
+ * but are not yet summaries. An entry needs summarization when:
+ *   - it has an indented body (should be stripped), or
+ *   - its kind is "full" (should be demoted to the summary tier), or
+ *   - its header differs from what `formatTodoOneline` would produce (i.e.
+ *     it is a long verbatim header, not a ≤15-word summary).
+ *
+ * Returns 0 when the Resolved section is already compacted (idempotent).
+ * `check compact` uses this to detect in-budget (≤50) TODOs that still need
+ * a formatting rewrite, so `--mode fix` is triggered before entries overflow.
+ */
+export function countTodoPendingSummarization(content) {
+    const spec = SPECS["todo-resolved"];
+    const entries = parseTodoResolved(content, spec);
+    if (entries.length <= MAX_FULL_ENTRIES)
+        return 0;
+    const summaryTier = entries.slice(MAX_FULL_ENTRIES, MAX_TOTAL_ENTRIES);
+    let count = 0;
+    for (const entry of summaryTier) {
+        if (entry.body) {
+            count++;
+            continue;
+        }
+        if (entry.kind === "full") {
+            count++;
+            continue;
+        }
+        // kind=oneline, no body: check if header matches the summary format
+        // by forcing kind="full" through formatTodoOneline (truncation path).
+        const expected = formatTodoOneline({ ...entry, kind: "full" });
+        if (entry.header.trim() !== expected.trim())
+            count++;
+    }
+    return count;
+}
 /**
  * Move resolved rows from severity bands into `## ✓ Resolved`, creating the
  * section when absent. Newly migrated rows are prepended (newest-first folds).
@@ -255,4 +323,3 @@ export function parseEntries(text, specName) {
     const onelineEntries = parseOnelineEntries(archiveBody, spec);
     return [...fullEntries, ...onelineEntries];
 }
-//# sourceMappingURL=parse.js.map

package/dist/hooks/compaction/retention.js

@@ -5,11 +5,11 @@
  * by `apply.ts` (which writes the compacted result back to disk)
  * and by `status.ts` (which counts overflow without writing).
  */
-import { MAX_FULL_ENTRIES, MAX_ONELINE_ENTRIES, applyRetentionCaps } from "../common.js";
+import { MAX_FULL_ENTRIES, MAX_ONELINE_ENTRIES, MAX_TOTAL_ENTRIES, applyRetentionCaps } from "../common.js";
 import { truncateWords } from "./dryRun.js";
 export 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 - 50, 0));
+    return Math.max(Math.max(activeCount - MAX_FULL_ENTRIES, 0), Math.max(archiveCount - MAX_ONELINE_ENTRIES, 0), Math.max(totalCount - MAX_TOTAL_ENTRIES, 0));
 }
 export function stableSortBy(arr, key, reverse = false) {
     return arr
@@ -100,13 +100,16 @@ export function yamlArchiveEntry(specName, entry) {
         const summary = yamlSummaryText(e, "trajectory", "grades");
         return { summary: `Audit ${number}${datePart}: ${summary}` };
     }
+    if (specName === "experiments") {
+        return { number: e.number, summary: yamlSummaryText(e, "conclusion", "label") };
+    }
     if (specName === "session") {
         return { timestamp: String(e.timestamp ?? ""), summary: yamlSummaryText(e, "summary") };
     }
     return { summary: yamlSummaryText(e, "summary") };
 }
 export function yamlSortEntries(entries, specName) {
-    if (specName === "decisions" || specName === "health") {
+    if (specName === "decisions" || specName === "health" || specName === "experiments") {
         return stableSortBy(entries, yamlEntryNumber);
     }
     if (specName === "session") {
@@ -114,12 +117,12 @@ export function yamlSortEntries(entries, specName) {
     }
     return stableSortBy(entries, yamlEntryNumber, true);
 }
-export function yamlRecentFullAndOlder(entries, specName) {
+export function yamlRecentFullAndOlder(entries, specName, fullCapacity = MAX_FULL_ENTRIES) {
     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);
+    const recent = newestFirst.slice(0, fullCapacity);
+    const older = newestFirst.slice(fullCapacity);
     return [yamlSortEntries(recent, specName), older];
 }
 function yamlArchiveSortKey(entry) {
@@ -155,7 +158,7 @@ function decisionSatisfactionState(entry) {
     const state = satisfaction.state;
     return typeof state === "string" ? state : null;
 }
-function decisionRequiresUserReview(entry) {
+export function decisionRequiresUserReview(entry) {
     if (!entry || typeof entry !== "object")
         return true;
     // cast: decision record fields read from parsed decisions.yaml
@@ -163,37 +166,37 @@ function decisionRequiresUserReview(entry) {
     if (!satisfaction || typeof satisfaction !== "object")
         return true;
     const confirmation = satisfaction.user_confirmation;
+    const confirmedBy = confirmation && typeof confirmation === "object" ? confirmation.confirmed_by : null;
+    const confirmedAt = confirmation && typeof confirmation === "object" ? confirmation.confirmed_at : null;
     return (decisionSatisfactionState(entry) !== "user_confirmed_satisfied" ||
         !confirmation ||
         typeof confirmation !== "object" ||
-        Object.keys(confirmation).length === 0);
+        typeof confirmedBy !== "string" ||
+        confirmedBy.trim() === "" ||
+        typeof confirmedAt !== "string" ||
+        confirmedAt.trim() === "");
+}
+export function decisionSatisfiedActiveCount(active) {
+    return active.filter((e) => !decisionRequiresUserReview(e)).length;
 }
 export 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 - 50, 0);
+    return Math.max(protectedActive - MAX_FULL_ENTRIES, protectedArchive - MAX_ONELINE_ENTRIES, protectedActive + protectedArchive - MAX_TOTAL_ENTRIES, 0);
 }
-export function selectDecisionActiveEntries(active) {
+export function selectDecisionActiveEntries(active, fullCapacity = MAX_FULL_ENTRIES) {
     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);
+    const satisfiedCapacity = Math.max(fullCapacity - protectedEntries.length, 0);
+    const keepSatisfied = newestSatisfied.slice(0, satisfiedCapacity);
+    const compactSatisfied = newestSatisfied.slice(satisfiedCapacity);
     return [yamlSortEntries([...protectedEntries, ...keepSatisfied], "decisions"), compactSatisfied];
 }
 export 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 yamlSortEntries([...protectedEntries, ...keepSatisfied], "decisions");
+    // Review pressure is a projection concern, not a write failure. Capacity
+    // selection happens after archive recovery so protected records are never
+    // discarded merely because they are unresolved.
+    return yamlSortEntries(archiveCandidates, "decisions");
 }
 export { applyRetentionCaps };
-//# sourceMappingURL=retention.js.map