@skrr-ai/cli 0.1.127 → 0.1.129

package/dist/lib/iso-instant.d.ts

@@ -0,0 +1,52 @@
+/**
+ * One reading of "an ISO-8601 UTC instant" for every CLI flag that takes one.
+ *
+ * `tasks remind --at` and `tasks schedule --at` each had their own: remind ran
+ * `new Date(value)` behind a `/^\d{4}-\d{2}-\d{2}T/` check, and schedule forwarded
+ * the string and printed the server's zod issue. `new Date()` is the wrong tool
+ * for an instant, in two ways that both stored a different time than the one
+ * typed and said nothing (OSK-21504, OSK-21506):
+ *
+ *   - a time with no zone is read in the zone of the MACHINE running the CLI, so
+ *     the same command stored different instants on different laptops;
+ *   - a day that does not exist overflows into the next month
+ *     (`2027-02-30` is `2027-03-02`).
+ *
+ * The rule here is the one `tasks schedule --help` already states and the server's
+ * `z.string().datetime()` enforces: a calendar-real date, a time with seconds, and
+ * a literal `Z`. A numeric offset is refused too, even though it names an instant:
+ * the two commands must agree, and the server's schedule door does not take one.
+ *
+ * Never reads the machine's zone. Pure.
+ */
+export type InstantProblem = 'not_a_date' | 'date_only' | 'no_zone' | 'numeric_offset' | 'not_a_real_date' | 'not_a_real_time';
+export type InstantParse = {
+    ok: true;
+    date: Date;
+    iso: string;
+} | {
+    ok: false;
+    problem: InstantProblem;
+    message: string;
+};
+/**
+ * Parse a flag value as a UTC instant, or say precisely what is wrong with it.
+ *
+ * `label` is what the user typed (`--at`, `scheduledFor`), so the message names
+ * their input rather than a REST field they never saw.
+ */
+export declare function parseUtcInstant(raw: string, label?: string): InstantParse;
+/** `2027-02-02T09:00:00Z` - the instant in UTC, whole seconds when there are no milliseconds. */
+export declare function formatUtcInstant(date: Date): string;
+/**
+ * `2027-02-02 01:00:00 PST` - the same instant on this machine's wall clock, with the
+ * zone NAMED. `toLocaleString()` printed neither the zone nor anything that mapped back
+ * to the instant that was typed (OSK-21505). `timeZone` is for tests and defaults to
+ * the machine's own.
+ */
+export declare function formatLocalInstant(date: Date, timeZone?: string): string;
+/**
+ * The instant for a person: UTC first (it is what was typed and what is stored), then the
+ * local reading with its zone name. A machine already on UTC gets the UTC form alone.
+ */
+export declare function describeInstant(date: Date, timeZone?: string): string;

