@skrr-ai/cli 0.1.126 → 0.1.128

package/dist/commands/commitments/effective-policy.js

@@ -1,23 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isoWallClock = isoWallClock;
 exports.effectivePolicyLines = effectivePolicyLines;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const commitments_1 = require("../../lib/commitments");
 const commitment_product_1 = require("../../lib/commitment-product");
+const commitment_attention_copy_1 = require("../../lib/commitment-attention-copy");
 /** Which limit binds the daily action runs — the fix lives on that object. */
 const RUN_LIMIT_BINDING_LABELS = {
     northstar_allocation: 'Northstar allocation',
     workspace_admin: 'workspace limit',
     owner: 'owner limit',
 };
+/**
+ * `2026-11-02 00:00` for an instant, in a time zone. Built from parts, never from a locale: `02/11/2026`
+ * is the 2nd of November to one reader and the 11th of February to the next, and the budget reset is
+ * exactly the date a person reads this line for.
+ */
+function isoWallClock(instant, timeZone = 'UTC') {
+    const date = new Date(String(instant ?? ''));
+    if (Number.isNaN(date.getTime()))
+        return undefined;
+    try {
+        const parts = new Intl.DateTimeFormat('en-US', {
+            timeZone,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            hourCycle: 'h23',
+        }).formatToParts(date);
+        const part = (type) => parts.find((p) => p.type === type)?.value;
+        return `${part('year')}-${part('month')}-${part('day')} ${part('hour')}:${part('minute')}`;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** The admission day is UTC and said so; the shared Northstar pools are named apart. */
 function budgetDayLines(policy) {
     const day = policy.budgetDay;
     const shared = policy.portfolio?.sharedBudget;
     const lines = [];
     if (day) {
-        lines.push(`Daily budgets reset at ${day.resetsAt ?? '00:00 UTC'}${day.localResetAt ? ` (${day.localResetAt} ${day.localTimeZone})` : ''}`);
+        // The server's `localResetAt` is day-first (`02/11/2026, 00:00`); the next reset is rebuilt from the
+        // ISO instant it also sends, so the date reads the same to everyone.
+        const next = isoWallClock(day.nextResetAt);
+        const local = day.localTimeZone && day.localTimeZone !== 'UTC'
+            ? isoWallClock(day.nextResetAt, day.localTimeZone)
+            : undefined;
+        const when = [
+            next ? `next ${next} UTC` : undefined,
+            local ? `${local} ${day.localTimeZone}` : undefined,
+        ].filter(Boolean);
+        lines.push(`Daily budgets reset at ${day.resetsAt ?? '00:00 UTC'}${when.length ? ` (${when.join('; ')})` : ''}`);
     }
     if (shared?.status === 'unavailable') {
         lines.push('Northstar shared run pools: unavailable (could not be read)');
@@ -36,7 +74,15 @@ function budgetDayLines(policy) {
     }
     return lines;
 }
-function effectivePolicyLines(policy) {
+/** An effective-policy `{ mode, value }` limit, back to the stored `null` = unlimited. */
+function storedLimit(limit) {
+    return limit?.mode === 'limited' ? limit.value : null;
+}
+/**
+ * `stored` is the Commitment's own policy, read beside the effective one: the no-reply back-off
+ * is not part of the effective-policy answer, so without it that line is left out, not guessed.
+ */
+function effectivePolicyLines(policy, stored) {
     const governance = policy.governance || {};
     const owner = policy.owner || {};
     const lines = [];
@@ -61,7 +107,16 @@ function effectivePolicyLines(policy) {
         lines.push(`Owner action-run limit: ${runLimit.mode === 'unbounded' ? 'Unlimited' : `${runLimit.value}/day`}`);
     }
     const effectiveRuns = policy.effective?.actionRunsPerDay;
-    if (effectiveRuns) {
+    // A portfolio pool of 0 refuses every action run, so "Unlimited" on the line above it is false and
+    // the pool line below it ("action runs 0/day") contradicts it: say what the pool means here.
+    const sharedPool = policy.portfolio?.sharedBudget;
+    const poolRefusesAll = sharedPool?.status === 'available' &&
+        sharedPool.actionRunsPerDay === 0 &&
+        sharedPool.actionRunsPerDayState !== 'malformed';
+    if (poolRefusesAll) {
+        lines.push('Action runs: none (portfolio pool is 0/day)');
+    }
+    else if (effectiveRuns) {
         const bindingLabel = RUN_LIMIT_BINDING_LABELS[effectiveRuns.binding];
         const binding = bindingLabel ? ` (binding: ${bindingLabel})` : '';
         lines.push(`Effective action-run limit: ${effectiveRuns.mode === 'unbounded' ? 'Unlimited' : `${effectiveRuns.value}/day`}${binding}`);
@@ -72,6 +127,21 @@ function effectivePolicyLines(policy) {
     }
     if (policy.observation?.sensing)
         lines.push("Sensing runs: the Agent's own permissions");
+    // How much it may interrupt the owner (OSK-21120). The JSON has carried the cap and the gap as
+    // `owner.userNudgesPerDay` / `minUserNudgeIntervalMs`; the text dropped both.
+    if (owner.userNudgesPerDay) {
+        lines.push(...(0, commitment_attention_copy_1.nudgeSettingLines)({
+            maxUserNudgesPerDay: storedLimit(owner.userNudgesPerDay),
+            minUserNudgeIntervalMs: storedLimit(owner.minUserNudgeIntervalMs),
+            noReply: stored?.attention?.noReply,
+        }, { withNoReply: Boolean(stored) }));
+    }
+    // Which event sources may wake it (OSK-21113). The effective-policy answer has never carried
+    // `allowedEventSources`, so it is read from the Commitment's own policy; unread, the line is
+    // left out, because "all allowed" would be a claim.
+    if (stored) {
+        lines.push(`Event sources: ${(0, commitment_attention_copy_1.describeEventSources)(stored.executionBudget?.allowedEventSources)}`);
+    }
     lines.push(...budgetDayLines(policy));
     return lines;
 }
@@ -104,8 +174,18 @@ class CommitmentsEffectivePolicy extends base_command_1.BaseCommand {
             this.log(JSON.stringify(policy, null, 2));
             return;
         }
+        // The Commitment's own policy, for the settings the effective answer does not carry. A failed
+        // read costs those lines, never the command.
+        let stored = null;
+        try {
+            stored =
+                (await commitments_1.commitmentApi.get(args.id))?.commitment?.policy ?? null;
+        }
+        catch {
+            stored = null;
+        }
         this.log('Effective policy:');
-        for (const line of effectivePolicyLines(policy))
+        for (const line of effectivePolicyLines(policy, stored))
             this.log(`  ${line}`);
         if (flags.verbose) {
             this.log('\nRaw policy diagnostics:');

package/dist/commands/commitments/hypotheses.js

@@ -55,20 +55,20 @@ class CommitmentsHypotheses extends base_command_1.BaseCommand {
             this.handleApiError(err);
         }
         if (flags.json) {
+            // One JSON document and nothing else: has_more / next_cursor are in it.
             this.log(JSON.stringify(response, null, 2));
+            return;
         }
-        else {
-            // A filtered-out list is not an empty ledger — say which filter did it
-            // (OSK-10953).
-            const filters = [
-                flags.status ? `--status ${flags.status}` : null,
-                flags['investigation-key'] ? `--investigation-key ${flags['investigation-key']}` : null,
-            ].filter(Boolean);
-            const emptyMessage = filters.length
-                ? `No hypotheses match ${filters.join(' ')}.`
-                : 'No hypotheses recorded.';
-            (0, commitments_1.renderCommitmentHypotheses)(response, (line) => this.log(line), { emptyMessage });
-        }
+        // A filtered-out list is not an empty ledger — say which filter did it
+        // (OSK-10953).
+        const filters = [
+            flags.status ? `--status ${flags.status}` : null,
+            flags['investigation-key'] ? `--investigation-key ${flags['investigation-key']}` : null,
+        ].filter(Boolean);
+        const emptyMessage = filters.length
+            ? `No hypotheses match ${filters.join(' ')}.`
+            : 'No hypotheses recorded.';
+        (0, commitments_1.renderCommitmentHypotheses)(response, (line) => this.log(line), { emptyMessage });
         (0, commitments_1.renderListPageHint)(response, (line) => this.log(line));
     }
 }

package/dist/commands/commitments/next-tick.js

@@ -71,6 +71,11 @@ function formatNextTick(projection) {
         // is entirely in that: a reader who thinks a check just ran will misread
         // every number on the commitment afterwards.
         'Projection only — no check was recorded, no budget spent, no action routed.',
+        // And what it does not MODEL (OSK-21104): it decides from the evidence alone. A real Check also
+        // applies the repeat-evidence window, earlier Runs and owed retries, today's Run budget, the
+        // dispatch breaker and the attention contract, so it can stop sooner than this, or run a
+        // retry this does not show. Without the sentence a projected `enqueue_agent_turn` reads as a promise.
+        "It decides from the evidence alone: a real check also applies the repeat-evidence window, earlier runs and owed retries, today's run budget, the dispatch breaker and the attention contract, so it can stop sooner (or run a retry) than shown here.",
         '',
         `Posture:    ${decision.posture ?? '-'}`,
         `Health:     ${decision.health ?? '-'}`,

package/dist/commands/commitments/observations.js

@@ -152,25 +152,26 @@ class CommitmentsObservations extends base_command_1.BaseCommand {
             this.handleApiError(err);
         }
         if (flags.json) {
+            // One JSON document and nothing else: has_more / next_cursor are in it
+            // (OSK-21118).
             this.printJsonResult(response);
+            return;
         }
-        else {
-            // "The commitment has none" and "your filter matched none" are different
-            // facts; a filter that empties the list must not claim the first
-            // (OSK-10953).
-            const filters = [
-                flags.latest ? '--latest' : null,
-                flags['declared-only'] ? '--declared-only' : null,
-                flags['changed-only'] ? '--changed-only' : null,
-                flags.since ? `--since ${flags.since}` : null,
-            ].filter(Boolean);
-            const emptyMessage = filters.length
-                ? `No observations match ${filters.join(' ')}.`
-                : 'No observations recorded.';
-            if (response?.truncated)
-                this.log(`TRUNCATED: ${response.omitted} current keys omitted; increase --limit (max 200).`);
-            (0, commitments_1.renderCommitmentObservations)(response, (line) => this.log(line), { emptyMessage });
-        }
+        // "The commitment has none" and "your filter matched none" are different
+        // facts; a filter that empties the list must not claim the first
+        // (OSK-10953).
+        const filters = [
+            flags.latest ? '--latest' : null,
+            flags['declared-only'] ? '--declared-only' : null,
+            flags['changed-only'] ? '--changed-only' : null,
+            flags.since ? `--since ${flags.since}` : null,
+        ].filter(Boolean);
+        const emptyMessage = filters.length
+            ? `No observations match ${filters.join(' ')}.`
+            : 'No observations recorded.';
+        if (response?.truncated)
+            this.log(`TRUNCATED: ${response.omitted} current keys omitted; increase --limit (max 200).`);
+        (0, commitments_1.renderCommitmentObservations)(response, (line) => this.log(line), { emptyMessage });
         (0, commitments_1.renderListPageHint)(response, (line) => this.log(line));
     }
 }

package/dist/commands/commitments/pack/list.js

@@ -41,7 +41,8 @@ class CommitmentsPackList extends base_command_1.BaseCommand {
         (0, format_1.renderTable)(rows.map((pack) => ({
             id: String(pack.id),
             version: String(pack.version),
-            title: String(pack.title || ''),
+            // The catalogue names a Pack `label`; reading only `title` printed a blank column for all eight.
+            title: String(pack.label || pack.title || ''),
         })), [
             // No maxWidth: a clipped pack id cannot be pasted into `pack plan --pack` (OSK-6175).
             { key: 'id', header: 'PACK ID' },

package/dist/commands/commitments/pack/plan.d.ts

@@ -1,4 +1,10 @@
 import { BaseCommand } from '../../../base-command';
+import { type CommitmentPackPlanResponse } from '../../../lib/commitments';
+/**
+ * Lines for what the plan says will stop the loop from ever being activated. `bind` would still
+ * write a draft, so a reader who sees only "Nothing was created" must also see this.
+ */
+export declare function formatReadiness(readiness: CommitmentPackPlanResponse['readiness']): string[];
 /**
  * Draft what a Pack WOULD create, without creating it.
  *

package/dist/commands/commitments/pack/plan.js

@@ -1,8 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatReadiness = formatReadiness;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../../base-command");
 const commitments_1 = require("../../../lib/commitments");
+/**
+ * Lines for what the plan says will stop the loop from ever being activated. `bind` would still
+ * write a draft, so a reader who sees only "Nothing was created" must also see this.
+ */
+function formatReadiness(readiness) {
+    if (!readiness?.length)
+        return [];
+    const lines = [];
+    for (const item of readiness) {
+        lines.push(`Not ready:  ${item.label} — ${item.reason}`);
+        if (item.hint)
+            lines.push(`            ${item.hint}`);
+    }
+    lines.push('            `bind` would still create the draft, but `pack activate` will be refused until this is fixed.');
+    return lines;
+}
 /**
  * Draft what a Pack WOULD create, without creating it.
  *
@@ -87,6 +104,8 @@ class CommitmentsPackPlan extends base_command_1.BaseCommand {
             const holder = placement.holder === 'space_lead' ? ' (the Space lead)' : '';
             this.log(`Space loop: ${placement.spaceId}, held by ${placement.agentId}${holder}`);
         }
+        for (const line of formatReadiness(result.readiness))
+            this.log(line);
         this.log('\nNothing was created. Pass this digest to `skrr commitments pack bind --plan-digest`.');
     }
 }

package/dist/commands/commitments/preflight.d.ts

@@ -35,7 +35,26 @@ export declare function nextRunsLines(report: {
     verdict?: string;
     nextRuns?: string[];
 }): string[];
+/**
+ * The first line of a preflight. `Ready to run` is a statement about activation (no blocking gate),
+ * and it sat directly above a spend-gate warning that the daily Run budget is 0, i.e. that no agent
+ * turn can ever start (OSK-21224). The verdict stays `ready` on purpose: a zero ACTION budget does
+ * not stop the sensing lane, so refusing activation would be wrong for a Commitment that only
+ * observes. The headline carries the caveat instead of contradicting the gate below it.
+ */
+export declare function preflightHeadline(report: Pick<CommitmentPreflightReport, 'verdict' | 'gates'>, persisted: boolean): string;
 export declare function preflightGateLines(gate: PreflightGate, verbose?: boolean): string[];
+/**
+ * The `Attention:` footer, and under it the settings behind the verdict (OSK-21120).
+ *
+ * "delivery allowed now" is the same words for a cap of 1, a mute lifted and no limit at all, so
+ * the cap, the gap and the no-reply rule are said beside it. `policy` is the stored policy the
+ * report was computed from, or the unsaved one under `--from-json`; without it nothing is said
+ * about the settings, rather than a guess. The raw reason code (`policy_nudge_muted`) is printed only
+ * with `--verbose`: beside the sentence it said the same thing twice, in a vocabulary nobody types
+ * (OSK-21124).
+ */
+export declare function attentionFooterLines(attention: CommitmentPreflightReport['attention'] | undefined, policy?: Record<string, any> | null, verbose?: boolean): string[];
 export default class CommitmentsPreflight extends BaseCommand {
     static description: string;
     static examples: string[];

package/dist/commands/commitments/preflight.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nextRunsLines = nextRunsLines;
+exports.preflightHeadline = preflightHeadline;
 exports.preflightGateLines = preflightGateLines;
+exports.attentionFooterLines = attentionFooterLines;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const commitments_1 = require("../../lib/commitments");
 const prompt_1 = require("../../lib/prompt");
+const commitment_attention_copy_1 = require("../../lib/commitment-attention-copy");
 const preflight_copy_1 = require("../../lib/preflight-copy");
 /**
  * The lines one preflight gate contributes.
@@ -41,6 +44,25 @@ function nextRunsLines(report) {
         : 'Next runs:';
     return ['', header, ...report.nextRuns.map((run) => `  ${run}`)];
 }
+/**
+ * The first line of a preflight. `Ready to run` is a statement about activation (no blocking gate),
+ * and it sat directly above a spend-gate warning that the daily Run budget is 0, i.e. that no agent
+ * turn can ever start (OSK-21224). The verdict stays `ready` on purpose: a zero ACTION budget does
+ * not stop the sensing lane, so refusing activation would be wrong for a Commitment that only
+ * observes. The headline carries the caveat instead of contradicting the gate below it.
+ */
+function preflightHeadline(report, persisted) {
+    const label = persisted ? 'Preflight' : 'Pre-create preview (nothing persisted)';
+    if (report.verdict === 'blocked')
+        return `${label}: Run is blocked`;
+    if (report.verdict !== 'ready')
+        return `${label}: A capability or configuration check is still needed`;
+    const reasons = report.gates?.find((gate) => gate.id === 'budget_bounds')?.detail?.reasons;
+    const noActionRuns = Array.isArray(reasons) && reasons.includes('action_runs_zero');
+    return noActionRuns
+        ? `${label}: Ready to run, but its daily Run budget is 0, so no agent turn will start`
+        : `${label}: Ready to run`;
+}
 function preflightGateLines(gate, verbose = false) {
     // "Could it contact you now?" is not a Run gate. It answers whether a message
     // would reach the owner, and a limit the owner set themselves (zero nudges a day,
@@ -50,15 +72,36 @@ function preflightGateLines(gate, verbose = false) {
     // (OSK-15420). Say what it is in words, and which setting moves it.
     if (gate.id === 'attention' && gate.verdict === 'block') {
         const copy = (0, data_provider_1.describeSuppression)(gate.reason);
+        // "Held until your quiet hours end." named no time and no zone; the report has both (OSK-21122).
+        const quietEnd = gate.reason === 'policy_quiet_hours'
+            ? (0, commitment_attention_copy_1.describeQuietHoursEnd)(gate.detail?.quietHours)
+            : null;
         const lines = [
             `  ${'info'.padEnd(5)} ${gate.label} — ${copy.title.toLowerCase()}${verbose && gate.reason ? ` (${gate.reason})` : ''}`,
-            `        ${copy.detail}`,
+            `        ${quietEnd ?? copy.detail}`,
         ];
-        if (copy.settingKey)
+        // Whose quiet hours these are, when they are not the Commitment's own (OSK-21151): a reader
+        // would otherwise be sent to a field this Commitment does not hold.
+        const note = gate.detail?.note;
+        if (typeof note === 'string' && note.trim())
+            lines.push(`        ${note.trim()}`);
+        // The policy field is a path into JSON, not something to type: the sentence above says what
+        // it means, so the path joins the code behind --verbose (OSK-21124).
+        if (verbose && copy.settingKey)
             lines.push(`        Setting: ${copy.settingKey}`);
         return lines;
     }
-    const mark = gate.verdict === 'pass' ? 'ok' : gate.verdict === 'block' ? 'BLOCK' : 'warn';
+    // A `block` the report itself marks advisory stops nothing: it is not a Run-admission gate, so it
+    // never feeds the verdict or `pack activate`. Printed BLOCK, `pack preflight` read "ready" above
+    // two BLOCK lines (dogfooded on a goal_advance draft); the tag has to mean what the report means.
+    const advisoryBlock = gate.verdict === 'block' && gate.admission === 'advisory';
+    const mark = advisoryBlock
+        ? 'info'
+        : gate.verdict === 'pass'
+            ? 'ok'
+            : gate.verdict === 'block'
+                ? 'BLOCK'
+                : 'warn';
     // A BLOCKING gate always states its reason. `ok` gates got a helpful `note`
     // and `warn` gates got a reason token, and the BLOCK gates — the only ones
     // that stop the run — got the label and nothing: two of them side by side,
@@ -75,7 +118,8 @@ function preflightGateLines(gate, verbose = false) {
     const hasNote = typeof note === 'string' && Boolean(note.trim());
     const showReason = verbose || (gate.verdict === 'block' && !hasNote);
     const lines = [
-        `  ${mark.padEnd(5)} ${gate.label}${showReason && gate.reason ? ` — ${gate.reason}` : ''}`,
+        `  ${mark.padEnd(5)} ${gate.label}${showReason && gate.reason ? ` — ${gate.reason}` : ''}` +
+            (advisoryBlock ? ' (advisory: does not stop a run)' : ''),
     ];
     if (hasNote) {
         lines.push(`        ${String(note).trim()}`);
@@ -92,6 +136,13 @@ function preflightGateLines(gate, verbose = false) {
         else if (status === 'invalid') {
             lines.push('        Active owner rules: unknown (stored rules invalid).');
         }
+        else if (status === 'archived' &&
+            typeof count === 'number' &&
+            Number.isSafeInteger(count) &&
+            count >= 0) {
+            // The Compass is archived, not unreadable: its rules are counted, and still enforced.
+            lines.push(`        Active owner rules: ${count} (on the archived Compass, still enforced).`);
+        }
         else if (status === 'available' &&
             typeof count === 'number' &&
             Number.isSafeInteger(count) &&
@@ -116,6 +167,29 @@ function preflightGateLines(gate, verbose = false) {
         lines.push(`        ${sentence}`);
     return lines;
 }
+/**
+ * The `Attention:` footer, and under it the settings behind the verdict (OSK-21120).
+ *
+ * "delivery allowed now" is the same words for a cap of 1, a mute lifted and no limit at all, so
+ * the cap, the gap and the no-reply rule are said beside it. `policy` is the stored policy the
+ * report was computed from, or the unsaved one under `--from-json`; without it nothing is said
+ * about the settings, rather than a guess. The raw reason code (`policy_nudge_muted`) is printed only
+ * with `--verbose`: beside the sentence it said the same thing twice, in a vocabulary nobody types
+ * (OSK-21124).
+ */
+function attentionFooterLines(attention, policy, verbose = false) {
+    const code = verbose && attention?.suppressedBy ? ` (${attention.suppressedBy})` : '';
+    const lines = [
+        '',
+        `Attention: ${attention?.allowed ? 'delivery allowed now' : `held back — ${(0, data_provider_1.describeSuppression)(attention?.suppressedBy).title.toLowerCase()}${code}`}`,
+    ];
+    if (policy) {
+        for (const line of (0, commitment_attention_copy_1.nudgeSettingLines)((0, commitment_attention_copy_1.nudgeSettingsFromPolicy)(policy)))
+            lines.push(`  ${line}`);
+        lines.push(`  Quiet hours: ${(0, commitment_attention_copy_1.describeQuietHours)(policy.quietHours)}`);
+    }
+    return lines;
+}
 class CommitmentsPreflight extends base_command_1.BaseCommand {
     static description = 'Dry-run a commitment: runtime gates, capabilities, attention policy and upcoming runs (runs nothing)';
     static examples = [
@@ -151,16 +225,37 @@ class CommitmentsPreflight extends base_command_1.BaseCommand {
             this.error('--next must be between 1 and 10', { exit: 1 });
         }
         let report;
+        // The policy the verdict was computed from, for the settings printed under it.
+        let policy = null;
         try {
-            report = args.id
-                ? await commitments_1.commitmentApi.preflight(args.id, flags.next)
-                : await commitments_1.commitmentApi.draftPreflight({
-                    commitment: (0, commitments_1.normalizeCreateBody)(await (0, prompt_1.readJsonBody)(flags['from-json'])),
+            if (args.id) {
+                report = await commitments_1.commitmentApi.preflight(args.id, flags.next);
+                try {
+                    policy =
+                        (await commitments_1.commitmentApi.get(args.id))?.commitment?.policy ?? null;
+                }
+                catch {
+                    policy = null;
+                }
+            }
+            else {
+                const rawBody = await (0, prompt_1.readJsonBody)(flags['from-json']);
+                const draft = (0, commitments_1.normalizeCreateBody)(rawBody);
+                const ignoredWarning = (0, commitments_1.ignoredCreateKeysWarning)((0, commitments_1.ignoredCreateKeys)(rawBody));
+                if (ignoredWarning)
+                    this.warn(ignoredWarning);
+                policy = draft.policy ?? {};
+                const quietHoursProblem = (0, commitment_attention_copy_1.quietHoursInputProblem)(policy);
+                if (quietHoursProblem)
+                    throw new Error(quietHoursProblem);
+                report = await commitments_1.commitmentApi.draftPreflight({
+                    commitment: draft,
                     ...(flags['event-fixture']
                         ? { eventFixture: await (0, prompt_1.readJsonBody)(flags['event-fixture']) }
                         : {}),
                     ...(flags.next !== undefined ? { nextRunCount: flags.next } : {}),
                 });
+            }
         }
         catch (err) {
             this.handleApiError(err);
@@ -170,7 +265,9 @@ class CommitmentsPreflight extends base_command_1.BaseCommand {
             this.log(JSON.stringify(report, null, 2));
             return;
         }
-        this.log(`${args.id ? 'Preflight' : 'Pre-create preview (nothing persisted)'}: ${report.verdict === 'ready' ? 'Ready to run' : report.verdict === 'blocked' ? 'Run is blocked' : 'A capability or configuration check is still needed'}`);
+        this.log(preflightHeadline(report, Boolean(args.id)));
+        for (const line of (0, commitments_1.activationRefusalLines)(report.activation))
+            this.log(line);
         // Whose permissions the run will use (OSK-11975), before the gates, so an
         // Execute Commitment on a plan-mode Agent is the first thing read
         // (OSK-12065).
@@ -211,7 +308,8 @@ class CommitmentsPreflight extends base_command_1.BaseCommand {
                 (endpoint.reason ? ` (${endpoint.reason})` : '') +
                 (!endpoint.available && endpoint.detail ? ` — ${endpoint.detail}` : ''));
         }
-        this.log(`\nAttention: ${report.attention?.allowed ? 'delivery allowed now' : `held back — ${(0, data_provider_1.describeSuppression)(report.attention?.suppressedBy).title.toLowerCase()}${report.attention?.suppressedBy ? ` (${report.attention.suppressedBy})` : ''}`}`);
+        for (const line of attentionFooterLines(report.attention, policy, flags.verbose))
+            this.log(line);
         if (report.verdict === 'blocked')
             process.exitCode = 1;
     }

package/dist/commands/commitments/trigger-status.js

@@ -82,6 +82,14 @@ function formatTriggerStatus(status) {
                 '(fired or disabled — cannot wake this commitment)');
         }
     }
+    // The plan can be converged and every row enabled while nothing can wake (Always-On off). `convergence`
+    // is a fact about the rows; this is the other fact, from the same projection `commitments status` reads.
+    const wake = status.wake;
+    if (wake?.held) {
+        lines.push(`Wakes:       HELD — ${wake.reason ?? 'blocked'}`);
+        if (wake.detail)
+            lines.push(`  ${String(wake.detail).replace(/\s+/g, ' ').trim()}`);
+    }
     const bindings = Array.isArray(status.bindings) ? status.bindings : [];
     lines.push('');
     if (bindings.length === 0) {

package/dist/commands/commitments/update.d.ts

@@ -49,6 +49,7 @@ export default class CommitmentsUpdate extends BaseCommand {
         'cadence-mode': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         timezone: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         isolation: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'max-nudges': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'max-concurrent-runs': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'concurrency-reason': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };