agentera 3.0.0-dev.7 → 3.0.0-dev.72

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

@@ -1,13 +1,30 @@
 import { publicDoctorStatus } from "../../../upgrade/doctor.js";
 import { projectInstallTrack } from "../../../upgrade/compatibility.js";
-import { formatNextAction } from "../../orientation.js";
-import { requestedFields, REQUIRED_SPARSE_CONTEXT_FIELDS } from "../../stateQuery.js";
+import { formatNextAction, startupPlanSummary } from "../../orientation.js";
+import { requestedFields, REQUIRED_SPARSE_CONTEXT_FIELDS, PRIME_STRUCTURED_FIELDS, RETIRED_PRIME_FIELD_CORRECTIONS, availablePrimeFields, } from "../../stateQuery.js";
 import { emitStructured } from "../../structured.js";
-import { startupCompletenessContract } from "../../startupCompletenessContract.js";
-export { startupCompletenessContract } from "../../startupCompletenessContract.js";
+import { emitInvalidInput } from "../../errors.js";
+import { preCutoverCommand } from "../../preCutoverCommand.js";
+import { truncateCodePoints } from "../../../core/text.js";
+import { briefOrientationPayload, briefUtf8Bytes } from "./briefOrientation.js";
+import { capabilityContext } from "../../capabilityContext/contract.js";
+import { startupAggregation } from "../../capabilityContext/startupAggregation.js";
+export { briefOrientationPayload, PRIME_BRIEF_MAX_UTF8_BYTES } from "./briefOrientation.js";
+/** Authority for the complete status startup capsule, including instructions. */
+export const PRIME_STATUS_CONTEXT_MAX_UTF8_BYTES = 22500;
 /** Project a single {@link NextAction} to its JSON record shape. */
 function nextActionEntry(action) {
-    return { object: action.object, capability: action.capability, reason: action.reason, phase: action.phase };
+    return {
+        object: action.object,
+        capability: action.capability,
+        reason: action.reason,
+        phase: action.phase,
+        ...(action.id ? { id: action.id } : {}),
+        ...(action.artifact ? { artifact: action.artifact } : {}),
+        ...(action.outcome ? { outcome: action.outcome } : {}),
+        ...(typeof action.eligible === "boolean" ? { eligible: action.eligible } : {}),
+        ...(action.retrieval ? { retrieval: action.retrieval } : {}),
+    };
 }
 /** Ranked state-readiness hint for the prime JSON `next_action` field (D76).
  *  The recommended entry is flattened to top-level `object`/`capability`/
@@ -15,33 +32,75 @@ function nextActionEntry(action) {
  *  and `alternatives` carries the cascade branches the early-return model
  *  would have skipped, each with the same `{object, capability, reason, phase}`
  *  shape. */
