@skrr-ai/cli 0.1.128 → 0.1.129

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/northstars.d.ts

@@ -11,6 +11,10 @@ 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
@@ -52,6 +56,19 @@ export declare const northstarApi: {
     }>;
     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;
@@ -166,6 +183,32 @@ export declare function describeReviewAllocations(result: {
     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.

package/dist/lib/northstars.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.northstarWideFlag = 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.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;
@@ -15,6 +18,7 @@ exports.reviewerReadiness = reviewerReadiness;
 exports.readAllocationRefresh = readAllocationRefresh;
 exports.describeAllocationRefresh = describeAllocationRefresh;
 exports.describeReviewAllocations = describeReviewAllocations;
+exports.runBudgetFloorNote = runBudgetFloorNote;
 exports.renderGovernance = renderGovernance;
 exports.describeAutoBudget = describeAutoBudget;
 exports.reviewNote = reviewNote;
@@ -67,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 ---------------------------------------------------- */
@@ -92,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)))
@@ -171,7 +230,9 @@ exports.NORTHSTAR_REASON_WORDS = {
     // 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',
-    superseded: 'a newer review proposed the same thing',
+    // 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',
@@ -460,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);
 }
@@ -555,6 +618,37 @@ function describeReviewAllocations(result) {
     }
     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})`);
@@ -576,6 +670,9 @@ function renderGovernance(status, log) {
     }
     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.');
     }
@@ -583,6 +680,10 @@ function renderGovernance(status, log) {
     const eb = status.executionBudget ?? {};
     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('');
     const trigger = status.reviewTrigger;
     log(trigger.scheduled
@@ -734,11 +835,18 @@ function renderIntentList(intents, log, options = {}) {
         log('No management intents.');
         return;
     }
+    // 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,
+        // 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 ?? '',
@@ -746,28 +854,36 @@ function renderIntentList(intents, log, options = {}) {
     }));
     const headers = {
         id: 'INTENT',
+        review: 'REVIEW',
         kind: 'KIND',
         target: 'COMMITMENT',
         verdict: 'VERDICT',
+        risk: 'RISK',
         source: 'SOURCE',
     };
-    const fixedKeys = ['id', 'kind', 'target', 'verdict', '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;
-    // Five gaps of two spaces separate the six columns.
-    const whyBudget = Math.max(INTENT_WHY_MIN_WIDTH, terminal - fixedWidth - 10);
+    // 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: 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);

package/dist/lib/proposals.js

@@ -153,11 +153,15 @@ function renderNorthstarIntentView(view) {
         return null;
     const context = view.decisionContext;
     const verdict = view.sourceStatus;
-    const risk = context.riskLevel ?? context.snapshot.riskLevel ?? 'unknown';
+    // The intent's own rating (`intentRisk`), the one `northstars intents list` prints under RISK.
+    const risk = (0, northstars_1.intentRisk)({ riskLevel: context.riskLevel ?? context.snapshot.riskLevel });
     const hasTarget = Boolean(context.snapshot.targetCommitmentId || view.commitmentId);
     const lines = [proposalTitleFor(view), ''];
     lines.push(`Proposal    ${view.id}`);
-    lines.push(`Kind        ${context.snapshot.kind} · risk ${risk}`);
+    lines.push(`Kind        ${context.snapshot.kind}`);
+    // Said once, here, because this is where a person who saw a lower "recommendation risk" on the
+    // recommendation this came from looks for the reason the two differ.
+    lines.push(`Risk        ${risk}  (rated for this change; the recommendation behind it has its own "recommendation risk")`);
     lines.push(`Target      ${hasTarget ? intentTarget(view) : 'none (a new commitment)'}`);
     if (context.reason)
         lines.push(`Why         ${context.reason}`);

package/dist/lib/store-artifact-releases.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `/api/store/artifacts/skill/:entityId/releases` — the seller's own
+ * publication history for one skill, newest release first.
+ *
+ * It answers the question a headless seller has after `store artifacts release`:
+ * where did my releases land, and did a curator admit or refuse one (with the
+ * note they left)? The source snapshot and its private storage references are
+ * never in this projection. One release in full is `store artifacts receipt`.
+ *
+ * The route is written out at its own call site rather than composed from a
+ * builder, like the rest of the Store CLI: the parity checker reads the LITERAL
+ * at the call site.
+ */
+export type StoreArtifactReleaseSummary = {
+    releaseId: string;
+    releaseNumber: number;
+    versionLabel?: string;
+    status?: string;
+    admission?: {
+        state?: string;
+        review?: {
+            note?: string;
+            decidedAt?: string;
+        };
+    };
+    createdAt?: string;
+    updatedAt?: string;
+    publishedAt?: string;
+};
+export type StoreArtifactReleaseHistory = {
+    data: StoreArtifactReleaseSummary[];
+    /** Pass as `before` for the next (older) page; null when this is the last. */
+    nextBefore: number | null;
+};
+/** `GET /artifacts/skill/:entityId/releases` — `limit` 1-50 (default 10), `before` a release number. */
+export declare function listSkillArtifactReleases(entityId: string, params?: {
+    limit?: number;
+    before?: number;
+}): Promise<StoreArtifactReleaseHistory>;

package/dist/lib/store-artifact-releases.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSkillArtifactReleases = listSkillArtifactReleases;
+const api_fetch_1 = require("./api-fetch");
+const triggers_1 = require("./triggers");
+/** `GET /artifacts/skill/:entityId/releases` — `limit` 1-50 (default 10), `before` a release number. */
+async function listSkillArtifactReleases(entityId, params = {}) {
+    return (0, api_fetch_1.apiFetch)((0, triggers_1.withQuery)(`/api/store/artifacts/skill/${encodeURIComponent(entityId)}/releases`, {
+        limit: params.limit,
+        before: params.before,
+    }));
+}

package/dist/lib/store-library.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `/api/store/library/items` — the Skill, Action and Service copies the signed-in
+ * buyer holds in the active workspace, with whether each copy can still be used.
+ *
+ * Agent purchases are NOT here: `skrr store installs` reads those. This is the
+ * other three artifact kinds, which the web Library page lists and which had no
+ * headless read at all.
+ *
+ * The route is written out at its own call site rather than composed from a
+ * builder, like the rest of the Store CLI: the parity checker reads the LITERAL
+ * at the call site.
+ */
+/** One bought copy. `copyAvailable` is false once the copy is suspended, revoked or uninstalled. */
+export type StoreLibraryItem = {
+    /** The listing or release the buyer bought. */
+    sourceId: string;
+    /** The buyer's own installed copy; null while fulfillment has not produced one. */
+    copyId: string | null;
+    name: string | null;
+    copyAvailable: boolean;
+    /** The Agent the copy was installed onto (Skills and Actions only). */
+    targetAgentId?: string | null;
+    entitlementState?: string;
+    fulfillmentState?: string;
+    purchasedAt?: string;
+};
+export type StoreLibraryItems = {
+    skills: StoreLibraryItem[];
+    actions: StoreLibraryItem[];
+    services: StoreLibraryItem[];
+};
+/**
+ * `GET /library/items`. The workspace is required by the server (400
+ * `A workspace is required` without one), so it travels as the explicit
+ * header, the way `store installs` sends it.
+ */
+export declare function getStoreLibraryItems(workspaceId?: string): Promise<StoreLibraryItems>;

package/dist/lib/store-library.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStoreLibraryItems = getStoreLibraryItems;
+const api_fetch_1 = require("./api-fetch");
+/**
+ * `GET /library/items`. The workspace is required by the server (400
+ * `A workspace is required` without one), so it travels as the explicit
+ * header, the way `store installs` sends it.
+ */
+async function getStoreLibraryItems(workspaceId) {
+    return (0, api_fetch_1.apiFetch)('/api/store/library/items', workspaceId ? { headers: { 'X-Workspace-Id': workspaceId } } : undefined);
+}

package/dist/lib/task-calendar.d.ts

@@ -0,0 +1,19 @@
+/**
+ * What `skrr tasks list --calendar` tells a person about the answer it printed.
+ *
+ * The calendar read used to end with "Note: calendar occurrence expansion reached its safety cap."
+ * whatever had been cut, and "No calendar occurrences." whatever had been missed (OSK-21382,
+ * OSK-21510): no limit, no cutoff, no Task, no remedy, and the server's warning codes were never
+ * shown. The server now says which bounds it reached (`truncations`) and which access warnings
+ * apply; this words them.
+ */
+import type { TaskCalendarResponse, TaskCalendarTruncation } from '@skrr-ai/data-provider';
+export declare function describeCalendarTruncation(truncation: TaskCalendarTruncation): string;
+export declare function describeCalendarWarning(code: string): string;
+/**
+ * The lines to print after a calendar answer: empty when the read was complete. A calendar that
+ * was cut short never reads as complete, and every cut says what it was.
+ */
+export declare function calendarNoticeLines(calendar: TaskCalendarResponse): string[];
+/** The window that was actually read, in UTC, and what a date-only range stood for. */
+export declare function calendarWindowLine(calendar: Pick<TaskCalendarResponse, 'from' | 'to'>): string;