@skrr-ai/cli 0.1.104 → 0.1.106

package/dist/lib/commitments.js

@@ -2,11 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.COMMITMENT_CLI_EVALUATORS = exports.COMMITMENT_CREATE_KEYS = exports.COMMITMENT_REMEDIATION_ACTIONS = exports.COMMITMENT_FEEDBACK_KINDS = exports.commitmentApi = exports.commitmentPackApi = exports.MAX_COMMITMENT_INTERVAL_MS = exports.MIN_COMMITMENT_INTERVAL_MS = exports.COMMITMENT_EXECUTION_ISOLATION_MODES = exports.COMMITMENT_AUTHORABLE_CADENCE_MODES = exports.COMMITMENT_KIND_VALUES = exports.COMMITMENT_STATUSES = exports.COMMITMENT_CADENCE_MAX_TIMES = exports.COMMITMENT_CADENCE_TIME_PATTERN = exports.COMMITMENT_CADENCE_MODES = exports.COMMITMENT_TEMPLATE_IDS = exports.COMMITMENT_WATCHED_SOURCES = void 0;
 exports.permissionLines = permissionLines;
+exports.scheduleIssueLines = scheduleIssueLines;
 exports.retiredFieldsLine = retiredFieldsLine;
 exports.readCommitmentAgentDirective = readCommitmentAgentDirective;
 exports.normalizeCreateBody = normalizeCreateBody;
 exports.parseCommitmentConcurrencyLimit = parseCommitmentConcurrencyLimit;
 exports.commitmentConcurrencyEnvelopePatch = commitmentConcurrencyEnvelopePatch;
+exports.describeEvidenceGate = describeEvidenceGate;
 exports.describeCommitmentConcurrency = describeCommitmentConcurrency;
 exports.parseIntervalToMs = parseIntervalToMs;
 exports.normalizeWatchedSourceDeclarations = normalizeWatchedSourceDeclarations;
@@ -14,10 +16,14 @@ exports.buildWatchedSources = buildWatchedSources;
 exports.describeEvidenceHealth = describeEvidenceHealth;
 exports.describeIntervalMs = describeIntervalMs;
 exports.buildSuccessCriteria = buildSuccessCriteria;
+exports.pendingCadenceRequestLines = pendingCadenceRequestLines;
 exports.cadenceLabel = cadenceLabel;
 exports.renderCommitmentList = renderCommitmentList;
 exports.extractStandstillFromCheck = extractStandstillFromCheck;
 exports.describeExecutorBlocked = describeExecutorBlocked;
+exports.describeOperation = describeOperation;
+exports.describeOperationFix = describeOperationFix;
+exports.describeStoppedBy = describeStoppedBy;
 exports.withLiveAssessment = withLiveAssessment;
 exports.renderCommitmentSummary = renderCommitmentSummary;
 exports.describeWakeDecision = describeWakeDecision;
@@ -29,6 +35,7 @@ exports.formatCommitmentCycles = formatCommitmentCycles;
 exports.formatCommitmentExplanation = formatCommitmentExplanation;
 exports.renderListPageHint = renderListPageHint;
 exports.describeObservationArtifacts = describeObservationArtifacts;
+exports.observationLegend = observationLegend;
 exports.renderCommitmentObservations = renderCommitmentObservations;
 exports.renderCommitmentHypotheses = renderCommitmentHypotheses;
 exports.renderCommitmentLineage = renderCommitmentLineage;
@@ -100,6 +107,21 @@ function permissionLines(permissions) {
     }
     return lines;
 }
