agentera 3.0.0-dev.7 → 3.0.0-dev.72

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

package/dist/hooks/compaction/status.js

@@ -1,5 +1,5 @@
 /**
- * Compaction status reporting (read-only).
+ * Compaction status reporting and projection repair.
  *
  * Walks each tracked artifact path, counts active/archive entries, and
  * builds a `CompactionStatus` per artifact plus a per-status operation
@@ -11,13 +11,19 @@ import path from "node:path";
 import { DEFAULT_ARTIFACT_PATHS, parseDocsYamlMapping } from "../common.js";
 import { loadYamlMapping } from "../../core/yaml.js";
 import { COMPACTABLE_YAML_ARTIFACTS, NON_COMPACTABLE_ARTIFACTS } from "./dryRun.js";
-import { decisionProtectedOverflowCount, overLimitCount, yamlArchiveEntries, } from "./retention.js";
-import { compactFile, compactYamlFile } from "./apply.js";
-import { countTodoResolvedEntries } from "./parse.js";
+import { detectStateMode } from "../../state/stateMode.js";
+import { discoverEntities } from "../../state/entityStorage.js";
+import { decisionProtectedOverflowCount, decisionSatisfiedActiveCount, overLimitCount, yamlArchiveEntries, } from "./retention.js";
+import { compactFile, compactYamlBytes, compactYamlFile } from "./apply.js";
+import { countTodoResolvedEntries, countTodoResolvedSectionHeadings, countTodoPendingSummarization, TODO_DROPPED_RECOVERY_GUIDANCE, } from "./parse.js";
 import { YAML_SPEC_BY_ARTIFACT } from "./dryRun.js";
+import { InjectedMutationFailure, withStateMutation, } from "../../state/write/mutation.js";
+import { hydrateDecisionRecords } from "../../state/decisionOverlay.js";
+import { loadProjectionPolicy } from "../../state/projectionPolicy.js";
+import { ARTIFACT_PROTOCOL_PATHS } from "../../registries/artifactProtocolIds.js";
 function artifactPaths(projectRoot) {
     const paths = { ...DEFAULT_ARTIFACT_PATHS };
-    const docsPath = path.join(projectRoot, ".agentera", "docs.yaml");
+    const docsPath = path.join(projectRoot, ARTIFACT_PROTOCOL_PATHS.docs);
     if (fs.existsSync(docsPath)) {
         Object.assign(paths, parseDocsYamlMapping(fs.readFileSync(docsPath, "utf8")));
     }
@@ -71,8 +77,9 @@ function yamlLists(p, activeKey, archiveKey) {
     const archive = data[archiveKey] || [];
     return [Array.isArray(active) ? active : [], Array.isArray(archive) ? archive : []];
 }
-function countStatus(artifact, p, activeCount, archiveCount, protectedOverflowCount = 0) {
+function countStatus(artifact, p, activeCount, archiveCount, protectedOverflowCount = 0, budgetActiveCount, projectionRecovery, projectionState) {
     const totalCount = activeCount + archiveCount;
+    const budgetActive = budgetActiveCount ?? activeCount;
     return {
         artifact,
         path: p,
@@ -80,19 +87,100 @@ function countStatus(artifact, p, activeCount, archiveCount, protectedOverflowCo
         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",
+        over_limit_count: projectionState ? 0 : overLimitCount(budgetActive, archiveCount),
+        reason: projectionState
+            ? projectionState === "over_defaults"
+                ? "lossless projection exceeds display defaults; numbered archives remain authoritative"
+                : "lossless projection is within display defaults"
+            : protectedOverflowCount
+                ? "protected-overflow review pressure"
+                : "uniform_10_40_50",
         protected_overflow_count: protectedOverflowCount,
         exists: true,
+        ...(projectionState ? { projection_state: projectionState } : {}),
+        ...(projectionRecovery ? { projection_recovery: projectionRecovery } : {}),
     };
 }
+function projectionRecoveryFor(projectRoot, artifact, p) {
+    try {
+        return compactYamlBytes(fs.readFileSync(p, "utf8"), artifact, projectRoot).result.recovery;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function computeCompactionStatus(projectRoot) {
+    if (detectStateMode(projectRoot) === "entities") {
+        const discovered = discoverEntities(projectRoot);
+        const issueCount = discovered.issues.length;
+        return [{
+                artifact: "entity_state",
+                path: path.join(projectRoot, ".agentera", "entities"),
+                classification: issueCount ? "error" : "canonical_entities",
+                active_count: discovered.entities.length,
+                archive_count: 0,
+                total_count: discovered.entities.length,
+                over_limit_count: 0,
+                reason: issueCount
+                    ? `${issueCount} canonical entity validation issue(s); run agentera check validate state --format json`
+                    : "canonical entity state is independently stored and is not compacted",
+                protected_overflow_count: 0,
+                exists: true,
+            }];
+    }
     const paths = artifactPaths(projectRoot);
+    const projectionPolicy = loadProjectionPolicy();
     const statuses = [];
     const todoPath = paths.todo;
     if (fs.existsSync(todoPath)) {
-        const counts = countTodoResolvedEntries(fs.readFileSync(todoPath, "utf8"));
-        statuses.push(countStatus("todo#Resolved", todoPath, counts.full, counts.oneline));
+        const todoText = fs.readFileSync(todoPath, "utf8");
+        const headingCount = countTodoResolvedSectionHeadings(todoText);
+        if (headingCount > 1) {
+            // Refuse rather than silently process only the first `## ✓ Resolved`
+            // section: duplicates hide the trailing entries from the budget and
+            // from fix-mode migration. TODO has no lossless numbered archive, so
+            // recovery once entries are dropped is Git-only.
+            statuses.push({
+                artifact: "todo#Resolved",
+                path: todoPath,
+                classification: "error",
+                active_count: null,
+                archive_count: null,
+                total_count: null,
+                over_limit_count: null,
+                reason: `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,
+                protected_overflow_count: 0,
+                exists: true,
+            });
+        }
+        else if (headingCount === 0) {
+            statuses.push({
+                artifact: "todo#Resolved",
+                path: todoPath,
+                classification: "error",
+                active_count: null,
+                archive_count: null,
+                total_count: null,
+                over_limit_count: null,
+                reason: "TODO.md has no required '## ✓ Resolved' section; add exactly one before compacting.",
+                protected_overflow_count: 0,
+                exists: true,
+            });
+        }
+        else {
+            const counts = countTodoResolvedEntries(todoText);
+            const status = countStatus("todo#Resolved", todoPath, counts.full, counts.oneline);
+            // Detect in-budget (≤50) TODOs that still need a formatting rewrite:
+            // rows 11-50 that are long verbatim headers instead of ≤15-word
+            // summaries. This triggers `--mode fix` before entries overflow.
+            const pendingSummarization = countTodoPendingSummarization(todoText);
+            if (pendingSummarization > 0) {
+                status.pending_summarization_count = pendingSummarization;
+            }
+            statuses.push(status);
+        }
     }
     else {
         statuses.push(missingStatus("todo#Resolved", todoPath, "compactable"));
@@ -109,8 +197,17 @@ export function computeCompactionStatus(projectRoot) {
                 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));
+            const protectedOverflowCount = artifact === "decisions"
+                ? decisionProtectedOverflowCount(hydrateDecisionRecords(active, projectRoot), hydrateDecisionRecords(archive, projectRoot))
+                : 0;
+            const budgetActiveCount = artifact === "decisions"
+                ? decisionSatisfiedActiveCount(hydrateDecisionRecords(active, projectRoot))
+                : undefined;
+            statuses.push(countStatus(artifact, p, active.length, archive.length, protectedOverflowCount, budgetActiveCount, projectionRecoveryFor(projectRoot, artifact, p), active.length > projectionPolicy.activeEntries ||
+                archive.length > projectionPolicy.summaryEntries ||
+                active.length + archive.length > projectionPolicy.totalEntries
+                ? "over_defaults"
+                : "within_defaults"));
         }
         else {
             statuses.push(missingStatus(artifact, p, "compactable"));
@@ -182,21 +279,35 @@ function operationForStatus(status, mode) {
         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.projection_recovery?.refused_count) {
+        return base("refused", `projection retained ${status.projection_recovery.retained_full} full entr${status.projection_recovery.retained_full === 1 ? "y" : "ies"}; archive recovery is required before summarization`);
     }
-    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}`);
+    if (status.projection_state === "over_defaults") {
+        return base(mode === "fix" ? "pending_projection" : "projection", "projection exceeds display defaults; archive history remains lossless");
+    }
+    if (!status.over_limit_count && !status.pending_summarization_count) {
+        return base("ok", status.projection_state === "within_defaults"
+            ? "within configured lossless projection defaults"
+            : "within uniform_10_40_50 limits");
+    }
+    if (status.over_limit_count) {
+        return base(mode === "check" ? "over_limit" : "pending_fix", `over uniform_10_40_50 limit by ${status.over_limit_count}`);
+    }
+    // pending_summarization_count > 0 but within budget: rows 11-50 need
+    // ≤15-word summary formatting, not entry removal.
+    const n = status.pending_summarization_count;
+    return base(mode === "check" ? "formatting" : "pending_formatting", `${n} resolved entr${n === 1 ? "y" : "ies"} in summary tier need ≤15-word summarization`);
 }
 export function checkCompaction(projectRoot) {
     return computeCompactionStatus(projectRoot).map((status) => operationForStatus(status, "check"));
 }
-export function fixCompaction(projectRoot) {
+function fixCompactionUnlocked(projectRoot, transaction) {
     const operations = [];
     for (const status of computeCompactionStatus(projectRoot)) {
         const baseline = operationForStatus(status, "fix");
-        if (baseline.action !== "pending_fix") {
+        if (baseline.action !== "pending_fix" &&
+            baseline.action !== "pending_projection" &&
+            baseline.action !== "pending_formatting") {
             operations.push(baseline);
             continue;
         }
@@ -204,10 +315,10 @@ export function fixCompaction(projectRoot) {
         let result;
         try {
             if (status.artifact === "todo#Resolved") {
-                result = compactFile(p, "todo-resolved");
+                result = transaction.mutateProjection(p, (stage) => compactFile(stage, "todo-resolved"));
             }
             else if (status.artifact in YAML_SPEC_BY_ARTIFACT) {
-                result = compactYamlFile(p, status.artifact);
+                result = transaction.mutateProjection(p, (stage) => compactYamlFile(stage, status.artifact, projectRoot));
             }
             else {
                 operations.push({ status, mode: "fix", action: "skipped", changed: false, result: null, message: `no fixer registered for ${status.artifact}` });
@@ -215,6 +326,8 @@ export function fixCompaction(projectRoot) {
             }
         }
         catch (exc) {
+            if (exc instanceof InjectedMutationFailure)
+                throw exc;
             operations.push({ status, mode: "fix", action: "error", changed: false, result: null, message: exc.message });
             continue;
         }
@@ -226,16 +339,22 @@ export function fixCompaction(projectRoot) {
             result,
             message: `full ${result.full_before}->${result.full_after}; ` +
                 `archive ${result.oneline_before}->${result.oneline_after}; ` +
-                `dropped ${result.dropped}`,
+                `omitted ${result.omitted_count ?? 0}; dropped ${result.dropped}`,
         });
     }
     return operations;
 }
-export function runCompaction(projectRoot, mode = "check") {
+export function fixCompaction(projectRoot, options = {}) {
+    return withStateMutation(projectRoot, (transaction) => fixCompactionUnlocked(projectRoot, transaction), options);
+}
+export function runCompaction(projectRoot, mode = "check", options = {}) {
     if (mode === "check")
         return checkCompaction(projectRoot);
-    if (mode === "fix")
-        return fixCompaction(projectRoot);
+    if (mode === "fix") {
+        if (detectStateMode(projectRoot) === "entities") {
+            return computeCompactionStatus(projectRoot).map((status) => operationForStatus(status, "fix"));
+        }
+        return fixCompaction(projectRoot, options);
+    }
     throw new Error(`unknown compaction mode: ${mode}`);
 }
-//# sourceMappingURL=status.js.map

package/dist/hooks/compaction/types.js

@@ -3,4 +3,3 @@
  * status reporting, the apply writers, and the CLI consumers.
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/hooks/validateArtifact/agentFacing.js

@@ -7,4 +7,3 @@
 import { ARTIFACT_PROTOCOL_PATHS, HUMAN_FACING_ARTIFACT_IDS } from "../../registries/artifactProtocolIds.js";
 export { ARTIFACT_PROTOCOL_PATHS, HUMAN_FACING_ARTIFACT_IDS };
 export const AGENT_FACING_ARTIFACT_IDS = new Set(Object.keys(ARTIFACT_PROTOCOL_PATHS).filter((id) => !HUMAN_FACING_ARTIFACT_IDS.has(id)));
-//# sourceMappingURL=agentFacing.js.map

package/dist/hooks/validateArtifact/index.js

@@ -1,9 +1,6 @@
 /**
- * Public surface for the validate-artifact hook. The CLI command
- * (`packages/cli/src/cli/commands/validate.ts`), the smoke checks, and
- * the dispatch entry all import the public classes from this barrel
- * to keep import paths stable as the file is split across the
- * per-responsibility submodules.
+ * Artifact validation used by the explicit `agentera check validate artifact`
+ * command and state publication.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -11,10 +8,8 @@ import { loadYamlMapping } from "../../core/yaml.js";
 import { resolvePath } from "../../core/paths.js";
 import { normalizeArtifactProtocolId } from "../../registries/artifactProtocolIds.js";
 import { DEFAULT_ARTIFACT_PATHS } from "../common.js";
-import { ArtifactWrite, RuntimeEventParser } from "./runtime.js";
-import { isMapping } from "./schema.js";
 import { validateMd } from "./markdown.js";
-import { artifactForWrite, defaultArtifactPath, readIfNeeded, compactAfterValidWrite, } from "./traversal.js";
+import { defaultArtifactPath, readIfNeeded, } from "./traversal.js";
 import { schemasDirDefault, validateYamlContent } from "./violations.js";
 import { AGENT_FACING_ARTIFACT_IDS, HUMAN_FACING_ARTIFACT_IDS } from "./agentFacing.js";
 export class ArtifactSchemaValidator {
@@ -43,37 +38,6 @@ export class ArtifactSchemaValidator {
     validateMarkdown(content, name, schema = null) {
         return validateMd(content, name, schema);
     }
-    validateWrite(write, cwd) {
-        const absPath = path.isAbsolute(write.file_path) ? write.file_path : path.join(cwd, write.file_path);
-        const rel = path.relative(cwd, absPath).replace(/\\/g, "/");
-        const basename = path.basename(absPath);
-        const artifact = artifactForWrite(absPath, rel, basename, cwd);
-        if (artifact && AGENT_FACING_ARTIFACT_IDS.has(artifact)) {
-            const schema = this.loadSchema(artifact);
-            if (schema === null)
-                return [];
-            if (Object.keys(schema).length === 0)
-                return [`${artifact}: schema file is empty or contains no valid definitions`];
-            const content = readIfNeeded(write.content, absPath);
-            if (content === null)
-                return [];
-            let violations = this.validateYaml(content, schema, artifact);
-            if (violations.length > 0)
-                return violations;
-            return compactAfterValidWrite(artifact, absPath);
-        }
-        if (artifact && HUMAN_FACING_ARTIFACT_IDS.has(artifact)) {
-            const content = readIfNeeded(write.content, absPath);
-            if (content === null)
-                return [];
-            const schema = this.loadSchema(artifact);
-            const violations = this.validateMarkdown(content, artifact, schema);
-            if (violations.length > 0)
-                return violations;
-            return compactAfterValidWrite(artifact, absPath);
-        }
-        return [];
-    }
     validateExplicit(artifact, filePath, cwd) {
         const content = readIfNeeded(null, filePath);
         if (content === null)
@@ -103,33 +67,11 @@ export class ArtifactSchemaValidator {
 export function loadSchema(name) {
     return new ArtifactSchemaValidator().loadSchema(name);
 }
-export class HookCliAdapter {
-    parser;
+export class ArtifactValidationAdapter {
     validator;
-    constructor(parser, validator) {
-        this.parser = parser ?? new RuntimeEventParser();
+    constructor(validator) {
         this.validator = validator ?? new ArtifactSchemaValidator();
     }
-    run(raw, defaultCwd = null) {
-        let data;
-        try {
-            if (!raw.trim())
-                return [0, []];
-            data = JSON.parse(raw);
-        }
-        catch {
-            return [0, []];
-        }
-        if (!isMapping(data))
-            return [0, []];
-        const write = this.parser.parse(data);
-        if (write === null)
-            return [0, []];
-        // cast: cwd read from the runtime hook's JSON stdin payload
-        const cwd = (data.cwd ?? defaultCwd ?? process.cwd());
-        const violations = this.validator.validateWrite(write, cwd);
-        return violations.length > 0 ? [2, violations] : [0, []];
-    }
     runExplicit(artifact, filePath, cwd) {
         artifact = artifact.trim();
         const defaultPath = defaultArtifactPath(artifact, cwd);
@@ -147,5 +89,4 @@ export class HookCliAdapter {
         return violations.length > 0 ? [2, payload] : [0, payload];
     }
 }
-export { ArtifactWrite, RuntimeEventParser, resolvePath };
-//# sourceMappingURL=index.js.map
+export { resolvePath };

package/dist/hooks/validateArtifact/markdown.js

@@ -5,18 +5,14 @@
  * section check (ITEM, RELEASE, TOKEN).
  */
 import { parseTodoMarkdownListItem } from "../../cli/todoMarkdown.js";
