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

package/dist/cli/orientation.js

@@ -1,12 +1,38 @@
 import fs from "node:fs";
 import path from "node:path";
-import { resolveArtifactPath, } from "../registries/artifactRegistry.js";
-import { activeObjectiveName, artifactPath, loadRegistryForSchemas, } from "./appContext.js";
-import { asList, extractEntries, firstPresent, loadArtifact, progressEntriesForOutput, recentCycles, truncate, } from "./stateQuery.js";
-import { decisionContextEntry, latestHealthAudit, normalizeSeverity } from "./commands/state/index.js";
+import { preCutoverCommand } from "./preCutoverCommand.js";
+import { loadArtifactRecord, resolveArtifactPath, } from "../registries/artifactRegistry.js";
+import { activeObjectiveName, artifactPath, resolveRegistryModelPath, } from "./appContext.js";
+import { asList, extractEntries, firstPresent, loadArtifact, recentCycles, truncate, } from "./stateQuery.js";
+import { normalizeSeverity } from "./commands/state/index.js";
 import { isResolvedTodoMarkdownStatus, parseTodoMarkdownListItem } from "./todoMarkdown.js";
-import { TODO_SEVERITY_ORDER, TODO_SEVERITY_ORDER_KEYS } from "./todoSeverity.js";
+import { truncateCodePoints } from "../core/text.js";
+import { TODO_SEVERITY_ORDER_KEYS } from "./todoSeverity.js";
+import { evaluateTodoReadinessQueue, } from "./todoReadinessSelection.js";
 import { capabilityStartupComplete } from "./startupCompletenessContract.js";
+import { discoverPlanArtifacts, planCatalogEntry, planDocumentParts } from "./planArtifacts.js";
+import { planLifecycleState } from "./planLifecycleState.js";
+import { firstActionablePlanTask } from "./capabilityContext/planState.js";
+import { resolveSourceRoot } from "../core/sourceRoot.js";
+import { entityListFamily } from "../state/entityRetrievalHelp.js";
+import { scanYamlCollection } from "../state/startupProjection.js";
+import { numberedArchiveContract } from "../state/archiveDiscovery.js";
+const PLAN_FAMILY = entityListFamily("plans");
+const PLAN_TASK_FAMILY = entityListFamily("plan_tasks");
+const OBJECTIVE_FAMILY = entityListFamily("objective");
+const PLAN_LIST_COMMAND = preCutoverCommand(`state ${PLAN_FAMILY.commandTokens.join(" ")} list --format json`);
+function planTaskListCommand(planId) {
+    const selector = typeof planId === "string" && planId ? ` ${planId}` : "";
+    return preCutoverCommand(`state ${PLAN_TASK_FAMILY.commandTokens.join(" ")} list${selector} --limit 100 --format json`);
+}
+function planTaskGetCommand(taskId) {
+    const selector = typeof taskId === "string" && taskId ? taskId : "ID";
+    return preCutoverCommand(`state ${PLAN_TASK_FAMILY.commandTokens.join(" ")} get --id ${selector} --format json`);
+}
+function objectiveGetCommand(objectiveId) {
+    const selector = typeof objectiveId === "string" && objectiveId ? objectiveId : "ID";
+    return preCutoverCommand(`state ${OBJECTIVE_FAMILY.commandTokens.join(" ")} get --id ${selector} --format json`);
+}
 /**
  * Orientation summaries layer for prime/status. Faithful port of the
  * scripts/agentera `_*_summary`, `_load_todo_items`, `_issue_counts`,
@@ -16,12 +42,6 @@ export const DONE_STATUSES = new Set(["complete", "completed", "closed", "done",
 export const BLOCKED_STATUSES = new Set(["blocked", "stuck"]);
 export const DECISION_ATTENTION_MAX_ENTRIES = 3;
 const TODO_SECTION_SEVERITIES = Object.fromEntries(TODO_SEVERITY_ORDER_KEYS.map((key) => [key, key]));
-const TODO_PLAN_SIGNALS = new Set([
-    "acceptance", "artifact", "capability", "capability-context", "compatibility", "contract",
-    "cross-capability", "docs", "metadata", "migration", "schema", "startup", "surface", "test", "validation",
-]);
-const PROFILE_STALE_DAYS_ENV = "AGENTERA_PROFILE_MAX_AGE_DAYS";
-const DEFAULT_PROFILE_STALE_DAYS = 7;
 const AUDIT_STALE_DAYS_ENV = "AGENTERA_AUDIT_MAX_AGE_DAYS";
 const DEFAULT_AUDIT_STALE_DAYS = 30;
 const AUDIT_STALE_CYCLES_ENV = "AGENTERA_AUDIT_MAX_CYCLES";
@@ -68,8 +88,22 @@ export function loadNamedArtifact(schemas, name) {
         return null;
     return loadArtifact(artifactPath(info, name));
 }
-export function registryArtifactPath(artifactId, schemasDir, env = process.env) {
-    const record = loadRegistryForSchemas(schemasDir).get(artifactId);
+export function registryArtifactPath(artifactId, schemasDir, env = process.env, options = {}) {
+    // Targeted lookup: resolving a single identity (e.g. `profile` against a
+    // v2-shaped install) must not walk the full registry and warn about every
+    // required schema that happens to be absent from this install. Only the
+    // requested identity is inspected; model/schemas authority is shared with the
+    // full loader via `resolveRegistryModelPath`.
+    let record;
+    try {
+        record = loadArtifactRecord(artifactId, schemasDir, resolveRegistryModelPath(schemasDir));
+    }
+    catch (exc) {
+        if (options.warn !== false) {
+            process.stderr.write(`warning: failed to load artifact registry for schemas: ${exc.message}\n`);
+        }
+        record = undefined;
+    }
     if (record === undefined)
         throw new Error(`artifact registry does not define '${artifactId}'`);
     return resolveArtifactPath(record, process.cwd(), activeObjectiveName(), env);
@@ -86,34 +120,6 @@ export function parseProfileHeaderDates(text) {
     const validatedUtc = validatedDate ? dateFromIso(validatedDate) : null;
     return { generatedDate, validatedDate, generatedUtc, validatedUtc };
 }
-function profileRefreshAnchorUtc(text) {
-    const { generatedUtc, validatedUtc } = parseProfileHeaderDates(text);
-    if (generatedUtc === null && validatedUtc === null)
-        return null;
-    if (generatedUtc === null)
-        return validatedUtc;
-    if (validatedUtc === null)
-        return generatedUtc;
-    return Math.max(generatedUtc, validatedUtc);
-}
-export function checkProfileStaleness(profilePath, env = process.env) {
-    if (!fs.existsSync(profilePath))
-        return null;
-    let text;
-    try {
-        text = fs.readFileSync(profilePath, "utf8");
-    }
-    catch (exc) {
-        process.stderr.write(`warning: failed to read profile path ${profilePath}: ${exc.message}\n`);
-        return null;
-    }
-    const anchor = profileRefreshAnchorUtc(text);
-    if (anchor === null)
-        return null;
-    const staleDays = intEnv(env, PROFILE_STALE_DAYS_ENV, DEFAULT_PROFILE_STALE_DAYS);
-    const since = daysSince(anchor);
-    return [since >= staleDays, since, staleDays];
-}
 export function healthAuditDate(entry) {
     for (const key of ["date", "timestamp"]) {
         const value = entry[key];
@@ -136,8 +142,25 @@ function progressEntryDate(entry) {
     }
     return null;
 }
+function scanSchemaArtifact(schemas, artifactId) {
+    const info = schemas[artifactId];
+    const contract = numberedArchiveContract(artifactId, resolveSourceRoot());
+    const currentPath = info ? artifactPath(info, artifactId) : path.join(process.cwd(), ".agentera", `${artifactId}.yaml`);
+    const primary = scanYamlCollection(currentPath, contract.entryCollection, artifactId, contract.entryNumberField);
+    const active = artifactId === "progress" && !primary.collection_found
+        ? scanYamlCollection(currentPath, "progress", artifactId, contract.entryNumberField)
+        : primary;
+    return {
+        active,
+        archive: scanYamlCollection(currentPath, "archive", artifactId, contract.entryNumberField),
+    };
+}
 function cyclesSinceHealthAudit(schemas, auditDate) {
-    const entries = extractEntries(loadNamedArtifact(schemas, "progress"));
+    const info = schemas.progress;
+    if (!info)
+        return null;
+    const scan = scanSchemaArtifact(schemas, "progress").active;
+    const entries = scan.entries.map((entry) => entry.fields);
     if (entries.length === 0)
         return null;
     let count = 0;
@@ -239,7 +262,7 @@ export function loadTodoItems(schemas) {
 export function issueCounts(todoItems) {
     const counts = { critical: 0, degraded: 0, normal: 0, annoying: 0 };
     for (const item of todoItems) {
-        const severity = item.severity;
+        const severity = String(item.severity ?? "normal");
         if (severity === "critical")
             counts.critical += 1;
         else if (severity === "degraded" || severity === "warning")
@@ -251,89 +274,201 @@ export function issueCounts(todoItems) {
     }
     return counts;
 }
-function todoNeedsPlan(item) {
-    const text = item.text.toLowerCase();
-    let signalCount = 0;
-    for (const signal of TODO_PLAN_SIGNALS)
-        if (text.includes(signal))
-            signalCount += 1;
-    return signalCount >= 2 || (signalCount >= 1 && text.length > 180);
-}
 // ── per-artifact summaries ──────────────────────────────────────────
 export function planSummary(schemas) {
-    const data = loadNamedArtifact(schemas, "plan");
-    if (!data || typeof data !== "object" || Array.isArray(data)) {
-        return {
+    const info = schemas.plan;
+    if (!info) {
+        const summary = {
             exists: false,
             active: false,
             tasks: [],
             status: "absent",
             title: "",
-            absence_reason: "No active plan artifact is available from agentera plan.",
+            active_path: "",
+            absence_reason: "No active plan artifact is available from agentera state plan.",
         };
+        summary.lifecycle_state = planLifecycleState(summary);
+        return summary;
     }
-    const d = data;
-    const legacyEntries = asList(d.entries);
-    let tasks;
-    let status;
-    let title;
-    if (legacyEntries.length > 0) {
-        tasks = legacyEntries;
-        status = entryStatusPy(tasks[0], "");
-        title = String(firstPresent(tasks[0], ["title", "name"], ""));
-    }
-    else {
-        const header = d.header && typeof d.header === "object" && !Array.isArray(d.header) ? d.header : {};
-        tasks = asList(d.tasks);
-        status = String(firstPresent(header, ["status"], d.status ?? "") || "");
-        title = String(firstPresent(header, ["title"], d.title ?? "") || "");
+    const discovery = discoverPlanArtifacts(artifactPath(info, "plan"));
+    const activeDiagnostics = discovery.diagnostics.filter((diagnostic) => diagnostic.path === discovery.activePath && diagnostic.category !== "legacy");
+    const archivedPlans = discovery.archived.map((artifact) => planCatalogEntry(artifact, discovery.activePath));
+    if (!discovery.active) {
+        const summary = {
+            exists: activeDiagnostics.length === 0 && archivedPlans.length > 0,
+            active: false,
+            tasks: [],
+            status: activeDiagnostics.length > 0 ? "invalid" : archivedPlans.length > 0 ? "archived" : "absent",
+            title: "",
+            active_path: discovery.activePath,
+            absence_reason: activeDiagnostics.length > 0
+                ? "Current plan artifact is invalid; see diagnostics."
+                : archivedPlans.length > 0
+                    ? "No active plan artifact is available; archived plan state is history only."
+                    : "No active plan artifact is available from agentera state plan.",
+            complete: 0,
+            total: 0,
+            complete_plan: false,
+            first_pending: null,
+            archived_plans: archivedPlans,
+            archive_count: archivedPlans.length,
+            invalid_archive_paths: discovery.invalidArchivePaths,
+            ...(activeDiagnostics.length > 0 ? { invalid_path: discovery.activePath } : {}),
+            diagnostics: discovery.diagnostics,
+        };
+        summary.lifecycle_state = planLifecycleState(summary);
+        return summary;
     }
+    const d = discovery.active.data;
+    const parts = planDocumentParts(d);
+    const tasks = parts.tasks;
+    const status = parts.legacyEntries ? entryStatusPy(tasks[0], "") : parts.status;
+    const title = parts.legacyEntries
+        ? String(firstPresent(tasks[0] ?? {}, ["title", "name"], ""))
+        : parts.title;
     const complete = tasks.filter((task) => DONE_STATUSES.has(entryStatusPy(task, ""))).length;
     const total = tasks.length;
     const completePlan = DONE_STATUSES.has(status.toLowerCase()) && complete === total;
-    let firstPending = null;
-    if (!completePlan) {
-        for (const task of tasks) {
-            const ts = entryStatusPy(task, "pending");
-            if (DONE_STATUSES.has(ts) || BLOCKED_STATUSES.has(ts))
-                continue;
-            firstPending = task;
-            break;
-        }
-    }
-    return {
+    const firstPending = completePlan
+        ? null
+        : firstActionablePlanTask(tasks);
+    const summary = {
         exists: true,
         status,
         title,
+        active_path: discovery.activePath,
         constraints: d.constraints ?? null,
         scope: d.scope ?? null,
         design: d.design ?? null,
         tasks,
         complete,
         total,
-        active: !completePlan,
+        active: true,
         complete_plan: completePlan,
         first_pending: firstPending,
+        archived_plans: archivedPlans,
+        archive_count: archivedPlans.length,
+        invalid_archive_paths: discovery.invalidArchivePaths,
+        diagnostics: discovery.diagnostics,
+    };
+    summary.lifecycle_state = planLifecycleState(summary);
+    return summary;
+}
+/** Startup keeps plan routing metadata, not the full active plan body. */
+export function startupPlanSummary(plan) {
+    const tasks = asList(plan.tasks).filter((task) => task && typeof task === "object" && !Array.isArray(task));
+    const boundedTasks = tasks.slice(0, 10).map((task) => {
+        const item = {};
+        for (const key of ["id", "artifact", "name", "title", "status", "depends_on", "acceptance_summary", "evidence_summary", "blocked_reasons", "evaluation_state"]) {
+            if (!(key in task))
+                continue;
+            if (key === "acceptance_summary" || key === "evidence_summary") {
+                const summary = task[key];
+                item[key] = summary && typeof summary === "object" && !Array.isArray(summary)
+                    ? { count: summary.count ?? asList(summary.items).length }
+                    : null;
+            }
+            else if (key === "evaluation_state") {
+                const evaluation = task[key];
+                item[key] = evaluation && typeof evaluation === "object" && !Array.isArray(evaluation)
+                    ? Object.fromEntries(Object.entries(evaluation).filter(([name]) => ["attempt_count", "failure_count", "last_verdict"].includes(name)))
+                    : null;
+            }
+            else if (key === "depends_on") {
+                item[key] = asList(task[key]).slice(0, 20);
+            }
+            else if (key === "blocked_reasons") {
+                item[key] = asList(task[key]).slice(0, 3).map((reason) => truncateCodePoints(String(reason), 160));
+            }
+            else {
+                item[key] = typeof task[key] === "string" ? truncateCodePoints(task[key], 256) : task[key];
+            }
+        }
+        return item;
+    });
+    const archived = asList(plan.archived_plans).slice(0, 10);
+    const diagnostics = asList(plan.diagnostics).slice(0, 10);
+    const totalTasks = Number(plan.total ?? tasks.length);
+    const taskOmission = plan.task_omission && typeof plan.task_omission === "object" && !Array.isArray(plan.task_omission) ? plan.task_omission : {};
+    const finalTaskOmission = {
+        ...taskOmission,
+        omitted: totalTasks > boundedTasks.length,
+        total: totalTasks,
+        returned_count: boundedTasks.length,
+        omitted_count: Math.max(0, totalTasks - boundedTasks.length),
+        omission_reason: totalTasks > boundedTasks.length ? taskOmission.omission_reason ?? "startup_detail_capacity" : "none",
+        retrieval: taskOmission.retrieval ?? { list: planTaskListCommand(plan.id), restart: planTaskListCommand(plan.id), get: PLAN_TASK_FAMILY.get },
+    };
+    const pending = plan.first_pending && typeof plan.first_pending === "object" && !Array.isArray(plan.first_pending)
+        ? plan.first_pending
+        : null;
+    const pendingDependencies = pending ? asList(pending.depends_on).slice(0, 20).map(String) : [];
+    const pendingAcceptance = pending
+        ? asList(pending.acceptance).slice(0, 10).map((item) => truncateCodePoints(String(item), 200, "…"))
+        : [];
+    const firstPending = pending ? {
+        id: pending.id ?? null,
+        artifact: pending.artifact ?? "plan",
+        name: truncateCodePoints(String(pending.name ?? pending.title ?? ""), 256, "…"),
+        status: pending.status ?? "pending",
+        depends_on: pendingDependencies,
+        dependency_count: asList(pending.depends_on).length,
+        omitted_dependency_count: Math.max(0, asList(pending.depends_on).length - pendingDependencies.length),
+        acceptance: pendingAcceptance,
+        acceptance_count: asList(pending.acceptance).length,
+        omitted_acceptance_count: Math.max(0, asList(pending.acceptance).length - pendingAcceptance.length),
+        retrieval: { get: planTaskGetCommand(pending.id) },
+    } : null;
+    return {
+        id: plan.id ?? null,
+        artifact: plan.artifact ?? "plan",
+        exists: Boolean(plan.exists),
+        active: Boolean(plan.active),
+        status: plan.status,
+        title: plan.title ?? "",
+        complete: plan.complete ?? 0,
+        superseded: plan.superseded ?? 0,
+        total: totalTasks,
+        task_status_counts: plan.task_status_counts ?? {},
+        task_omission: finalTaskOmission,
+        complete_plan: Boolean(plan.complete_plan),
+        first_pending: firstPending,
+        tasks: boundedTasks,
+        task_count: totalTasks,
+        omitted_task_count: Math.max(0, totalTasks - boundedTasks.length),
+        archived_plans: archived,
+        archive_count: plan.archive_count ?? archived.length,
+        omitted_archive_count: Math.max(0, Number(plan.archive_count ?? archived.length) - archived.length),
+        invalid_archive_paths: (plan.invalid_archive_paths ?? []).slice(0, 10),
+        diagnostics,
+        omitted_diagnostic_count: Math.max(0, (plan.diagnostics ?? []).length - diagnostics.length),
+        source_contract: {
+            detail_availability: totalTasks > boundedTasks.length ? "summary" : "full",
+            retrieval: PLAN_LIST_COMMAND,
+            raw_archive_records: false,
+        },
+        lifecycle_state: plan.lifecycle_state ?? null,
     };
 }
 export function docsSummary(schemas, startupInput = {}) {
-    const data = loadNamedArtifact(schemas, "docs");
-    if (!data || typeof data !== "object" || Array.isArray(data)) {
-        return { exists: false, status: "absent", absence_reason: "No docs mapping artifact is available from agentera docs." };
+    const info = schemas.docs;
+    if (!info) {
+        return { exists: false, status: "absent", absence_reason: "No docs mapping artifact is available from agentera state docs." };
     }
-    const d = data;
-    const mapping = asList(d.mapping);
-    const index = asList(d.index);
-    const coverage = d.coverage && typeof d.coverage === "object" && !Array.isArray(d.coverage) ? d.coverage : {};
-    const conventions = d.conventions && typeof d.conventions === "object" && !Array.isArray(d.conventions) ? d.conventions : {};
+    const docsPath = artifactPath(info, "docs");
+    const mapping = scanYamlCollection(docsPath, "mapping", "docs", "artifact");
+    const index = scanYamlCollection(docsPath, "index", "docs", "artifact");
+    const exists = fs.existsSync(docsPath);
+    const header = exists ? truncateCodePoints(fs.readFileSync(docsPath, "utf8"), 4096) : "";
+    const lastAudit = /^last_audit:\s*(.+)$/m.exec(header)?.[1]?.trim().replace(/^['"]|['"]$/g, "") ?? null;
     return {
-        exists: true,
+        exists,
         status: "available",
-        last_audit: d.last_audit ?? null,
-        conventions,
-        mapping,
-        mapping_entries: mapping.length,
-        coverage,
+        last_audit: lastAudit,
+        conventions: {},
+        mapping: mapping.entries.slice(0, 10).map((entry) => entry.fields),
+        mapping_entries: mapping.entries.length,
+        coverage: {},
         source_contract: {
             capability_startup_complete: capabilityStartupComplete(startupInput),
             raw_artifact_reads_required: false,
@@ -344,30 +479,41 @@ export function docsSummary(schemas, startupInput = {}) {
                 "Document closeout context metadata for docs/TODO/changelog/progress synchronization",
             ],
         },
-        indexed_documents: index.length,
+        indexed_documents: index.entries.length,
     };
 }
 export function progressSummary(schemas) {
-    const data = loadNamedArtifact(schemas, "progress");
-    const entries = extractEntries(data);
+    const info = schemas.progress;
+    if (!info)
+        return { exists: false, status: "absent", absence_reason: "No progress cycles are available from agentera progress." };
+    const scan = scanSchemaArtifact(schemas, "progress").active;
+    const entries = scan.entries.map((entry) => entry.fields);
     if (entries.length === 0) {
         return { exists: false, status: "absent", absence_reason: "No progress cycles are available from agentera progress." };
     }
-    const latest = progressEntriesForOutput(recentCycles(entries, 1))[0];
+    const latest = recentCycles(entries, 1)[0] ?? {};
+    const latestCycle = {};
+    for (const key of ["number", "timestamp", "type", "phase", "what", "status"]) {
+        if (key in latest)
+            latestCycle[key] = latest[key];
+    }
     return {
         exists: true,
         status: "available",
-        latest,
-        latest_verification: latest.verified ?? null,
+        latest: latestCycle,
+        latest_verification: latest.verified_present ? { present: true } : null,
         cycle_count: entries.length,
     };
 }
 export function healthSummary(schemas, env = process.env) {
-    const data = loadNamedArtifact(schemas, "health");
-    const entries = extractEntries(data);
+    const info = schemas.health;
+    if (!info)
+        return { exists: false };
+    const scan = scanSchemaArtifact(schemas, "health").active;
+    const entries = scan.entries.map((entry) => entry.fields);
     if (entries.length === 0)
         return { exists: false };
-    const latest = latestHealthAudit(entries);
+    const latest = [...entries].sort((left, right) => Number(right.number ?? 0) - Number(left.number ?? 0))[0] ?? null;
     if (!latest)
         return { exists: false };
     const grades = latest.grades && typeof latest.grades === "object" && !Array.isArray(latest.grades) ? latest.grades : {};
@@ -382,11 +528,11 @@ export function healthSummary(schemas, env = process.env) {
     const trajectory = String(latest.trajectory ?? "");
     const auditDate = healthAuditDate(latest);
     const dateStr = auditDate !== null ? isoFromUtc(auditDate) : null;
-    const latestNumber = typeof latest.number === "string" || typeof latest.number === "number" ? latest.number : "?";
     const latestTimestamp = typeof latest.timestamp === "string" ? latest.timestamp : null;
     const summary = {
         exists: true,
-        number: latestNumber,
+        id: latest.id ?? null,
+        artifact: "health",
         date: dateStr,
         timestamp: dateStr ?? latestTimestamp,
         trajectory,
@@ -495,9 +641,7 @@ export function statePresence(plan, docs, progress, health, objective) {
 }
 // ── decisions follow-up + attention ─────────────────────────────────
 export function decisionFollowUp(schemas) {
-    const data = loadNamedArtifact(schemas, "decisions");
-    for (const rawEntry of extractEntries(data)) {
-        const entry = decisionContextEntry(rawEntry);
+    for (const entry of startupDecisionEntries(schemas)) {
         const satisfaction = entry.satisfaction;
         if (!satisfaction || typeof satisfaction !== "object" || Array.isArray(satisfaction) || !satisfaction.review_needed)
             continue;
@@ -507,6 +651,15 @@ export function decisionFollowUp(schemas) {
     }
     return null;
 }
+export function startupDecisionEntries(schemas) {
+    if (!schemas.decisions)
+        return [];
+    const scans = scanSchemaArtifact(schemas, "decisions");
+    return [...scans.active.entries, ...scans.archive.entries].map((candidate) => ({
+        ...candidate.fields,
+        ...(candidate.identity.number !== null && candidate.fields.number === undefined ? { number: candidate.identity.number } : {}),
+    }));
+}
 function decisionAttentionState(satisfaction) {
     const state = satisfaction.state;
     if (state === null || state === undefined || state === "")
@@ -520,18 +673,17 @@ function decisionAttentionState(satisfaction) {
     return "unrecognized";
 }
 export function decisionReviewAttention(schemas) {
-    const data = loadNamedArtifact(schemas, "decisions");
     const reviewEntries = [];
     const stateCounts = {};
-    for (const rawEntry of extractEntries(data)) {
-        const entry = decisionContextEntry(rawEntry);
+    for (const entry of startupDecisionEntries(schemas)) {
         const satisfaction = entry.satisfaction;
         if (!satisfaction || typeof satisfaction !== "object" || Array.isArray(satisfaction) || !satisfaction.review_needed)
             continue;
         const state = decisionAttentionState(satisfaction);
         stateCounts[state] = (stateCounts[state] ?? 0) + 1;
         reviewEntries.push({
-            number: typeof entry.number === "string" || typeof entry.number === "number" ? entry.number : "?",
+            id: String(entry.stable_id ?? entry.number ?? "legacy-unaddressable"),
+            artifact: "decisions",
             title: truncate(firstPresent(entry, ["question", "choice", "summary"], "decision review"), 80),
             state,
             source: satisfaction.source ?? null,
@@ -544,7 +696,7 @@ export function decisionReviewAttention(schemas) {
         .sort()
         .map((name) => `${name}=${stateCounts[name]}`)
         .join(", ");
-    const refs = boundedEntries.map((entry) => `Decision ${entry.number}: ${entry.title}`).join("; ");
+    const refs = boundedEntries.map((entry) => `Decision ${entry.id}: ${entry.title}`).join("; ");
     const more = reviewEntries.length - boundedEntries.length;
     const suffix = more > 0 ? `; +${more} more` : "";
     return {
@@ -560,8 +712,28 @@ export function decisionReviewAttention(schemas) {
 export function formatNextAction(action) {
     if (!action)
         return "object=VISION refresh | capability=vision | reason=no executable follow-up | phase=envision";
-    const phase = "phase" in action && action.phase ? ` | phase=${action.phase}` : "";
-    return `object=${truncate(action.object)} | capability=${action.capability} | reason=${action.reason}${phase}`;
+    const fields = [
+        `object=${truncate(action.object)}`,
+        `capability=${action.capability}`,
+        `reason=${action.reason}`,
+    ];
+    if ("phase" in action && action.phase)
+        fields.push(`phase=${action.phase}`);
+    if ("id" in action && action.id)
+        fields.push(`id=${action.id}`);
+    if ("artifact" in action && action.artifact)
+        fields.push(`artifact=${action.artifact}`);
+    if ("outcome" in action && action.outcome)
+        fields.push(`outcome=${action.outcome}`);
+    if ("eligible" in action && typeof action.eligible === "boolean")
+        fields.push(`eligible=${String(action.eligible)}`);
+    if ("retrieval" in action
+        && action.retrieval
+        && typeof action.retrieval === "object"
+        && "exact" in action.retrieval
+        && typeof action.retrieval.exact === "string")
+        fields.push(`retrieval=${action.retrieval.exact}`);
+    return fields.join(" | ");
 }
 /**
  * Evolved state-readiness hint (Decision 76). Evaluates every cascade branch
@@ -569,17 +741,25 @@ export function formatNextAction(action) {
  * envision → PH5 audit). Position 1 (`recommended`) is the branch that would
  * have won under the legacy early-return cascade.
  */
-export function selectStatusReadiness(plan, health, objective, todoItems, decision, savedContext) {
+export function selectStatusReadiness(plan, health, objective, todoItems, decision, savedContext, completeTodoReadiness) {
     const candidates = [];
     const pending = plan.first_pending;
     if (pending && typeof pending === "object" && !Array.isArray(pending)) {
         const number = pending.number ?? "?";
         const title = firstPresent(pending, ["name", "title"], "pending task");
+        const id = typeof pending.id === "string" ? pending.id : undefined;
         candidates.push({
             object: `PLAN Task ${number}: ${title}`,
             capability: "orchestrate",
             reason: "first pending plan task",
             phase: "build",
+            ...(id ? {
+                id,
+                artifact: typeof pending.artifact === "string" ? pending.artifact : "plan",
+                outcome: String(pending.status ?? "pending"),
+                eligible: true,
+                retrieval: { exact: planTaskGetCommand(id) },
+            } : {}),
         });
     }
     if (health.degrading) {
@@ -593,25 +773,63 @@ export function selectStatusReadiness(plan, health, objective, todoItems, decisi
         });
     }
     if (objective.active) {
+        const id = typeof objective.id === "string" ? objective.id : undefined;
         candidates.push({
             object: `OBJECTIVE: ${objective.metric || objective.title}`,
             capability: "optimize",
             reason: "active non-closed objective",
             phase: "build",
+            ...(id ? {
+                id,
+                artifact: typeof objective.artifact === "string" ? objective.artifact : "objective",
+                outcome: objective.status ?? "active",
+                eligible: true,
+                retrieval: { exact: objectiveGetCommand(id) },
+            } : {}),
         });
     }
-    if (todoItems.length > 0) {
-        const item = [...todoItems].sort((a, b) => (TODO_SEVERITY_ORDER[a.severity] ?? 2) - (TODO_SEVERITY_ORDER[b.severity] ?? 2))[0];
-        if (todoNeedsPlan(item)) {
-            candidates.push({ object: `TODO: ${item.text}`, capability: "plan", reason: "complex TODO needs planning", phase: "plan" });
-        }
-        else {
-            candidates.push({ object: `TODO: ${item.text}`, capability: "build", reason: "highest-priority open TODO", phase: "build" });
+    const todoReadiness = completeTodoReadiness ?? evaluateTodoReadinessQueue(todoItems.map((item) => ({
+        id: String(item.id ?? ""),
+        artifact: String(item.artifact ?? "todo"),
+        record: { ...item, description: item.text },
+    })));
+    if (todoReadiness.selected) {
+        const item = todoReadiness.selected;
+        candidates.push({
+            object: `TODO ${item.id}: ${truncate(item.description, 120)}`,
+            capability: item.capability,
+            reason: item.reason,
+            phase: item.phase,
+            id: item.id,
+            artifact: item.artifact,
+            outcome: item.result,
+            eligible: item.eligible,
+            retrieval: item.retrieval,
+        });
+        if (todoReadiness.triage.count > 0) {
+            candidates.push({
+                object: `TODO triage: ${todoReadiness.triage.count} item(s)`,
+                capability: "status",
+                reason: todoReadiness.triage.recovery,
+                phase: "audit",
+                outcome: "needs-triage",
+                eligible: false,
+            });
         }
     }
+    else if (todoReadiness.abstainRecovery) {
+        candidates.push({
+            object: "TODO queue: no actionable item",
+            capability: "status",
+            reason: todoReadiness.abstainRecovery,
+            phase: "audit",
+            outcome: "needs-triage",
+            eligible: false,
+        });
+    }
     if (health.stale && !health.degrading) {
         candidates.push({
-            object: `HEALTH: Audit ${health.number ?? "?"} stale`,
+            object: `HEALTH: audit ${String(health.id ?? "unknown")} stale`,
             capability: "audit",
             reason: "stale health audit",
             phase: "audit",
@@ -642,8 +860,7 @@ export function selectStatusReadiness(plan, health, objective, todoItems, decisi
 }
 /** Legacy single-entry projection of {@link selectStatusReadiness}: the
  *  top-priority candidate as `{object, capability, reason}` (no `phase`). */
-export function selectStatusNextAction(plan, health, objective, todoItems, decision, savedContext) {
-    const { recommended } = selectStatusReadiness(plan, health, objective, todoItems, decision, savedContext);
+export function selectStatusNextAction(plan, health, objective, todoItems, decision, savedContext, completeTodoReadiness) {
+    const { recommended } = selectStatusReadiness(plan, health, objective, todoItems, decision, savedContext, completeTodoReadiness);
     return { object: recommended.object, capability: recommended.capability, reason: recommended.reason };
 }
-//# sourceMappingURL=orientation.js.map