agentera 3.0.0-dev.5 → 3.0.0-dev.51

package/dist/cli/orientation.js

@@ -1,40 +1,51 @@
 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.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 { 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`,
+ * `_decision_*`, `_select_status_next_action`, and staleness helpers.
+ */
 export const DONE_STATUSES = new Set(["complete", "completed", "closed", "done", "resolved", "retired"]);
 export const BLOCKED_STATUSES = new Set(["blocked", "stuck"]);
 export const DECISION_ATTENTION_MAX_ENTRIES = 3;
-export const STARTUP_COMPLETENESS_MISSING_STATE = [];
-const TODO_SEVERITY_ORDER = {
-    critical: 0,
-    degraded: 1,
-    warning: 1,
-    normal: 2,
-    info: 3,
-    annoying: 3,
-};
-const TODO_SECTION_SEVERITIES = {
-    critical: "critical",
-    degraded: "degraded",
-    warning: "warning",
-    normal: "normal",
-    info: "info",
-    annoying: "annoying",
-};
-const TODO_PLANERA_SIGNALS = new Set([
-    "acceptance", "artifact", "capability", "capability-context", "compatibility", "contract",
-    "cross-capability", "docs", "metadata", "migration", "schema", "startup", "surface", "test", "validation",
-]);
-const PROFILERA_STALE_DAYS_ENV = "AGENTERA_PROFILERA_MAX_AGE_DAYS";
-const DEFAULT_PROFILERA_STALE_DAYS = 7;
-const INSPEKTERA_STALE_DAYS_ENV = "AGENTERA_INSPEKTERA_MAX_AGE_DAYS";
-const DEFAULT_INSPEKTERA_STALE_DAYS = 30;
-const INSPEKTERA_STALE_CYCLES_ENV = "AGENTERA_INSPEKTERA_MAX_CYCLES";
-const DEFAULT_INSPEKTERA_STALE_CYCLES = 10;
+const TODO_SECTION_SEVERITIES = Object.fromEntries(TODO_SEVERITY_ORDER_KEYS.map((key) => [key, key]));
+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";
+const DEFAULT_AUDIT_STALE_CYCLES = 10;
 function intEnv(env, key, def) {
     const raw = env[key] ?? String(def);
     const n = parseInt(raw, 10);
@@ -77,33 +88,37 @@ export function loadNamedArtifact(schemas, name) {
         return null;
     return loadArtifact(artifactPath(info, name));
 }
-export function registryArtifactPath(artifactId, schemasDir) {
-    const record = loadRegistryForSchemas(schemasDir).get(artifactId);
-    if (record === undefined)
-        throw new Error(`artifact registry does not define '${artifactId}'`);
-    return resolveArtifactPath(record, process.cwd(), activeObjectiveName());
-}
-// ── staleness ───────────────────────────────────────────────────────
-export function checkProfileraStaleness(profilePath, env = process.env) {
-    if (!fs.existsSync(profilePath))
-        return null;
-    let text;
+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 {
-        text = fs.readFileSync(profilePath, "utf8");
+        record = loadArtifactRecord(artifactId, schemasDir, resolveRegistryModelPath(schemasDir));
     }
     catch (exc) {
-        process.stderr.write(`warning: failed to read profile path ${profilePath}: ${exc.message}\n`);
-        return null;
+        if (options.warn !== false) {
+            process.stderr.write(`warning: failed to load artifact registry for schemas: ${exc.message}\n`);
+        }
+        record = undefined;
     }
-    const m = /<!-- Generated:\s*(\d{4}-\d{2}-\d{2})/.exec(text);
-    if (!m)
-        return null;
-    const gen = dateFromIso(m[1]);
-    if (gen === null)
-        return null;
-    const staleDays = intEnv(env, PROFILERA_STALE_DAYS_ENV, DEFAULT_PROFILERA_STALE_DAYS);
-    const since = daysSince(gen);
-    return [since >= staleDays, since, staleDays];
+    if (record === undefined)
+        throw new Error(`artifact registry does not define '${artifactId}'`);
+    return resolveArtifactPath(record, process.cwd(), activeObjectiveName(), env);
+}
+// ── staleness ───────────────────────────────────────────────────────
+const PROFILE_GENERATED_RE = /<!-- Generated:\s*(\d{4}-\d{2}-\d{2})/;
+const PROFILE_VALIDATED_RE = /Validated:\s*(\d{4}-\d{2}-\d{2})/;
+export function parseProfileHeaderDates(text) {
+    const genMatch = PROFILE_GENERATED_RE.exec(text);
+    const generatedDate = genMatch ? genMatch[1] : null;
+    const generatedUtc = generatedDate ? dateFromIso(generatedDate) : null;
+    const valMatch = PROFILE_VALIDATED_RE.exec(text);
+    const validatedDate = valMatch ? valMatch[1] : null;
+    const validatedUtc = validatedDate ? dateFromIso(validatedDate) : null;
+    return { generatedDate, validatedDate, generatedUtc, validatedUtc };
 }
 export function healthAuditDate(entry) {
     for (const key of ["date", "timestamp"]) {
@@ -127,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;
@@ -139,11 +171,11 @@ function cyclesSinceHealthAudit(schemas, auditDate) {
     }
     return count;
 }
-function checkInspekteraAuditStaleness(schemas, latest, auditDate, env = process.env) {
+function checkAuditStaleness(schemas, latest, auditDate, env = process.env) {
     if (latest === null || auditDate === null)
         return null;
-    const staleDaysThreshold = intEnv(env, INSPEKTERA_STALE_DAYS_ENV, DEFAULT_INSPEKTERA_STALE_DAYS);
-    const staleCyclesThreshold = intEnv(env, INSPEKTERA_STALE_CYCLES_ENV, DEFAULT_INSPEKTERA_STALE_CYCLES);
+    const staleDaysThreshold = intEnv(env, AUDIT_STALE_DAYS_ENV, DEFAULT_AUDIT_STALE_DAYS);
+    const staleCyclesThreshold = intEnv(env, AUDIT_STALE_CYCLES_ENV, DEFAULT_AUDIT_STALE_CYCLES);
     const since = daysSince(auditDate);
     const cyclesSince = cyclesSinceHealthAudit(schemas, auditDate);
     const timeStale = since >= staleDaysThreshold;
@@ -168,7 +200,7 @@ function checkInspekteraAuditStaleness(schemas, latest, auditDate, env = process
     if (cyclesSince !== null)
         result.cycles_since_audit = cyclesSince;
     if (isStale)
-        result.suggested_action = "Run inspektera to refresh health audit";
+        result.suggested_action = "Run audit to refresh health audit";
     return result;
 }
 // ── todo items + issue counts ───────────────────────────────────────
@@ -230,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")
@@ -242,123 +274,246 @@ export function issueCounts(todoItems) {
     }
     return counts;
 }
-function todoNeedsPlanera(item) {
-    const text = item.text.toLowerCase();
-    let signalCount = 0;
-    for (const signal of TODO_PLANERA_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) {
-    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." };
+export function docsSummary(schemas, startupInput = {}) {
+    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: STARTUP_COMPLETENESS_MISSING_STATE.length === 0,
+            capability_startup_complete: capabilityStartupComplete(startupInput),
             raw_artifact_reads_required: false,
             state_families: [
                 "plan task details, dependencies, acceptance criteria, and evidence summaries",
                 "docs artifact mapping and source-contract completeness metadata",
-                "latest progress verification metadata needed for Orkestrera evaluation",
-                "Dokumentera closeout context metadata for docs/TODO/changelog/progress synchronization",
+                "latest progress verification metadata needed for Orchestrate evaluation",
+                "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 : {};
@@ -373,18 +528,20 @@ export function healthSummary(schemas, env = process.env) {
     const trajectory = String(latest.trajectory ?? "");
     const auditDate = healthAuditDate(latest);
     const dateStr = auditDate !== null ? isoFromUtc(auditDate) : null;
+    const latestTimestamp = typeof latest.timestamp === "string" ? latest.timestamp : null;
     const summary = {
         exists: true,
-        number: latest.number ?? "?",
+        id: latest.id ?? null,
+        artifact: "health",
         date: dateStr,
-        timestamp: dateStr ?? latest.timestamp ?? null,
+        timestamp: dateStr ?? latestTimestamp,
         trajectory,
         grade: worst ? worst[1] : "",
         worst,
         degrading: ["degrading", "declining", "worse"].includes(trajectory.toLowerCase()) ||
             (worst !== null && worst[2] >= gradeRank.D),
     };
-    const staleness = checkInspekteraAuditStaleness(schemas, latest, auditDate, env);
+    const staleness = checkAuditStaleness(schemas, latest, auditDate, env);
     if (staleness !== null)
         Object.assign(summary, staleness);
     return summary;
@@ -402,7 +559,7 @@ function objectiveStatus(data) {
     return String(firstPresent(header, ["status"], data.status ?? objective.status ?? "") || "").toLowerCase();
 }
 export function activeObjectiveSummary() {
-    const root = path.join(process.cwd(), ".agentera", "optimera");
+    const root = path.join(process.cwd(), ".agentera", "optimize");
     let isDir = false;
     try {
         isDir = fs.statSync(root).isDirectory();
@@ -465,7 +622,11 @@ export function statePresence(plan, docs, progress, health, objective) {
         objective: Boolean(objective.exists),
     };
     const absence = {};
-    for (const [name, summary] of [["plan", plan], ["docs", docs], ["progress", progress]]) {
+    for (const [name, summary] of [
+        ["plan", plan],
+        ["docs", docs],
+        ["progress", progress],
+    ]) {
         if (!summary.exists && summary.absence_reason)
             absence[name] = summary.absence_reason;
     }
@@ -480,43 +641,49 @@ 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" || !satisfaction.review_needed)
+        if (!satisfaction || typeof satisfaction !== "object" || Array.isArray(satisfaction) || !satisfaction.review_needed)
             continue;
-        const number = entry.number ?? "?";
+        const number = typeof entry.number === "string" || typeof entry.number === "number" ? entry.number : "?";
         const title = firstPresent(entry, ["question", "choice"], "decision follow-up");
-        return { object: `DECISION ${number} follow-up`, title };
+        return { object: `DECISION ${number} follow-up`, title: String(title) };
     }
     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 === "")
         return "missing";
     if (state === "user_confirmed_satisfied" && satisfaction.review_needed)
         return "unconfirmed_user_confirmed_satisfied";
-    if (["open", "provisionally_satisfied", "review_needed"].includes(state))
+    if (["open", "provisionally_satisfied", "review_needed"].includes(String(state)))
         return String(state);
     if (state === "user_confirmed_satisfied")
         return "user_confirmed_satisfied";
     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" || !satisfaction.review_needed)
+        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: 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,
@@ -529,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 {
@@ -544,55 +711,156 @@ export function decisionReviewAttention(schemas) {
 }
 export function formatNextAction(action) {
     if (!action)
-        return "object=VISION refresh | capability=visionera | reason=no executable follow-up";
-    return `object=${truncate(action.object)} | capability=${action.capability} | reason=${action.reason}`;
+        return "object=VISION refresh | capability=vision | reason=no executable follow-up | phase=envision";
+    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(" | ");
 }
-export function selectHejNextAction(plan, health, objective, todoItems, decision, savedContext) {
+/**
+ * Evolved state-readiness hint (Decision 76). Evaluates every cascade branch
+ * (no early-return); each candidate carries a protocol.yaml phase tag (PH1
+ * 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, 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");
-        return { object: `PLAN Task ${number}: ${title}`, capability: "orkestrera", reason: "first pending plan 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) {
         const worst = health.worst;
         const target = worst ? `${worst[0]}:${worst[1]}` : "degrading health";
-        return { object: `HEALTH: ${target}`, capability: "inspektera", reason: "critical or degrading health" };
+        candidates.push({
+            object: `HEALTH: ${target}`,
+            capability: "audit",
+            reason: "critical or degrading health",
+            phase: "audit",
+        });
     }
     if (objective.active) {
-        return {
+        const id = typeof objective.id === "string" ? objective.id : undefined;
+        candidates.push({
             object: `OBJECTIVE: ${objective.metric || objective.title}`,
-            capability: "optimera",
+            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 (todoNeedsPlanera(item)) {
-            return { object: `TODO: ${item.text}`, capability: "planera", reason: "complex TODO needs planning" };
+    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,
+            });
         }
-        return { object: `TODO: ${item.text}`, capability: "realisera", reason: "highest-priority open TODO" };
+    }
+    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) {
-        return {
-            object: `HEALTH: Audit ${health.number ?? "?"} stale`,
-            capability: "inspektera",
+        candidates.push({
+            object: `HEALTH: audit ${String(health.id ?? "unknown")} stale`,
+            capability: "audit",
             reason: "stale health audit",
-        };
+            phase: "audit",
+        });
     }
     if (decision) {
-        return { object: String(decision.object), capability: "resonera", reason: "unresolved decision follow-up" };
+        candidates.push({
+            object: String(decision.object),
+            capability: "discuss",
+            reason: "unresolved decision follow-up",
+            phase: "deliberate",
+        });
     }
     const visionExists = fs.existsSync(path.join(process.cwd(), ".agentera", "vision.yaml"));
-    if (plan.exists && !plan.complete_plan) {
-        return { object: "VISION refresh", capability: "planera", reason: "no executable follow-up" };
+    if ((plan.exists && !plan.complete_plan) || visionExists) {
+        candidates.push({ object: "VISION refresh", capability: "plan", reason: "no executable follow-up", phase: "envision" });
     }
-    if (visionExists) {
-        return { object: "VISION refresh", capability: "planera", reason: "no executable follow-up" };
+    if (savedContext && !visionExists) {
+        candidates.push({ object: "Direction clarification", capability: "discuss", reason: "saved context without vision", phase: "envision" });
     }
-    if (savedContext) {
-        return { object: "Direction clarification", capability: "resonera", reason: "saved context without vision" };
+    candidates.push({ object: "VISION refresh", capability: "vision", reason: "fresh project direction", phase: "envision" });
+    // Guarantee at least one alternative so the hint never collapses to a single entry.
+    if (candidates.length < 2) {
+        candidates.push({ object: "Direction clarification", capability: "discuss", reason: "clarify project direction", phase: "envision" });
     }
-    return { object: "VISION refresh", capability: "visionera", reason: "fresh project direction" };
+    const [recommended, ...alternatives] = candidates;
+    return { recommended, alternatives };
+}
+/** 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, 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