@skrr-ai/cli 0.1.127 → 0.1.129

package/dist/lib/northstars.js

@@ -1,14 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.northstarApi = exports.NORTHSTAR_RECOMMENDATION_STATUSES = exports.NORTHSTAR_PRIORITY_TIERS = exports.NORTHSTAR_STATUSES = exports.NORTHSTAR_REVIEW_STATUSES = exports.NORTHSTAR_MANAGEMENT_INTENT_KINDS = exports.NORTHSTAR_INTENT_VERDICTS = exports.NORTHSTAR_EXECUTION_MODES = exports.NORTHSTAR_APPROVAL_TRIGGERS = exports.NORTHSTAR_ANALYSIS_MODES = void 0;
+exports.northstarWideFlag = exports.CRITICAL_COMMITMENT_APPROVAL_NOTE = exports.ALLOCATION_INPUT_FLAGS = exports.NORTHSTAR_LIST_DEFAULT_LIMIT = exports.NORTHSTAR_REASON_WORDS = exports.northstarApi = exports.NORTHSTAR_RECOMMENDATION_STATUSES = exports.NORTHSTAR_PRIORITY_TIERS = exports.NORTHSTAR_STATUSES = exports.NORTHSTAR_REVIEW_STATUSES = exports.NORTHSTAR_MANAGEMENT_INTENT_KINDS = exports.NORTHSTAR_INTENT_VERDICTS = exports.NORTHSTAR_EXECUTION_MODES = exports.NORTHSTAR_APPROVAL_TRIGGERS = exports.NORTHSTAR_ANALYSIS_MODES = void 0;
+exports.intentRisk = intentRisk;
+exports.shortReviewId = shortReviewId;
+exports.lookupReview = lookupReview;
 exports.humanMs = humanMs;
 exports.shortDate = shortDate;
+exports.describeNorthstarReason = describeNorthstarReason;
+exports.describeDecisionRefusal = describeDecisionRefusal;
+exports.describeDecisionOutcome = describeDecisionOutcome;
+exports.listFooter = listFooter;
 exports.renderNorthstarList = renderNorthstarList;
+exports.describeMaxActive = describeMaxActive;
 exports.renderNorthstar = renderNorthstar;
 exports.renderRecommendationList = renderRecommendationList;
+exports.reviewerReadiness = reviewerReadiness;
+exports.readAllocationRefresh = readAllocationRefresh;
+exports.describeAllocationRefresh = describeAllocationRefresh;
+exports.describeReviewAllocations = describeReviewAllocations;
+exports.runBudgetFloorNote = runBudgetFloorNote;
 exports.renderGovernance = renderGovernance;
+exports.describeAutoBudget = describeAutoBudget;
+exports.reviewNote = reviewNote;
+exports.describeReviewReason = describeReviewReason;
 exports.renderReviewList = renderReviewList;
 exports.renderIntentList = renderIntentList;
+exports.intentBudgetNote = intentBudgetNote;
 /**
  * northstars.ts — request-based client for the Northstar portfolio layer
  * (`/api/northstars/*`) and its Portfolio Governor.
@@ -31,6 +48,7 @@ exports.renderIntentList = renderIntentList;
  * re-declared. The API validates against those exact strings; a second copy here
  * is how the CLI silently drifts from the server that rejects it.
  */
+const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 Object.defineProperty(exports, "NORTHSTAR_ANALYSIS_MODES", { enumerable: true, get: function () { return data_provider_1.NORTHSTAR_ANALYSIS_MODES; } });
 Object.defineProperty(exports, "NORTHSTAR_APPROVAL_TRIGGERS", { enumerable: true, get: function () { return data_provider_1.NORTHSTAR_APPROVAL_TRIGGERS; } });
@@ -53,6 +71,37 @@ exports.NORTHSTAR_STATUSES = [
 ];
 exports.NORTHSTAR_PRIORITY_TIERS = ['critical', 'high', 'medium', 'low'];
 exports.NORTHSTAR_RECOMMENDATION_STATUSES = ['open', 'applied', 'dismissed'];
