agentera 3.0.0-dev.75 → 3.0.0-dev.77

package/dist/registries/glossaryCandidateProjectionAuthority.js

@@ -12,13 +12,61 @@ function sameStrings(actual, expected) {
 function nonEmpty(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
+const EXPLICIT_ABSTENTION_KEYS = [
+    "attributed_quotation",
+    "ambiguous_reference",
+    "conflicting_meaning",
+    "empty_meaning",
+    "empty_term",
+    "example_context",
+    "hypothetical_definition",
+    "malformed_span",
+    "meaning_bound_exceeded",
+    "negated_definition",
+    "indirect_question",
+    "future_definition",
+    "project_only_scope",
+    "question_definition",
+    "retracted_definition",
+    "sarcasm_marker",
+    "stale_anchor",
+    "structural_fragment",
+    "term_bound_exceeded",
+    "unsafe_syntax",
+    "uncertain_scope",
+    "unresolved_anchor",
+    "provenance_incomplete",
+    "user_authorship_required",
+];
+const RECURRING_ABSTENTION_KEYS = [
+    "agent_only_evidence",
+    "copied_content",
+    "provenance_missing",
+    "insufficient_independent_origins",
+    "insufficient_projects",
+    "insufficient_sessions",
+    "conversation_evidence_incomplete",
+    "conversation_evidence_bound_exceeded",
+    "project_only_scope",
+    "noise_term",
+    "too_many_qualifying_origins",
+    "user_authorship_required",
+];
 /** Validate the authority-owned bounds for the internal candidate projection. */
 export function validatePersonalCandidateProjectionAuthority(authority) {
     const mining = mapping(authority.personal_mining_authority);
     const projection = mapping(mining?.candidate_projection);
+    const refreshProduction = mapping(projection?.refresh_production);
+    const refreshProjection = mapping(refreshProduction?.projection);
+    const refreshConcurrency = mapping(refreshProduction?.concurrency);
+    const refreshContender = mapping(refreshConcurrency?.contender);
+    const partialFailure = mapping(refreshProduction?.partial_failure);
+    const safeReplacement = mapping(refreshProduction?.safe_replacement);
     const selection = mapping(projection?.selection);
     const sourceFamilies = mapping(selection?.source_families);
     const projectIdentity = mapping(selection?.project_identity);
+    const miningSummary = mapping(projection?.mining_summary);
+    const summaryReconciliation = mapping(miningSummary?.reconciliation);
     const excerpts = mapping(projection?.excerpts);
     const excerptCompatibility = mapping(excerpts?.compatibility);
     const retention = mapping(projection?.retention);
@@ -35,6 +83,109 @@ export function validatePersonalCandidateProjectionAuthority(authority) {
     const privacy = mapping(mining?.privacy);
     const contentExclusion = mapping(privacy?.content_exclusion);
     const storageFilesystem = mapping(mapping(privacy?.storage)?.filesystem);
+    const malformedProjectionReplacementException = mapping(storageFilesystem?.malformed_candidate_projection_replacement_exception);
+    const errors = [];
+    if (refreshProduction?.status !== "active" ||
+        refreshProduction?.runtime !==
+            "packages/cli/src/analytics/personalGlossaryRefreshProjection.ts#produceCurrentPersonalGlossaryProjection" ||
+        refreshProduction?.trigger !== "explicit_consented_evidence_refresh_success" ||
+        refreshProjection?.count !== "exactly_one" ||
+        refreshProjection?.generation_binding !== "exact_published_evidence_generation" ||
+        refreshProjection?.policy_binding !== "exact_personal_mining_policy_version" ||
+        !nonEmpty(refreshProduction?.rule)) {
+        errors.push("personal_mining_authority refresh production must require one projection bound to the exact evidence generation and mining policy");
+    }
+    if (refreshConcurrency?.serialization !== "profile_local_exclusive_refresh_commit" ||
+        refreshConcurrency?.lock_lifetime !==
+            "before_evidence_publication_through_projection_binding_verification" ||
+        refreshContender?.refresh_outcome !== "failure" ||
+        refreshContender?.process_exit !== "nonzero" ||
+        refreshContender?.local_history_read !== false ||
+        refreshContender?.tier_write !== false ||
+        refreshContender?.projection_status !== "failed" ||
+        refreshContender?.projection_write !== false ||
+        refreshContender?.evidence_status !== "current_generation_remains_readable" ||
+        refreshContender?.recovery !== "npx -y agentera@next report refresh --consent local-history") {
+        errors.push("personal_mining_authority refresh production must serialize evidence and projection commit and fail contenders without writes");
+    }
+    if (partialFailure?.refresh_outcome !== "failure" ||
+        partialFailure?.process_exit !== "nonzero" ||
+        partialFailure?.evidence_status !== "published" ||
+        partialFailure?.projection_status !== "failed" ||
+        partialFailure?.tier_write_reporting !== "evidence_published_projection_not_written" ||
+        partialFailure?.current_generation !== "published_evidence_remains_current") {
+        errors.push("personal_mining_authority refresh production must report evidence and projection outcomes separately and preserve published evidence on projection failure");
+    }
+    if (safeReplacement?.authorization !== "explicit_consented_refresh_only" ||
+        safeReplacement?.target !== "exact_configured_candidate_projection_file" ||
+        safeReplacement?.precondition !== "existing_owned_regular_file_is_malformed" ||
+        safeReplacement?.operation !== "atomic_regular_file_replacement" ||
+        !sameStrings(safeReplacement?.reject, [
+            "symlink",
+            "non_regular_file",
+            "configured_path_mismatch",
+            "path_escape",
+        ]) ||
+        safeReplacement?.filesystem_exception !==
+            "personal_mining_authority.privacy.storage.filesystem.malformed_candidate_projection_replacement_exception" ||
+        !sameStrings(safeReplacement?.replaceable_state, ["candidate_projection"]) ||
+        !sameStrings(safeReplacement?.preserved_state, [
+            "current_evidence_generation",
+            "review_records",
+            "personal_profile",
+            "project_state",
+            "project_glossary",
+        ])) {
+        errors.push("personal_mining_authority refresh replacement must target only the exact owned regular projection and preserve evidence, review, profile, and project state");
+    }
+    if (malformedProjectionReplacementException?.scope !==
+        "malformed_candidate_projection_replacement_only" ||
+        malformedProjectionReplacementException?.authorization !== "explicit_consented_refresh_only" ||
+        malformedProjectionReplacementException?.precondition !==
+            "existing_owned_regular_file_is_malformed" ||
+        malformedProjectionReplacementException?.target !==
+            "exact_configured_candidate_projection_file" ||
+        malformedProjectionReplacementException?.inspection !==
+            "lstat_exact_target_without_following_symlinks" ||
+        malformedProjectionReplacementException?.required_type !== "regular_file" ||
+        !sameStrings(malformedProjectionReplacementException?.reject, [
+            "symlink",
+            "non_regular_file",
+            "configured_path_mismatch",
+            "path_escape",
+        ]) ||
+        malformedProjectionReplacementException?.operation !== "atomic_regular_file_replacement" ||
+        malformedProjectionReplacementException?.outside_scope !== "configured_path_use_as_provided") {
+        errors.push("personal_mining_authority filesystem exception must confine malformed projection replacement to the exact configured regular file with no-follow inspection");
+    }
+    if (miningSummary?.schema_version !== "agentera.personalGlossaryMiningSummary.v1" ||
+        miningSummary?.location !== "report.mining_summary" ||
+        !sameStrings(miningSummary?.family_fields, [
+            "candidate_count",
+            "abstention_count",
+            "abstentions_by_reason",
+        ]) ||
+        !sameStrings(miningSummary?.explicit_abstention_keys, EXPLICIT_ABSTENTION_KEYS) ||
+        !sameStrings(miningSummary?.recurring_abstention_keys, RECURRING_ABSTENTION_KEYS) ||
+        summaryReconciliation?.fixed_keys !== "all_keys_present_as_nonnegative_integers" ||
+        summaryReconciliation?.family_abstentions !== "abstention_count_equals_sum_of_reason_counts" ||
+        summaryReconciliation?.total_candidates !==
+            "total_equals_explicit_plus_recurring_candidate_counts" ||
+        summaryReconciliation?.total_abstentions !==
+            "total_equals_explicit_plus_recurring_abstention_counts" ||
+        summaryReconciliation?.projection_input !== "report_input_count_equals_total_candidate_count" ||
+        !sameStrings(miningSummary?.forbidden_content, [
+            "terms",
+            "source_ids",
+            "evidence_anchors",
+            "project_ids",
+            "project_keys",
+            "paths",
+            "excerpts",
+        ]) ||
+        !nonEmpty(miningSummary?.rule)) {
+        errors.push("personal_mining_authority candidate projection must retain reconciled fixed-key aggregate mining counts without sensitive identity or content");
+    }
     if (projection?.status !== "active" ||
         projection?.runtime !==
             "packages/cli/src/analytics/personalGlossaryCandidateProjection.ts#projectPersonalGlossaryCandidates" ||
@@ -106,8 +257,7 @@ export function validatePersonalCandidateProjectionAuthority(authority) {
         currentGeneration?.unavailable_behavior !== "current_generation_unavailable" ||
         currentGeneration?.stale_projection_behavior !== "projection_stale" ||
         !nonEmpty(retrieval?.rule) ||
-        retrievalCommand?.canonical !==
-            "npx -y agentera@next report personal-glossary-candidates" ||
+        retrievalCommand?.canonical !== "npx -y agentera@next report personal-glossary-candidates" ||
         retrievalCommand?.namespace !== "report" ||
         retrievalCommand?.format !== "json" ||
         retrievalCommand?.project_checkout !== "not_required" ||
@@ -189,9 +339,7 @@ export function validatePersonalCandidateProjectionAuthority(authority) {
         storageFilesystem?.symlink_confinement !== "not_claimed" ||
         !nonEmpty(storageFilesystem?.rule) ||
         !nonEmpty(persistence?.rule)) {
-        return [
-            "personal_mining_authority candidate projection must bound deterministic allocation, private retrieval, content exclusion, safe excerpts, host-filesystem storage, retention, and user-local replay",
-        ];
+        errors.push("personal_mining_authority candidate projection must bound deterministic allocation, private retrieval, content exclusion, safe excerpts, host-filesystem storage, retention, and user-local replay");
     }
-    return [];
+    return errors;
 }

package/dist/registries/glossaryCandidateProjectionContract.js

@@ -23,6 +23,7 @@ export function personalGlossaryCandidateProjectionContract(pathname = glossaryE
     const retention = mapping(privacy?.retention);
     const projectIdentity = mapping(selection?.project_identity);
     const persistence = mapping(projection?.persistence);
+    const miningSummary = mapping(projection?.mining_summary);
     const families = mapping(selection?.source_families);
     const sourceFamilies = Object.fromEntries(Object.entries(families ?? {}).flatMap(([family, values]) => Array.isArray(values) && values.every((value) => typeof value === "string")
         ? [[family, [...values]]]
@@ -53,6 +54,9 @@ export function personalGlossaryCandidateProjectionContract(pathname = glossaryE
             ? contentExclusion.candidate_reason
             : "",
         excerptSensitiveContentAction: typeof contentExclusion?.excerpt_action === "string" ? contentExclusion.excerpt_action : "",
+        miningSummarySchemaVersion: typeof miningSummary?.schema_version === "string" ? miningSummary.schema_version : "",
+        explicitAbstentionKeys: strings(miningSummary?.explicit_abstention_keys),
+        recurringAbstentionKeys: strings(miningSummary?.recurring_abstention_keys),
         candidateReadCommand: projectGlossaryDevelopmentValue(retrievalCommand?.canonical, "candidate_retrieval.command"),
         candidateReadSchemaVersion: typeof list?.schema_version === "string" ? list.schema_version : "",
         candidateReadDefaultLimit: typeof list?.default_limit === "number" ? list.default_limit : 0,

package/dist/registries/glossaryEntryContract.js

@@ -388,8 +388,8 @@ export function validateGlossaryEntryContract(pathname = glossaryEntryAuthorityP
         errors.push("project glossary digest and build publication must remain active under the declared consumer boundary");
     }
     if (confirmedVariantGuard?.owner !==
-        "packages/cli/src/validate/v1LegacyCruft.ts#scanPost30CruftViolations" ||
-        confirmedVariantGuard?.validation_surface !== "packages/cli/test/cli/v1LegacyCruft.test.ts" ||
+        "packages/cli/src/validate/glossaryVariantGuard.ts#scanConfirmedVariantViolations" ||
+        confirmedVariantGuard?.validation_surface !== "packages/cli/test/cli/glossaryVariantGuard.test.ts" ||
         confirmedVariantGuard?.loader !==
             "packages/cli/src/state/write/glossaryPublication.ts#loadProjectGlossaryDocument" ||
         confirmedVariantGuard?.matching !== "exact_case_sensitive_boundary_aware_literal" ||
@@ -424,7 +424,7 @@ export function validateGlossaryEntryContract(pathname = glossaryEntryAuthorityP
             "vendor",
         ]) ||
         !nonEmpty(confirmedVariantGuard?.exclusion_rule)) {
-        errors.push("confirmed variant guard must reuse validated project glossary pairs and bounded legacy-cruft exclusions");
+        errors.push("confirmed variant guard must reuse validated project glossary pairs and bounded exclusions");
     }
     if (proposalValidation?.owner !== "audit" ||
         proposalValidation?.shared_runtime !==

package/dist/registries/packagePublication.js

@@ -52,12 +52,12 @@ export const ACTIVATION_CENSUS_AUTHORITY = deepFreeze({
         cli: { count: 27, sha256: "986a637f5c11c57ab7a897a01bd291d0811846e5339c3831c715932cf9659ad4" },
         capability: { count: 12, sha256: "007e1157a892fec54182b1803aeaa442cf8e2e332e6a055c3bd020e2b0731867" },
         runtime: { count: 81, sha256: "03fe600a3a27f05daf0d1b59c16b00bedc354a13c70ea60be0b457175fdf743c" },
-        reference: { count: 25, sha256: "2094946cd6e189c6ab3db16dd0725596cec759abcea88d8335b05215b65ccfc2" },
+        reference: { count: 26, sha256: "aa1ad513d89b66c9133a8572cef2dce760e76d6ee39d2ffa2d4e312578dcc847" },
         state: { count: 38, sha256: "7ab0dd6ef1b1b1ce66bd9ea94d1de3d542528233e928a44102e289bf12416681" },
         package: { count: 67, sha256: "d73cd86fed39057cf9ae73e462a59e842372392b1e88846f2b220378a2ff75cc" },
         bootstrap: { count: 34, sha256: "71c2038744e2518a6adb722acbb5f9352bddfb5d1c92eeb0e347297ef2ca2f1e" },
     },
-    total: { count: 284, sha256: "3f30b26839aec47639f2197c9efda5caf2a73d5afca9fb38ff9a341e18a72b98" },
+    total: { count: 285, sha256: "042700a26b34afba57b60eaf4a4529d9e02ce39d8574e6883dfb892eebc64fd5" },
 });
 /** Each dimension names the production contract it observes independently. */
 export const ACTIVATION_EVIDENCE_SOURCES = deepFreeze({

package/dist/runtime/nativeResourceCleanup.js

@@ -313,6 +313,7 @@ export function loadNativeResourceCleanupContract(contractPath = path.join(resol
         configuration: data.configuration_inventory.map((unit) => ({
             id: unit.id,
             host: unit.host,
+            destination: unit.destination,
             key: unit.key,
         })),
     };

package/dist/state/entityMigrationTodo.js

@@ -110,7 +110,7 @@ export function todoReconciliationMigrationPlan(todoPath, files, entries) {
     }));
     if (byLine.size !== rows.length)
         return undefined;
-    const lines = todo.bytes.toString("utf8").split(/\r?\n/);
+    const lines = todo.bytes.toString("utf8").split(/\r?\n/).map((line) => line === "## Resolved" ? "## ✓ Resolved" : line);
     for (const row of rows) {
         const entry = byLine.get(row.index);
         if (!entry?.proposed_target)

package/dist/state/todoDocsEntities.js

@@ -22,6 +22,7 @@ import { loadTodoReconciliationActivation, todoLegacyRowFingerprint, todoReconci
 import { normalizeTodoOwnerCorrectionEvidence, planTodoOwnerCorrection, planTodoRepair } from "./todoReconciliationRepair.js";
 import { readTodoMarkdown, renderManagedMarkdown } from "./todoMarkdownProjection.js";
 import { inactiveTodoActivationSafety, rejectUnsafeInactiveTodoActivation, unsafeInactiveDuplicateDiagnosis } from "./todoActivationSafety.js";
+import { assertTodoSeverityHeadingStructure, todoSeveritySectionForHeading } from "./todoSeverityHeadings.js";
 const ID = /^[a-z]{10}$/;
 const SHA256 = /^[a-f0-9]{64}$/;
 const TODO = { artifact: "todo", boundary: "todo_item", order: "severity_then_status_then_markdown_order_then_id" };
@@ -139,6 +140,7 @@ function todoAuthority() {
     };
 }
 export function managedRows(markdown, activation, entities) {
+    assertTodoSeverityHeadingStructure(markdown);
     const result = new Map();
     const order = new Map();
     const legacy = [];
@@ -146,7 +148,7 @@ export function managedRows(markdown, activation, entities) {
     markdown.split(/\r?\n/).forEach((line, index) => {
         const heading = line.trim().match(/^##\s+(.+)$/)?.[1]?.toLowerCase();
         if (heading)
-            section = heading.includes("critical") ? "critical" : heading.includes("degraded") ? "degraded" : heading.includes("annoying") ? "annoying" : heading.includes("resolved") ? "resolved" : heading.includes("normal") ? "normal" : heading === "notes" ? null : section;
+            section = todoSeveritySectionForHeading(line) ?? (heading === "notes" ? null : section);
         const item = parseTodoMarkdownListItem(line.trim());
         if (!item)
             return;
@@ -291,16 +293,17 @@ function inspectTodoReadView(root, sourceRoot, entities) {
     catch (error) {
         if (error instanceof StateWriteInputError && /Markdown/i.test(error.body.message))
             throw error;
+        const diagnosis = error instanceof StateWriteInputError && mapping(error.body.diagnosis) ? error.body.diagnosis : undefined;
         return {
             rows: new Map(),
             drift: {
                 schema_version: RECONCILIATION_VERSION,
-                status: "unsafe",
+                status: "conflict", action_required: true,
                 read_effect: "none",
                 next_write_boundary: "atomic_reconciliation",
                 authority: todoAuthority(),
                 counts: { managed: 0, drifted: 0, conflicts: 1 },
-                items: [],
+                items: [], ...(diagnosis ? { diagnosis } : {}),
             },
         };
     }
@@ -669,6 +672,8 @@ export function mutateTodoDocsEntity(req, options = {}) {
         const correctingOwners = artifact === "todo" && req.spec.verb === "correct-owners";
         const ownerEvidence = correctingOwners ? normalizeTodoOwnerCorrectionEvidence(req.input ?? {}) : null;
         const pending = todoBinding ? inspectTodoReconciliation(pinnedRoot, todoBinding) : [];
+        if (artifact === "todo")
+            assertTodoSeverityHeadingStructure(readTodoMarkdown(todoPublicPath(pinnedRoot, sourceRoot)).text);
         const initialActivation = artifact === "todo" ? loadTodoReconciliationActivation(pinnedRoot) : null;
         if (artifact === "todo" && ["activate", "repair", "correct-owners"].includes(req.spec.verb)) {
             const repairing = req.spec.verb === "repair";

package/dist/state/todoMarkdownProjection.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import { renderTodoPublicRecord } from "../cli/todoMarkdown.js";
 import { reject } from "./write/errors.js";
+import { TODO_SEVERITY_HEADINGS, todoSeveritySectionForHeading } from "./todoSeverityHeadings.js";
 const TODO_MARKDOWN_MAX_BYTES = 1024 * 1024;
 export function readTodoMarkdown(target) {
     if (!fs.existsSync(target))
@@ -21,7 +22,7 @@ export function readTodoMarkdown(target) {
     return { bytes, text: text };
 }
 function sectionFor(record) { return record.status === "resolved" ? "resolved" : String(record.severity); }
-function headingFor(section) { return section === "resolved" ? "## ✓ Resolved" : `## → ${section[0].toUpperCase()}${section.slice(1)}`; }
+function headingFor(section) { return TODO_SEVERITY_HEADINGS.find((entry) => entry.section === section).heading; }
 function rowFor(id, record) { return `- [${record.status === "resolved" ? "x" : " "}] [id:${id}] ${renderTodoPublicRecord(record)}`; }
 export function renderManagedMarkdown(markdown, records, existing) {
     const byLine = new Map([...existing.values()].map((row) => [row.line, row]));
@@ -29,16 +30,27 @@ export function renderManagedMarkdown(markdown, records, existing) {
     const lines = markdown.split(/\r?\n/).flatMap((line, index) => { const row = byLine.get(index); if (!row)
         return [line]; const record = records.get(row.id); if (!record || sectionFor(record) !== row.section)
         return []; retained.add(row.id); return [rowFor(row.id, record)]; });
-    for (const section of ["critical", "degraded", "normal", "annoying", "resolved"]) {
+    for (const { section } of TODO_SEVERITY_HEADINGS) {
         const ids = [...records.entries()].filter(([id, record]) => !retained.has(id) && sectionFor(record) === section).sort(([left], [right]) => { const a = existing.get(left); const b = existing.get(right); return (a?.section === section ? a.snapshot.order : Number.MAX_SAFE_INTEGER) - (b?.section === section ? b.snapshot.order : Number.MAX_SAFE_INTEGER) || left.localeCompare(right); }).map(([id]) => id);
         if (!ids.length)
             continue;
         let heading = lines.findIndex((line) => line.trim().toLowerCase() === headingFor(section).toLowerCase());
         if (heading < 0) {
-            if (lines.at(-1)?.trim())
-                lines.push("");
-            lines.push(headingFor(section));
-            heading = lines.length - 1;
+            const order = TODO_SEVERITY_HEADINGS.findIndex((entry) => entry.section === section);
+            const later = lines.findIndex((line) => {
+                const found = todoSeveritySectionForHeading(line);
+                return found !== null && TODO_SEVERITY_HEADINGS.findIndex((entry) => entry.section === found) > order;
+            });
+            if (later >= 0) {
+                lines.splice(later, 0, headingFor(section), "");
+                heading = later;
+            }
+            else {
+                if (lines.at(-1)?.trim())
+                    lines.push("");
+                lines.push(headingFor(section));
+                heading = lines.length - 1;
+            }
         }
         let insert = heading + 1;
         while (insert < lines.length && !/^##\s+/.test(lines[insert].trim()))

package/dist/state/todoReconciliationInspection.js

@@ -76,6 +76,19 @@ function errorCounts(error) {
         ...(diagnosis.omitted_count !== undefined ? { omitted_count: diagnosis.omitted_count } : {}),
     };
 }
+function errorRisks(error) {
+    return error instanceof StateWriteInputError && mapping(error.body.diagnosis) ? error.body.diagnosis : undefined;
+}
+function errorInspection(state, error) {
+    const risks = errorRisks(error);
+    const result = inspection(state, errorCounts(error), risks);
+    if (risks?.classification === "todo_severity_heading_structure" && error instanceof StateWriteInputError) {
+        result.preview_command = null;
+        result.apply_command = null;
+        result.recovery_command = error.body.recovery ?? result.recovery_command;
+    }
+    return result;
+}
 /** Read-only classification shared by prime, doctor, and whole-state validation. */
 export function inspectTodoReconciliationState(root, sourceRoot = resolveSourceRoot(), discovery) {
     try {
@@ -112,7 +125,7 @@ export function inspectTodoReconciliationState(root, sourceRoot = resolveSourceR
             return inspection(safety.safe ? "inactive" : "unsafe_inactive", safety.counts, safety.safe ? undefined : safety.risks);
         }
         catch (error) {
-            return inspection("unsafe_inactive", errorCounts(error));
+            return errorInspection("unsafe_inactive", error);
         }
     }
     try {
@@ -122,7 +135,7 @@ export function inspectTodoReconciliationState(root, sourceRoot = resolveSourceR
         return inspection(unsafe ? "unsafe_active" : "healthy_active", counts);
     }
     catch (error) {
-        return inspection("unsafe_active", errorCounts(error));
+        return errorInspection("unsafe_active", error);
     }
 }
 function publicSnapshot(record, order) {

package/dist/state/todoReconciliationRepair.js

@@ -3,6 +3,7 @@ import { parseTodoMarkdownListItem, renderTodoPublicRecord } from "../cli/todoMa
 import { canonicalRecordJson } from "./archiveDiscovery.js";
 import { reject } from "./write/errors.js";
 import { todoLegacyRowFingerprint, TODO_OWNER_CORRECTION_INPUT_VERSION, TODO_OWNER_CORRECTION_PREVIEW_COMMAND, TODO_REPAIR_PREVIEW_COMMAND } from "./todoReconciliationActivation.js";
+import { assertTodoSeverityHeadingStructure, todoSeveritySectionForHeading } from "./todoSeverityHeadings.js";
 const RECONCILIATION_VERSION = "agentera.todoReconciliation.v1";
 const DIAGNOSTIC_LIMIT = 20;
 function mapping(value) { return value !== null && typeof value === "object" && !Array.isArray(value); }
@@ -91,6 +92,7 @@ export function normalizeTodoOwnerCorrectionEvidence(input) {
     };
 }
 function scanRows(markdown) {
+    assertTodoSeverityHeadingStructure(markdown);
     const managed = new Map();
     const legacy = [];
     const order = new Map();
@@ -98,7 +100,7 @@ function scanRows(markdown) {
     markdown.split(/\r?\n/).forEach((line, index) => {
         const heading = line.trim().match(/^##\s+(.+)$/)?.[1]?.toLowerCase();
         if (heading)
-            section = heading.includes("critical") ? "critical" : heading.includes("degraded") ? "degraded" : heading.includes("annoying") ? "annoying" : heading.includes("resolved") ? "resolved" : heading.includes("normal") ? "normal" : heading === "notes" ? null : section;
+            section = todoSeveritySectionForHeading(line) ?? (heading === "notes" ? null : section);
         const item = parseTodoMarkdownListItem(line.trim());
         if (!item)
             return;

package/dist/state/todoSeverityHeadings.js

@@ -0,0 +1,71 @@
+import { reject } from "./write/errors.js";
+export const TODO_SEVERITY_HEADINGS = [
+    { section: "critical", name: "Critical", heading: "## ⇶ Critical" },
+    { section: "degraded", name: "Degraded", heading: "## ⇉ Degraded" },
+    { section: "normal", name: "Normal", heading: "## → Normal" },
+    { section: "annoying", name: "Annoying", heading: "## ⇢ Annoying" },
+    { section: "resolved", name: "Resolved", heading: "## ✓ Resolved" },
+];
+const DIAGNOSTIC_LIMIT = 20;
+const byName = new Map(TODO_SEVERITY_HEADINGS.map((entry) => [entry.name.toLowerCase(), entry]));
+function candidate(line) {
+    const content = line.trim().match(/^##\s+(.+?)\s*$/)?.[1];
+    if (!content)
+        return null;
+    const name = content.match(/^(?:[^\p{L}\p{N}\s]+\s+)?(Critical|Degraded|Normal|Annoying|Resolved)$/iu)?.[1];
+    return name ? byName.get(name.toLowerCase()) ?? null : null;
+}
+export function todoSeveritySectionForHeading(line) {
+    const entry = candidate(line);
+    return entry && line.trim() === entry.heading ? entry.section : null;
+}
+export function inspectTodoSeverityHeadings(markdown) {
+    const diagnostics = [];
+    const seen = new Set();
+    let greatestOrder = -1;
+    for (const [index, line] of markdown.split(/\r?\n/).entries()) {
+        const entry = candidate(line);
+        if (!entry)
+            continue;
+        const order = TODO_SEVERITY_HEADINGS.indexOf(entry);
+        const add = (diagnostic) => { diagnostics.push(diagnostic); };
+        if (line.trim() !== entry.heading)
+            add({
+                code: "todo_severity_heading_mismatch",
+                classification: "glyph_name_mismatch",
+                line: index + 1,
+                expected_heading: entry.heading,
+                recovery: `Replace TODO.md line ${index + 1} with '${entry.heading}'.`,
+            });
+        if (seen.has(entry.section))
+            add({
+                code: "todo_severity_heading_duplicate",
+                classification: "duplicate",
+                line: index + 1,
+                expected_heading: entry.heading,
+                recovery: `Keep exactly one '${entry.heading}' section and move its rows there.`,
+            });
+        if (order < greatestOrder)
+            add({
+                code: "todo_severity_heading_out_of_order",
+                classification: "out_of_order",
+                line: index + 1,
+                expected_heading: entry.heading,
+                recovery: "Order managed TODO sections as Critical, Degraded, Normal, Annoying, then Resolved; missing sections are allowed.",
+            });
+        seen.add(entry.section);
+        greatestOrder = Math.max(greatestOrder, order);
+    }
+    return { diagnostics: diagnostics.slice(0, DIAGNOSTIC_LIMIT), omitted_count: Math.max(0, diagnostics.length - DIAGNOSTIC_LIMIT) };
+}
+export function assertTodoSeverityHeadingStructure(markdown) {
+    const diagnosis = inspectTodoSeverityHeadings(markdown);
+    if (!diagnosis.diagnostics.length)
+        return;
+    reject({
+        class: "conflict",
+        message: "TODO.md managed severity section structure is malformed",
+        diagnosis: { classification: "todo_severity_heading_structure", ...diagnosis },
+        recovery: "Apply every bounded TODO.md heading correction exactly as reported, then retry; no state was changed.",
+    });
+}

package/dist/upgrade/legacyAgentCleanup.js

@@ -204,7 +204,7 @@ export function scanLegacyCapabilityAgentPaths(agentsDir) {
     }
     return hits.sort();
 }
-/** Scan a tree for reintroduced Swedish-verb agents (v1LegacyCruft-style guard). */
+/** Scan a tree for reintroduced Swedish-verb agents. */
 export function scanLegacySwedishVerbAgentViolations(root) {
     const resolved = resolvePath(root);
     const violations = [];

package/dist/upgrade/migrateArtifactsV2ToV3.js

@@ -19,14 +19,6 @@ import { applyInstalledHooksRetirementItems, planInstalledHooksRetirementItems,
  * v2→v3 migration phases: artifacts (noop for YAML), runtime rewire, cleanup.
  */
 export const MIGRATION_STATUSES = ["pending", "applied", "noop", "blocked", "failed"];
-export const V1_ARTIFACT_PAIRS = [
-    [".agentera/PROGRESS.md", ".agentera/progress.yaml"],
-    [".agentera/PLAN.md", ".agentera/plan.yaml"],
-    [".agentera/DECISIONS.md", ".agentera/decisions.yaml"],
-    [".agentera/HEALTH.md", ".agentera/health.yaml"],
-    [".agentera/DOCS.md", ".agentera/docs.yaml"],
-    ["VISION.md", ".agentera/vision.yaml"],
-];
 const PLAN_ARCHIVE_FILE = /^PLAN-.+\.ya?ml$/i;
 const PLAN_LIFECYCLE_ACTION = "normalize-plan-lifecycle";
 function isMapping(value) {
@@ -178,16 +170,6 @@ export function summarizePhase(name, items, message = "") {
     }
     return { name, status, summary, items, message };
 }
-export function detectV1ArtifactPairs(project) {
-    const root = resolvePath(project);
-    const found = [];
-    for (const [md, yaml] of V1_ARTIFACT_PAIRS) {
-        if (isFile(path.join(root, md)) && !isFile(path.join(root, yaml))) {
-            found.push(md);
-        }
-    }
-    return found;
-}
 function listV2YamlArtifacts(project) {
     const root = resolvePath(project);
     const agenteraDir = path.join(root, ".agentera");
@@ -218,21 +200,13 @@ export function planArtifactsPhase(project) {
             },
         ]);
     }
-    const v1Pairs = detectV1ArtifactPairs(root);
-    const v1Items = v1Pairs.map((source) => ({
-        status: "blocked",
-        action: "manual-v1-handoff",
-        source,
-        message: "v1 Markdown state is unsupported; convert it with a v2 CLI before running the v2-to-v3 upgrade",
-    }));
     const yamlArtifacts = listV2YamlArtifacts(root);
     const lifecycleItems = lifecyclePlanArtifacts(root);
-    if (yamlArtifacts.length === 0 && v1Items.length === 0 && lifecycleItems.length === 0) {
+    if (yamlArtifacts.length === 0 && lifecycleItems.length === 0) {
         return summarizePhase("artifacts", [], "no project artifacts found");
     }
     const lifecycleSources = new Set(lifecycleItems.flatMap((item) => item.source ? [item.source] : []));
     const items = [
-        ...v1Items,
         ...yamlArtifacts.filter((source) => !lifecycleSources.has(source)).map((source) => ({
             status: "noop",
             action: "preserve",

package/dist/upgrade/nextMajorDoctor.js

@@ -7,19 +7,6 @@ import { resolveRunningVersion } from "./versionResolution.js";
  */
 export const NEXT_MAJOR_SECTION_HEADER = "Next major";
 export const NEXT_MAJOR_LINE_CAP = 6;
-/** v1 installs predate the channel authority; hardcoded stable-line successor mapping. */
-export const V1_NEXT_MAJOR_FALLBACK = {
-    concept: "forward_successor_line",
-    currentVersion: "1.x",
-    currentChannel: "stable",
-    channel: "stable",
-    version: "2.x",
-    announced: true,
-    npmOnlyAdvisory: "",
-    guideUrl: "https://github.com/jgabor/agentera/blob/main/UPGRADE.md#recommended-upgrade-v1--v2-stable-channel",
-    previewCommand: "npx -y agentera@latest upgrade --dry-run",
-    irreversibleAdvisory: "Forward migration upgrades artifact format from Markdown to YAML; review the preview before applying.",
-};
 function parseNextMajorBlock(raw) {
     if (raw === null || raw === undefined) {
         return null;
@@ -120,14 +107,6 @@ export function resolveNextMajorDoctorLines(ctx) {
     const displayChannel = install?.kind === "v2_managed_app_home" ? "stable" : currentChannel;
     const runningDistributionMajor = ctx.runningDistributionMajor ??
         (install?.kind === "v2_managed_app_home" ? 2 : cliDistributionMajor(sourceRoot));
-    if (runningDistributionMajor === 1) {
-        const block = V1_NEXT_MAJOR_FALLBACK;
-        return formatNextMajorDoctorLines({
-            currentVersion: block.currentVersion,
-            currentChannel: block.currentChannel,
-            block,
-        });
-    }
     const authorityBlock = loadChannelNextMajor(sourceRoot, successorChannel);
     if (!authorityBlock || !authorityBlock.announced) {
         return null;