-import { classifyTodoSectionHeading, isLegacyStrikethroughTodoLine, } from "../compaction/parse.js";
+import { classifyTodoSectionHeading, countTodoResolvedSectionHeadings, isLegacyStrikethroughTodoLine, } from "../compaction/parse.js";
 import { isMapping } from "./schema.js";
-const TODO_RESOLVED_HEADING_RE = /^##\s*(?:✓\s+)?Resolved\s*$/im;
 function validateTodoResolvedPlacement(content, name) {
     const violations = [];
     let section = "other";
-    let hasResolvedHeading = TODO_RESOLVED_HEADING_RE.test(content);
-    let hasResolvedItems = false;
     for (const line of content.split(/\r\n|\r|\n/)) {
         const kind = classifyTodoSectionHeading(line);
         if (kind === "resolved") {
-            hasResolvedHeading = true;
             section = "resolved";
             continue;
         }
@@ -33,20 +29,24 @@ function validateTodoResolvedPlacement(content, name) {
             continue;
         const parsed = parseTodoMarkdownListItem(trimmed);
         if (parsed?.status === "resolved") {
-            hasResolvedItems = true;
             if (section === "severity") {
                 violations.push(`${name}: resolved checkbox item must live under '## ✓ Resolved', not in severity bands`);
                 break;
             }
         }
         if (isLegacyStrikethroughTodoLine(trimmed)) {
-            hasResolvedItems = true;
             violations.push(`${name}: legacy strikethrough resolved items are not allowed; use '- [x]' under '## ✓ Resolved'`);
             break;
         }
     }
-    if (hasResolvedItems && !hasResolvedHeading) {
-        violations.push(`${name}: missing '## ✓ Resolved' section for resolved items`);
+    // Exactly one section keeps parsing and compaction unambiguous, including
+    // before the first item is resolved. See todo.yaml TC8.
+    const resolvedHeadingCount = countTodoResolvedSectionHeadings(content);
+    if (resolvedHeadingCount === 0) {
+        violations.push(`${name}: missing required '## ✓ Resolved' section`);
+    }
+    else if (resolvedHeadingCount > 1) {
+        violations.push(`${name}: ${resolvedHeadingCount} '## ✓ Resolved' sections found; merge into exactly one (duplicate sections hide entries from the compaction gate and parsing processes only the first).`);
     }
     return violations;
 }
@@ -143,4 +143,3 @@ export function validateMdTokens(content, name, violations) {
         violations.push(`${name}: missing YAML code block with token definitions (expected '\`\`\`yaml')`);
     }
 }
-//# sourceMappingURL=markdown.js.map