package/dist/lib/iso-instant.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * One reading of "an ISO-8601 UTC instant" for every CLI flag that takes one.
+ *
+ * `tasks remind --at` and `tasks schedule --at` each had their own: remind ran
+ * `new Date(value)` behind a `/^\d{4}-\d{2}-\d{2}T/` check, and schedule forwarded
+ * the string and printed the server's zod issue. `new Date()` is the wrong tool
+ * for an instant, in two ways that both stored a different time than the one
+ * typed and said nothing (OSK-21504, OSK-21506):
+ *
+ *   - a time with no zone is read in the zone of the MACHINE running the CLI, so
+ *     the same command stored different instants on different laptops;
+ *   - a day that does not exist overflows into the next month
+ *     (`2027-02-30` is `2027-03-02`).
+ *
+ * The rule here is the one `tasks schedule --help` already states and the server's
+ * `z.string().datetime()` enforces: a calendar-real date, a time with seconds, and
+ * a literal `Z`. A numeric offset is refused too, even though it names an instant:
+ * the two commands must agree, and the server's schedule door does not take one.
+ *
+ * Never reads the machine's zone. Pure.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUtcInstant = parseUtcInstant;
+exports.formatUtcInstant = formatUtcInstant;
+exports.formatLocalInstant = formatLocalInstant;
+exports.describeInstant = describeInstant;
+const EXAMPLE = '2026-12-01T09:00:00Z';
+const UTC_INSTANT = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?Z$/;
+const ZONELESS = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(\.\d+)?)?$/;
+const OFFSET = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(\.\d+)?)?([+-])(\d{2}):?(\d{2})$/;
+const DATE_ONLY = /^(\d{4})-(\d{2})-(\d{2})$/;
+const MONTH_NAMES = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+];
+function daysInMonth(year, month) {
+    return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+/**
+ * What is wrong with the calendar part, or `null` when the date exists.
+ * Checked by construction rather than by `new Date()`, which accepts the overflow.
+ */
+function calendarProblem(year, month, day) {
+    if (month < 1 || month > 12)
+        return `month ${String(month).padStart(2, '0')} does not exist`;
+    const last = daysInMonth(year, month);
+    if (day < 1 || day > last) {
+        return `${MONTH_NAMES[month - 1]} ${year} has ${last} days, so day ${String(day).padStart(2, '0')} does not exist`;
+    }
+    return null;
+}
+function clockProblem(hour, minute, second) {
+    if (hour > 23 || minute > 59 || second > 59) {
+        return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}:${String(second).padStart(2, '0')} is not a time of day`;
+    }
+    return null;
+}
+function rule(label) {
+    return `${label} must be an ISO-8601 UTC time ending in Z, for example ${EXAMPLE}`;
+}
+/**
+ * Parse a flag value as a UTC instant, or say precisely what is wrong with it.
+ *
+ * `label` is what the user typed (`--at`, `scheduledFor`), so the message names
+ * their input rather than a REST field they never saw.
+ */
+function parseUtcInstant(raw, label = '--at') {
+    const value = String(raw ?? '').trim();
+    const fail = (problem, reason) => ({
+        ok: false,
+        problem,
+        message: `${rule(label)}. ${reason}`,
+    });
+    const utc = UTC_INSTANT.exec(value);
+    if (utc) {
+        const [year, month, day, hour, minute, second] = utc.slice(1, 7).map(Number);
+        const calendar = calendarProblem(year, month, day);
+        if (calendar)
+            return fail('not_a_real_date', `"${value}" is not a real date: ${calendar}.`);
+        const clock = clockProblem(hour, minute, second);
+        if (clock)
+            return fail('not_a_real_time', `"${value}" is not a real time: ${clock}.`);
+        const date = new Date(value);
+        if (Number.isNaN(date.getTime())) {
+            return fail('not_a_date', `"${value}" is not a date.`);
+        }
+        return { ok: true, date, iso: date.toISOString() };
+    }
+    const zoneless = ZONELESS.exec(value);
+    if (zoneless) {
+        return fail('no_zone', `"${value}" has no time zone, so it could mean a different moment on each machine. ` +
+            `Add Z if it is UTC, or convert it to UTC first.`);
+    }
+    const offset = OFFSET.exec(value);
+    if (offset) {
+        const [year, month, day, hour, minute] = offset.slice(1, 6).map(Number);
+        const second = Number(offset[6] ?? 0);
+        const sign = offset[8] === '-' ? -1 : 1;
+        const shiftMinutes = sign * (Number(offset[9]) * 60 + Number(offset[10]));
+        let converted = '';
+        if (!calendarProblem(year, month, day) && !clockProblem(hour, minute, second)) {
+            const at = new Date(Date.UTC(year, month - 1, day, hour, minute, second) - shiftMinutes * 60_000);
+            converted = ` (${value} is ${at.toISOString().replace(/\.000Z$/, 'Z')})`;
+        }
+        return fail('numeric_offset', `Numeric offsets such as ${offset[8]}${offset[9]}:${offset[10]} are not accepted; convert the time to UTC and end it with Z${converted}.`);
+    }
+    const dateOnly = DATE_ONLY.exec(value);
+    if (dateOnly) {
+        const calendar = calendarProblem(Number(dateOnly[1]), Number(dateOnly[2]), Number(dateOnly[3]));
+        return fail(calendar ? 'not_a_real_date' : 'date_only', calendar
+            ? `"${value}" is not a real date: ${calendar}.`
+            : `"${value}" is a date without a time; add a time of day, e.g. ${value}T09:00:00Z.`);
+    }
+    return fail('not_a_date', `"${value}" is not an ISO-8601 date and time.`);
+}
+/** `2027-02-02T09:00:00Z` - the instant in UTC, whole seconds when there are no milliseconds. */
+function formatUtcInstant(date) {
+    return date.toISOString().replace(/\.000Z$/, 'Z');
+}
+/**
+ * `2027-02-02 01:00:00 PST` - the same instant on this machine's wall clock, with the
+ * zone NAMED. `toLocaleString()` printed neither the zone nor anything that mapped back
+ * to the instant that was typed (OSK-21505). `timeZone` is for tests and defaults to
+ * the machine's own.
+ */
+function formatLocalInstant(date, timeZone) {
+    const parts = new Intl.DateTimeFormat('en-CA', {
+        ...(timeZone ? { timeZone } : {}),
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hourCycle: 'h23',
+        timeZoneName: 'short',
+    }).formatToParts(date);
+    const get = (type) => parts.find((p) => p.type === type)?.value ?? '';
+    return `${get('year')}-${get('month')}-${get('day')} ${get('hour')}:${get('minute')}:${get('second')} ${get('timeZoneName')}`;
+}
+/**
+ * The instant for a person: UTC first (it is what was typed and what is stored), then the
+ * local reading with its zone name. A machine already on UTC gets the UTC form alone.
+ */
+function describeInstant(date, timeZone) {
+    const utc = formatUtcInstant(date);
+    const local = formatLocalInstant(date, timeZone);
+    if (/ (UTC|GMT)$/.test(local))
+        return utc;
+    return `${utc} (${local})`;
+}

package/dist/lib/machines.d.ts

@@ -1,4 +1,4 @@
-import type { DaemonContactState, DaemonMaintenanceSummary } from '@skrr-ai/data-provider';
+import type { DaemonContactState, DaemonMaintenanceSummary, MachineIcon, MachineIconPatch } from '@skrr-ai/data-provider';
 /**
  * machines.ts — request client for `/api/machines`.
  *
@@ -134,6 +134,7 @@ export interface Machine {
         name?: string;
         description?: string;
         tags?: string[];
+        icon?: MachineIcon;
     };
     lease: Record<string, unknown> | null;
     controls: {
@@ -271,7 +272,19 @@ export interface MachinePreferencesPatch {
     name?: string;
     description?: string;
     tags?: string[];
+    /** A preset, or null for the default. An uploaded image is not set by a patch. */
+    icon?: MachineIconPatch;
 }
+/**
+ * The value of `--icon`: a preset's id, or `none` (also `default`) to go back to
+ * the default. Throws a sentence that names the valid ids, because the only other
+ * way to learn them would be to send a wrong one and read the server's refusal.
+ * An uploaded image is a different flag (`--icon-file`): a name that is not a
+ * preset is never guessed to be a path.
+ */
+export declare function parseMachineIconFlag(value: string): MachineIconPatch;
+/** What `machines show`/`update` print for an icon: the preset's id, or what kind of image. */
+export declare function describeMachineIcon(icon: MachineIcon | undefined): string;
 /**
  * How many of a machine's harnesses still represent a capability it has.
  *

package/dist/lib/machines.js

@@ -10,6 +10,8 @@ exports.harnessStateLabel = harnessStateLabel;
 exports.summarizeDaemons = summarizeDaemons;
 exports.isThisComputer = isThisComputer;
 exports.machineListView = machineListView;
+exports.parseMachineIconFlag = parseMachineIconFlag;
+exports.describeMachineIcon = describeMachineIcon;
 exports.liveHarnessCount = liveHarnessCount;
 exports.listMachines = listMachines;
 exports.getMachine = getMachine;
@@ -229,6 +231,28 @@ function machineListView(machine, options) {
         ...(hidden > 0 ? { hiddenHarnessCount: hidden } : {}),
     };
 }
+/**
+ * The value of `--icon`: a preset's id, or `none` (also `default`) to go back to
+ * the default. Throws a sentence that names the valid ids, because the only other
+ * way to learn them would be to send a wrong one and read the server's refusal.
+ * An uploaded image is a different flag (`--icon-file`): a name that is not a
+ * preset is never guessed to be a path.
+ */
+function parseMachineIconFlag(value) {
+    const id = value.trim().toLowerCase();
+    if (id === 'none' || id === 'default')
+        return null;
+    if ((0, data_provider_1.isMachineIconPresetId)(id))
+        return { kind: 'preset', id };
+    throw new Error(`--icon: "${value}" is not an icon. Choose one of ${data_provider_1.MACHINE_ICON_PRESET_IDS.join(', ')}, ` +
+        'or "none" to go back to the default. To use your own image, pass --icon-file <path>.');
+}
+/** What `machines show`/`update` print for an icon: the preset's id, or what kind of image. */
+function describeMachineIcon(icon) {
+    if (!icon)
+        return 'default';
+    return icon.kind === 'preset' ? icon.id : 'uploaded image';
+}
 /**
  * How many of a machine's harnesses still represent a capability it has.
  *

package/dist/lib/northstars.d.ts

@@ -1,25 +1,3 @@
-/**
- * northstars.ts — request-based client for the Northstar portfolio layer
- * (`/api/northstars/*`) and its Portfolio Governor.
- *
- * A **Northstar** groups and prioritizes many Commitments without owning their
- * loop. The **Governor** is a MODE of its periodic review, not a separate
- * entity: a review rolls portfolio health up, allocates each Commitment a
- * cadence band and run budget, and emits TYPED management intents that a single
- * router turns into `CommitmentControl` mutations — advisory, awaiting a human,
- * or (narrowly) automatic.
- *
- * Two dials, deliberately separate:
- *   - `analysisMode`  — does an Agent get to think about this portfolio?
- *   - `executionMode` — how much write authority does the outcome carry?
- *
- * Both default to the safe end (`deterministic` / `advisory`), which is exactly
- * what a Northstar did before the Governor existed.
- *
- * Every vocabulary below is RE-EXPORTED from `@skrr-ai/data-provider`, never
- * 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.
- */
 import { NORTHSTAR_ANALYSIS_MODES, NORTHSTAR_APPROVAL_TRIGGERS, NORTHSTAR_EXECUTION_MODES, NORTHSTAR_INTENT_VERDICTS, NORTHSTAR_MANAGEMENT_INTENT_KINDS, NORTHSTAR_REVIEW_STATUSES } from '@skrr-ai/data-provider';
 import type { Northstar, NorthstarAnalysisMode, NorthstarExecutionMode, NorthstarGovernance, NorthstarGovernanceStatus, NorthstarGovernanceUpdateParams, NorthstarListResponse, NorthstarManagementIntent, NorthstarManagementIntentKind, NorthstarRecommendation, NorthstarReviewRecord, NorthstarStatusResponse } from '@skrr-ai/data-provider';
 import { withQuery } from './triggers';
@@ -33,6 +11,20 @@ export type { Northstar, NorthstarAnalysisMode, NorthstarExecutionMode, Northsta
 export declare const NORTHSTAR_STATUSES: readonly ["active", "paused", "achieved", "archived"];
 export declare const NORTHSTAR_PRIORITY_TIERS: readonly ["critical", "high", "medium", "low"];
 export declare const NORTHSTAR_RECOMMENDATION_STATUSES: readonly ["open", "applied", "dismissed"];
+export declare function intentRisk(intent: {
+    riskLevel?: string | null;
+} | null | undefined): string;
+export declare function shortReviewId(id: string): string;
+/**
+ * What a configure that changed the allocation inputs (the run budget, the critical reserve, the
+ * cadence band) says it did to the linked commitments. Additive on the server: absent from an
+ * older server, `allocationsPending` only when non-zero, `allocationsRefreshFailed` only on failure.
+ */
+export type AllocationRefreshFields = {
+    allocationsRefreshed?: number;
+    allocationsPending?: number;
+    allocationsRefreshFailed?: boolean;
+};
 export declare const northstarApi: {
     list: (query?: Parameters<typeof withQuery>[1]) => Promise<NorthstarListResponse>;
     create: (body: Record<string, unknown>) => Promise<Northstar>;
@@ -51,23 +43,208 @@ export declare const northstarApi: {
         northstarId: string;
         northstarVersion: number;
         governance: NorthstarGovernance;
-    }>;
+    } & AllocationRefreshFields>;
     reviews: (id: string, query?: Parameters<typeof withQuery>[1]) => Promise<{
         data: NorthstarReviewRecord[];
+        has_more?: boolean;
     }>;
     review: (id: string, reviewId: string) => Promise<NorthstarReviewRecord>;
     reviewNow: (id: string) => Promise<Record<string, unknown>>;
     intents: (id: string, query?: Parameters<typeof withQuery>[1]) => Promise<{
         data: NorthstarManagementIntent[];
+        has_more?: boolean;
     }>;
     decideIntent: (id: string, intentId: string, body: Record<string, unknown>) => Promise<Record<string, unknown>>;
 };
+/**
+ * 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`.
+ */
+export declare function lookupReview(northstarId: string, typed: string): Promise<{
+    review: NorthstarReviewRecord;
+} | {
+    ambiguous: string[];
+}>;
 /** ms → a short human duration, for a table cell that must stay narrow. */
 export declare function humanMs(ms?: number): string;
 export declare function shortDate(value?: string): string;
+export declare const NORTHSTAR_REASON_WORDS: Readonly<Record<string, string>>;
+/** A code in words; an unknown code comes back unchanged, an absent one says so. */
+export declare function describeNorthstarReason(code: string | null | undefined): string;
+export type NorthstarDecisionContext = {
+    northstarId: string;
+    intentId: string;
+    decision: 'approve' | 'reject';
+    /** The CLI binary name, for the command a sentence tells the reader to run. */
+    bin?: string;
+};
+/**
+ * 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).
+ */
+export declare function describeDecisionRefusal(body: Record<string, unknown>, ctx: NorthstarDecisionContext): {
+    code: string;
+    text: string;
+};
+export type NorthstarDecisionOutcome = {
+    /** The arrow line (`nsi_x → applied`), printed before any explanation. */
+    headline: string;
+    /** 0 only when the thing asked for now holds. */
+    exitCode: 0 | 1;
+    /** What to say after the headline. */
+    text?: string;
+    /** The raw code behind a non-zero exit, for `--json` and `Code:`. */
+    code?: string;
+};
+/**
+ * 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.
+ */
+export declare function describeDecisionOutcome(result: Record<string, unknown>, ctx: NorthstarDecisionContext): NorthstarDecisionOutcome;
+/** What the server returned before `--limit` existed; sent explicitly so a page is never silently smaller. */
+export declare const 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.
+ */
+export declare function listFooter(input: {
+    shown: number;
+    hasMore: boolean;
+    limit: number;
+    max: number;
+    nextCursor?: string | null;
+    cursor?: boolean;
+}): string;
 export declare function renderNorthstarList(rows: Northstar[], log: (line: string) => void): void;
+/**
+ * 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.
+ */
+export declare function describeMaxActive(value: number | undefined): string;
 export declare function renderNorthstar(status: NorthstarStatusResponse, log: (line: string) => void): void;
 export declare function renderRecommendationList(rows: NorthstarRecommendation[], log: (line: string) => void): void;
+/**
+ * No reviewer configured, a ready one, and an unreachable one are three
+ * different answers — and the third is the one an operator needs spelled out,
+ * because a scheduled review trigger says nothing about whether the agent that
+ * would run it is online.
+ */
+export declare function reviewerReadiness(reviewer: NorthstarGovernanceStatus['reviewer']): string;
+/** The `governance configure` flags that move what a commitment's allocation is computed from. */
+export declare const ALLOCATION_INPUT_FLAGS: readonly ["max-runs-per-day", "clear-max-runs-per-day", "critical-reserve", "min-interval-hours", "max-interval-hours", "max-relative-change"];
+export type AllocationRefresh = {
+    refreshed: number;
+    pending: number;
+    failed: boolean;
+};
+/** The refresh summary a configure response carries, or undefined from a server that sends none. */
+export declare function readAllocationRefresh(response: AllocationRefreshFields | undefined): AllocationRefresh | undefined;
+/**
+ * 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.
+ */
+export declare function describeAllocationRefresh(refresh: AllocationRefresh | undefined, options: {
+    northstarId: string;
+    inputsSent: boolean;
+    bin?: string;
+}): {
+    lines: string[];
+    warnings: string[];
+};
+/**
+ * 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.
+ */
+export declare function describeReviewAllocations(result: {
+    review?: unknown;
+    allocations?: unknown;
+    attention?: unknown;
+}): string;
+/**
+ * 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.
+ */
+export declare function runBudgetFloorNote(value: unknown): string | 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.
+ */
+export declare const 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";
 export declare function renderGovernance(status: NorthstarGovernanceStatus, log: (line: string) => void): void;
+/**
+ * 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).
+ */
+export declare function describeAutoBudget(budget: NorthstarGovernanceStatus['mutationBudget']): string;
+/** One cell of words for what a review did beyond "it ran"; empty when there is nothing to add. */
+export declare function reviewNote(review: NorthstarReviewRecord): string;
+/** `Reason` line of one review: the words, with the raw code kept beside them for grep. */
+export declare function describeReviewReason(reason: string): string;
 export declare function renderReviewList(reviews: NorthstarReviewRecord[], log: (line: string) => void): void;
-export declare function renderIntentList(intents: NorthstarManagementIntent[], log: (line: string) => void): void;
+/** `--wide` on every command that prints the intents table. */
+export declare const northstarWideFlag: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+export type IntentTableOptions = {
+    /** Never clip the reason, and keep the machine code beside it as `[code]`. */
+    wide?: boolean;
+    /** Terminal width to fit the table to; defaults to the real terminal, else 250. */
+    columns?: number;
+};
+/**
+ * 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.
+ */
+export declare function renderIntentList(intents: NorthstarManagementIntent[], log: (line: string) => void, options?: IntentTableOptions): void;
+/**
+ * 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`).
+ */
+export declare function intentBudgetNote(truncated: unknown, cap?: unknown): string;