-function nextActionPayload(state) {
-    const { recommended, alternatives } = state.next_action;
+function nextActionPayload({ recommended, alternatives }) {
     return {
         ...nextActionEntry(recommended),
         alternatives: alternatives.map(nextActionEntry),
     };
 }
-const STATUS_STRUCTURED_FIELDS = [
-    "command", "status", "app_home", "app", "mode", "profile", "v1_migration", "health",
-    "todo", "plan", "docs", "progress", "objective", "state_presence", "project_integration", "attention",
-    "decision_attention", "next_action", "orchestration_context", "closeout_context",
-    "evidence_context", "benchmark_context", "execution_context", "source", "source_contract",
+const STATUS_STRUCTURED_FIELDS = PRIME_STRUCTURED_FIELDS;
+const DEFAULT_PUBLIC_ATTENTION_LIMIT = 6;
+export function projectPublicOrientationAttention(state) {
+    const glossary = state.glossary_caveat_attention;
+    const policy = state.glossary_caveat_attention_policy;
+    if (!glossary || !policy)
+        return state.attention.slice(0, DEFAULT_PUBLIC_ATTENTION_LIMIT);
+    const unrelated = state.attention.filter((item) => item !== glossary);
+    const unrelatedLimit = Math.max(0, policy.public_limit - policy.reserved_slots);
+    return [...unrelated.slice(0, unrelatedLimit), glossary].slice(0, policy.public_limit);
+}
+/** Top-level conditional fields whose default/inactive payload is omitted from
+ *  the default bare briefing so startup does not carry default-only adjective
+ *  noise. They remain declared in PRIME_STRUCTURED_FIELDS (selectable via
+ *  `--fields` and advertised in `source_contract.fields`) and are recovered
+ *  through `state_presence` (missing-vs-empty semantics) plus a named
+ *  authoritative command. The full payload kept by `buildOrientationJsonPayload`
+ *  still populates them, so explicit `--fields <name>` selection, the text
+ *  briefing, and downstream state consumers are unaffected. */
+const OMITTABLE_DEFAULT_CONDITIONAL_TOP_FIELDS = [
+    "v1_migration",
+    "docs",
+    "objective",
 ];
-/** Deprecated JSON field selectors kept for pre-3.0.0 consumers; not listed in source_contract.fields. */
-const DEPRECATED_PRIME_FIELD_ALIASES = ["issues"];
-const ISSUES_FIELD_DEPRECATION_MESSAGE = "Deprecation: prime JSON field 'issues' is deprecated; use 'todo'. The 'issues' field will be removed at the 3.0.0 stable cut.\n";
-function shouldEmitIssuesDeprecation(requested, payload) {
-    if (!("issues" in payload))
+/** Whether a conditional top-level field carries present/active payload (not the
+ *  default-only state that should be omitted from the default briefing). The
+ *  activity predicate mirrors each summary's "default" branch so absence stays
+ *  non-ambiguous: a survivor key is present exactly when the field is active. */
+function isConditionalFieldPresent(field, payload) {
+    const value = payload[field];
+    if (value === null || value === undefined)
         return false;
-    if (requested.length === 0)
+    if (typeof value !== "object" || Array.isArray(value))
         return true;
-    return requested.includes("issues");
+    const obj = value;
+    // v1_migration: present when v1 artifacts are detected (detected !== true is
+    // the default state; recover via `agentera upgrade --dry-run`).
+    if (field === "v1_migration")
+        return obj.detected === true;
+    // docs: present when a docs mapping artifact exists (exists !== true is the
+    // absent state; recover via the canonical docs list command).
+    if (field === "docs")
+        return obj.exists === true;
+    // objective: present when an objective is active (active !== true is the
+    // none-active state; state_presence.active.objective disambiguates).
+    if (field === "objective")
+        return obj.active === true;
+    return true;
 }
-function emitIssuesFieldDeprecationWarning(requested, payload, err) {
-    if (shouldEmitIssuesDeprecation(requested, payload)) {
-        err(ISSUES_FIELD_DEPRECATION_MESSAGE);
+/** Return a default-briefing copy of `payload` with inactive conditional
+ *  top-level fields removed. Required fields and `state_presence` (the
+ *  missing-vs-empty authority) are always retained. Used only by the default
+ *  bare emission path; explicit `--fields` selection keeps the full payload. */
+function omitInactiveConditionalDefaults(payload) {
+    const out = {};
+    for (const [key, value] of Object.entries(payload)) {
+        if (OMITTABLE_DEFAULT_CONDITIONAL_TOP_FIELDS.includes(key) &&
+            !isConditionalFieldPresent(key, payload)) {
+            continue;
+        }
+        out[key] = value;
     }
+    return out;
 }
 function orientationAppHome(bundle) {
     return {
@@ -53,11 +112,23 @@ function orientationAppHome(bundle) {
         user_data_root: bundle.userDataRoot,
     };
 }
-export function buildOrientationJsonPayload(state, command) {
+function capabilityContextPointer(requiredBeforeRendering = true) {
+    return {
+        capability: "status",
+        fetch_command: preCutoverCommand("prime --context status --format json"),
+        required_before_rendering: requiredBeforeRendering,
+        note: requiredBeforeRendering
+            ? "Dashboard rendering instructions (template, field rules, exit marker) are owned by the status capability. Run the fetch_command before rendering."
+            : "Includes dashboard instructions and bounded state; no second prime call.",
+    };
+}
+export function buildOrientationJsonPayload(state, command, options = {}) {
     const bundle = state.app;
     const schemasDir = state.schemas_dir;
     const bundlePublic = publicDoctorStatus(bundle);
     const appHome = orientationAppHome(bundle);
+    const todoReconciliation = state.todo_reconciliation ?? null;
+    const startup = startupAggregation(capabilityContext("status") ?? {}, state.health, state.state_cutover, todoReconciliation);
     const bespoke = {
         orchestration_context: null,
         closeout_context: null,
@@ -73,24 +144,26 @@ export function buildOrientationJsonPayload(state, command) {
         : "single installed CLI call; app/v1/profile safety included; no preflight glob/read/import/doctor calls during normal prime";
     return {
         command,
-        status: "ok",
+        outcome: startup.outcome,
         app_home: appHome,
         app: bundlePublic,
         mode: state.mode,
-        profile: state.profile_dict,
         v1_migration: state.v1_migration,
+        shared_skill: state.shared_skill,
         project_integration: state.project_integration,
+        ...(state.todo_reconciliation?.status === "action_required" ? { todo_reconciliation: state.todo_reconciliation } : {}),
         health: state.health,
-        todo: state.counts,
-        issues: state.counts,
-        plan: state.plan,
+        todo: { ...state.counts, detail: state.todo_detail },
+        plan: startupPlanSummary(state.plan),
         docs: state.docs,
         progress: state.progress,
         objective: state.objective,
         state_presence: state.state_presence,
-        attention: state.attention.slice(0, 6),
+        attention: projectPublicOrientationAttention(state).map((item) => truncateCodePoints(item, 200, "…")),
         decision_attention: state.decision_attention,
-        next_action: nextActionPayload(state),
+        history: state.history,
+        next_action: nextActionPayload(state.next_action),
+        startup,
         orchestration_context: bespoke.orchestration_context,
         closeout_context: bespoke.closeout_context,
         evidence_context: bespoke.evidence_context,
@@ -102,24 +175,113 @@ export function buildOrientationJsonPayload(state, command) {
             artifacts_present: state.mode === "returning",
         },
         source_contract: {
-            fields: STATUS_STRUCTURED_FIELDS,
+            fields: state.todo_reconciliation?.status === "action_required" ? [...STATUS_STRUCTURED_FIELDS, "todo_reconciliation"] : STATUS_STRUCTURED_FIELDS,
             render,
             access,
-            empty_state: "fresh mode with missing artifact summaries and zero issue counts",
-            capability_startup: startupCompletenessContract({ profileStatus: state.profile_status }),
-            capability_context: null,
+            empty_state: "fresh: summaries absent; zero TODO items",
+            capability_context: capabilityContextPointer(options.capabilityContextRequiredBeforeRendering ?? true),
         },
     };
 }
-function availablePrimeFields(command) {
-    const base = command === "prime" ? [...STATUS_STRUCTURED_FIELDS, "capability_context"] : STATUS_STRUCTURED_FIELDS;
-    return [...base, ...DEPRECATED_PRIME_FIELD_ALIASES];
+/** The status dashboard consumes a compact view of the one startup aggregation. */
+export function buildStatusContextState(state, _command = "prime", _options = {}) {
+    const todoReconciliation = state.todo_reconciliation ?? null;
+    const startup = startupAggregation(capabilityContext("status") ?? {}, state.health, state.state_cutover, todoReconciliation);
+    const plan = state.plan;
+    const firstPending = plan.first_pending && typeof plan.first_pending === "object" && !Array.isArray(plan.first_pending)
+        ? plan.first_pending
+        : null;
+    const risks = todoReconciliation?.risks;
+    const unsafeDetailOmitted = todoReconciliation?.state === "unsafe_inactive"
+        && Boolean(risks && typeof risks === "object" && !Array.isArray(risks) && Number(risks.omitted_count) > 0);
+    const recovery = unsafeDetailOmitted && typeof todoReconciliation.recovery_command === "string"
+        ? todoReconciliation.recovery_command
+        : null;
+    const todoAttention = unsafeDetailOmitted
+        ? new Set(state.todo_items.map((item) => `${String(item.severity)}: TODO: ${String(item.text)}`))
+        : new Set();
+    const attention = projectPublicOrientationAttention(state)
+        .flatMap((item) => item === `action-required: TODO reconciliation is unsafe inactive; ${recovery}`
+        ? ["action-required: TODO reconciliation is unsafe inactive; see capability_context.startup.todo_reconciliation"]
+        : todoAttention.has(item) ? [] : [item])
+        .map((item) => truncateCodePoints(item, 200, "…"));
+    const redactRecovery = (action) => recovery !== null && action.reason === recovery
+        ? { ...action, reason: "See capability_context.startup.todo_reconciliation for recovery." }
+        : action;
+    const nextAction = {
+        recommended: redactRecovery(state.next_action.recommended),
+        alternatives: state.next_action.alternatives
+            .filter((action) => !unsafeDetailOmitted || action.artifact !== "todo")
+            .map(redactRecovery),
+    };
+    return {
+        outcome: startup.outcome,
+        mode: state.mode,
+        project_integration: {
+            recommendation: state.project_integration.recommendation,
+            ...(state.project_integration.message ? { message: state.project_integration.message } : {}),
+            ...(state.project_integration.dry_run_command ? { dry_run_command: state.project_integration.dry_run_command } : {}),
+            ...(state.project_integration.apply_command ? { apply_command: state.project_integration.apply_command } : {}),
+        },
+        health: {
+            exists: state.health.exists,
+            status: state.health.status ?? null,
+            id: state.health.id ?? null,
+            grade: state.health.grade ?? null,
+            worst: state.health.worst ?? null,
+            trajectory: state.health.trajectory ?? null,
+            degrading: Boolean(state.health.degrading),
+        },
+        todo: { ...state.counts, detail: state.todo_detail },
+        plan: {
+            exists: plan.exists,
+            active: plan.active ?? false,
+            id: plan.id ?? null,
+            artifact: plan.exists ? plan.artifact ?? "plan" : null,
+            status: plan.status,
+            title: plan.title ?? null,
+            complete: plan.complete ?? 0,
+            total: plan.total ?? 0,
+            complete_plan: plan.complete_plan ?? false,
+            first_pending: firstPending ? {
+                id: firstPending.id ?? null,
+                artifact: firstPending.artifact ?? "plan",
+                name: firstPending.name ?? firstPending.title ?? null,
+                status: firstPending.status ?? null,
+            } : null,
+        },
+        progress: { exists: state.progress.exists, status: state.progress.status ?? null, latest: state.progress.latest ?? null },
+        objective: { exists: state.objective.exists, active: state.objective.active ?? false, title: state.objective.title ?? null },
+        state_presence: state.state_presence,
+        attention,
+        next_action: nextActionPayload(nextAction),
+    };
 }
-export function emitPrime(command, payload, format, fieldsArg, out, err) {
+export function emitPrime(command, payload, format, fieldsArg, out, err, options = {}) {
+    const retiredRejection = rejectRetiredPrimeFields(command, format, fieldsArg, out, err);
+    if (retiredRejection !== null)
+        return retiredRejection;
     const requested = requestedFields(fieldsArg);
-    emitIssuesFieldDeprecationWarning(requested, payload, err);
+    // The default bare briefing first omits inactive conditional top-level fields
+    // (v1_migration/docs/objective when default) so startup does not carry
+    // default-only payload, then — for the bare default only — projects the full
+    // payload to a bounded decision brief (Plan Task 3). Explicit `--fields`
+    // selection and `--context` use their governed payloads. Dashboard history is
+    // already projected at collection time so ordinary list detail is not copied
+    // into startup (see default_emission_omission_contract + brief_omission_contract).
+    const conditional = requested.length === 0 && options.bareBrief ? omitInactiveConditionalDefaults(payload) : payload;
+    const effectivePayload = requested.length === 0 && options.bareBrief
+        ? briefOrientationPayload(conditional, { budgetBytes: options.briefBudgetBytes })
+        : conditional;
     if (requested.length === 0) {
-        emitStructured(payload, format, out);
+        if (format === "json" && options.maxUtf8Bytes !== undefined) {
+            const bytes = briefUtf8Bytes(effectivePayload);
+            if (bytes > options.maxUtf8Bytes) {
+                err(`Error: ${command} JSON output is ${bytes} UTF-8 bytes, over the ${options.maxUtf8Bytes}-byte startup budget; use the named recovery commands in the projected output contract.\n`);
+                return 1;
+            }
+        }
+        emitStructured(effectivePayload, format, out);
         return 0;
     }
     const available = availablePrimeFields(command);
@@ -133,14 +295,40 @@ export function emitPrime(command, payload, format, fieldsArg, out, err) {
         if (field in payload && !(field in selected))
             selected[field] = payload[field];
     }
+    if (format === "json" && options.maxUtf8Bytes !== undefined) {
+        const bytes = briefUtf8Bytes(selected);
+        if (bytes > options.maxUtf8Bytes) {
+            err(`Error: ${command} JSON output is ${bytes} UTF-8 bytes, over the ${options.maxUtf8Bytes}-byte startup budget; use the named recovery commands in the projected output contract.\n`);
+            return 1;
+        }
+    }
     emitStructured(selected, format, out);
     return 0;
 }
+/** Reject a retired selector before state collection or output projection. Text
+ *  mode uses JSON because a retired-field request is an automation-shaped
+ *  selector and must return one machine-readable correction, not a briefing. */
+export function rejectRetiredPrimeFields(command, format, fieldsArg, out, err) {
+    const requested = requestedFields(fieldsArg);
+    const retired = requested.find((field) => field in RETIRED_PRIME_FIELD_CORRECTIONS);
+    if (retired === undefined)
+        return null;
+    const replacement = RETIRED_PRIME_FIELD_CORRECTIONS[retired];
+    return emitInvalidInput({ out, err }, {
+        format: format === "yaml" ? "yaml" : "json",
+        body: {
+            class: "invalid_choice",
+            message: `prime field '${retired}' is retired; use '${replacement}'`,
+            valid_values: [replacement],
+            syntax: preCutoverCommand(`${command} --fields ${replacement} --format json`),
+            example: preCutoverCommand(`${command} --fields ${replacement} --format json`),
+            recovery: `Replace '${retired}' with '${replacement}' and retry; no state was changed.`,
+        },
+    });
+}
 export function printOrientationTextBriefing(state, command, out) {
     const bundle = state.app;
     const mode = state.mode;
-    const profileStatus = state.profile_status;
-    const profile = state.profile;
     const health = state.health;
     const counts = state.counts;
     const plan = state.plan;
@@ -149,24 +337,47 @@ export function printOrientationTextBriefing(state, command, out) {
     const attention = state.attention;
     const nextAction = state.next_action;
     const dashboardLabel = command === "prime" ? "prime orientation dashboard" : "prime orientation dashboard";
-    out(`agentera ${command}\n`);
+    out(`${preCutoverCommand(command)}\n`);
     out(`app_home: install_track=${projectInstallTrack(bundle.installKind)} | status=${bundle.status} | home=${bundle.appHome} | ` +
         `source=${bundle.appHomeSource} | managed_app=${bundle.managedAppRoot} | user_data=${bundle.userDataRoot} | expected=${bundle.expectedVersion} | ` +
         `expected_source=${bundle.expectedVersionSource ?? "-"} | current=${bundle.markerVersion || "-"}\n`);
     out(`mode: ${mode}\n`);
     const projectIntegration = state.project_integration;
     out(`project_integration: recommendation=${projectIntegration.recommendation} | ` +
-        `channel=${projectIntegration.update_channel} | pending_runtime=${projectIntegration.pending_runtime}\n`);
+        `channel=${projectIntegration.update_channel} | pending_artifacts=${projectIntegration.pending_artifacts}\n`);
     if (projectIntegration.recommendation === "upgrade" && projectIntegration.message) {
         out(`project_integration_message: ${projectIntegration.message}\n`);
     }
-    out(`profile: ${profileStatus} | path=${profile}\n`);
-    if (health.exists) {
+    out(`shared_skill: status=${String(state.shared_skill.status)} | path=${String(state.shared_skill.path)}\n`);
+    const todoReconciliation = state.todo_reconciliation ?? null;
+    const startup = startupAggregation(capabilityContext("status") ?? {}, state.health, state.state_cutover, todoReconciliation);
+    out(`outcome: ${String(startup.outcome)}\n`);
+    if (health.exists && health.id) {
         const worst = health.worst;
         const worstText = worst ? `${worst[0]}:${worst[1]}` : "none";
-        out(`health: audit=${health.number} | grade=${health.grade || "unknown"} | ` +
+        out(`health: id=${health.id} | artifact=${health.artifact ?? "health"} | grade=${health.grade || "unknown"} | ` +
             `trajectory=${health.trajectory || "unknown"} | worst=${worstText}\n`);
     }
+    if (health.degraded_history) {
+        const degraded = health.degraded_history;
+        out(`health: degraded_history | summaries=${String(degraded.summary_count ?? 0)} | returned=${String(degraded.returned_count ?? 0)} | omitted=${String(degraded.omitted_count ?? 0)} | ` +
+            `detail=summary-only | recovery=${preCutoverCommand("state health list --limit 20 --format json")}\n`);
+    }
+    const latestProgress = state.progress.latest;
+    if (latestProgress) {
+        out(`progress: id=${String(latestProgress.id ?? "unknown")} | artifact=${String(latestProgress.artifact ?? "progress")} | ` +
+            `what=${String(latestProgress.what ?? "unknown")}\n`);
+    }
+    if (state.progress.degraded_history) {
+        const degraded = state.progress.degraded_history;
+        out(`progress: degraded_history | summaries=${String(degraded.summary_count ?? 0)} | returned=${String(degraded.returned_count ?? 0)} | omitted=${String(degraded.omitted_count ?? 0)} | ` +
+            `detail=summary-only | recovery=${preCutoverCommand("state progress list --limit 20 --format json")}\n`);
+    }
+    const decisionHistory = state.history.decisions?.degraded_history;
+    if (decisionHistory) {
+        out(`decisions: degraded_history | summaries=${String(decisionHistory.summary_count ?? 0)} | returned=${String(decisionHistory.returned_count ?? 0)} | omitted=${String(decisionHistory.omitted_count ?? 0)} | ` +
+            `detail=summary-only | recovery=${preCutoverCommand("state decisions list --limit 20 --format json")}\n`);
+    }
     out(`todo: critical=${counts.critical} | degraded=${counts.degraded} | normal=${counts.normal} | annoying=${counts.annoying}\n`);
     if (!presence.any_active) {
         const missing = Object.keys(presence.absence).sort().join(", ") || "none";
@@ -187,7 +398,7 @@ export function printOrientationTextBriefing(state, command, out) {
     }
     if (attention.length > 0) {
         out("attention:\n");
-        for (const item of attention.slice(0, 6))
+        for (const item of projectPublicOrientationAttention(state))
             out(`- ${item}\n`);
     }
     out("next_action:\n");
@@ -196,15 +407,15 @@ export function printOrientationTextBriefing(state, command, out) {
         out(`- alt: ${formatNextAction(alt)}\n`);
     }
     out("source_contract:\n");
-    out("- fields=app_home,mode,profile,v1_migration,project_integration,health,todo,plan,docs,progress,objective,state_presence,attention,decision_attention,next_action,orchestration_context,closeout_context,evidence_context,benchmark_context,execution_context\n");
+    out(`- fields=${PRIME_STRUCTURED_FIELDS.join(", ")}\n`);
     out(`- render=caller-owned README-style ${dashboardLabel}\n`);
     out("- access=single installed CLI call; app/v1/profile safety included; no preflight glob/read/import/doctor calls\n");
-    const startup = startupCompletenessContract({ profileStatus: state.profile_status });
-    out(`- capability_startup_complete=${String(startup.complete_for_capability_startup).toLowerCase()}\n`);
+    out(`- startup_outcome=${String(startup.outcome)}\n`);
+    out(`- capability_context: fetch rendering instructions via \`${preCutoverCommand("prime --context status --format json")}\`\n`);
+    out(`- detail_discovery=${String(startup.detail_discovery.schema)}\n`);
     out(`- raw_artifact_reads_required=${String(startup.raw_artifact_reads_required).toLowerCase()}; policy=${startup.raw_artifact_read_policy}\n`);
-    const missingState = startup.missing_state.join("; ") || "none";
-    out(`- missing_state=${missingState}\n`);
-    out(`- confidence_caveats=${startup.confidence_caveats.join("; ")}\n`);
-    out(`- cli_fallback=${startup.cli_fallback.join("; ")}\n`);
+    const deferred = startup.availability
+        .filter((entry) => entry.availability === "deferred")
+        .map((entry) => String(entry.family));
+    out(`- deferred_detail=${deferred.join(", ") || "none"}\n`);
 }
-//# sourceMappingURL=orientationOutput.js.map

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

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

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

@@ -36,4 +36,3 @@ export function v1MigrationSummary(v1Artifacts, opts) {
     }
     return summary;
 }
-//# sourceMappingURL=v1Migration.js.map

package/dist/cli/commands/prime.js

@@ -1,12 +1,33 @@
 import { PRIME_BLOB } from "../prime-blob.js";
 import { buildPrimeCapabilityContextPayload, validatePrimeCapability } from "../capabilityContext.js";
 import { collectOrientationState } from "./prime/collectOrientationState.js";
-import { buildOrientationJsonPayload, emitPrime, printOrientationTextBriefing } from "./prime/orientationOutput.js";
+import { buildOrientationJsonPayload, buildStatusContextState, emitPrime, rejectRetiredPrimeFields, PRIME_BRIEF_MAX_UTF8_BYTES, PRIME_STATUS_CONTEXT_MAX_UTF8_BYTES, printOrientationTextBriefing, } from "./prime/orientationOutput.js";
+import { emitInvalidInput } from "../errors.js";
+import { BuildExecutionRequestError, loadBuildExecutionRequest, } from "./prime/buildExecutionRequest.js";
+import { preCutoverCommand } from "../preCutoverCommand.js";
 export { collectOrientationState } from "./prime/collectOrientationState.js";
+export function buildStatusCapabilityContextPayload(state, command = "prime") {
+    const payload = buildPrimeCapabilityContextPayload(state, "status", command);
+    return finalizeStatusCapabilityContextPayload(payload, state, command);
+}
+export function finalizeStatusCapabilityContextPayload(payload, state, command = "prime") {
+    const capabilityContext = payload.capability_context;
+    const context = capabilityContext.context;
+    // status_context carries the dashboard state. Startup availability remains
+    // singular on capability_context.startup.
+    delete capabilityContext.app;
+    // status_context already carries the canonical bounded plan projection.
+    delete context.plan;
+    context.status_context = buildStatusContextState(state, command, {
+        budgetBytes: PRIME_BRIEF_MAX_UTF8_BYTES,
+        degradedMode: "status_routing",
+    });
+    return payload;
+}
 /**
  * prime orientation command. Port of scripts/agentera cmd_prime / cmd_status.
- * The text briefing (default), --guidance, --dashboard, --context, and
- * --format json paths are all wired.
+ * The text briefing (default), --guidance, deprecated --dashboard, --context,
+ * and --format json paths are all wired.
  */
 export function cmdPrime(args, io = {}) {
     const out = io.out ?? ((t) => process.stdout.write(t));
@@ -15,6 +36,17 @@ export function cmdPrime(args, io = {}) {
     const capability = args.context ?? null;
     const dashboard = Boolean(args.dashboard || args.orientation);
     const guidance = Boolean(args.guidance);
+    const input = args.input ?? null;
+    const format = args.format ?? "text";
+    const inputErrorFormat = args.format === "json" || args.format === "yaml" ? args.format : "text";
+    const rejectInput = (body) => emitInvalidInput(io, { format: inputErrorFormat, body });
+    if (input !== null && (capability !== "build" || dashboard || guidance)) {
+        return rejectInput({
+            class: "unsupported_target",
+            message: "--input is valid only with prime --context build",
+            syntax: preCutoverCommand("prime --context build --input <file|-> --format json"),
+        });
+    }
     if (capability !== null && dashboard) {
         err("Error: prime --context and prime --dashboard/--orientation are mutually exclusive\n");
         return 2;
@@ -27,12 +59,19 @@ export function cmdPrime(args, io = {}) {
         err("Error: prime --dashboard/--orientation and prime --guidance are mutually exclusive\n");
         return 2;
     }
+    const retiredFieldRejection = rejectRetiredPrimeFields(command, format, args.fields, out, err);
+    if (retiredFieldRejection !== null)
+        return retiredFieldRejection;
     if (guidance) {
         out(PRIME_BLOB);
         return 0;
     }
-    const format = args.format ?? "text";
-    const collectOpts = { home: args.home, installRoot: args.installRoot, expectedVersion: args.expectedVersion };
+    const collectOpts = {
+        projectRoot: args.projectRoot,
+        home: args.home,
+        installRoot: args.installRoot,
+        expectedVersion: args.expectedVersion,
+    };
     if (capability !== null) {
         try {
             validatePrimeCapability(capability);
@@ -45,25 +84,51 @@ export function cmdPrime(args, io = {}) {
             err("Error: prime --context requires --format json\n");
             return 2;
         }
+        let buildRequest = null;
+        if (input !== null) {
+            try {
+                buildRequest = loadBuildExecutionRequest(input, io.stdin);
+            }
+            catch (error) {
+                if (error instanceof BuildExecutionRequestError)
+                    return rejectInput(error.body);
+                return rejectInput({ class: "invalid_format", message: "Build execution request input could not be read" });
+            }
+        }
         const state = collectOrientationState(collectOpts);
-        const payload = buildPrimeCapabilityContextPayload(state, capability, command);
-        return emitPrime(command, payload, format, args.fields, out, err);
+        if (buildRequest !== null && state.plan.active === true) {
+            return rejectInput({
+                class: "conflict",
+                message: "Transient no-plan Build input conflicts with the current plan-owned execution context",
+                recovery: "Run Build without --input for the current plan, or close/archive that plan before retrying; no state was changed.",
+            });
+        }
+        const payload = capability === "status"
+            ? buildStatusCapabilityContextPayload(state, command)
+            : buildPrimeCapabilityContextPayload(state, capability, command, buildRequest);
+        return emitPrime(command, payload, format, args.fields, out, err, {
+            maxUtf8Bytes: capability === "status" ? PRIME_STATUS_CONTEXT_MAX_UTF8_BYTES : undefined,
+        });
     }
     if (dashboard) {
         if (format === "text") {
             err("Error: prime --dashboard requires --format json\n");
             return 2;
         }
+        err("Deprecation: prime --dashboard is retained as an alias for `prime --context status --format json`; use the status startup capsule directly.\n");
         const state = collectOrientationState(collectOpts);
-        const payload = buildOrientationJsonPayload(state, command);
-        return emitPrime(command, payload, format, args.fields, out, err);
+        const payload = buildStatusCapabilityContextPayload(state, command);
+        return emitPrime(command, payload, format, args.fields, out, err, {
+            maxUtf8Bytes: PRIME_STATUS_CONTEXT_MAX_UTF8_BYTES,
+        });
     }
     const state = collectOrientationState(collectOpts);
     if (format !== "text") {
         const payload = buildOrientationJsonPayload(state, command);
-        return emitPrime(command, payload, format, args.fields, out, err);
+        // Bare default: project to the bounded decision brief (prime-briefing,
+        // 12000-byte budget). Explicit `--fields` selection keeps full payload.
+        return emitPrime(command, payload, format, args.fields, out, err, { bareBrief: true });
     }
     printOrientationTextBriefing(state, command, out);
     return 0;
 }
-//# sourceMappingURL=prime.js.map

package/dist/cli/commands/profileGrounding.js

@@ -0,0 +1,55 @@
+import { personalProfileGroundingContract } from "../../registries/glossaryEntryContract.js";
+import { emitInvalidInput } from "../errors.js";
+import { acquireProfile } from "../profileAcquisition.js";
+import { emitStructured } from "../structured.js";
+const COMMAND = "agentera report profile-grounding --format json";
+const REQUEST_RECOVERY = `Run ${COMMAND}; no profile bytes were changed.`;
+const INVALID_PROFILE_MESSAGE = "PROFILE.md is unavailable for bounded profile grounding.";
+function invalid(io, body, recovery) {
+    return emitInvalidInput(io, { format: "json", body: { ...body, recovery } });
+}
+export function runProfileGroundingCommand(argv, io) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        const [name, inline] = argument.split("=", 2);
+        if (name !== "--format") {
+            return invalid(io, { class: "unrecognized_argument", message: "profile-grounding accepts only --format json", syntax: COMMAND }, REQUEST_RECOVERY);
+        }
+        const value = inline ?? argv[++index];
+        if (value !== "json") {
+            return invalid(io, { class: "invalid_choice", message: "profile-grounding requires --format json", valid_values: ["json"] }, REQUEST_RECOVERY);
+        }
+    }
+    const contract = personalProfileGroundingContract();
+    const acquired = acquireProfile();
+    const output = io.out ?? ((text) => process.stdout.write(text));
+    if (acquired.validity.status !== "valid" || acquired.groundingContent === null) {
+        emitStructured({
+            schemaVersion: contract.schemaVersion,
+            command: "report profile-grounding",
+            status: acquired.validity.status,
+            validity: acquired.validity,
+            freshness: acquired.freshness,
+            content: null,
+            recovery: acquired.validity.recovery,
+            error: {
+                class: "profile_unavailable",
+                message: INVALID_PROFILE_MESSAGE,
+                recovery: acquired.validity.recovery,
+            },
+        }, "json", output);
+        return 2;
+    }
+    emitStructured({
+        schemaVersion: contract.schemaVersion,
+        command: "report profile-grounding",
+        status: "ok",
+        validity: acquired.validity,
+        freshness: acquired.freshness,
+        content: acquired.groundingContent,
+        content_utf8_bytes: Buffer.byteLength(acquired.groundingContent),
+        excluded: "owned_personal_glossary_section",
+        recovery: null,
+    }, "json", output);
+    return 0;
+}