+/* --------------------------------------------------------------------------
+ * Which risk a person sees
+ *
+ * Two different things carry a `riskLevel` and they are NOT one number. A recommendation
+ * (`northstars recommendations`) is rated by the reviewer when it recommends; an INTENT
+ * (`northstars intents`, `proposals show`) is rated by the governance policy for the change it
+ * would make, and that is the rating the policy gates on, records and sends in the
+ * awaiting-approval notice. They differ on purpose: a pause is recommended as `low` (it is the
+ * lowest-priority commitment over the cap) and is a `high`-risk change to apply. Printed side by
+ * side under one word they read as a contradiction (OSK-21192), so:
+ *
+ *   - every surface that shows an INTENT shows the intent's own rating, labelled `risk`;
+ *   - a recommendation's rating is labelled `recommendation risk`, wherever it is shown.
+ *
+ * A rating the server did not send is `unknown`, never `low`: an absent rating is not a safe one.
+ * -------------------------------------------------------------------------- */
+function intentRisk(intent) {
+    return intent?.riskLevel || 'unknown';
+}
+/**
+ * A review id short enough for a table: `nsrev_3727b5959f436d29b69c1832` is `nsrev_3727b595`. The
+ * full id stays in `--json`. `reviews <northstar> --review` accepts the short form too
+ * (`resolveReviewRef`); an id that does not look like a prefix and a long hex run is left as it is.
+ */
+const SHORT_ID_HEX = 8;
+function shortReviewId(id) {
+    const match = /^([a-z]+_)([0-9a-f]+)$/i.exec(id);
+    return match && match[2].length > SHORT_ID_HEX
+        ? `${match[1]}${match[2].slice(0, SHORT_ID_HEX)}`
+        : id;
+}
 const base = (id) => `/api/northstars/${encodeURIComponent(id)}`;
 exports.northstarApi = {
     /* --- portfolio CRUD ---------------------------------------------------- */
@@ -78,6 +127,30 @@ exports.northstarApi = {
     intents: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/intents`, query)),
     decideIntent: (id, intentId, body) => data_provider_1.request.post(`${base(id)}/intents/${encodeURIComponent(intentId)}/decide`, body),
 };
+/**
+ * One review, from the id a person typed. The full id is asked for first, exactly as before. Only when
+ * the server has no review of that exact id is the typed text read as the start of one, among the
+ * northstar's newest 100 reviews: that is what the REVIEW column of `intents list` prints
+ * (`shortReviewId`), so the table's own output can be pasted back. A prefix of several reviews is
+ * reported, not guessed; one of none, or of a review older than the newest 100, raises the server's
+ * original "not found". Both ids are in `--json`.
+ */
+async function lookupReview(northstarId, typed) {
+    try {
+        return { review: await exports.northstarApi.review(northstarId, typed) };
+    }
+    catch (error) {
+        if (error?.status !== 404 || !typed.trim())
+            throw error;
+        const listed = await exports.northstarApi.reviews(northstarId, { limit: 100 });
+        const matches = (listed.data ?? []).filter((review) => review.id.startsWith(typed.trim()));
+        if (matches.length === 0)
+            throw error;
+        if (matches.length > 1)
+            return { ambiguous: matches.map((review) => review.id) };
+        return { review: await exports.northstarApi.review(northstarId, matches[0].id) };
+    }
+}
 /** ms → a short human duration, for a table cell that must stay narrow. */
 function humanMs(ms) {
     if (!Number.isFinite(Number(ms)))
@@ -96,6 +169,260 @@ function shortDate(value) {
     const date = new Date(value);
     return Number.isNaN(date.getTime()) ? '—' : date.toISOString().replace('T', ' ').slice(0, 16);
 }
+/* --------------------------------------------------------------------------
+ * Reason codes in words
+ *
+ * The server refuses, skips and decides with machine codes
+ * (`reviewer_agent_not_always_on`, `northstar_version_drift`, ...). A code is
+ * for a script; a person reading a table or an error needs the sentence. This
+ * is the ONE place those sentences live, so a command never invents its own
+ * wording (the old governance line guessed "offline" for a reviewer that was
+ * simply not Always-On) and `--json` can carry the same text as `reasonText`.
+ *
+ * Entries are CLAUSES, lower-case with no trailing full stop, so a caller can
+ * put them after "agent turn not started:" or inside a longer sentence. A code
+ * with no entry is returned AS IT IS: an unknown code printed raw is honest,
+ * a guessed explanation is not.
+ * ------------------------------------------------------------------------ */
+exports.NORTHSTAR_REASON_WORDS = {
+    // An agent turn that was not reserved for an agent_assisted review.
+    no_reviewer_agent_configured: 'no reviewer agent is set on this northstar',
+    northstar_paused: 'the northstar is paused',
+    northstar_achieved: 'the northstar is marked achieved',
+    northstar_archived: 'the northstar is archived',
+    analysis_mode_not_agent_assisted: 'analysis mode is deterministic, so no agent is asked',
+    managed_agent_missing: 'the reviewer agent does not exist or is not visible to you',
+    always_on_control_unavailable: "the reviewer agent's Always-On state could not be read just now",
+    always_on_disabled: 'Always-On is turned off for the reviewer agent',
+    always_on_suspended: 'Always-On is suspended for the reviewer agent',
+    always_on_stale_generation: "the reviewer agent's Always-On state changed while this ran",
+    reviewer_agent_foreign_owner: "the reviewer agent belongs to someone other than this northstar's owner",
+    reviewer_agent_not_always_on: 'the reviewer agent is not Always-On (it is not offline; turn Always-On on for it)',
+    run_already_reserved: 'an agent run was already reserved for this review',
+    envelope_build_failed: 'the review could not be packaged for the agent',
+    governance_run_reservation_failed: 'reserving the agent turn failed unexpectedly',
+    run_not_reserved: 'the run queue declined to reserve the agent turn',
+    enqueue_failed: 'the agent turn could not be queued',
+    agent_run_reserved: 'an agent turn is reserved; its results land asynchronously',
+    // Why an intent was recorded, held or refused by policy.
+    execution_mode_advisory: 'execution mode is advisory: recorded for you to read, nothing is changed',
+    execution_mode_approval: 'execution mode is approval: it waits for a person',
+    proposal_only: 'a proposal: the governor never applies it, a person does',
+    commitment_protected: "the commitment is on this northstar's protected list",
+    intent_kind_not_allowed: "this kind of intent is not in the northstar's allowed list",
+    critical_commitment_lifecycle: 'it changes a critical commitment, which always needs a person',
+    resume_requires_approval: 'resuming always needs a person',
+    budget_telemetry_unavailable: 'the automatic-change budget could not be read, so it fell back to approval',
+    critical_demotion: 'it would demote a critical commitment',
+    tier_change_too_large: 'the tier change is larger than one step',
+    weight_change_too_large: 'the weight change exceeds the allowed relative change',
+    bounds_increase_compute: 'it would buy more compute',
+    bounds_change_exceeds_max_relative_change: 'the bounds change exceeds the allowed relative change',
+    auto_pause_evidence_incomplete: 'the evidence for an automatic pause is incomplete',
+    no_auto_rule_for_kind: 'no automatic rule covers this kind of change',
+    auto_mutation_review_cap_reached: 'this review already made its maximum automatic changes',
+    auto_mutation_daily_cap_reached: "today's automatic-change cap is used up",
+    mutation_cooldown_active: 'the commitment was changed automatically too recently (cooldown)',
+    commitment_not_linked_to_northstar: 'the commitment is no longer linked to this northstar',
+    commitment_not_found: 'the commitment no longer exists',
+    approved_by_user: 'approved by a person',
+    rejected_by_user: 'rejected by a person',
+    // Why a decision (approve / reject) was refused or did not take effect.
+    commitment_version_drift: 'the commitment changed after this was proposed',
+    northstar_version_drift: 'the northstar changed after this was proposed',
+    // Two ways to the same ending: a newer review asks the same question again, or a concurrent review
+    // is already making (or has made) this very change. Either way another review has it.
+    superseded: 'another review already proposed or made the same change',
+    recommendation_dismissed: 'its recommendation was dismissed',
+    intent_not_found: "no such intent in this northstar's 50 most recent reviews",
+    review_not_found: 'no such review on this northstar',
+    northstar_not_found: 'no such northstar',
+    owner_approval_required: "only the northstar's owner can approve a proposal",
+    transition_lost: 'another decision landed first',
+    claim_lost: 'another process is already applying it',
+    mutation_error: 'the change failed part-way and was left for the repair pass',
+    proposal_kind_requires_manual_action: 'this kind of proposal is completed by hand',
+};
+/** A code in words; an unknown code comes back unchanged, an absent one says so. */
+function describeNorthstarReason(code) {
+    if (!code)
+        return 'no reason was recorded';
+    return exports.NORTHSTAR_REASON_WORDS[code] ?? code;
+}
+function utcStamp(value) {
+    const stamp = shortDate(typeof value === 'string' ? value : undefined);
+    return stamp === '—' ? undefined : `${stamp} UTC`;
+}
+function stringField(source, key) {
+    const value = source?.[key];
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+/**
+ * A refused decision, as one sentence with its next step.
+ *
+ * `body` is the server's refusal (`reason`, plus the context it adds: the two
+ * northstar versions, or when and by whom the intent was already decided).
+ */
+function describeDecisionRefusal(body, ctx) {
+    const code = stringField(body, 'reason') ?? stringField(body, 'error') ?? 'unknown';
+    const bin = ctx.bin ?? 'skrr';
+    const reviewNow = `Run \`${bin} northstars review-now ${ctx.northstarId}\` for a fresh proposal.`;
+    const intents = `\`${bin} northstars intents list ${ctx.northstarId}\``;
+    const notApplied = ctx.decision === 'approve' ? 'the approval was not applied' : 'the rejection was not recorded';
+    if (code === 'northstar_version_drift') {
+        const proposed = body.proposedAtNorthstarVersion;
+        const current = body.currentNorthstarVersion;
+        const versions = typeof proposed === 'number' && typeof current === 'number'
+            ? ` (it was at v${proposed}, now v${current})`
+            : '';
+        return {
+            code,
+            text: `The northstar changed after this was proposed${versions}, so ${notApplied} and the intent was invalidated. ${reviewNow}`,
+        };
+    }
+    if (code === 'intent_not_pending') {
+        const verdict = stringField(body, 'verdict') ?? 'decided';
+        if (verdict === 'advisory') {
+            return {
+                code,
+                text: "This intent is advisory: this northstar's execution mode records it for you to read and does not ask for a decision. " +
+                    `To get proposals you can approve, run \`${bin} northstars governance configure ${ctx.northstarId} --execution approval\` and review again.`,
+            };
+        }
+        if (verdict === 'applying') {
+            return {
+                code,
+                text: `This intent is being applied right now — nothing to do. Check its verdict with ${intents}.`,
+            };
+        }
+        // `invalidated` is the platform ending an intent (the northstar moved, a newer review replaced
+        // it, its recommendation was dismissed), never a person's decision: attributing it to "you"
+        // because your click was the one that found it out is false (OSK-21247). Say why instead.
+        if (verdict === 'invalidated') {
+            const why = stringField(body, 'verdictReason');
+            const when = utcStamp(body.decidedAt);
+            return {
+                code,
+                text: `This intent was already invalidated${why ? ` (${describeNorthstarReason(why)})` : ''}${when ? ` at ${when}` : ''} — nothing changed.`,
+            };
+        }
+        let by = '';
+        if (body.decidedByYou === true)
+            by = ' by you';
+        else if (body.decidedByYou === false)
+            by = ' by someone else';
+        const at = utcStamp(body.decidedAt);
+        return {
+            code,
+            text: `This intent was already ${verdict}${by}${at ? ` at ${at}` : ''} — nothing changed.`,
+        };
+    }
+    if (code === 'transition_lost') {
+        return {
+            code,
+            text: `Another decision on this intent landed at the same moment, so yours was not recorded. Run ${intents} to see how it ended.`,
+        };
+    }
+    if (code === 'intent_not_found') {
+        return {
+            code,
+            text: `No intent ${ctx.intentId} in this northstar's 50 most recent reviews. If it is older, pass --review <review-id>.`,
+        };
+    }
+    const words = describeNorthstarReason(code);
+    return { code, text: `${words.charAt(0).toUpperCase()}${words.slice(1)}.` };
+}
+/**
+ * What a decision that the server ACCEPTED (HTTP 200) actually did.
+ *
+ * One exit rule: an approval exits 0 only when the intent is `applied`, and a
+ * rejection only when it is `rejected`. An approval the version fence
+ * invalidated, or one whose change has not landed, used to print a line shaped
+ * like success and exit 0, so a script could not tell it from one that worked.
+ */
+function describeDecisionOutcome(result, ctx) {
+    const bin = ctx.bin ?? 'skrr';
+    const verdict = stringField(result, 'verdict') ?? 'unknown';
+    const headline = `${ctx.intentId} → ${verdict}`;
+    const replayed = result.replayed === true;
+    const reviewNow = `Run \`${bin} northstars review-now ${ctx.northstarId}\` for a fresh proposal.`;
+    if (ctx.decision === 'reject') {
+        if (verdict === 'rejected') {
+            return {
+                headline,
+                exitCode: 0,
+                ...(replayed ? { text: 'Already rejected — nothing changed.' } : {}),
+            };
+        }
+        return {
+            headline,
+            exitCode: 1,
+            code: verdict,
+            text: `The intent was not rejected; its verdict is ${verdict}.`,
+        };
+    }
+    const continuation = result.continuation;
+    const applyResult = result.applyResult;
+    if (verdict === 'applied') {
+        const commitmentId = stringField(continuation, 'commitmentId');
+        const status = stringField(continuation, 'status');
+        let text;
+        if (status === 'draft_created') {
+            text = `Created draft commitment ${commitmentId ?? ''}`.trim();
+            text += '. Configure and activate it when you are ready.';
+        }
+        else if (status === 'executor_reassigned') {
+            text = `Reassigned the executor of ${commitmentId ?? 'the commitment'}.`;
+        }
+        if (replayed)
+            text = `Already applied — nothing changed.${text ? ` ${text}` : ''}`;
+        return { headline, exitCode: 0, ...(text ? { text } : {}) };
+    }
+    // Not applied. The reason is the apply step's, or a continuation's.
+    const code = stringField(applyResult, 'reason') ??
+        stringField(continuation, 'reason') ??
+        stringField(continuation, 'status');
+    let text;
+    if (code === 'commitment_version_drift' || code === 'commitment_not_found') {
+        const what = code === 'commitment_not_found'
+            ? 'The commitment no longer exists'
+            : 'The commitment changed after this was proposed';
+        text = `${what}, so the approval was not applied and the intent was invalidated. ${reviewNow}`;
+    }
+    else if (code) {
+        text = `Your approval is recorded, but nothing was applied: ${describeNorthstarReason(code)}.`;
+    }
+    else {
+        text = `Your approval is recorded, but the change has not landed yet (verdict: ${verdict}). It is retried automatically; check \`${bin} northstars intents list ${ctx.northstarId}\`.`;
+    }
+    return { headline, exitCode: 1, code: code ?? verdict, text };
+}
+/** What the server returned before `--limit` existed; sent explicitly so a page is never silently smaller. */
+exports.NORTHSTAR_LIST_DEFAULT_LIMIT = 50;
+/**
+ * The footer under a list that was cut short. `has_more: false` used to be
+ * unconditional on these lists, so a page of `--limit` rows read as the whole
+ * answer; the server now says when there is more and this says what to do.
+ * Empty when the page is complete.
+ *
+ * `cursor` is true only for a list that can be paged (`northstars list`); the
+ * reviews and intents lists have no cursor, so their way on is a larger
+ * `--limit`, or a narrower `--status` once `--limit` is at its ceiling.
+ */
+function listFooter(input) {
+    if (!input.hasMore)
+        return '';
+    const head = `Showing ${input.shown} — more available;`;
+    const atMax = input.limit >= input.max;
+    if (input.cursor && input.nextCursor) {
+        return atMax
+            ? `${head} --limit is already at its maximum (${input.max}), so continue with --cursor ${input.nextCursor}`
+            : `${head} raise --limit (max ${input.max}) or page with --cursor ${input.nextCursor}`;
+    }
+    return atMax
+        ? `${head} --limit is already at its maximum (${input.max}), so narrow the list with --status`
+        : `${head} raise --limit (max ${input.max})`;
+}
 function renderNorthstarList(rows, log) {
     if (rows.length === 0) {
         log('No northstars.');
@@ -121,6 +448,18 @@ function renderNorthstarList(rows, log) {
         { key: 'reviewed', header: 'REVIEWED' },
     ], log);
 }
+/** A budget that was never set says so; `—` is kept for a timestamp that does not exist yet. */
+const notSet = (value) => value === undefined || value === null ? 'not set' : String(value);
+/**
+ * The active-commitment cap, in words. `0` is accepted and stored, and a review
+ * treats it as "no cap" (it does not flag every commitment over a cap of zero),
+ * so the screen says that rather than letting `0` read as a limit.
+ */
+function describeMaxActive(value) {
+    if (value === undefined || value === null)
+        return 'not set';
+    return value === 0 ? '0 (no cap)' : String(value);
+}
 function renderNorthstar(status, log) {
     const ns = status.northstar;
     log(`${ns.title}  (${ns.id})`);
@@ -128,7 +467,7 @@ function renderNorthstar(status, log) {
     if (ns.description)
         log(`About       ${ns.description}`);
     log(`Priority    ${ns.priority?.tier ?? '—'} / weight ${ns.priority?.weight ?? '—'}`);
-    log(`Attention   total ${ns.attentionBudget?.totalWeight ?? '—'} · max active ${ns.attentionBudget?.maxActiveCommitments ?? '—'}`);
+    log(`Attention   total ${notSet(ns.attentionBudget?.totalWeight)} · max active ${describeMaxActive(ns.attentionBudget?.maxActiveCommitments)}`);
     const cadence = ns.reviewCadence ?? {};
     log(`Review      ${cadence.mode ?? 'manual'}${cadence.intervalMs ? ` every ${humanMs(cadence.intervalMs)}` : ''}   next ${shortDate(cadence.nextReviewAt)}   last ${shortDate(ns.state?.lastReviewedAt)}`);
     if (ns.goalIds?.length)
@@ -182,7 +521,9 @@ function renderRecommendationList(rows, log) {
         { key: 'kind', header: 'KIND' },
         { key: 'target', header: 'TARGET' },
         { key: 'status', header: 'STATUS' },
-        { key: 'risk', header: 'RISK' },
+        // The reviewer's rating of the recommendation. The intent made from it is rated separately
+        // (`intents list` RISK) and may be higher; see `intentRisk`.
+        { key: 'risk', header: 'RECOMMENDATION RISK' },
         { key: 'reason', header: 'WHY', maxWidth: 46 },
     ], log);
 }
@@ -195,45 +536,248 @@ function renderRecommendationList(rows, log) {
 function reviewerReadiness(reviewer) {
     if (!reviewer)
         return '';
+    // The server's own admission gate is the authority on whether the NEXT review
+    // gets an agent turn: it also knows a paused northstar or a deterministic
+    // analysis mode, which `ready` (is the agent Always-On) does not.
+    const admission = reviewer.admission;
+    if (admission) {
+        if (admission.admitted)
+            return '  [ready]';
+        if (admission.reason === 'analysis_mode_not_agent_assisted') {
+            return `  [not in use: ${describeNorthstarReason(admission.reason)}]`;
+        }
+        return `  [not ready: ${describeNorthstarReason(admission.reason)}]`;
+    }
     if (reviewer.ready)
         return '  [ready]';
-    return `  [not ready: ${reviewer.reason ?? 'offline'}]`;
+    // No reason from an older server is "unknown", never a guess: the old fallback
+    // said "offline" about an agent that was reachable and merely not Always-On.
+    return `  [not ready: ${reviewer.reason ? describeNorthstarReason(reviewer.reason) : 'reason unknown'}]`;
+}
+/** The `governance configure` flags that move what a commitment's allocation is computed from. */
+exports.ALLOCATION_INPUT_FLAGS = [
+    'max-runs-per-day',
+    'clear-max-runs-per-day',
+    'critical-reserve',
+    'min-interval-hours',
+    'max-interval-hours',
+    'max-relative-change',
+];
+/** The refresh summary a configure response carries, or undefined from a server that sends none. */
+function readAllocationRefresh(response) {
+    if (typeof response?.allocationsRefreshed !== 'number')
+        return undefined;
+    return {
+        refreshed: response.allocationsRefreshed,
+        pending: response.allocationsPending ?? 0,
+        failed: response.allocationsRefreshFailed === true,
+    };
+}
+/**
+ * What `governance configure` says about the linked commitments. The server re-applies a changed
+ * budget or cadence band to every linked active commitment at once and answers how many it wrote,
+ * how many it could not, and whether the refresh itself failed; the command discarded all of it and
+ * re-read the status, so "nothing happened" and "applied to three" looked the same (OSK-21245).
+ *
+ * `inputsSent` is whether this call touched an allocation input: only then is "already up to date" a
+ * true statement, since a zero is also what an unrelated change (the analysis mode) answers.
+ */
+function describeAllocationRefresh(refresh, options) {
+    const lines = [];
+    const warnings = [];
+    if (!refresh)
+        return { lines, warnings };
+    const bin = options.bin ?? 'skrr';
+    if (refresh.failed) {
+        warnings.push(`The policy is saved, but re-applying it to the linked commitments failed. The next review applies it, or run \`${bin} northstars review-now ${options.northstarId}\`.`);
+    }
+    if (refresh.pending > 0) {
+        warnings.push(`${refresh.pending} linked commitment(s) were out of date but could not be updated yet; the next review applies them.`);
+    }
+    if (refresh.refreshed > 0) {
+        lines.push(`Applied to ${refresh.refreshed} linked commitment(s) now.`);
+    }
+    else if (options.inputsSent && !refresh.failed && refresh.pending === 0) {
+        lines.push('Allocations already up to date: no linked commitment needed a write.');
+    }
+    return { lines, warnings };
+}
+/**
+ * The `Allocations` line of `review-now`. The count is of commitments WRITTEN, so `0` does not say
+ * "nothing happened": it is what a review prints when a configure already applied the budget, or
+ * when no active commitment is linked, or when no review row could be opened to write under.
+ */
+function describeReviewAllocations(result) {
+    const written = Array.isArray(result.allocations) ? result.allocations.length : 0;
+    if (written > 0)
+        return `Allocations ${written} commitment(s) re-budgeted`;
+    if (!result.review)
+        return 'Allocations not written: the review could not be recorded';
+    if (Array.isArray(result.attention) && result.attention.length === 0) {
+        return 'Allocations nothing to allocate: no active commitment is linked';
+    }
+    return 'Allocations already up to date: no commitment needed a write';
+}
+/**
+ * The sentence for a portfolio run budget smaller than the number of linked active commitments
+ * (OSK-21334): each still gets the floor of 1 run/day, so the ceilings add up to more than the
+ * budget. The server derives it once (`portfolioRunBudgetFloor.js`) and carries it, when it
+ * applies, on the `governance show` read, the `review-now` result and the effective policy's
+ * `portfolio`; every one of those three prints THIS sentence, so none composes its own and they
+ * cannot disagree. Absent from an older server, and from a budget that covers every commitment:
+ * no line, never a guess.
+ *
+ * Takes the carried field as it arrives (`unknown`), because two of the three callers read it off
+ * an untyped body.
+ */
+function runBudgetFloorNote(value) {
+    const floor = value;
+    if (!floor || floor.code !== 'run_budget_below_active_commitments')
+        return undefined;
+    return typeof floor.message === 'string' && floor.message ? floor.message : undefined;
 }
+/**
+ * What `critical_commitment` on the always-ask list does and does not do (OSK-21333).
+ *
+ * The list governs PROMOTION to critical (`critical_promotion`): remove the class and a bounded_auto
+ * review applies a small promotion itself. It does not govern the way back: a demotion away from
+ * critical is held for a person in `bounded_auto` whatever the list says (`critical_demotion`,
+ * `NorthstarGovernancePolicy.classifyIntent`: the demotion rule never reads the list). The behaviour
+ * is pinned by `NorthstarGovernancePolicy.spec.js` ("critical_commitment off the approval list"),
+ * the words by `cli/src/commands/northstars/__tests__/critical-approval-help.spec.ts`. The flag help
+ * and the `Approval for` line of `governance show` both read this one sentence, so neither can
+ * drift from the other.
+ */
+exports.CRITICAL_COMMITMENT_APPROVAL_NOTE = 'critical_commitment governs promotion to critical only; demotion away from critical (critical_demotion) is always held for a person, whatever this list says';
 function renderGovernance(status, log) {
     const g = status.governance;
     log(`Northstar   ${status.northstarId}  (v${status.northstarVersion}, ${status.status})`);
     log(`Analysis    ${g.analysisMode}`);
     log(`Execution   ${g.executionMode}`);
     const readiness = reviewerReadiness(status.reviewer);
-    log(`Reviewer    ${g.reviewerAgentId || '—'}${readiness}`);
+    log(`Reviewer    ${g.reviewerAgentId || 'none'}${readiness}`);
     log('');
     log(`Cadence band  ${humanMs(g.cadencePolicy.minIntervalMs)} … ${humanMs(g.cadencePolicy.maxIntervalMs)}  (max step ${Math.round((g.cadencePolicy.maxRelativeChange ?? 0) * 100)}%)`);
-    log(`Intent budget ${g.maxIntentsPerReview}/review · auto ${g.maxAutoMutationsPerReview}/review, ${g.maxAutoMutationsPerDay}/day · cooldown ${humanMs(g.mutationCooldownMs)}`);
-    log(`Allowed       ${g.allowedIntentKinds.join(', ') || '—'}`);
-    log(`Approval for  ${g.requireApprovalFor.join(', ') || '—'}`);
-    if (g.protectedCommitmentIds.length) {
-        log(`Protected     ${g.protectedCommitmentIds.join(', ')}`);
+    // 0 is a setting, not an absence: a review keeps NO intents at all.
+    const intentBudget = g.maxIntentsPerReview === 0
+        ? '0/review (no intents are ever recorded)'
+        : `${g.maxIntentsPerReview}/review`;
+    log(`Intent budget ${intentBudget} · auto ${g.maxAutoMutationsPerReview}/review, ${g.maxAutoMutationsPerDay}/day · cooldown ${humanMs(g.mutationCooldownMs)}`);
+    // An empty list is a decision with consequences, not an absence of one: say what it does.
+    log(`Allowed       ${g.allowedIntentKinds.join(', ') || 'none — every intent is refused'}`);
+    if (g.allowedIntentKinds.length === 0) {
+        log(`  ! Every intent a review proposes is refused (intent_kind_not_allowed). Allow a kind with \`governance configure ${status.northstarId} --allow <kind>\`.`);
+    }
+    log(`Approval for  ${g.requireApprovalFor.join(', ') ||
+        'none — no change class is always held for a person (the execution mode still decides)'}`);
+    // True whatever the list holds, so it is printed for an empty one too: removing
+    // `critical_commitment` frees promotion, and never the way back.
+    log(`              ${exports.CRITICAL_COMMITMENT_APPROVAL_NOTE}.`);
+    if (g.requireApprovalFor.length === 0) {
+        log('  ! No change class is on the always-ask list, so the execution mode alone decides what waits for you.');
     }
+    log(`Protected     ${g.protectedCommitmentIds.join(', ') || 'none'}`);
     const eb = status.executionBudget ?? {};
-    log(`Exec budget   action runs/day ${eb.maxRunsPerDay ?? '—'} · concurrent ${eb.maxConcurrentRuns ?? '—'} · critical reserve ${eb.reserveWeightForCritical ?? '—'}`);
-    log(`Observation runs/day ${eb.maxObservationRunsPerDay ?? '—'} · daily budgets reset at 00:00 UTC`);
+    log(`Exec budget   action runs/day ${notSet(eb.maxRunsPerDay)} · concurrent ${eb.maxConcurrentRuns == null ? 'not set' : `${eb.maxConcurrentRuns} (recorded, not enforced)`} · critical reserve ${notSet(eb.reserveWeightForCritical)}`);
+    log(`Observation runs/day ${notSet(eb.maxObservationRunsPerDay)} · daily budgets reset at 00:00 UTC`);
+    // A budget below the number of active commitments is still given to each at the floor of 1/day.
+    const floorNote = runBudgetFloorNote(status.runBudgetFloor);
+    if (floorNote)
+        log(`  ! ${floorNote}`);
     log('');
-    log(`Review trigger ${status.reviewTrigger.scheduled ? 'scheduled' : 'manual'}  every ${humanMs(status.reviewTrigger.intervalMs)}  next ${shortDate(status.reviewTrigger.nextFireAt)}`);
+    const trigger = status.reviewTrigger;
+    log(trigger.scheduled
+        ? `Review trigger scheduled  every ${humanMs(trigger.intervalMs)}  next ${shortDate(trigger.nextFireAt)}`
+        : 'Review trigger manual  (no schedule: a review runs only when you run `review-now`)');
     if (status.latestReview) {
         log(`Last review    ${status.latestReview.id}  ${status.latestReview.status}  ${shortDate(status.latestReview.startedAt)}  (${status.latestReview.intentCount} intent(s))`);
     }
     else {
-        log('Last review    —');
+        log('Last review    none yet');
     }
     if (status.autonomousRun) {
         log(`Agent run      ${status.autonomousRun.id}  ${status.autonomousRun.status}`);
     }
     const counts = status.intentCounts ?? {};
     log(`Intents        open ${counts.open ?? 0} · awaiting approval ${counts.awaiting_approval ?? 0} · applied ${counts.applied ?? 0} · invalidated ${counts.invalidated ?? 0}`);
-    const budget = status.mutationBudget;
-    log('unavailable' in budget
-        ? 'Auto budget    unavailable (governor fails closed to approval)'
-        : `Auto budget    ${budget.appliedToday}/${budget.maxAutoMutationsPerDay} used today · ${budget.remainingToday} left`);
+    log(describeAutoBudget(status.mutationBudget));
+}
+/**
+ * The automatic-change budget line.
+ *
+ * `0/day` is a MODE (automatic changes off, everything waits for approval), and `used` can
+ * legitimately exceed any cap, because the changes were made before the owner lowered it. A bare
+ * `2/0 used today · 0 left` collapses both into a ratio over 100% that says neither (OSK-21233).
+ */
+function describeAutoBudget(budget) {
+    if ('unavailable' in budget) {
+        return 'Auto budget    unavailable (governor fails closed to approval)';
+    }
+    const cap = budget.maxAutoMutationsPerDay;
+    const used = budget.appliedToday;
+    const earlier = `${used} made earlier today, before the cap was lowered`;
+    if (cap === 0) {
+        const note = used > 0 ? ` (${earlier})` : '';
+        return `Auto budget    automatic changes off (0/day) — everything waits for approval${note}`;
+    }
+    if (used > cap)
+        return `Auto budget    ${cap}/day · 0 left (${earlier})`;
+    return `Auto budget    ${used}/${cap} used today · ${budget.remainingToday} left`;
+}
+/**
+ * Reasons that mean an `agent_assisted` review did NOT get an agent turn. A
+ * `succeeded` status says the review finished, not that an agent reviewed
+ * anything, so the table must say it in words (the reason also lives on the
+ * record, and used to be visible only through `review-now` and `--review`).
+ */
+const AGENT_TURN_NOT_STARTED = new Set([
+    'no_reviewer_agent_configured',
+    'northstar_paused',
+    'northstar_achieved',
+    'northstar_archived',
+    'analysis_mode_not_agent_assisted',
+    'managed_agent_missing',
+    'always_on_control_unavailable',
+    'always_on_disabled',
+    'always_on_suspended',
+    'always_on_stale_generation',
+    'reviewer_agent_foreign_owner',
+    'reviewer_agent_not_always_on',
+    'run_already_reserved',
+    'envelope_build_failed',
+    'governance_run_reservation_failed',
+    'run_not_reserved',
+    'enqueue_failed',
+]);
+/** One cell of words for what a review did beyond "it ran"; empty when there is nothing to add. */
+function reviewNote(review) {
+    // A review the intent budget cut short is not a review with nothing to say. The count lived in the
+    // snapshot, and the list printed `—` for it, so scanning the list hid it (OSK-21249).
+    const omitted = Number(review.deterministicSnapshot?.truncatedIntents);
+    const budget = Number.isFinite(omitted) && omitted > 0
+        ? `${omitted} intent(s) omitted (--max-intents-per-review)`
+        : '';
+    return [agentTurnNote(review), budget].filter(Boolean).join('; ');
+}
+function agentTurnNote(review) {
+    if (review.status === 'failed') {
+        return `failed: ${review.errorMessage ?? describeNorthstarReason(review.reason)}`;
+    }
+    if (review.status === 'awaiting_agent')
+        return 'waiting for the agent turn';
+    if (review.analysisMode === 'agent_assisted' && review.status === 'succeeded') {
+        if (review.reason && AGENT_TURN_NOT_STARTED.has(review.reason)) {
+            return `agent turn not started: ${describeNorthstarReason(review.reason)}`;
+        }
+        if (!review.autonomousRunId)
+            return 'agent turn not started: no reason was recorded';
+    }
+    return '';
+}
+/** `Reason` line of one review: the words, with the raw code kept beside them for grep. */
+function describeReviewReason(reason) {
+    const words = describeNorthstarReason(reason);
+    return words === reason ? reason : `${words}  [${reason}]`;
 }
 function renderReviewList(reviews, log) {
     if (reviews.length === 0) {
@@ -247,6 +791,7 @@ function renderReviewList(reviews, log) {
         mode: `${review.analysisMode ?? '—'}/${review.executionMode ?? '—'}`,
         intents: String((review.intents ?? []).length),
         run: review.autonomousRunId ?? '—',
+        note: reviewNote(review) || '—',
     })), [
         { key: 'id', header: 'REVIEW' },
         { key: 'started', header: 'STARTED' },
@@ -254,26 +799,109 @@ function renderReviewList(reviews, log) {
         { key: 'mode', header: 'MODE' },
         { key: 'intents', header: 'INTENTS' },
         { key: 'run', header: 'AGENT RUN' },
+        { key: 'note', header: 'NOTE' },
     ], log);
 }
-function renderIntentList(intents, log) {
+/** `--wide` on every command that prints the intents table. */
+exports.northstarWideFlag = core_1.Flags.boolean({
+    description: 'Do not clip the WHY column, and keep the machine code beside the reason as [code]',
+});
+/**
+ * The WHY column never shrinks below this, however narrow the terminal. The reviewer's sentences run
+ * to about 105 characters ("This northstar's attention budget allows 12 active commitments; this
+ * is the lowest priority over the cap."), and the part that matters is often at the END of one
+ * ("Commitment tier (high) drifted from northstar tier (low)."): at the old floor of 40 the default
+ * clip cut it before the fact, and the owner needed `--wide` to read the reason (OSK-21248).
+ */
+const INTENT_WHY_MIN_WIDTH = 110;
+/** No terminal to overflow (a pipe, a log): the table is as wide as it needs to be. */
+const INTENT_TABLE_DEFAULT_COLUMNS = 250;
+function whyCell(row, wide, budget) {
+    if (!wide)
+        return (0, format_1.truncateAtWord)(row.why, budget);
+    return row.code && row.code !== row.why ? `${row.why} [${row.code}]` : row.why;
+}
+/**
+ * The intents table.
+ *
+ * WHY is the HUMAN reason the governor wrote (`reason`), not the machine code in
+ * `verdictReason`, which says why an intent needed approval (`execution_mode_approval`)
+ * and is no reason for the change itself. The code stays in `--json`, and beside
+ * the sentence as `[code]` under `--wide`. By default the sentence is cut at a
+ * word boundary to what the terminal leaves after the other columns.
+ */
+function renderIntentList(intents, log, options = {}) {
     if (intents.length === 0) {
         log('No management intents.');
         return;
     }
-    (0, format_1.renderTable)(intents.map((intent) => ({
+    // The flattened list (`intents list`) carries the review each intent came from; one review's own
+    // intents (`reviews --review`, `review-now`) all share the review the command already names, so a
+    // column of one repeated value would only push WHY off the screen.
+    const withReview = intents.some((intent) => Boolean(intent.reviewId));
+    const rows = intents.map((intent) => ({
         id: intent.id,
+        review: intent.reviewId ? shortReviewId(intent.reviewId) : '—',
         kind: intent.kind,
         target: intent.targetCommitmentId ?? '—',
         verdict: intent.verdict,
-        why: intent.verdictReason ?? intent.reason ?? '—',
+        // The intent's OWN rating (see `intentRisk`), never its recommendation's.
+        risk: intentRisk(intent),
+        // No sentence from the governor: the policy code in words (an unknown code stays as it is).
+        why: intent.reason ?? (intent.verdictReason ? describeNorthstarReason(intent.verdictReason) : '—'),
+        code: intent.verdictReason ?? '',
         source: intent.source ?? 'deterministic',
+    }));
+    const headers = {
+        id: 'INTENT',
+        review: 'REVIEW',
+        kind: 'KIND',
+        target: 'COMMITMENT',
+        verdict: 'VERDICT',
+        risk: 'RISK',
+        source: 'SOURCE',
+    };
+    const fixedKeys = (withReview
+        ? ['id', 'review', 'kind', 'target', 'verdict', 'risk', 'source']
+        : ['id', 'kind', 'target', 'verdict', 'risk', 'source']);
+    const fixedWidth = fixedKeys.reduce((sum, key) => sum + Math.max((0, format_1.displayWidth)(headers[key]), ...rows.map((row) => (0, format_1.displayWidth)(row[key]))), 0);
+    const terminal = options.columns ?? process.stdout.columns ?? INTENT_TABLE_DEFAULT_COLUMNS;
+    // Two spaces separate every fixed column from the next, and the last from WHY.
+    const whyBudget = Math.max(INTENT_WHY_MIN_WIDTH, terminal - fixedWidth - fixedKeys.length * 2);
+    (0, format_1.renderTable)(rows.map((row) => ({
+        id: row.id,
+        review: row.review,
+        kind: row.kind,
+        target: row.target,
+        verdict: row.verdict,
+        risk: row.risk,
+        source: row.source,
+        why: whyCell(row, options.wide === true, whyBudget),
     })), [
-        { key: 'id', header: 'INTENT' },
-        { key: 'kind', header: 'KIND' },
-        { key: 'target', header: 'COMMITMENT' },
-        { key: 'verdict', header: 'VERDICT' },
-        { key: 'source', header: 'SOURCE' },
-        { key: 'why', header: 'WHY', maxWidth: 48 },
+        { key: 'id', header: headers.id },
+        ...(withReview ? [{ key: 'review', header: headers.review }] : []),
+        { key: 'kind', header: headers.kind },
+        { key: 'target', header: headers.target },
+        { key: 'verdict', header: headers.verdict },
+        { key: 'risk', header: headers.risk },
+        { key: 'source', header: headers.source },
+        { key: 'why', header: 'WHY' },
     ], log);
 }
+/**
+ * The line that says a review's intent budget cut something off. A cap of 0
+ * records nothing at all, which a screen reading "No management intents." made
+ * indistinguishable from a review with nothing to say; the count was only in
+ * `--json` (`deterministicSnapshot.truncatedIntents`).
+ */
+function intentBudgetNote(truncated, cap) {
+    const count = Number(truncated);
+    if (!Number.isFinite(count) || count <= 0)
+        return '';
+    const limit = Number.isFinite(Number(cap)) && cap !== undefined && cap !== null ? Number(cap) : undefined;
+    const budget = limit === undefined ? '' : ` (${limit})`;
+    const hint = limit === 0
+        ? 'a cap of 0 records no intents at all'
+        : 'raise it with `governance configure --max-intents-per-review`';
+    return `${count} intent(s) omitted by --max-intents-per-review${budget}: ${hint}.`;
+}