@skrr-ai/cli 0.1.127 → 0.1.129

package/dist/commands/commitments/create.js

@@ -10,6 +10,7 @@ const base_command_1 = require("../../base-command");
 const guide_pointer_1 = require("../../lib/guide-pointer");
 const web_url_1 = require("../../lib/web-url");
 const prompt_1 = require("../../lib/prompt");
+const commitment_attention_copy_1 = require("../../lib/commitment-attention-copy");
 const triggers_1 = require("../../lib/triggers");
 const commitment_product_1 = require("../../lib/commitment-product");
 const commitments_1 = require("../../lib/commitments");
@@ -153,8 +154,27 @@ function createCadenceFromFlags({ eventDriven, cadence: cadenceInput, cadenceMod
  * it. `{code, reason, fix}` mirrors the MCP surface's refusal; `guide` points
  * at the section that explains the code when one does (resolved offline).
  */
+/** Everything that blocks an activation, when the server listed more than the first gate. */
+function activationBlockers(body) {
+    const diagnostic = body?.diagnostic;
+    if (!Array.isArray(diagnostic?.blockers))
+        return [];
+    const blockers = [];
+    for (const item of diagnostic.blockers) {
+        const gate = item?.gate;
+        const reason = item?.reason;
+        if (typeof gate === 'string' && gate && typeof reason === 'string' && reason) {
+            blockers.push({ gate, reason });
+        }
+    }
+    return blockers;
+}
 function commitmentActivationRefusal(err, { id, bin }) {
     const refusal = (0, base_command_1.apiRefusal)(err);
+    // `resume` answers with every blocking gate, but only the first is in the message. Fixing it
+    // revealed the next one on the following try (Always-On, then the runtime), so the refusal says
+    // all of them when there is more than one (dogfood df-261031-commitment-authoring, F12).
+    const blockers = activationBlockers(refusal.body);
     const errorField = refusal.body?.error;
     const code = refusal.code ||
         (typeof errorField === 'string' && /^[A-Za-z][A-Za-z0-9_]*$/.test(errorField)
@@ -162,11 +182,17 @@ function commitmentActivationRefusal(err, { id, bin }) {
             : undefined) ||
         'COMMITMENT_ACTIVATION_REFUSED';
     const guide = (0, guide_pointer_1.agentGuidePointerFor)(code);
+    // The blocking gate's own remedy beats the generic "fix the gate the reason names": the reason is
+    // a token, and the sentence that says what to run is the hint beside it (OSK-21126).
+    const hint = (0, base_command_1.commitmentActivationHint)(refusal.body);
     return {
         code,
         reason: refusal.message || (err instanceof Error ? err.message : 'Activation was refused.'),
-        fix: (0, data_provider_1.describeCommitmentActivationFix)(code === 'COMMITMENT_ACTIVATION_REFUSED' ? undefined : code, { turnOn: `run \`${bin} commitments resume ${id}\`` }),
+        fix: hint
+            ? `${hint} Then run \`${bin} commitments resume ${id}\`.`
+            : (0, data_provider_1.describeCommitmentActivationFix)(code === 'COMMITMENT_ACTIVATION_REFUSED' ? undefined : code, { turnOn: `run \`${bin} commitments resume ${id}\`` }),
         ...(guide ? { guide } : {}),
+        ...(blockers.length > 1 ? { blockers } : {}),
     };
 }
 /**
@@ -210,6 +236,7 @@ cat > commitment.json <<'JSON'
   }],
   "policy": {
     "maxUserNudgesPerDay": 0,
+    "quietHours": { "enabled": true, "start": "22:00", "end": "07:00", "timezone": "Asia/Shanghai" },
     "executionBudget": { "maxRunsPerDay": 0, "maxObservationRunsPerDay": 0, "maxCostUsdPerDay": 0 }
   }
 }
@@ -217,11 +244,27 @@ JSON
 <%= config.bin %> commitments preflight --from-json commitment.json
 <%= config.bin %> commitments create --from-json commitment.json --json`,
         '<%= config.bin %> commitments create --agent <agent-id> --title "Keep CI healthy" --outcome "Failed checks are repaired" --watch github --github-event check_run_failed --event-driven --delivery draft-pr --repo owner/repo --base main --status draft',
+        `# Govern a Commitment with a Compass. There is no flag: "compassId" goes in the --from-json body.
+# It must be an active Compass of the same Agent (a draft may name an archived one).
+# The binding cannot be changed later: bind a successor Commitment to another Compass instead.
+cat > commitment.json <<'JSON'
+{
+  "agentId": "<agent-id>",
+  "compassId": "<compass-id>",
+  "title": "Keep p99 under 300 ms",
+  "status": "draft",
+  "target": { "outcome": "p99 API latency stays under 300 ms" }
+}
+JSON
+<%= config.bin %> commitments create --from-json commitment.json --json
+<%= config.bin %> compass commitments <compass-id> --agent <agent-id>   # lists it once it is bound`,
     ];
     static flags = {
-        json: core_1.Flags.boolean({ description: 'Output the created commitment as JSON' }),
+        json: core_1.Flags.boolean({
+            description: 'Output the created commitment as JSON: the commitment itself, not wrapped (commitments show --json puts it under .commitment)',
+        }),
         'from-json': core_1.Flags.string({
-            description: 'JSON file (or "-" for stdin) for fields not exposed as flags. See examples below for daily times, named agent_run keys and zero budgets.',
+            description: `JSON file (or "-" for stdin) for fields not exposed as flags. See examples below for daily times, named agent_run keys, zero budgets and "compassId" (binds a Compass; fixed at creation). ${commitment_attention_copy_1.QUIET_HOURS_HELP} ${commitment_attention_copy_1.EVENT_SOURCES_HELP}`,
         }),
         agent: core_1.Flags.string({ description: 'Agent that owns and watches this commitment (required)' }),
         kind: core_1.Flags.string({
@@ -321,7 +364,7 @@ JSON
             options: [...commitments_1.COMMITMENT_EXECUTION_ISOLATION_MODES],
             hidden: true,
         }),
-        'max-nudges': core_1.Flags.integer({ description: 'Max user nudges per day (0..20)' }),
+        'max-nudges': core_1.Flags.string({ description: commitment_attention_copy_1.MAX_NUDGES_FLAG_HELP }),
         'max-concurrent-runs': core_1.Flags.string({
             description: 'Owner concurrency policy: "unlimited" (default) or 1..100. Finite values require --concurrency-reason and cannot be activated by an autonomous Agent session.',
         }),
@@ -337,7 +380,11 @@ JSON
             // `createBodySchema` is a z.strictObject, so unwrap a `plan --json`
             // envelope and drop any key it does not declare (a contract dumped from
             // `list --json` carries id/version/state/… and would otherwise 400).
-            payload = (0, commitments_1.normalizeCreateBody)(await (0, prompt_1.readJsonBody)(flags['from-json']));
+            const rawBody = await (0, prompt_1.readJsonBody)(flags['from-json']);
+            payload = (0, commitments_1.normalizeCreateBody)(rawBody);
+            const ignoredWarning = (0, commitments_1.ignoredCreateKeysWarning)((0, commitments_1.ignoredCreateKeys)(rawBody));
+            if (ignoredWarning)
+                this.warn(ignoredWarning);
             if (flags.agent)
                 payload.agentId = flags.agent;
             if (flags.kind)
@@ -430,8 +477,9 @@ JSON
                 (0, commitment_product_1.normalizeTaskReviewPolicy)(declaredDelivery.reviewPolicy);
             if (flags.isolation)
                 policy.executionIsolation = flags.isolation;
-            if (flags['max-nudges'] !== undefined)
-                policy.maxUserNudgesPerDay = flags['max-nudges'];
+            const maxNudges = (0, commitment_attention_copy_1.parseMaxNudgesFlag)(flags['max-nudges']);
+            if (maxNudges !== undefined)
+                policy.maxUserNudgesPerDay = maxNudges;
             const concurrencyPatch = (0, commitments_1.commitmentConcurrencyEnvelopePatch)({
                 rawValue: flags['max-concurrent-runs'],
                 reason: flags['concurrency-reason'],
@@ -446,6 +494,9 @@ JSON
             }
             if (Object.keys(policy).length)
                 payload.policy = policy;
+            const quietHoursProblem = (0, commitment_attention_copy_1.quietHoursInputProblem)(policy);
+            if (quietHoursProblem)
+                throw new Error(quietHoursProblem);
             if (payload.createdVia === undefined) {
                 payload.createdVia = process.env.OVERSKY_AUTONOMOUS_SESSION === '1' ? 'agent_cli' : 'cli';
             }
@@ -533,6 +584,12 @@ JSON
         if (activation && !activation.activated) {
             const { refusal } = activation;
             this.warn(`Activation refused (${refusal.code}): ${refusal.reason}`);
+            if (refusal.blockers) {
+                this.warn(`All ${refusal.blockers.length} things blocking it (it stays a draft until each is fixed):`);
+                for (const blocker of refusal.blockers)
+                    this.warn(`  - ${blocker.gate}: ${blocker.reason}`);
+                this.warn(`Details: ${this.config.bin} commitments preflight ${String(commitment?.id)}`);
+            }
             if (refusal.fix)
                 this.warn(`Fix: ${refusal.fix}`);
             if (refusal.guide)

package/dist/commands/commitments/doctor.js

@@ -86,7 +86,9 @@ function spaceLoopLine(value) {
     if (status === 'admitted') {
         detail = loop.principalVersion ? ` (principal v${loop.principalVersion})` : '';
     }
-    return `Space loop: ${status}${loop.spaceId ? ` · ${loop.spaceId}` : ''}${detail}`;
+    // Said in words first, with the code kept in parentheses for anyone who searches by it.
+    const said = status !== 'admitted' && loop.detail ? ` — ${loop.detail}` : '';
+    return `Space loop: ${status}${loop.spaceId ? ` · ${loop.spaceId}` : ''}${said}${detail}`;
 }
 class CommitmentsDoctor extends base_command_1.BaseCommand {
     static description = 'Summarize commitment readiness and the next operator action';

package/dist/commands/commitments/effective-policy.d.ts

@@ -1,5 +1,15 @@
 import { BaseCommand } from '../../base-command';
-export declare function effectivePolicyLines(policy: Record<string, any>): string[];
+/**
+ * `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.
+ */
+export declare function isoWallClock(instant: unknown, timeZone?: string): string | undefined;
+/**
+ * `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.
+ */
+export declare function effectivePolicyLines(policy: Record<string, any>, stored?: Record<string, any> | null): string[];
 /** Show the policy actually governing a Commitment without changing it. */
 export default class CommitmentsEffectivePolicy extends BaseCommand {
     static description: string;

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

@@ -1,23 +1,62 @@
 "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");
+const northstars_1 = require("../../lib/northstars");
 /** 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)');
@@ -33,10 +72,23 @@ function budgetDayLines(policy) {
                 ? 'no ceiling'
                 : `${value}/day`;
         lines.push(`Northstar shared pools: action runs ${pool(shared.actionRunsPerDay, shared.actionRunsPerDayState)} · observation runs ${pool(shared.observationRunsPerDay, shared.observationRunsPerDayState)}`);
+        // A pool below the number of linked active commitments is still handed out at the floor of
+        // 1/day each: the same sentence `northstars governance show` and `review-now` print (OSK-21334).
+        const floorNote = (0, northstars_1.runBudgetFloorNote)(policy.portfolio?.runBudgetFloor);
+        if (floorNote)
+            lines.push(`! ${floorNote}`);
     }
     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 +113,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 +133,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 +180,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/explain.js

@@ -24,13 +24,22 @@ class CommitmentsExplain extends base_command_1.BaseCommand {
         this.requireAuth();
         const { args, flags } = await this.parse(CommitmentsExplain);
         try {
-            const explanation = await commitments_1.commitmentApi.explain(args.commitmentId);
+            // The explanation names neither the bound Compass nor its status, so the text view reads the
+            // Commitment beside it (the read `show` renders). `--json` stays the explanation as the
+            // server sent it, with no extra request. A failed read must not fail the explanation
+            // (OSK-21332): it becomes a "not shown" line instead.
+            const [explanation, read] = await Promise.all([
+                commitments_1.commitmentApi.explain(args.commitmentId),
+                flags.json ? null : commitments_1.commitmentApi.get(args.commitmentId).catch(() => null),
+            ]);
             if (flags.json) {
                 this.log(JSON.stringify(explanation, null, 2));
                 return;
             }
             for (const line of (0, commitments_1.formatCommitmentExplanation)(explanation))
                 this.log(line);
+            for (const line of (0, commitments_1.explainCompassLines)(args.commitmentId, read?.commitment))
+                this.log(line);
         }
         catch (err) {
             this.handleApiError(err);

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

@@ -18,6 +18,20 @@ import { BaseCommand } from '../../base-command';
  * the command body so it can be unit-tested without the oclif harness.
  */
 export declare function formatDroppedFields(droppedFields: string[] | undefined): string[];
+/**
+ * The zone a proposal's daily times will be read in, said before the person applies it (OSK-21336).
+ * The planner is not told a timezone unless `--timezone` is passed, and the proposal is printed as raw JSON,
+ * so "every day at 9am" came back as `times: ["09:00"]` with no zone; applied as it is, a daily cadence with
+ * no zone is read in UTC, while the web wizard writes the browser's zone for the same proposal and says so.
+ * Nothing for a proposal with no daily times.
+ */
+export declare function planTimezoneLines(proposal: {
+    cadence?: {
+        mode?: unknown;
+        times?: unknown;
+        timezone?: unknown;
+    };
+} | null | undefined, requestedTimezone?: string): string[];
 export default class CommitmentsPlan extends BaseCommand {
     static description: string;
     static examples: string[];

package/dist/commands/commitments/plan.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatDroppedFields = formatDroppedFields;
+exports.planTimezoneLines = planTimezoneLines;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const commitments_1 = require("../../lib/commitments");
@@ -36,6 +37,35 @@ function formatDroppedFields(droppedFields) {
         lines.push(`  - ${field}`);
     return lines;
 }
+/**
+ * The zone a proposal's daily times will be read in, said before the person applies it (OSK-21336).
+ * The planner is not told a timezone unless `--timezone` is passed, and the proposal is printed as raw JSON,
+ * so "every day at 9am" came back as `times: ["09:00"]` with no zone; applied as it is, a daily cadence with
+ * no zone is read in UTC, while the web wizard writes the browser's zone for the same proposal and says so.
+ * Nothing for a proposal with no daily times.
+ */
+function planTimezoneLines(proposal, requestedTimezone) {
+    const cadence = proposal?.cadence;
+    if (!cadence || cadence.mode !== 'daily' || !Array.isArray(cadence.times) || !cadence.times.length) {
+        return [];
+    }
+    const times = cadence.times.filter((time) => typeof time === 'string');
+    if (!times.length)
+        return [];
+    const label = `daily time${times.length === 1 ? '' : 's'} ${times.join(', ')}`;
+    if (typeof cadence.timezone === 'string' && cadence.timezone) {
+        return ['', `The ${label} ${times.length === 1 ? 'is' : 'are'} read in ${cadence.timezone}.`];
+    }
+    return [
+        '',
+        `Note: the ${label} ${times.length === 1 ? 'carries' : 'carry'} no timezone, so applying this as it is reads ` +
+            `${times.length === 1 ? 'it' : 'them'} in UTC (the web wizard would use your browser's zone). ` +
+            (requestedTimezone
+                ? `You planned with --timezone ${requestedTimezone}, but the proposal did not keep it: add "timezone": ` +
+                    `"${requestedTimezone}" to its cadence.`
+                : 'Add "timezone": "<IANA zone>" to its cadence, or plan again with --timezone <IANA zone>.'),
+    ];
+}
 class CommitmentsPlan extends base_command_1.BaseCommand {
     static description = 'Draft a commitment contract from a sentence (read-only proposal — nothing is created)';
     static examples = [
@@ -115,6 +145,8 @@ class CommitmentsPlan extends base_command_1.BaseCommand {
             this.log('No proposal produced.');
             return;
         }
+        for (const line of planTimezoneLines(response.proposal, flags.timezone))
+            this.log(line);
         this.log('');
         this.log('Proposed contract:');
         this.log(JSON.stringify(response.proposal, null, 2));

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

@@ -35,7 +35,26 @@ export declare function nextRunsLines(report: {
     verdict?: string;
     nextRuns?: string[];
 }): string[];
-export declare function preflightGateLines(gate: PreflightGate, verbose?: boolean): 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, refusesActivation?: 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[];