agentera 3.0.0-dev.4 → 3.0.0-dev.46

package/dist/cli/commands/prime/buildExecutionRequest.js

@@ -0,0 +1,165 @@
+import fs from "node:fs";
+import { hasControlChars } from "../../argvalidate.js";
+import { loadYamlMapping } from "../../../core/yaml.js";
+import { preCutoverCommand } from "../../preCutoverCommand.js";
+export const BUILD_EXECUTION_REQUEST_SCHEMA = "agentera.buildExecutionRequest.v1";
+export const BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES = 32 * 1024;
+export const BUILD_EXECUTION_REQUEST_MAX_ITEMS = 12;
+export const BUILD_EXECUTION_REQUEST_MAX_CODE_POINTS = 160;
+const BUILD_EXECUTION_REQUEST_READ_CHUNK_BYTES = 8 * 1024;
+export class BuildExecutionRequestError extends Error {
+    body;
+    constructor(body) {
+        super(body.message);
+        this.body = body;
+    }
+}
+function fail(body) {
+    throw new BuildExecutionRequestError(body);
+}
+function codePointLength(value) {
+    return [...value].length;
+}
+function validateText(value, field) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        fail({ class: "schema_violation", message: `Build execution request ${field} must be a non-empty string` });
+    }
+    if (codePointLength(value) > BUILD_EXECUTION_REQUEST_MAX_CODE_POINTS) {
+        fail({ class: "schema_violation", message: `Build execution request ${field} exceeds 160 Unicode code points` });
+    }
+    if (hasControlChars(value)) {
+        fail({ class: "schema_violation", message: `Build execution request ${field} contains control characters` });
+    }
+    return value;
+}
+function unreadableInput() {
+    return fail({
+        class: "invalid_format",
+        message: "Build execution request input must be one readable regular file or bounded stdin stream",
+        syntax: preCutoverCommand("prime --context build --input <file|-> --format json"),
+    });
+}
+function oversizedInput() {
+    return fail({ class: "schema_violation", message: "Build execution request input exceeds the 32768-byte UTF-8 bound" });
+}
+function readBoundedDescriptor(fd) {
+    const chunks = [];
+    let total = 0;
+    while (total <= BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES) {
+        const remaining = BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES + 1 - total;
+        const chunk = Buffer.allocUnsafe(Math.min(BUILD_EXECUTION_REQUEST_READ_CHUNK_BYTES, remaining));
+        const count = fs.readSync(fd, chunk, 0, chunk.byteLength, null);
+        if (count === 0)
+            break;
+        chunks.push(chunk.subarray(0, count));
+        total += count;
+    }
+    if (total > BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES)
+        oversizedInput();
+    return Buffer.concat(chunks, total);
+}
+function sameIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function readBoundedFile(source) {
+    let observed;
+    try {
+        observed = fs.lstatSync(source, { bigint: true });
+    }
+    catch {
+        return unreadableInput();
+    }
+    if (observed.isSymbolicLink() || !observed.isFile())
+        unreadableInput();
+    if (observed.size > BigInt(BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES))
+        oversizedInput();
+    let fd = null;
+    try {
+        fd = fs.openSync(source, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+        const opened = fs.fstatSync(fd, { bigint: true });
+        if (!opened.isFile() || !sameIdentity(observed, opened))
+            unreadableInput();
+        if (opened.size > BigInt(BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES))
+            oversizedInput();
+        return readBoundedDescriptor(fd);
+    }
+    catch (error) {
+        if (error instanceof BuildExecutionRequestError)
+            throw error;
+        return unreadableInput();
+    }
+    finally {
+        if (fd !== null)
+            fs.closeSync(fd);
+    }
+}
+function readBytes(source, readStdin) {
+    if (source !== "-")
+        return readBoundedFile(source);
+    if (readStdin) {
+        let value;
+        try {
+            value = readStdin();
+        }
+        catch {
+            return unreadableInput();
+        }
+        const bytes = typeof value === "string" ? Buffer.from(value, "utf8") : value;
+        if (bytes.byteLength > BUILD_EXECUTION_REQUEST_MAX_UTF8_BYTES)
+            oversizedInput();
+        return bytes;
+    }
+    if (process.stdin.isTTY)
+        return Buffer.alloc(0);
+    try {
+        return readBoundedDescriptor(0);
+    }
+    catch (error) {
+        if (error instanceof BuildExecutionRequestError)
+            throw error;
+        return unreadableInput();
+    }
+}
+export function loadBuildExecutionRequest(source, readStdin) {
+    const bytes = readBytes(source, readStdin);
+    let input;
+    try {
+        const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        input = loadYamlMapping(text);
+    }
+    catch {
+        return fail({
+            class: "invalid_format",
+            message: "Build execution request input must be one valid UTF-8 YAML or JSON mapping",
+        });
+    }
+    const fields = Object.keys(input);
+    const expected = ["schema_version", "scope", "acceptance"];
+    if (fields.some((field) => !expected.includes(field))) {
+        fail({ class: "schema_violation", message: "Build execution request contains unsupported fields" });
+    }
+    if (fields.length !== expected.length || expected.some((field) => !Object.hasOwn(input, field))) {
+        fail({ class: "schema_violation", message: "Build execution request requires exactly schema_version, scope, and acceptance" });
+    }
+    if (input.schema_version !== BUILD_EXECUTION_REQUEST_SCHEMA) {
+        fail({ class: "schema_violation", message: `Build execution request schema_version must be ${BUILD_EXECUTION_REQUEST_SCHEMA}` });
+    }
+    const scope = validateText(input.scope, "scope");
+    if (!Array.isArray(input.acceptance) || input.acceptance.length < 1 || input.acceptance.length > BUILD_EXECUTION_REQUEST_MAX_ITEMS) {
+        fail({ class: "schema_violation", message: "Build execution request acceptance must contain 1 to 12 strings" });
+    }
+    const acceptance = input.acceptance.map((value, index) => validateText(value, `acceptance[${index}]`));
+    if (new Set(acceptance).size !== acceptance.length) {
+        fail({ class: "schema_violation", message: "Build execution request acceptance must not contain duplicate values" });
+    }
+    return {
+        schema_version: BUILD_EXECUTION_REQUEST_SCHEMA,
+        scope,
+        acceptance,
+        source: {
+            kind: source === "-" ? "stdin" : "file",
+            schema_version: BUILD_EXECUTION_REQUEST_SCHEMA,
+            persisted: false,
+        },
+    };
+}

package/dist/cli/commands/prime/bundleStatus.js

@@ -0,0 +1,190 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { APP_OUTDATED, buildDoctorStatus } from "../../../upgrade/doctor.js";
+import { doctorRoots, loadSuiteVersion, resolveDoctorInstallRoot, resolveSourceRootStrict } from "../../../upgrade/appModel.js";
+import { isNpxBundleRoot } from "../../../core/sourceRoot.js";
+import { resolveInvokedUpdateChannel } from "../../../upgrade/channels.js";
+import { classifyResolvedRoot } from "../../../state/installRoot.js";
+import { resolveLatestOnChannel } from "../../../upgrade/versionResolution.js";
+import { resolveNpxPlatformStatus } from "../../../upgrade/npxPlatformStatus.js";
+function frontmatterVersion(p) {
+    let lines;
+    try {
+        if (!fs.statSync(p).isFile())
+            return null;
+        lines = fs.readFileSync(p, "utf8").split(/\r\n|\r|\n/);
+    }
+    catch {
+        return null;
+    }
+    if (lines.length === 0 || lines[0].trim() !== "---")
+        return null;
+    for (const line of lines.slice(1)) {
+        const stripped = line.trim();
+        if (stripped === "---")
+            return null;
+        if (stripped.startsWith("version:")) {
+            const version = stripped.split(":", 2)[1].trim().replace(/^["']|["']$/g, "");
+            return version || null;
+        }
+    }
+    return null;
+}
+function versionKey(version) {
+    if (!version)
+        return [];
+    const parts = [];
+    for (const item of version.split(/[.+_-]/)) {
+        if (/^\d+$/.test(item))
+            parts.push(parseInt(item, 10));
+        else
+            break;
+    }
+    return parts;
+}
+function versionKeyGe(a, b) {
+    const n = Math.max(a.length, b.length);
+    for (let i = 0; i < n; i++) {
+        const ai = a[i] ?? 0;
+        const bi = b[i] ?? 0;
+        if (ai !== bi)
+            return ai > bi;
+    }
+    return true;
+}
+function visibleSkillVersion(home, env, installRoot, sourceRoot) {
+    const candidates = [];
+    if (env.AGENTERA_VISIBLE_SKILL_ROOT)
+        candidates.push(env.AGENTERA_VISIBLE_SKILL_ROOT);
+    candidates.push(path.join(installRoot, "skills", "agentera"));
+    candidates.push(path.join(sourceRoot, "skills", "agentera"));
+    candidates.push(path.join(home, ".config", "opencode", "skills", "agentera"));
+    candidates.push(path.join(home, ".agents", "skills", "agentera"));
+    const versions = [];
+    for (const root of candidates) {
+        const version = frontmatterVersion(path.join(root, "SKILL.md"));
+        if (version)
+            versions.push([versionKey(version), version, root]);
+    }
+    if (versions.length === 0)
+        return [null, null];
+    versions.sort((a, b) => (versionKeyGe(a[0], b[0]) ? -1 : 1));
+    return [versions[0][1], versions[0][2]];
+}
+function recognizedSkillRoots(home, env, installRoot, sourceRoot) {
+    const roots = [];
+    if (env.AGENTERA_VISIBLE_SKILL_ROOT)
+        roots.push(env.AGENTERA_VISIBLE_SKILL_ROOT);
+    roots.push(path.join(installRoot, "skills", "agentera"));
+    roots.push(path.join(sourceRoot, "skills", "agentera"));
+    roots.push(path.join(home, ".config", "opencode", "skills", "agentera"));
+    roots.push(path.join(home, ".agents", "skills", "agentera"));
+    return roots;
+}
+function detectSkillRootDivergence(home, env, installRoot, sourceRoot, expected) {
+    if (!expected)
+        return [];
+    const expectedKey = versionKey(expected);
+    if (expectedKey.length === 0)
+        return [];
+    const divergent = [];
+    const seen = new Set();
+    for (const root of recognizedSkillRoots(home, env, installRoot, sourceRoot)) {
+        if (seen.has(root))
+            continue;
+        seen.add(root);
+        const version = frontmatterVersion(path.join(root, "SKILL.md"));
+        if (!version)
+            continue;
+        if (!versionKeyGe(versionKey(version), expectedKey)) {
+            divergent.push({ root, version });
+        }
+    }
+    return divergent;
+}
+function statusExpectedVersion(opts, sourceRoot, home, env, installRoot, channel) {
+    if (opts.expectedVersion)
+        return [opts.expectedVersion, "--expected-version"];
+    if (env.AGENTERA_EXPECTED_VERSION)
+        return [env.AGENTERA_EXPECTED_VERSION, "AGENTERA_EXPECTED_VERSION"];
+    if (channel.channel === "stable") {
+        const roots = doctorRoots(installRoot);
+        const classification = classifyResolvedRoot(roots.activeBundleRoot, { source: "explicit" });
+        if (classification.current_version) {
+            return [classification.current_version, "installed app registry"];
+        }
+        return [resolveLatestOnChannel(channel, sourceRoot), "stable channel catalog"];
+    }
+    const sourceVersion = loadSuiteVersion(sourceRoot);
+    const [visibleVersion, visibleSource] = visibleSkillVersion(home, env, installRoot, sourceRoot);
+    if (visibleVersion && versionKeyGe(versionKey(visibleVersion), versionKey(sourceVersion))) {
+        return [visibleVersion, visibleSource || "visible skill"];
+    }
+    return [sourceVersion, "source registry"];
+}
+export function statusBundleContext(opts) {
+    const env = opts.env ?? process.env;
+    const home = opts.home ? opts.home : os.homedir();
+    const sourceRoot = resolveSourceRootStrict(env);
+    const channel = resolveInvokedUpdateChannel({ env, home, sourceRoot });
+    const [installRoot, rootSource] = resolveDoctorInstallRoot(opts.installRoot ?? null, {
+        home,
+        env,
+        sourceRoot,
+    });
+    const [expected, expectedSource] = statusExpectedVersion(opts, sourceRoot, home, env, installRoot, channel);
+    const observation = {};
+    const status = buildDoctorStatus(installRoot, {
+        rootSource,
+        sourceRoot,
+        home,
+        project: process.cwd(),
+        expectedVersion: expected,
+        expectedCommands: ["prime"],
+        channel: channel.channel,
+        resolvedChannel: channel,
+        observation,
+        env,
+    });
+    status.expectedVersionSource = expectedSource;
+    if (isNpxBundleRoot(sourceRoot)) {
+        const { platformRoot, platformStatus } = resolveNpxPlatformStatus({
+            home,
+            sourceRoot,
+            project: process.cwd(),
+            expectedVersion: expected,
+            expectedCommands: ["prime"],
+            env,
+        });
+        status.platformAppHome = {
+            path: platformRoot,
+            status: platformStatus.status,
+            rootStatus: platformStatus.rootStatus,
+            dryRunCommand: platformStatus.dryRunCommand,
+            applyCommand: platformStatus.applyCommand,
+        };
+        status.cliApp = {
+            path: sourceRoot,
+            status: status.status,
+            rootStatus: status.rootStatus,
+        };
+    }
+    const divergent = detectSkillRootDivergence(home, env, installRoot, sourceRoot, expected);
+    if (divergent.length > 0) {
+        status.status = APP_OUTDATED;
+        for (const d of divergent) {
+            status.signals.push({
+                status: APP_OUTDATED,
+                kind: "skill_root_divergence",
+                message: `skill root ${d.root} is at v${d.version}; expected v${expected}`,
+                expected: expected ?? undefined,
+                actual: d.version,
+            });
+        }
+    }
+    return { bundle: status, channel, ...observation };
+}
+export function statusBundleStatus(opts) {
+    return statusBundleContext(opts).bundle;
+}

package/dist/cli/commands/prime/collectEntityOrientation.js

@@ -0,0 +1,311 @@
+import path from "node:path";
+import { listProgressEntities } from "../../../state/progressEntities.js";
+import { listDecisionEntities } from "../../../state/decisionEntities.js";
+import { listHealthEntities } from "../../../state/healthEntities.js";
+import { listPlanEntities, listPlanTaskEntities } from "../../../state/planEntities.js";
+import { listObjectiveEntities, listExperimentEntities } from "../../../state/objectiveExperimentEntities.js";
+import { assertTodoReconciliationReadable, listTodoDocsEntities, projectTodoReadEntities } from "../../../state/todoDocsEntities.js";
+import { inspectTodoReconciliationState } from "../../../state/todoReconciliationInspection.js";
+import { StateRetrievalFailure } from "../../../state/directRetrieval.js";
+import { discoverEntities } from "../../../state/entityStorage.js";
+import { summaryCaveat } from "../../../state/summaryEntityRead.js";
+import { boundStartupValue, STARTUP_ARRAY_LIMIT } from "../../../state/startupProjection.js";
+import { rememberPlanTaskIndex } from "../../planTaskIndex.js";
+import { firstActionablePlanTask } from "../../capabilityContext/planState.js";
+import { issueCounts } from "../../orientation.js";
+import { preCutoverCommand } from "../../preCutoverCommand.js";
+import { evaluateTodoReadinessQueue } from "../../todoReadinessSelection.js";
+import { projectCurrentGlossaryCaveats } from "../../../state/progressGlossaryCaveat.js";
+import { glossaryCaveatContract } from "../../../registries/glossaryCaveatContract.js";
+import { renderTodoPublicRecord } from "../../todoMarkdown.js";
+function entries(payload) {
+    return Array.isArray(payload.entries)
+        ? payload.entries.filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry))
+        : [];
+}
+function bounded(value) {
+    return boundStartupValue(value);
+}
+function record(entry) {
+    return entry?.record && typeof entry.record === "object" && !Array.isArray(entry.record)
+        ? entry.record
+        : {};
+}
+function header(entry) {
+    const value = record(entry).header;
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function terminal(status) {
+    return ["complete", "completed", "closed", "done", "resolved", "retired", "superseded"].includes(String(status ?? "").toLowerCase());
+}
+function healthSummary(latest, history) {
+    if (!latest) {
+        return history
+            ? { exists: true, status: "degraded", startup_outcome: "degraded", degraded_history: history }
+            : { exists: false, status: "absent", startup_outcome: "ok" };
+    }
+    const healthRecord = record(latest);
+    const grades = healthRecord.grades && typeof healthRecord.grades === "object" && !Array.isArray(healthRecord.grades)
+        ? healthRecord.grades
+        : {};
+    const ranks = { A: 0, B: 1, C: 2, D: 3, F: 4 };
+    let worst = null;
+    for (const [dimension, grade] of Object.entries(grades)) {
+        const text = String(grade);
+        const rank = ranks[text.toUpperCase().slice(0, 1)] ?? -1;
+        if (worst === null || rank > worst[2])
+            worst = [dimension, text, rank];
+    }
+    const trajectory = String(healthRecord.trajectory ?? "");
+    const degrading = ["degrading", "declining", "worse"].includes(trajectory.toLowerCase()) || (worst !== null && worst[2] >= ranks.D);
+    return {
+        exists: true,
+        status: degrading ? "degraded" : "available",
+        startup_outcome: degrading ? "degraded" : "ok",
+        id: latest.id,
+        artifact: latest.artifact,
+        date: String(healthRecord.date ?? ""),
+        trajectory,
+        grade: worst?.[1] ?? "",
+        worst,
+        degrading,
+        ...(history ? { degraded_history: history } : {}),
+    };
+}
+function degradedHistory(artifact, totalSummaryCount) {
+    if (totalSummaryCount === 0)
+        return undefined;
+    return {
+        summary_count: totalSummaryCount,
+        returned_count: 0,
+        omitted_count: totalSummaryCount,
+        retrieval: {
+            list: preCutoverCommand(`state ${artifact} list --limit 20 --format json`),
+            get: preCutoverCommand(`state ${artifact} get --id ID --format json`),
+        },
+    };
+}
+function projectedHistory(list, artifact, fullCount, summaryCount, degraded) {
+    const total = fullCount + summaryCount;
+    const listCommand = preCutoverCommand(`state ${artifact} list --limit 20 --format json`);
+    const getCommand = preCutoverCommand(`state ${artifact} get --id ID --format json`);
+    return {
+        schemaVersion: list.schemaVersion,
+        command: list.command,
+        status: summaryCount > 0 ? "degraded" : "ok",
+        compatibility: summaryCount > 0 ? (fullCount > 0 ? "mixed" : "degraded") : "current",
+        detail_availability: "omitted",
+        counts: { total, returned: 0, remaining: total, full: fullCount, summary: summaryCount },
+        ...(summaryCount > 0 ? { caveats: [summaryCaveat(artifact)] } : {}),
+        omitted: total > 0,
+        omitted_count: total,
+        omission_reason: total > 0 ? "startup_history_detail" : "none",
+        retrieval: { list: listCommand, get: getCommand },
+        ...(degraded ? { degraded_history: degraded } : {}),
+        source_contract: list.source_contract,
+    };
+}
+function selected(entries, artifact) {
+    if (entries.length < 2)
+        return entries[0];
+    const ids = entries.map((entry) => String(entry.id)).sort().join(", ");
+    const noun = artifact === "plan" ? "open plans" : "active objectives";
+    const list = preCutoverCommand(`state ${artifact} list --format json`);
+    throw new StateRetrievalFailure({
+        schemaVersion: "agentera.stateFailure.v1",
+        status: "fail",
+        error: {
+            class: "ambiguous",
+            artifact,
+            message: `multiple ${noun} require explicit selection: ${ids}`,
+            syntax: preCutoverCommand(`state ${artifact} get --id ID --format json`),
+            example: preCutoverCommand(`state ${artifact} get --id ${String(entries[0]?.id)} --format json`),
+            recovery: `Run ${list}, resolve the competing ${noun}, and retry prime.`,
+        },
+    }, 1);
+}
+/** Bounded startup projection built only from canonical entity readers. */
+export function collectEntityOrientation(projectRoot, sourceRoot) {
+    assertTodoReconciliationReadable(projectRoot, sourceRoot);
+    const discovery = discoverEntities(projectRoot, sourceRoot);
+    const todoReconciliation = inspectTodoReconciliationState(projectRoot, sourceRoot, discovery);
+    const caveatContract = glossaryCaveatContract(path.join(sourceRoot, "references", "artifacts", "glossary-entry-contract.yaml"));
+    const glossaryCaveatProjection = projectCurrentGlossaryCaveats(discovery.entities, caveatContract);
+    const invalidProgress = (entity) => (entity.artifact === "progress" || ["progress_cycle", "progress_summary"].includes(entity.boundary ?? "")) &&
+        entity.classification !== "valid";
+    const progressDiscovery = discovery.entities.some(invalidProgress)
+        ? { ...discovery, entities: discovery.entities.filter((entity) => !invalidProgress(entity)) }
+        : discovery;
+    const progressList = listProgressEntities(projectRoot, 10, {}, undefined, { sourceRoot, format: "json", discovery: progressDiscovery });
+    const decisionList = listDecisionEntities(projectRoot, 10, undefined, undefined, { sourceRoot, format: "json", discovery });
+    const healthList = listHealthEntities(projectRoot, 10, undefined, undefined, { sourceRoot, format: "json", discovery });
+    const planList = listPlanEntities(projectRoot, 2, undefined, { sourceRoot, format: "json", statuses: ["open", "active"], discovery });
+    const objectiveList = listObjectiveEntities(projectRoot, 2, undefined, { sourceRoot, format: "json", statuses: ["open", "active"], discovery });
+    const closedObjectiveList = listObjectiveEntities(projectRoot, 1, undefined, { sourceRoot, format: "json", statuses: ["closed"], discovery });
+    const todoList = listTodoDocsEntities(projectRoot, "todo", 20, undefined, { status: "open" }, { sourceRoot, format: "json", discovery });
+    const docsList = listTodoDocsEntities(projectRoot, "docs", 20, undefined, {}, { sourceRoot, format: "json", discovery });
+    const progressEntries = entries(progressList);
+    const healthEntries = entries(healthList);
+    const decisionEntries = entries(decisionList);
+    const fullProgressEntries = progressEntries.filter((entry) => entry.detail_availability === "full");
+    const fullHealthEntries = healthEntries.filter((entry) => entry.detail_availability === "full");
+    const fullDecisionEntries = decisionEntries.filter((entry) => entry.detail_availability === "full");
+    const progressHistory = degradedHistory("progress", discovery.entities.filter((entry) => entry.boundary === "progress_summary").length);
+    const decisionHistory = degradedHistory("decisions", discovery.entities.filter((entry) => entry.boundary === "decision_summary").length);
+    const healthHistory = degradedHistory("health", discovery.entities.filter((entry) => entry.boundary === "health_summary").length);
+    const progressFullCount = discovery.entities.filter((entry) => entry.boundary === "progress_cycle").length;
+    const decisionFullCount = discovery.entities.filter((entry) => entry.boundary === "decision").length;
+    const healthFullCount = discovery.entities.filter((entry) => entry.boundary === "health_audit").length;
+    const progressSummaryCount = discovery.entities.filter((entry) => entry.boundary === "progress_summary").length;
+    const decisionSummaryCount = discovery.entities.filter((entry) => entry.boundary === "decision_summary").length;
+    const healthSummaryCount = discovery.entities.filter((entry) => entry.boundary === "health_summary").length;
+    const planEntries = entries(planList);
+    const objectiveEntries = entries(objectiveList);
+    const todoEntries = entries(todoList);
+    const docsEntries = entries(docsList);
+    const selectedPlan = selected(planEntries, "plan");
+    const taskPage = selectedPlan
+        ? listPlanTaskEntities(projectRoot, String(selectedPlan.id), 100, undefined, { sourceRoot, format: "json", discovery })
+        : null;
+    const taskEntries = (taskPage
+        ? entries(taskPage)
+        : []).map((entry) => ({ ...record(entry), id: entry.id, artifact: entry.artifact, provenance: entry.provenance }));
+    const allTaskEntries = selectedPlan
+        ? discovery.entities
+            .filter((entry) => entry.boundary === "plan_task" && entry.classification === "valid" && entry.record?.plan === selectedPlan.id && entry.id)
+            .sort((left, right) => left.id.localeCompare(right.id))
+            .map((entry) => ({ ...entry.record, id: entry.id, artifact: entry.artifact, provenance: { storage: "canonical_entity_file", path: entry.relativePath } }))
+        : [];
+    const firstPending = firstActionablePlanTask(allTaskEntries);
+    const taskStatusCounts = allTaskEntries.reduce((counts, entry) => {
+        const status = String(entry.status ?? "pending").toLowerCase();
+        counts[status] = (counts[status] ?? 0) + 1;
+        return counts;
+    }, {});
+    const publicTaskEntries = taskEntries.slice(0, STARTUP_ARRAY_LIMIT);
+    const taskDetailOmitted = allTaskEntries.length > publicTaskEntries.length;
+    const taskRetrieval = selectedPlan
+        ? { list: preCutoverCommand(`state plan tasks list ${String(selectedPlan.id)} --limit 100 --format json`), restart: preCutoverCommand(`state plan tasks list ${String(selectedPlan.id)} --limit 100 --format json`), get: preCutoverCommand("state plan tasks get --id ID --format json") }
+        : {};
+    const plan = selectedPlan ? {
+        exists: true,
+        active: true,
+        id: selectedPlan.id,
+        artifact: selectedPlan.artifact,
+        status: String(header(selectedPlan).status ?? "open"),
+        title: String(header(selectedPlan).title ?? ""),
+        tasks: publicTaskEntries,
+        complete: taskStatusCounts.complete ?? 0,
+        superseded: taskStatusCounts.superseded ?? 0,
+        total: allTaskEntries.length,
+        complete_plan: allTaskEntries.length > 0 && allTaskEntries.every((entry) => terminal(entry.status)),
+        first_pending: firstPending ?? null,
+        task_status_counts: taskStatusCounts,
+        task_omission: { omitted: taskDetailOmitted, total: allTaskEntries.length, returned_count: publicTaskEntries.length, omitted_count: allTaskEntries.length - publicTaskEntries.length, omission_reason: taskDetailOmitted ? taskPage?.omitted === true ? taskPage.omission_reason : "startup_detail_capacity" : "none", retrieval: taskRetrieval },
+        diagnostics: [],
+    } : { exists: false, active: false, status: "missing", tasks: [], complete: 0, superseded: 0, total: 0, complete_plan: false, first_pending: null };
+    const latestProgress = fullProgressEntries[0];
+    const latestProgressRecord = record(latestProgress);
+    const progress = latestProgress ? {
+        exists: true,
+        status: "available",
+        latest: {
+            id: latestProgress.id,
+            artifact: latestProgress.artifact,
+            ...Object.fromEntries(["what", "next"]
+                .filter((field) => latestProgressRecord[field] !== undefined)
+                .map((field) => [field, latestProgressRecord[field]])),
+        },
+        ...(latestProgressRecord.verified === undefined ? {} : { latest_verification: latestProgressRecord.verified }),
+        cycle_count: Number(progressList.counts?.total ?? progressEntries.length),
+        ...(progressHistory ? { degraded_history: progressHistory } : {}),
+    } : progressEntries.length ? {
+        exists: true,
+        status: "degraded_history",
+        cycle_count: Number(progressList.counts?.total ?? progressEntries.length),
+        degraded_history: progressHistory,
+    } : { exists: false, status: "missing", cycle_count: 0 };
+    const health = healthSummary(fullHealthEntries[0], healthEntries.length ? healthHistory : undefined);
+    const activeObjective = selected(objectiveEntries, "objective");
+    const closedObjectiveCount = Number(closedObjectiveList.counts?.total ?? 0);
+    const objectiveRecord = record(activeObjective);
+    const objective = activeObjective ? {
+        exists: true,
+        active: true,
+        id: activeObjective.id,
+        artifact: activeObjective.artifact,
+        title: String(header(activeObjective).title ?? ""),
+        status: String(header(activeObjective).status ?? "open"),
+        metric: String(objectiveRecord.metric?.description ?? ""),
+        experiments: entries(listExperimentEntities(projectRoot, String(activeObjective.id), 20, undefined, { sourceRoot, format: "json", discovery })),
+        closed_count: closedObjectiveCount,
+    } : { exists: closedObjectiveCount > 0, active: false, closed_count: closedObjectiveCount };
+    const completeTodoEntities = projectTodoReadEntities(projectRoot, sourceRoot, discovery);
+    const todoReadiness = evaluateTodoReadinessQueue(completeTodoEntities, sourceRoot);
+    const todoItems = todoEntries.map((entry) => {
+        const todo = record(entry);
+        return {
+            id: String(entry.id), artifact: String(entry.artifact),
+            severity: String(todo.severity ?? "normal"),
+            status: String(todo.status ?? "open"),
+            kind: typeof todo.kind === "string" ? todo.kind : null,
+            target_version: typeof todo.target_version === "string" ? todo.target_version : null,
+            title: typeof todo.title === "string" ? todo.title : null,
+            requirements: Array.isArray(todo.requirements) ? todo.requirements : [],
+            acceptance: Array.isArray(todo.acceptance) ? todo.acceptance : [],
+            release_blocker: todo.release_blocker === true,
+            text: renderTodoPublicRecord(todo),
+        };
+    });
+    const todoCounts = issueCounts(completeTodoEntities
+        .filter((entry) => entry.record.status === "open")
+        .map((entry) => ({ severity: String(entry.record.severity ?? "normal") })));
+    const todoListCounts = todoList.counts;
+    const todoDetail = {
+        total: Number(todoListCounts?.total ?? todoEntries.length),
+        returned: Number(todoListCounts?.returned ?? todoEntries.length),
+        omitted: Number(todoListCounts?.remaining ?? 0),
+        retrieval: todoList.retrieval ?? {},
+    };
+    const docs = {
+        exists: docsEntries.length > 0,
+        status: docsEntries.length ? "available" : "missing",
+        indexed_documents: Number(docsList.counts?.total ?? docsEntries.length),
+        entries: docsEntries,
+    };
+    const reviewEntries = fullDecisionEntries.filter((entry) => {
+        const satisfaction = record(entry).satisfaction;
+        return satisfaction?.review_needed === true || satisfaction?.state === "open";
+    });
+    const decisionAttention = reviewEntries.length ? {
+        type: "decision_review",
+        count: reviewEntries.length,
+        states: {},
+        entries: reviewEntries.slice(0, 3).map((entry) => ({
+            id: String(entry.id), artifact: String(entry.artifact), title: String(record(entry).question ?? "Decision"), state: String(record(entry).satisfaction?.state ?? "open"), source: entry.provenance ?? null,
+        })),
+        max_entries: 3,
+        bounded: reviewEntries.length > 3,
+        attention: `${reviewEntries.length} decision(s) require review`,
+    } : null;
+    const firstDecision = reviewEntries[0];
+    const decision = firstDecision ? { object: String(firstDecision.id), title: String(record(firstDecision).question ?? "Decision review") } : null;
+    const projection = bounded({
+        plan, docs, progress, health, objective, todoItems, todoCounts, decision, decisionAttention,
+        glossaryCaveatAttention: glossaryCaveatProjection.attention,
+        glossaryCaveatAttentionPolicy: glossaryCaveatProjection.attention ? {
+            public_limit: glossaryCaveatProjection.publicAttentionLimit,
+            reserved_slots: glossaryCaveatProjection.reservedGlossarySlots,
+        } : null,
+        history: {
+            progress: projectedHistory(progressList, "progress", progressFullCount, progressSummaryCount, progressHistory),
+            decisions: projectedHistory(decisionList, "decisions", decisionFullCount, decisionSummaryCount, decisionHistory),
+            health: projectedHistory(healthList, "health", healthFullCount, healthSummaryCount, healthHistory),
+        },
+    });
+    // The opaque continuation cursor is already list-budget bounded and must stay
+    // byte-exact so omitted TODO detail remains recoverable.
+    const result = { ...projection, todoDetail, todoReadiness, todoReconciliation };
+    rememberPlanTaskIndex(result.plan, allTaskEntries);
+    return result;
+}