+/**
+ * The lines `show` prints for a stored schedule setting the engine cannot honour
+ * (OSK-15452): the cadence line above them reads as honoured while the daily times
+ * run on UTC. The sentence and the remedy are the server's; this only lays them out.
+ * An older server reports none, which prints nothing rather than a guess.
+ */
+function scheduleIssueLines(issues) {
+    const lines = [];
+    for (const issue of issues ?? []) {
+        lines.push(`Warning:   ${issue.message}`);
+        if (issue.fix)
+            lines.push(`           Fix: ${issue.fix}`);
+    }
+    return lines;
+}
 /**
  * One line naming fields that are still in the JSON but decide nothing any
  * more. Deprecation, not removal: `--json` keeps them for scripts.
@@ -449,6 +471,17 @@ function commitmentConcurrencyEnvelopePatch({ rawValue, reason, autonomous = pro
         ...(normalizedReason ? { maxConcurrentRunsReason: normalizedReason } : {}),
     };
 }
+/**
+ * What `policy.evidenceGate.requireMaterialEvidenceForAutonomousRun` does to this Commitment's
+ * scheduled runs, in a line `show` can print (OSK-15417). It existed only in `show --json`: nothing
+ * in help, docs or any text view said whether a run on an unchanged day would be held back.
+ */
+function describeEvidenceGate(commitment) {
+    const gate = commitment.policy?.evidenceGate;
+    return gate?.requireMaterialEvidenceForAutonomousRun === true
+        ? 'an autonomous run is held back unless the check found material evidence (a scheduled run on an unchanged day does not start)'
+        : 'off — an autonomous run is not held back for lack of material evidence';
+}
 function describeCommitmentConcurrency(commitment) {
     const envelope = commitment.policy?.executionBudget;
     const limit = envelope?.maxConcurrentRuns;
@@ -657,6 +690,12 @@ function describeEvidenceHealth(health, criteriaCount) {
     if (state === 'degraded_observability') {
         return `degraded_observability${detail} — ${describeDegradedObservability(reasons)}`;
     }
+    if (state === 'awaiting_first_evidence') {
+        // Not stale and not degraded: nothing has been reported yet. The server
+        // only says this while the first run has neither reported nor finished;
+        // after that, seeing nothing is `degraded_observability` again (OSK-16211).
+        return `awaiting_first_evidence${detail} — no evidence yet: the first run is still collecting it`;
+    }
     return `${state}${detail}`;
 }
 /**
@@ -680,6 +719,9 @@ function describeDegradedObservability(reasons) {
     if (has('evidence_stale')) {
         return "the freshest evidence is older than this commitment's freshness expectation";
     }
+    if (has('evidence_awaiting_first_report')) {
+        return 'no evidence yet: the first run has not reported';
+    }
     return 'the last check could not see everything it needs to judge this commitment';
 }
 /** Render an interval back as a compact human string. */
@@ -745,6 +787,29 @@ function buildSuccessCriteria(labels, opts = {}) {
         ...(evaluator === 'source_state' && source ? { config: { source } } : {}),
     }));
 }
