agentera 3.0.0-dev.2 → 3.0.0-dev.21

package/dist/cli/orientation.js

@@ -1,40 +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 { loadArtifactRecord, resolveArtifactPath, } from "../registries/artifactRegistry.js";
+import { activeObjectiveName, artifactPath, resolveRegistryModelPath, } from "./appContext.js";
 import { asList, extractEntries, firstPresent, loadArtifact, recentCycles, truncate, } from "./stateQuery.js";
-import { decisionContextEntry, latestHealthAudit, normalizeSeverity } from "./commands/state.js";
+import { normalizeSeverity } from "./commands/state/index.js";
+import { isResolvedTodoMarkdownStatus, parseTodoMarkdownListItem } from "./todoMarkdown.js";
+import { truncateCodePoints } from "../core/text.js";
+import { TODO_SEVERITY_ORDER, TODO_SEVERITY_ORDER_KEYS } from "./todoSeverity.js";
+import { capabilityStartupComplete } from "./startupCompletenessContract.js";
+import { discoverPlanArtifacts, planCatalogEntry, planDocumentParts } from "./planArtifacts.js";
+import { planLifecycleState } from "./planLifecycleState.js";
+import { dependencyReadyTasks } from "./capabilityContext/planState.js";
+import { resolveSourceRoot } from "../core/sourceRoot.js";
+import { scanYamlCollection } from "../state/startupProjection.js";
+import { numberedArchiveContract } from "../state/archiveDiscovery.js";
+/**
+ * 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_ITEM_RE = /^- \[([^\]]+)\]\s+(.*)/;
-const TODO_PLANERA_SIGNALS = new Set([
+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 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 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";
+const DEFAULT_AUDIT_STALE_CYCLES = 10;
 function intEnv(env, key, def) {
     const raw = env[key] ?? String(def);
     const n = parseInt(raw, 10);
@@ -77,14 +75,47 @@ export function loadNamedArtifact(schemas, name) {
         return null;
     return loadArtifact(artifactPath(info, name));
 }
-export function registryArtifactPath(artifactId, schemasDir) {
-    const record = loadRegistryForSchemas(schemasDir).get(artifactId);
+export function registryArtifactPath(artifactId, schemasDir, env = process.env) {
+    // 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) {
+        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());
+    return resolveArtifactPath(record, process.cwd(), activeObjectiveName(), env);
 }
 // ── staleness ───────────────────────────────────────────────────────
-export function checkProfileraStaleness(profilePath, env = process.env) {
+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 };
+}
+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;
@@ -95,14 +126,11 @@ export function checkProfileraStaleness(profilePath, env = process.env) {
         process.stderr.write(`warning: failed to read profile path ${profilePath}: ${exc.message}\n`);
         return null;
     }
-    const m = /<!-- Generated:\s*(\d{4}-\d{2}-\d{2})/.exec(text);
-    if (!m)
+    const anchor = profileRefreshAnchorUtc(text);
+    if (anchor === null)
         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);
+    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) {
@@ -127,8 +155,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 +184,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 +213,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 ───────────────────────────────────────
@@ -217,9 +262,12 @@ export function loadTodoItems(schemas) {
             continue;
         }
         if (currentSeverity) {
-            const m = TODO_ITEM_RE.exec(stripped);
-            if (m)
-                items.push({ severity: currentSeverity, status: "open", text: m[2].trim() });
+            const parsed = parseTodoMarkdownListItem(stripped);
+            if (!parsed || isResolvedTodoMarkdownStatus(parsed.status))
+                continue;
+            if (!parsed.description)
+                continue;
+            items.push({ severity: currentSeverity, status: parsed.status, text: parsed.description });
         }
     }
     return items;
@@ -239,123 +287,220 @@ export function issueCounts(todoItems) {
     }
     return counts;
 }
-function todoNeedsPlanera(item) {
+function todoNeedsPlan(item) {
     const text = item.text.toLowerCase();
     let signalCount = 0;
-    for (const signal of TODO_PLANERA_SIGNALS)
+    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: "",
+            active_path: "",
             absence_reason: "No active plan artifact is available from agentera 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 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
+        : dependencyReadyTasks(tasks).find((task) => entryStatusPy(task, "pending") === "pending") ?? null;
+    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;
 }
-export function docsSummary(schemas) {
-    const data = loadNamedArtifact(schemas, "docs");
-    if (!data || typeof data !== "object" || Array.isArray(data)) {
+/** 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 ["number", "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);
+    return {
+        exists: Boolean(plan.exists),
+        active: Boolean(plan.active),
+        status: plan.status,
+        title: plan.title ?? "",
+        complete: plan.complete ?? 0,
+        total: plan.total ?? tasks.length,
+        complete_plan: Boolean(plan.complete_plan),
+        first_pending: plan.first_pending && typeof plan.first_pending === "object" && !Array.isArray(plan.first_pending)
+            ? { number: plan.first_pending.number ?? null, name: plan.first_pending.name ?? plan.first_pending.title ?? "", status: plan.first_pending.status ?? "pending" }
+            : null,
+        tasks: boundedTasks,
+        task_count: tasks.length,
+        omitted_task_count: Math.max(0, tasks.length - 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: tasks.length > boundedTasks.length ? "summary" : "full",
+            retrieval: "agentera state plan --format json",
+            raw_archive_records: false,
+        },
+        lifecycle_state: plan.lifecycle_state ?? null,
+    };
+}
+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 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 = 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 : {};
@@ -370,18 +515,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 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: latest.number ?? "?",
+        number: latestNumber,
         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;
@@ -399,7 +546,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();
@@ -462,7 +609,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;
     }
@@ -477,43 +628,48 @@ 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 ?? "?",
+            number: typeof entry.number === "string" || typeof entry.number === "number" ? entry.number : "?",
             title: truncate(firstPresent(entry, ["question", "choice", "summary"], "decision review"), 80),
             state,
             source: satisfaction.source ?? null,
@@ -541,55 +697,91 @@ 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 phase = "phase" in action && action.phase ? ` | phase=${action.phase}` : "";
+    return `object=${truncate(action.object)} | capability=${action.capability} | reason=${action.reason}${phase}`;
 }
-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) {
+    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" };
+        candidates.push({
+            object: `PLAN Task ${number}: ${title}`,
+            capability: "orchestrate",
+            reason: "first pending plan task",
+            phase: "build",
+        });
     }
     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 {
+        candidates.push({
             object: `OBJECTIVE: ${objective.metric || objective.title}`,
-            capability: "optimera",
+            capability: "optimize",
             reason: "active non-closed objective",
-        };
+            phase: "build",
+        });
     }
     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" };
+        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" });
         }
-        return { object: `TODO: ${item.text}`, capability: "realisera", reason: "highest-priority open TODO" };
     }
     if (health.stale && !health.degrading) {
-        return {
+        candidates.push({
             object: `HEALTH: Audit ${health.number ?? "?"} stale`,
-            capability: "inspektera",
+            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) {
+    const { recommended } = selectStatusReadiness(plan, health, objective, todoItems, decision, savedContext);
+    return { object: recommended.object, capability: recommended.capability, reason: recommended.reason };
 }
 //# sourceMappingURL=orientation.js.map