agentera 3.0.0-dev.6 → 3.0.0-dev.69

package/dist/cli/capabilityContext/evidence.js

@@ -1,13 +1,13 @@
 import fs from "node:fs";
 import { artifactPath } from "../appContext.js";
 import { asList } from "../stateQuery.js";
-import { decisionContextEntry, decisionSourceContract, extractDecisionEntries } from "../commands/state/index.js";
 import { capabilityContext } from "./contract.js";
 import { docsConventions, sourceProvenance, uniqueList, hasRecordedValue } from "./shared.js";
-import { loadNamedArtifact } from "../orientation.js";
-import { sourceMetadata } from "../stateQuery.js";
-import { selectEvidenceTarget } from "./planState.js";
+import { selectEvidenceTarget, taskByRef } from "./planState.js";
 import { progressVerificationSummary, retryState } from "./progress.js";
+import { STATE_FAMILY_FALLBACK_COMMANDS, STATE_FAMILY_LIST_COMMANDS } from "./types.js";
+import { deferredStartupFamilies } from "./startupAggregation.js";
+import { preCutoverCommand } from "../preCutoverCommand.js";
 export function dateFromIsoUtc(s) {
     const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(s.trim());
     if (!m)
@@ -39,7 +39,7 @@ export function evidenceDocsState(docs) {
     const [currentState, currentStateCaveat] = currentStateStatus(docs.last_audit, "Docs");
     return {
         status: available ? "available" : "unavailable",
-        source_provenance: sourceProvenance("docs", "agentera docs --format json"),
+        source_provenance: sourceProvenance("docs", STATE_FAMILY_FALLBACK_COMMANDS.docs),
         mapping_entries: docs.mapping_entries ?? 0,
         indexed_documents: docs.indexed_documents ?? 0,
         last_audit: docs.last_audit ?? null,
@@ -54,14 +54,14 @@ export function evidenceDocsState(docs) {
 }
 export function evidenceHealthState(health) {
     const available = Boolean(health.exists);
-    const merged = { audit_number: health.number, ...health };
-    const nonEmptyFields = ["audit_number", "trajectory", "grade"].filter((f) => hasRecordedValue(merged[f]));
+    const nonEmptyFields = ["id", "artifact", "trajectory", "grade"].filter((f) => hasRecordedValue(health[f]));
     const auditDate = health.date ?? health.timestamp ?? null;
     const [currentState, currentStateCaveat] = currentStateStatus(auditDate, "Health");
     return {
         status: available ? "available" : "unavailable",
-        source_provenance: sourceProvenance("health", "agentera health --format json"),
-        audit_number: health.number ?? null,
+        source_provenance: sourceProvenance("health", STATE_FAMILY_LIST_COMMANDS.health),
+        id: health.id ?? null,
+        artifact: health.artifact ?? "health",
         date: auditDate,
         timestamp: auditDate,
         trajectory: health.trajectory ?? null,
@@ -81,7 +81,7 @@ export function evidenceTodoState(schemas, todoItems) {
     const exists = fs.existsSync(artifactPath(info, "todo"));
     return {
         status: exists ? "available" : "unavailable",
-        source_provenance: sourceProvenance("todo", "agentera todo --format json"),
+        source_provenance: sourceProvenance("todo", STATE_FAMILY_FALLBACK_COMMANDS.todo),
         open_count: todoItems.length,
         items: todoItems,
         non_empty_evidence_present: todoItems.length > 0,
@@ -90,7 +90,7 @@ export function evidenceTodoState(schemas, todoItems) {
     };
 }
 export function evidenceProtectedStateChecks() {
-    const source = sourceProvenance("evidence_context", "agentera prime --context inspektera --format json", "protected_state_checks");
+    const source = sourceProvenance("evidence_context", preCutoverCommand("prime --context audit --format json"), "protected_state_checks");
     return {
         status: "not_checked_by_design",
         allowed_status_values: ["verified_local", "not_checked_by_design", "requires_manual_check", "unavailable"],
@@ -120,8 +120,8 @@ export function evidenceVersionChecks(docs) {
     const conventions = docsConventions(docs);
     const versionFiles = asList(conventions.version_files);
     const semverPolicy = conventions.semver_policy && typeof conventions.semver_policy === "object" && !Array.isArray(conventions.semver_policy) ? conventions.semver_policy : {};
-    const source = sourceProvenance("docs", "agentera docs --format json", "summary.conventions");
-    const ec = (field) => sourceProvenance("evidence_context", "agentera prime --context inspektera --format json", field);
+    const source = sourceProvenance("docs", STATE_FAMILY_FALLBACK_COMMANDS.docs, "summary.conventions");
+    const ec = (field) => sourceProvenance("evidence_context", preCutoverCommand("prime --context audit --format json"), field);
     const checks = [
         {
             name: "docs_version_policy",
@@ -177,15 +177,11 @@ export function evidenceVersionChecks(docs) {
 }
 export function evidencePlanCriteria(plan, target) {
     const taskRefObj = target.task && typeof target.task === "object" && !Array.isArray(target.task) ? target.task : null;
-    let selected = null;
-    if (taskRefObj) {
-        const tasks = asList(plan.tasks).filter((t) => t && typeof t === "object" && !Array.isArray(t));
-        selected = tasks.find((t) => t.number === taskRefObj.number) ?? null;
-    }
+    const selected = taskByRef(plan, taskRefObj);
     const criteria = selected && typeof selected === "object" ? asList(selected.acceptance) : [];
     return {
         status: criteria.length > 0 ? "available" : "incomplete",
-        source_provenance: sourceProvenance("plan", "agentera plan --format json", "entries.acceptance"),
+        source_provenance: sourceProvenance("plan", STATE_FAMILY_FALLBACK_COMMANDS.plan, "entries.acceptance"),
         target: taskRefObj,
         criteria,
         criteria_count: criteria.length,
@@ -197,28 +193,49 @@ export function evidencePlanCriteria(plan, target) {
 export function residualRiskEntry(category, status, message, sp) {
     return { category, status, message, source_provenance: sp };
 }
-export function decisionContextRisk(schemas) {
-    const info = schemas.decisions ?? { path: ".agentera/decisions.yaml", record: undefined, schema: {}, fields: {} };
-    const p = artifactPath(info, "decisions");
-    const source = sourceMetadata("decisions", p);
-    const data = loadNamedArtifact(schemas, "decisions");
-    const entries = extractDecisionEntries(data).map((e) => decisionContextEntry(e));
-    if (!source.exists) {
+function decisionHistoryEntries(history) {
+    return asList(history.entries).flatMap((value) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return [];
+        const entry = value;
+        const record = entry.record;
+        if (!record || typeof record !== "object" || Array.isArray(record))
+            return [];
+        return [{ ...record, id: entry.id ?? null, artifact: entry.artifact ?? "decisions", retrieval: entry.retrieval ?? null }];
+    });
+}
+function decisionHistoryCounts(history) {
+    return history.counts && typeof history.counts === "object" && !Array.isArray(history.counts)
+        ? history.counts
+        : {};
+}
+export function decisionContextRisk(history) {
+    const entries = decisionHistoryEntries(history);
+    const counts = decisionHistoryCounts(history);
+    if (history.command !== "state decisions list") {
         return {
             status: "unavailable",
-            source_provenance: sourceProvenance("decisions", "agentera decisions --format json"),
+            source_provenance: sourceProvenance("decisions", STATE_FAMILY_LIST_COMMANDS.decisions),
             summary: null,
             caveats: ["Decision state is unavailable in CLI evidence context."],
         };
     }
-    const contract = decisionSourceContract(source, entries, {});
-    const compacted = contract.completeness.compacted_entries;
-    const missing = contract.completeness.entries_with_missing_fields;
-    const caveats = compacted || missing ? (contract.caveats ?? []) : [];
+    const omitted = Number(counts.remaining ?? history.omitted_count ?? 0);
+    const missing = entries.filter((entry) => !entry.id || !entry.date || !entry.question || !entry.choice).length;
+    const caveats = uniqueList([
+        ...(omitted > 0 ? [`Decision startup history omits ${omitted} decision detail entr${omitted === 1 ? "y" : "ies"}; run ${STATE_FAMILY_LIST_COMMANDS.decisions} for the ordinary bounded list.`] : []),
+        ...(missing > 0 ? [`${missing} bounded decision entr${missing === 1 ? "y is" : "ies are"} missing review context fields.`] : []),
+    ]);
     return {
         status: caveats.length > 0 ? "caveated" : "available",
-        source_provenance: sourceProvenance("decisions", "agentera decisions --format json"),
-        summary: contract.completeness,
+        source_provenance: sourceProvenance("decisions", STATE_FAMILY_LIST_COMMANDS.decisions),
+        summary: {
+            total_entries: Number(counts.total ?? entries.length),
+            returned_entries: Number(counts.returned ?? entries.length),
+            omitted_entries: omitted,
+            entries_with_missing_fields: missing,
+            authority: "canonical_entity_files",
+        },
         caveats,
     };
 }
@@ -244,6 +261,9 @@ export function decisionReviewDue(entry) {
     return [null, null];
 }
 export function decisionLabel(entry) {
+    const id = entry.id;
+    if (typeof id === "string" && id)
+        return `Decision ${id}`;
     const number = entry.number;
     if (number !== null && number !== undefined && number !== "")
         return `Decision ${number}`;
@@ -256,25 +276,21 @@ export function isoFromUtcMs(utc) {
     const d = new Date(utc);
     return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")}`;
 }
-export function decisionReviewPressure(schemas) {
-    const info = schemas.decisions ?? { path: ".agentera/decisions.yaml", record: undefined, schema: {}, fields: {} };
-    const p = artifactPath(info, "decisions");
-    const source = sourceMetadata("decisions", p);
-    const sp = sourceProvenance("decisions", "agentera decisions --format json");
-    if (!source.exists) {
+export function decisionReviewPressure(history) {
+    const sp = sourceProvenance("decisions", STATE_FAMILY_LIST_COMMANDS.decisions);
+    if (history.command !== "state decisions list") {
         return { status: "unavailable", source_provenance: sp, summary: null, stale_protected_decisions: [], caveats: [] };
     }
-    const data = loadNamedArtifact(schemas, "decisions");
-    const dd = data && typeof data === "object" && !Array.isArray(data) ? data : {};
-    const active = Array.isArray(dd.decisions) ? dd.decisions : [];
-    const archive = Array.isArray(dd.archive) ? dd.archive : [];
-    const activeEntries = active.filter((e) => e && typeof e === "object" && !Array.isArray(e)).map((e) => decisionContextEntry(e));
-    const archiveEntries = archive.filter((e) => e && typeof e === "object" && !Array.isArray(e)).map((e) => decisionContextEntry(e));
-    const protectedActive = activeEntries.filter((e) => e.satisfaction && typeof e.satisfaction === "object" && e.satisfaction.review_needed);
-    const protectedArchive = archiveEntries.filter((e) => e.satisfaction && typeof e.satisfaction === "object" && e.satisfaction.review_needed);
+    const activeEntries = decisionHistoryEntries(history);
+    const counts = decisionHistoryCounts(history);
+    const omitted = Number(counts.remaining ?? history.omitted_count ?? 0);
+    const protectedActive = activeEntries.filter((e) => e.satisfaction && typeof e.satisfaction === "object" && !Array.isArray(e.satisfaction) && e.satisfaction.review_needed);
+    const protectedArchive = [];
     const today = todayUtcMs();
     const stale = [];
-    let caveats = [];
+    let caveats = omitted > 0
+        ? [`Decision review pressure is bounded with ${omitted} decision(s) omitted; continue with ${STATE_FAMILY_LIST_COMMANDS.decisions}.`]
+        : [];
     for (const [collection, entries] of [["decisions", protectedActive], ["archive", protectedArchive]]) {
         for (const entry of entries) {
             const [field, reviewDate] = decisionReviewDue(entry);
@@ -295,20 +311,23 @@ export function decisionReviewPressure(schemas) {
     }
     caveats = uniqueList(caveats);
     return {
-        status: caveats.length > 0 ? "review_required" : "available",
+        status: stale.length > 0 || protectedOverflowCount > 0 ? "review_required" : omitted > 0 ? "degraded" : "available",
         source_provenance: sp,
         summary: {
             protected_active_decisions: protectedActive.length,
             protected_archive_decisions: protectedArchive.length,
             protected_overflow_count: protectedOverflowCount,
             stale_protected_decisions: stale.length,
+            returned_decisions: Number(counts.returned ?? activeEntries.length),
+            total_decisions: Number(counts.total ?? activeEntries.length),
+            omitted_decisions: omitted,
         },
         stale_protected_decisions: stale,
         caveats,
     };
 }
-export function inspekteraEvidenceContext(capability, schemas, plan, progress, health, todoItems, docs, profile, bundle) {
-    if (capability !== "inspektera")
+export function auditEvidenceContext(capability, schemas, plan, progress, health, todoItems, docs, profile, bundle, decisionHistory) {
+    if (capability !== "audit")
         return null;
     const capabilityContract = capabilityContext(capability) ?? {};
     const evaluationTarget = selectEvidenceTarget(plan);
@@ -319,34 +338,36 @@ export function inspekteraEvidenceContext(capability, schemas, plan, progress, h
     const todoState = evidenceTodoState(schemas, todoItems);
     const protectedStateChecks = evidenceProtectedStateChecks();
     const versionChecks = evidenceVersionChecks(docs);
-    const decisionRisk = decisionContextRisk(schemas);
-    const reviewPressure = decisionReviewPressure(schemas);
+    const decisionRisk = decisionContextRisk(decisionHistory);
+    const reviewPressure = decisionReviewPressure(decisionHistory);
     let stateCaveats = [];
     const attributedRisks = [];
-    for (const family of (capabilityContract.missing_state_families ?? [])) {
-        const message = `${family} state is not included in prime --context startup context.`;
+    for (const family of deferredStartupFamilies(capabilityContract)) {
+        const message = `${family} detail is deferred from prime --context startup.`;
         stateCaveats.push(message);
-        attributedRisks.push(residualRiskEntry("missing_state_family", "caveated", message, sourceProvenance("prime", "agentera prime --context inspektera --format json", "source_contract.capability_context.missing_state_families")));
+        attributedRisks.push(residualRiskEntry("deferred_state_detail", "caveated", message, sourceProvenance("prime", preCutoverCommand("prime --context audit --format json"), "capability_context.startup.availability")));
     }
     if (bundle.status !== "up_to_date") {
         const message = "Agentera app files are not up to date; this is a caveat, not approval to repair or update app files.";
         stateCaveats.push(message);
-        attributedRisks.push(residualRiskEntry("installed_app_state", "caveated", message, sourceProvenance("hej", "agentera hej --format json", "bundle.status")));
+        attributedRisks.push(residualRiskEntry("installed_app_state", "caveated", message, sourceProvenance("status", preCutoverCommand("prime --format json"), "app.status")));
     }
-    if (profile.status !== "loaded") {
+    if (profile.status !== "valid") {
         const message = "profile-derived state is unavailable in prime --context response.";
         stateCaveats.push(message);
-        attributedRisks.push(residualRiskEntry("profile_state", "unavailable", message, sourceProvenance("hej", "agentera hej --format json", "profile.status")));
+        attributedRisks.push(residualRiskEntry("profile_state", "unavailable", message, sourceProvenance("status", preCutoverCommand("prime --format json"), "profile.status")));
     }
     else if (profile.stale === true) {
         const message = "profile-derived state is stale; this is a caveat, not approval to refresh profile state.";
         stateCaveats.push(message);
-        attributedRisks.push(residualRiskEntry("profile_state", "caveated", message, sourceProvenance("hej", "agentera hej --format json", "profile.stale")));
+        attributedRisks.push(residualRiskEntry("profile_state", "caveated", message, sourceProvenance("status", preCutoverCommand("prime --format json"), "profile.stale")));
     }
     for (const component of [evaluationTarget, planCriteria, progressVerification, docsState, healthState, todoState, protectedStateChecks, versionChecks]) {
         for (const caveat of (component.caveats ?? [])) {
             stateCaveats.push(caveat);
-            attributedRisks.push(residualRiskEntry("evidence_family", "caveated", caveat, component.source_provenance ?? sourceProvenance("evidence_context", "agentera prime --context inspektera --format json")));
+            // cast: component source_provenance comes from evidence builders backed by parsed artifact/decision state
+            const componentSp = component.source_provenance ?? sourceProvenance("evidence_context", preCutoverCommand("prime --context audit --format json"));
+            attributedRisks.push(residualRiskEntry("evidence_family", "caveated", caveat, componentSp));
         }
     }
     for (const caveat of (decisionRisk.caveats ?? [])) {
@@ -383,16 +404,15 @@ export function inspekteraEvidenceContext(capability, schemas, plan, progress, h
     };
     const missingRequired = Object.entries(requiredState).filter(([, present]) => !present).map(([name]) => name);
     const fallbackCommands = uniqueList([
-        "agentera plan --format json",
-        "agentera progress --format json",
-        "agentera docs --format json",
-        "agentera health --format json",
-        "agentera todo --format json",
-        "agentera query --list-artifacts --format json",
-        ...(capabilityContract.cli_fallback ?? []),
+        STATE_FAMILY_FALLBACK_COMMANDS.plan,
+        STATE_FAMILY_FALLBACK_COMMANDS.progress,
+        STATE_FAMILY_FALLBACK_COMMANDS.docs,
+        STATE_FAMILY_FALLBACK_COMMANDS.health,
+        STATE_FAMILY_FALLBACK_COMMANDS.todo,
+        preCutoverCommand("state query --list-artifacts --format json"),
     ]);
     return {
-        capability: "inspektera",
+        capability: "audit",
         evaluation_target: evaluationTarget,
         plan_criteria: planCriteria,
         progress_verification: progressVerification,
@@ -415,10 +435,8 @@ export function inspekteraEvidenceContext(capability, schemas, plan, progress, h
             complete_for_evidence_context: missingRequired.length === 0,
             caveated: stateCaveats.length > 0,
             raw_artifact_reads_required: false,
-            raw_artifact_read_policy: "Use this evidence_context and included hej state first. Run listed routine/query CLI fallback commands " +
+            raw_artifact_read_policy: "Use this evidence_context and included status state first. Run listed routine/query CLI fallback commands " +
                 "for missing or incomplete evidence state; raw artifact reads are last-resort diagnostics, not normal evaluation startup behavior.",
-            included_state_families: capabilityContract.included_state_families ?? [],
-            missing_state_families: capabilityContract.missing_state_families ?? [],
             required_evidence_state: requiredState,
             missing_required_evidence_state: missingRequired,
             fallback_commands: fallbackCommands,
@@ -443,4 +461,3 @@ export function inspekteraEvidenceContext(capability, schemas, plan, progress, h
         },
     };
 }
-//# sourceMappingURL=evidence.js.map

package/dist/cli/capabilityContext/index.js

@@ -1,4 +1,3 @@
-export { CAPABILITY_NAMES, BESPOKE_CONTEXT_CAPABILITIES } from "./types.js";
+export { CAPABILITY_NAMES } from "./types.js";
 export { validatePrimeCapability } from "./shared.js";
 export { buildPrimeCapabilityContextPayload } from "./startup.js";
-//# sourceMappingURL=index.js.map

package/dist/cli/capabilityContext/orchestration.js

@@ -1,15 +1,30 @@
-import { asList } from "../stateQuery.js";
 import { capabilityContext } from "./contract.js";
 import { entryStatus, uniqueList } from "./shared.js";
 import { formatPlanTaskDepRef, indexPlanTasksByNumber, orchestrationTaskSummary, planDependsOnList, resolvePlanTaskByRef, DONE_STATUSES_ORCH, BLOCKED_STATUSES_ORCH, } from "./planState.js";
 import { progressVerificationSummary, retryState, evaluatorHandoff } from "./progress.js";
+import { STATE_FAMILY_FALLBACK_COMMANDS } from "./types.js";
+import { planLifecycleState } from "../planLifecycleState.js";
+import { planTaskIndex } from "../planTaskIndex.js";
+import { entityListFamily } from "../../state/entityRetrievalHelp.js";
+import { deferredStartupFamilies } from "./startupAggregation.js";
+import { preCutoverCommand, preCutoverCommandFromBare } from "../preCutoverCommand.js";
 export function orchestrationContext(capability, plan, progress, health, todoItems, docs, profile, nextAction) {
-    if (capability !== "orkestrera")
+    if (capability !== "orchestrate")
         return null;
-    const tasks = asList(plan.tasks).filter((t) => t && typeof t === "object" && !Array.isArray(t));
+    const lifecycle = planLifecycleState(plan);
+    const tasks = lifecycle.current_plan_degraded === true
+        ? []
+        : planTaskIndex(plan);
     const taskByNumber = indexPlanTasksByNumber(tasks);
     const dependencyReady = [];
     const blocked = [];
+    const complete = tasks.filter((task) => entryStatus(task, "pending") === "complete").length;
+    const superseded = tasks.filter((task) => entryStatus(task, "pending") === "superseded").length;
+    const statusCounts = tasks.reduce((counts, task) => {
+        const status = entryStatus(task, "pending");
+        counts[status] = (counts[status] ?? 0) + 1;
+        return counts;
+    }, {});
     for (const task of tasks) {
         const status = entryStatus(task, "pending");
         if (DONE_STATUSES_ORCH.has(status))
@@ -31,34 +46,44 @@ export function orchestrationContext(capability, plan, progress, health, todoIte
             dependencyReady.push(orchestrationTaskSummary(task));
     }
     const selected = dependencyReady.length > 0 ? dependencyReady[0] : null;
+    const planTasks = entityListFamily("plan_tasks");
+    const queueCommand = plan.id
+        ? preCutoverCommand(`state ${planTasks.commandTokens.join(" ")} list ${String(plan.id)} --limit 100 --format json`)
+        : null;
+    const queueRetrieval = queueCommand
+        ? { list: queueCommand, restart: queueCommand, get: preCutoverCommandFromBare(planTasks.get) }
+        : null;
     const stateCaveats = [];
     let fallbackCommands = [];
     const capabilityContract = capabilityContext(capability) ?? {};
-    for (const family of (capabilityContract.missing_state_families ?? [])) {
-        stateCaveats.push(`${family} state is not included in prime --context startup context.`);
+    for (const family of deferredStartupFamilies(capabilityContract)) {
+        stateCaveats.push(`${family} detail is deferred from prime --context startup.`);
     }
-    fallbackCommands.push(...(capabilityContract.cli_fallback ?? []));
     if (!plan.exists) {
         stateCaveats.push("plan state is unavailable; task queue cannot be complete.");
-        fallbackCommands.push("agentera plan --format json");
+        fallbackCommands.push(STATE_FAMILY_FALLBACK_COMMANDS.plan);
+    }
+    if (lifecycle.status === "degraded") {
+        stateCaveats.push(...(lifecycle.caveats ?? []));
+        fallbackCommands.push(STATE_FAMILY_FALLBACK_COMMANDS.plan);
     }
     if (!progress.exists) {
         stateCaveats.push("progress state is unavailable; latest verification is not summarized here.");
-        fallbackCommands.push("agentera progress --format json");
+        fallbackCommands.push(STATE_FAMILY_FALLBACK_COMMANDS.progress);
     }
     if (!health.exists) {
         stateCaveats.push("health state is unavailable or incomplete.");
-        fallbackCommands.push("agentera health --format json");
+        fallbackCommands.push(STATE_FAMILY_FALLBACK_COMMANDS.health);
     }
     if (!docs.exists) {
         stateCaveats.push("docs mapping state is unavailable or incomplete.");
-        fallbackCommands.push("agentera docs --format json");
+        fallbackCommands.push(STATE_FAMILY_FALLBACK_COMMANDS.docs);
     }
     if (todoItems.length === 0) {
         stateCaveats.push("todo state has no open entries in prime --context response; absence may mean none open or unavailable.");
-        fallbackCommands.push("agentera todo --format json");
+        fallbackCommands.push(STATE_FAMILY_FALLBACK_COMMANDS.todo);
     }
-    if (profile.status !== "loaded") {
+    if (profile.status !== "valid") {
         stateCaveats.push("profile-derived state is unavailable in prime --context response.");
     }
     else if (profile.stale === true) {
@@ -66,27 +91,26 @@ export function orchestrationContext(capability, plan, progress, health, todoIte
     }
     fallbackCommands = uniqueList(fallbackCommands);
     const progressVerification = progressVerificationSummary(progress);
-    const retry = retryState();
+    const retry = retryState(selected, tasks);
     const handoff = evaluatorHandoff(selected, progressVerification, retry, stateCaveats);
-    const complete = Boolean(plan.exists) && tasks.length > 0 && stateCaveats.length === 0;
+    const contextComplete = Boolean(plan.exists) && tasks.length > 0 && stateCaveats.length === 0 && (dependencyReady.length + blocked.length === 0 || queueRetrieval !== null);
     return {
-        capability: "orkestrera",
-        task_queue: { total: tasks.length, dependency_ready_tasks: dependencyReady, blocked_tasks: blocked },
+        capability: "orchestrate",
+        task_queue: { total: tasks.length, complete, superseded, status_counts: statusCounts, dependency_ready_tasks: dependencyReady, blocked_tasks: blocked, retrieval: queueRetrieval },
         selected_next_task: selected,
         selected_next_action: nextAction,
         progress_verification: progressVerification,
         retry_state: retry,
+        plan_lifecycle_state: lifecycle,
         evaluator_handoff: handoff,
         task_summaries: tasks.map((task) => orchestrationTaskSummary(task)),
         state_family_caveats: stateCaveats,
         fallback_commands: fallbackCommands,
         source_contract: {
-            complete_for_orchestration_context: complete,
+            complete_for_orchestration_context: contextComplete,
             raw_artifact_reads_required: false,
-            raw_artifact_read_policy: "Use this orchestration_context and included hej state first. Run listed routine CLI fallback commands " +
+            raw_artifact_read_policy: "Use this orchestration_context and included status state first. Run listed routine CLI fallback commands " +
                 "for missing or incomplete state families; raw artifact reads are last-resort diagnostics, not normal startup behavior.",
-            included_state_families: capabilityContract.included_state_families ?? [],
-            missing_state_families: capabilityContract.missing_state_families ?? [],
             fallback_commands: fallbackCommands,
             caveats: stateCaveats,
             owns: [
@@ -99,9 +123,9 @@ export function orchestrationContext(capability, plan, progress, health, todoIte
                 "retry_state provenance",
                 "evaluator handoff inputs",
                 "state-family caveats",
+                "plan lifecycle state",
             ],
             deferred: [],
         },
     };
 }
-//# sourceMappingURL=orchestration.js.map