+/**
+ * The cadence changes an Agent has proposed and nobody has decided. `cadence-requests decide` needs a request
+ * id, and `show` listed none, so a person could not find the id to pass (OSK-15422).
+ */
+function pendingCadenceRequestLines(commitment) {
+    const state = commitment?.state;
+    const requests = Array.isArray(state?.pendingCadenceRequests) ? state.pendingCadenceRequests : [];
+    const pending = requests.filter((item) => !!item &&
+        typeof item === 'object' &&
+        item.kind === 'cadence_change' &&
+        item.status === 'pending');
+    if (!pending.length)
+        return [];
+    return [
+        'Pending cadence requests (decide with `commitments cadence-requests decide <id> <request-id> --approve|--reject`):',
+        ...pending.map((item) => {
+            const from = item.basis?.intervalMs;
+            const to = item.requestedIntervalMs;
+            const reason = typeof item.reason === 'string' && item.reason ? ` — ${item.reason}` : '';
+            return `  ${String(item.id)}  ${describeIntervalMs(from)} → ${describeIntervalMs(to)}${reason}`;
+        }),
+    ];
+}
 function cadenceLabel(commitment) {
     const cadence = commitment.cadence;
     if (!cadence || !cadence.mode || cadence.mode === 'manual')
@@ -859,6 +924,71 @@ function describeExecutorBlocked(commitment) {
                 : reason || 'blocked';
     return `${label}${until ? ` until ${until}` : ''}`;
 }
+/**
+ * The Operation line's wording for a Commitment that is not running because of its lifecycle.
+ *
+ * The assessment reports `waiting` with reason `lifecycle_<status>` for a Commitment a person
+ * paused, and `show` printed that verbatim ("waiting — lifecycle_paused"): the word "waiting" and a
+ * raw code, indistinguishable from one waiting on a machine or an approval (OSK-15423). Any other
+ * operation and reason is printed as it always was.
+ */
+function describeOperation(operation, reason) {
+    const lifecycle = typeof reason === 'string' ? /^lifecycle_([a-z_]+)$/.exec(reason) : null;
+    if (!lifecycle)
+        return `${operation ?? 'blocked'}${reason ? ` — ${reason}` : ''}`;
+    const status = lifecycle[1];
+    const meaning = {
+        paused: 'paused, it will not run until it is resumed',
+        draft: 'a draft, it will not run until it is activated',
+        archived: 'archived, it will not run',
+        completed: 'completed, it will not run',
+        cancelled: 'cancelled, it will not run',
+    };
+    return `not running — ${meaning[status] ?? status}`;
+}
+/**
+ * What to do about an operation that is not running, from the operating state's
+ * first actionable blocker (`withLiveAssessment` carries it onto the view).
+ *
+ * `show` printed `Operation: blocked — typed_external_blocker` and nothing else,
+ * so the one line a reader acts on was a code; the remediation the server
+ * already composed sat only in `--json` and `doctor` (OSK-16212). Nothing is
+ * printed while the operation is ready or working, where a fix would contradict
+ * the line above it.
+ */
+function describeOperationFix(commitment, operation) {
+    if (operation === 'ready' || operation === 'working')
+        return null;
+    const blocker = commitment.firstActionableBlocker;
+    const remediation = blocker && typeof blocker.remediation === 'string' ? blocker.remediation.trim() : '';
+    if (!remediation)
+        return null;
+    const who = typeof blocker?.ownerLabel === 'string' && blocker.ownerLabel
+        ? blocker.ownerLabel
+        : typeof blocker?.owner === 'string' && blocker.owner
+            ? blocker.owner
+            : '';
+    return `${remediation}${who ? ` (${who})` : ''}`;
+}
+/**
+ * Who stopped a Commitment, and when and why, in one line. The server stores it as `stoppedBy`;
+ * `show` printed neither (OSK-15423), so a Commitment you paused did not say you had.
+ */
+function describeStoppedBy(commitment) {
+    const stoppedBy = commitment.stoppedBy;
+    if (!stoppedBy || typeof stoppedBy !== 'object')
+        return null;
+    const who = stoppedBy.kind === 'user'
+        ? 'a person'
+        : stoppedBy.kind === 'agent'
+            ? 'the Agent'
+            : stoppedBy.kind
+                ? 'the platform'
+                : 'someone';
+    const status = stoppedBy.status || commitment.status || 'stopped';
+    return (`${status} by ${who}${stoppedBy.at ? ` on ${stoppedBy.at}` : ''}` +
+        `${stoppedBy.reason ? `: ${stoppedBy.reason}` : ''}`);
+}
 /**
  * The commitment `show` should render: its stored contract, with the
  * assessment replaced by the one the operating state recomputed for this read
@@ -869,9 +999,30 @@ function describeExecutorBlocked(commitment) {
  */
 function withLiveAssessment(commitment, operatingState) {
     const live = operatingState?.assessment;
-    if (!live || typeof live !== 'object')
-        return commitment;
-    return { ...commitment, assessment: live };
+    // The remediation for a blocked operation lives on the operating state's
+    // first actionable blocker; the header printed only the code (OSK-16212).
+    const blocker = operatingState?.firstActionableBlocker &&
+        typeof operatingState.firstActionableBlocker === 'object'
+        ? { firstActionableBlocker: operatingState.firstActionableBlocker }
+        : {};
+    // The operating state also knows the executor's machine is stopped (`waiting_for_machine`),
+    // which the stored contract never carries; `show` printed neither (OSK-15423).
+    const executorBlocked = !commitment.executorBlocked &&
+        operatingState?.executorBlocked &&
+        typeof operatingState.executorBlocked === 'object'
+        ? { executorBlocked: operatingState.executorBlocked }
+        : {};
+    if (!live || typeof live !== 'object') {
+        return Object.keys(executorBlocked).length + Object.keys(blocker).length > 0
+            ? { ...commitment, ...executorBlocked, ...blocker }
+            : commitment;
+    }
+    return {
+        ...commitment,
+        ...executorBlocked,
+        ...blocker,
+        assessment: live,
+    };
 }
 function renderCommitmentSummary(commitment, log, 
 /**
@@ -879,19 +1030,34 @@ function renderCommitmentSummary(commitment, log,
  * complete / detach / reports render this same summary and hold only the
  * contract — they should not be made to fetch a check to print one line.
  */
-latestCheck) {
+latestCheck, 
+/**
+ * Stored schedule settings the engine cannot honour (OSK-15452), printed directly under the
+ * cadence they affect rather than after the free-text summary at the bottom. Optional for the
+ * same reason as `latestCheck`: only `show` reads them from the server.
+ */
+scheduleIssues) {
     log(`ID:        ${commitment.id ?? '-'}`);
     log(`Title:     ${commitment.title ?? '-'}`);
     log(`Kind:      ${commitment.kind ?? 'achieve'}`);
     log(`Status:    ${commitment.status ?? '-'}`);
+    const stopped = describeStoppedBy(commitment);
+    if (commitment.status !== 'active' && stopped)
+        log(`Stopped:   ${stopped}`);
     log(`Agent:     ${commitment.agentId ?? '-'}`);
     // A commitment whose executor cannot run anywhere should say so on the
     // header, not as a silent skip series — "executor cannot run until <date> —
     // reassign or add a fallback target" (design doc P4).
     const executorBlocked = describeExecutorBlocked(commitment);
     if (executorBlocked) {
-        log(`Executor:  blocked — ${executorBlocked}`);
-        log(`           Fix: reassign with \`skrr commitments handover ${commitment.id ?? '<id>'} --to <agent>\` or add a fallback target`);
+        // A stopped machine is started for the work: that is waiting, not blocked, and reassigning the
+        // Commitment is not its remedy (OSK-15423).
+        const machineWait = commitment.executorBlocked?.reason ===
+            'waiting_for_machine';
+        log(`Executor:  ${machineWait ? 'waiting' : 'blocked'} — ${executorBlocked}`);
+        if (!machineWait) {
+            log(`           Fix: reassign with \`skrr commitments handover ${commitment.id ?? '<id>'} --to <agent>\` or add a fallback target`);
+        }
     }
     if (commitment.goalId)
         log(`Goal:      ${commitment.goalId}`);
@@ -902,8 +1068,11 @@ latestCheck) {
     if (commitment.target?.deadlineAt)
         log(`Deadline:  ${commitment.target.deadlineAt}`);
     log(`Cadence:   ${cadenceLabel(commitment)}`);
+    for (const line of scheduleIssueLines(scheduleIssues))
+        log(line);
     log(`Delivery:  ${(0, commitment_product_1.deliveryLabel)(commitment.delivery?.mode)}${commitment.delivery?.repo ? ` · ${commitment.delivery.repo}` : ''}${commitment.delivery?.baseBranch ? ` → ${commitment.delivery.baseBranch}` : ''}`);
     log(`Concurrency: ${describeCommitmentConcurrency(commitment)}`);
+    log(`Evidence gate: ${describeEvidenceGate(commitment)}`);
     const criteria = commitment.target?.successCriteria || [];
     const evidenceHealth = latestCheck?.inputs?.evidenceHealth;
     const evidenceLine = describeEvidenceHealth(evidenceHealth, criteria.length);
@@ -912,7 +1081,10 @@ latestCheck) {
         : undefined;
     log(`Assessment: ${assessment?.label ?? 'Unknown'}`);
     log(`Evidence:   ${assessment?.evidence ?? 'unavailable'}`);
-    log(`Operation:  ${assessment?.operation ?? 'blocked'}${assessment?.operationReason ? ` — ${assessment.operationReason}` : ''}`);
+    log(`Operation:  ${describeOperation(assessment?.operation, assessment?.operationReason)}`);
+    const fix = describeOperationFix(commitment, assessment?.operation);
+    if (fix)
+        log(`            Fix: ${fix}`);
     if (commitment.state?.lastCheckedAt)
         log(`Checked:   ${commitment.state.lastCheckedAt}`);
     if (typeof commitment.state?.consecutiveUnresolvedChecks === 'number') {
@@ -1553,6 +1725,32 @@ function describeObservationArtifacts(artifacts) {
         .map((name) => `${counts.get(name)} ${name}`)
         .join(', ');
 }
+/** The VALUE column's width in `renderCommitmentObservations`, which `observationLegend` checks against. */
+const OBSERVATION_VALUE_WIDTH = 38;
+/**
+ * What the observations table's terse columns mean, for the rows actually on screen (OSK-15432).
+ *
+ * The table shortens VALUE to fit with `…`, so a reading cut by the screen looked the same as one
+ * the platform truncated; `undeclared` / `DECLARED no` and CLAMPED were defined nowhere. Only the
+ * terms present in THESE rows are explained, so an ordinary table adds nothing.
+ */
+function observationLegend(data) {
+    const lines = [];
+    const shortened = data.some((item) => (0, format_1.formatCell)(firstValue(item, ['value', 'observedValue', 'latestValue'])).length >
+        OBSERVATION_VALUE_WIDTH);
+    if (shortened) {
+        lines.push('VALUE is shortened to fit this table (…); the stored value is complete in --json.');
+    }
+    if (data.some((item) => item.declared === false)) {
+        lines.push('DECLARED no / REASON undeclared: the key is not declared on this Commitment’s agent_run ' +
+            'source, so the reading is recorded but can never open a loop.');
+    }
+    if (data.some((item) => item.observedAtClamped === true)) {
+        lines.push('CLAMPED yes: the observed time the run claimed was moved into the accepted window; ' +
+            'CLAIMED shows what it said.');
+    }
+    return lines;
+}
 function renderCommitmentObservations(response, log, options = {}) {
     const data = records(response.data);
     renderRows(data.map((item) => ({
@@ -1590,7 +1788,7 @@ function renderCommitmentObservations(response, log, options = {}) {
         { key: 'model', header: 'MODEL', maxWidth: 40 },
         { key: 'modelSource', header: 'MODEL SOURCE', maxWidth: 18 },
         { key: 'key', header: 'KEY', maxWidth: 30 },
-        { key: 'value', header: 'VALUE', maxWidth: 38 },
+        { key: 'value', header: 'VALUE', maxWidth: OBSERVATION_VALUE_WIDTH },
         { key: 'changed', header: 'CHANGED', maxWidth: 8 },
         { key: 'reason', header: 'REASON', maxWidth: 20 },
         { key: 'reference', header: 'REFERENCE', maxWidth: 80 },
@@ -1599,6 +1797,8 @@ function renderCommitmentObservations(response, log, options = {}) {
         { key: 'confidence', header: 'CONF', maxWidth: 6 },
         { key: 'artifacts', header: 'ARTIFACTS', maxWidth: 36 },
     ], options.emptyMessage || 'No observations recorded.', log);
+    for (const line of observationLegend(data))
+        log(line);
 }
 /** Human view for causal hypotheses. */
 function renderCommitmentHypotheses(response, log, options = {}) {

package/dist/lib/delegated-cli.js

@@ -50,6 +50,7 @@ const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const auth_core_1 = require("@skrr-ai/auth-core");
+const cli_handoff_wire_1 = require("@skrr-ai/auth-core/cli-handoff-wire");
 const loopback_http_1 = require("@skrr-ai/auth-core/loopback-http");
 function isDelegatedCliSession(env = process.env) {
     return Boolean(env.OVERSKY_AUTONOMOUS_SESSION === '1' &&
@@ -237,9 +238,17 @@ class DelegatedCliUnavailableError extends Error {
         this.upstreamCode = fields.upstreamCode;
         this.upstreamReason = fields.upstreamReason;
         this.retryAt = fields.retryAt;
+        // OSK-16216 — an older daemon names no remedy. The fallback is the SAME
+        // shared sentence a current daemon sends, with nothing filled in: this
+        // process cannot tell whether the desktop app or a `skrrd install` runs
+        // the daemon, and `skrr daemon login` alone is wrong for the first.
         this.remedy =
             fields.remedy ??
-                (fields.retryable ? undefined : 'run `skrr daemon login` on the machine running the daemon');
+                (fields.retryable
+                    ? undefined
+                    : (0, cli_handoff_wire_1.daemonSignInRemedy)({
+                        repinsDeviceKey: fields.upstreamCode === 'DEVICE_PROOF_PIN_MISMATCH',
+                    }));
     }
 }
 exports.DelegatedCliUnavailableError = DelegatedCliUnavailableError;
@@ -321,7 +330,9 @@ async function fetchDelegatedCliCredential(env = process.env, options = {}) {
                 throw new DelegatedCliUnavailableError(typeof body?.message === 'string' && body.message
                     ? `the daemon's delegated CLI broker could not mint a credential: ${body.message}`
                     : `the skrr server refused the daemon's request for this session's credential (${named}).`, {
-                    ...(typeof body?.upstreamStatus === 'number' ? { upstreamStatus: body.upstreamStatus } : {}),
+                    ...(typeof body?.upstreamStatus === 'number'
+                        ? { upstreamStatus: body.upstreamStatus }
+                        : {}),
                     ...(typeof body?.upstreamCode === 'string' ? { upstreamCode: body.upstreamCode } : {}),
                     ...(typeof body?.upstreamReason === 'string'
                         ? { upstreamReason: body.upstreamReason }

package/dist/lib/followups.d.ts

@@ -1,6 +1,12 @@
 import { withQuery } from './triggers';
 type Query = Parameters<typeof withQuery>[1];
 type Json = Record<string, unknown>;
+/**
+ * Check a `--in` / `--at` value against the bound the server enforces, before the round trip, and
+ * name the FLAG the user typed. The server's message names its own field (`in`, `once.runAt`) and,
+ * for a duration, used to give the bound in raw seconds (OSK-15415). Null when it is acceptable.
+ */
+export declare function whenFlagProblem(flag: 'in' | 'at', value: string | undefined): string | null;
 /**
  * The line a settle verb prints. A follow-up that had already ended is said to
  * have ended, with the terminal it actually has, rather than reported as the

package/dist/lib/followups.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.followupsApi = exports.FOLLOWUP_SUBJECT_FLAG_HELP = exports.FOLLOWUP_SUBJECT_EXTERNAL_KEY_RE = exports.WATCH_WAIT_KINDS = exports.FOLLOWUP_RESOLVE_OUTCOMES = exports.FOLLOWUP_STATES = exports.FOLLOWUP_KINDS = exports.followUpIdArg = void 0;
+exports.whenFlagProblem = whenFlagProblem;
 exports.settledLine = settledLine;
 exports.recipeWatchBoundsRefusal = recipeWatchBoundsRefusal;
 exports.resolveFollowUpAgent = resolveFollowUpAgent;
@@ -28,6 +29,17 @@ const triggers_1 = require("./triggers");
 const agent_resolver_1 = require("./agent-resolver");
 const MOUNT = '/api/followups';
 const base = (id) => `${MOUNT}/${encodeURIComponent(id)}`;
+/**
+ * Check a `--in` / `--at` value against the bound the server enforces, before the round trip, and
+ * name the FLAG the user typed. The server's message names its own field (`in`, `once.runAt`) and,
+ * for a duration, used to give the bound in raw seconds (OSK-15415). Null when it is acceptable.
+ */
+function whenFlagProblem(flag, value) {
+    if (value === undefined)
+        return null;
+    const refusal = (0, data_provider_1.validateFollowUpWhen)(value, `--${flag}`);
+    return refusal ? refusal.message : null;
+}
 /**
  * The line a settle verb prints. A follow-up that had already ended is said to
  * have ended, with the terminal it actually has, rather than reported as the

package/dist/lib/message-content.d.ts

@@ -11,6 +11,12 @@
  * join them with a paragraph break, and non-text parts (tool calls, images,
  * think blocks) are skipped the same way the `--json` response omits them.
  *
+ * A widget part (CSS, HTML and JavaScript an app draws in a frame) is a block of
+ * its fallback sentence: a terminal cannot draw it, the markup is never printed,
+ * and skipping it like the other non-text parts dropped the sentence from every
+ * message that also had text. A cut-off widget contributes nothing, as it does in
+ * the stored `text`.
+ *
  * Falls back to the flattened `text` string when a message carries no
  * structured content — user messages and historical rows never have it.
  */

package/dist/lib/message-content.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.messageTextBlocks = messageTextBlocks;
+const data_provider_1 = require("@skrr-ai/data-provider");
 /**
  * Flatten a conversation message's assistant `content[]` parts into readable
  * display blocks.
@@ -14,6 +15,12 @@ exports.messageTextBlocks = messageTextBlocks;
  * join them with a paragraph break, and non-text parts (tool calls, images,
  * think blocks) are skipped the same way the `--json` response omits them.
  *
+ * A widget part (CSS, HTML and JavaScript an app draws in a frame) is a block of
+ * its fallback sentence: a terminal cannot draw it, the markup is never printed,
+ * and skipping it like the other non-text parts dropped the sentence from every
+ * message that also had text. A cut-off widget contributes nothing, as it does in
+ * the stored `text`.
+ *
  * Falls back to the flattened `text` string when a message carries no
  * structured content — user messages and historical rows never have it.
  */
@@ -43,6 +50,9 @@ function textOfPart(part) {
         return '';
     }
     const p = part;
+    if (p.type === data_provider_1.UI_WIDGET_PART_TYPE) {
+        return widgetFallback(p[data_provider_1.UI_WIDGET_PART_TYPE]);
+    }
     if (typeof p.type === 'string' && p.type !== 'text') {
         return '';
     }
@@ -58,3 +68,17 @@ function textOfPart(part) {
     }
     return '';
 }
+/** The sentence that stands for a complete widget part, or `''` (never any of its markup). */
+function widgetFallback(widget) {
+    if (!widget || typeof widget !== 'object') {
+        return '';
+    }
+    const w = widget;
+    if (w.complete === false) {
+        return '';
+    }
+    return (0, data_provider_1.uiWidgetFallbackText)({
+        title: typeof w.title === 'string' ? w.title : undefined,
+        fallbackText: typeof w.fallbackText === 'string' ? w.fallbackText : undefined,
+    });
+}

package/dist/lib/operating-plan-loops.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The operating plan's planning loops, named (OSK-15416). The text view printed only
+ * "15 existing planning/reflection loops; 0 scheduled work blocks": a count that grew as follow-ups
+ * were armed and did not drop when they were cancelled (a cancelled loop stays in the list, disabled),
+ * and never said which wake was due when. The server already projects `enabled`, `status` and
+ * `nextAt` for each loop; only --json showed them.
+ */
+export declare function planningLoopLines(loops: unknown, todoCount: number): string[];

package/dist/lib/operating-plan-loops.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * The operating plan's planning loops, named (OSK-15416). The text view printed only
+ * "15 existing planning/reflection loops; 0 scheduled work blocks": a count that grew as follow-ups
+ * were armed and did not drop when they were cancelled (a cancelled loop stays in the list, disabled),
+ * and never said which wake was due when. The server already projects `enabled`, `status` and
+ * `nextAt` for each loop; only --json showed them.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planningLoopLines = planningLoopLines;
+const SHOWN = 10;
+function planningLoopLines(loops, todoCount) {
+    const all = (Array.isArray(loops) ? loops : []);
+    const armed = all.filter((loop) => loop.enabled !== false);
+    const disabled = all.length - armed.length;
+    const lines = [
+        '',
+        `${armed.length} armed planning/reflection loop${armed.length === 1 ? '' : 's'}` +
+            `${disabled > 0 ? ` (${disabled} more disabled or cancelled, not counted)` : ''}; ` +
+            `${todoCount} scheduled work block${todoCount === 1 ? '' : 's'}.`,
+    ];
+    // Soonest first; a loop with no due time (an event wait, unknown) after the dated ones.
+    const ordered = [...armed].sort((a, b) => (a.nextAt || '9999').localeCompare(b.nextAt || '9999'));
+    for (const loop of ordered.slice(0, SHOWN)) {
+        lines.push(`  ${loop.nextAt ?? '(no due time)'} · ${loop.label ?? 'Scheduled work'} · ` +
+            `${loop.kind ?? '-'} · ${loop.status ?? '-'} · ${loop.id ?? '-'}`);
+    }
+    if (ordered.length > SHOWN) {
+        lines.push(`  … and ${ordered.length - SHOWN} more armed (all of them in --json).`);
+    }
+    return lines;
+}

package/dist/lib/preflight-copy.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Plain-words sentences for two preflight gates whose verdicts used to be a bare `warn` (OSK-15425).
+ *
+ * "When is silence a problem?" printed only that freshness is advisory, with the reason
+ * (`evidence_unconfigured`) left in --json, so a reader could not tell whether silence would ever be
+ * flagged. "Where does its access come from?" printed no sentence at all. A credential whose expiry
+ * had passed read `stale`.
+ */
+type GateLike = {
+    id?: string;
+    verdict?: string;
+    reason?: string | null;
+    detail?: Record<string, unknown> | null;
+};
+/** The refusal as `code: words`, or the bare code when it is not one this knows. */
+export declare function sourceRefusalWords(code: string): string;
+/** Extra lines under a gate, or none. The gate's own note is printed by the caller. */
+export declare function gateExplanationLines(gate: GateLike): string[];
+/**
+ * The status word for a capability. A credential whose expiry has passed is `expired`, not the
+ * storage word `stale`, which gave no sign that time had run out.
+ */
+export declare function capabilityStatusLabel(capability: {
+    status?: string;
+    expiresAt?: string | null;
+}, now?: Date): string;
+export {};

package/dist/lib/preflight-copy.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Plain-words sentences for two preflight gates whose verdicts used to be a bare `warn` (OSK-15425).
+ *
+ * "When is silence a problem?" printed only that freshness is advisory, with the reason
+ * (`evidence_unconfigured`) left in --json, so a reader could not tell whether silence would ever be
+ * flagged. "Where does its access come from?" printed no sentence at all. A credential whose expiry
+ * had passed read `stale`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sourceRefusalWords = sourceRefusalWords;
+exports.gateExplanationLines = gateExplanationLines;
+exports.capabilityStatusLabel = capabilityStatusLabel;
+/** What a refused event-source code means, in words. An unknown code is printed as it is. */
+const SOURCE_REFUSAL_WORDS = {
+    source_authorization_descriptor_invalid: 'authorization record incomplete (it names no id to check access against)',
+    source_binding_detached: 'no longer matches a source attached to this Commitment',
+    source_access_revoked: 'access refused',
+    source_access_unavailable: 'access could not be checked just now',
+};
+/** The refusal as `code: words`, or the bare code when it is not one this knows. */
+function sourceRefusalWords(code) {
+    const words = SOURCE_REFUSAL_WORDS[code];
+    return words ? `${code}: ${words}` : code;
+}
+function sourceRefusalLine(row) {
+    const id = row.refId
+        ? `${row.selector ?? 'id'} ${row.refId}`
+        : `no ${row.selector ?? 'id'} given`;
+    const why = row.reason ? (SOURCE_REFUSAL_WORDS[row.reason] ?? row.reason) : 'access was refused';
+    return `Source ${row.source ?? 'unknown'} (${id}): ${why}.`;
+}
+/** Extra lines under a gate, or none. The gate's own note is printed by the caller. */
+function gateExplanationLines(gate) {
+    if (gate.verdict === 'pass')
+        return [];
+    if (gate.id === 'freshness') {
+        switch (gate.reason) {
+            case 'evidence_unconfigured':
+                return [
+                    'No freshness expectation is set, so nothing will flag this Commitment’s evidence as stale or silent.',
+                ];
+            case 'evidence_stale': {
+                const criteria = Array.isArray(gate.detail?.criteria)
+                    ? gate.detail.criteria
+                    : [];
+                const observed = criteria
+                    .filter((item) => item.evidence === 'stale' && item.observedAt)
+                    .map((item) => String(item.observedAt))
+                    .sort();
+                return [
+                    observed.length > 0
+                        ? `Its evidence is stale; the oldest reading is from ${observed[0]}.`
+                        : 'Its evidence is stale.',
+                ];
+            }
+            case 'evidence_partial':
+                return ['Only part of its evidence is current.'];
+            case 'evidence_unavailable':
+                return ['No evidence could be read just now, so freshness cannot be judged.'];
+            default:
+                return [];
+        }
+    }
+    // The gate carries the sources it checked; its reason alone is a bare code naming none of them.
+    if (gate.id === 'source_access') {
+        const rows = Array.isArray(gate.detail?.sources) ? gate.detail.sources : [];
+        return rows.filter((row) => row.access && row.access !== 'authorized').map(sourceRefusalLine);
+    }
+    if (gate.id === 'access' && gate.reason === 'capability_access_unverified') {
+        return [
+            'No access beyond an identity check is verified as available yet (see “Where access comes from” below).',
+        ];
+    }
+    return [];
+}
+/**
+ * The status word for a capability. A credential whose expiry has passed is `expired`, not the
+ * storage word `stale`, which gave no sign that time had run out.
+ */
+function capabilityStatusLabel(capability, now = new Date()) {
+    const status = capability.status ?? 'unknown';
+    if (status === 'stale' && capability.expiresAt) {
+        const expires = Date.parse(capability.expiresAt);
+        if (!Number.isNaN(expires) && expires <= now.getTime())
+            return 'expired';
+    }
+    return status;
+}

package/dist/lib/proposal-decision-command.d.ts

@@ -6,7 +6,7 @@ export declare abstract class ProposalDecisionCommand extends BaseCommand {
     static decision: ProposalDecision;
     static args: {
         kind: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
-        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        id: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;