@skrr-ai/cli 0.1.103 → 0.1.105

package/dist/lib/commitment-ledgers.d.ts

@@ -0,0 +1,9 @@
+export declare function renderActionHistory(page: {
+    data?: unknown[];
+    has_more?: boolean;
+    next_cursor?: string | null;
+} | undefined, log: (line: string) => void): void;
+export declare function renderReflection(review: Record<string, unknown> | undefined, log: (line: string) => void): void;
+export declare function renderCadenceDecisions(list: {
+    data?: unknown[];
+} | undefined, log: (line: string) => void): void;

package/dist/lib/commitment-ledgers.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderActionHistory = renderActionHistory;
+exports.renderReflection = renderReflection;
+exports.renderCadenceDecisions = renderCadenceDecisions;
+/**
+ * Human views for three Commitment read commands that printed raw JSON without `--json`
+ * (OSK-15435): `action-history`, `reflection` and `cadence-decisions`. `--json` is unchanged; these
+ * only replace the default. An empty ledger is a sentence, not `"data": []`.
+ */
+const format_1 = require("./format");
+const commitments_1 = require("./commitments");
+const text = (value, fallback = '-') => typeof value === 'string' && value.trim()
+    ? value
+    : typeof value === 'number'
+        ? String(value)
+        : fallback;
+/** First sentence-ish chunk of a message, bounded, so a table row stays a row. */
+function brief(value, max = 80) {
+    const raw = text(value, '');
+    if (!raw)
+        return '';
+    const firstLine = raw.split('\n')[0];
+    return firstLine.length > max ? `${firstLine.slice(0, max - 1)}…` : firstLine;
+}
+function minutes(ms) {
+    if (typeof ms !== 'number' || !Number.isFinite(ms))
+        return '-';
+    const m = Math.round(ms / 60000);
+    if (m >= 1440 && m % 1440 === 0)
+        return `${m / 1440}d`;
+    if (m >= 60 && m % 60 === 0)
+        return `${m / 60}h`;
+    return `${m}m`;
+}
+function renderActionHistory(page, log) {
+    const rows = (Array.isArray(page?.data) ? page.data : []);
+    if (rows.length === 0) {
+        log('No actions recorded.');
+    }
+    else {
+        (0, format_1.renderTable)(rows.map((row) => ({
+            when: text(row.occurredAt),
+            type: text(row.type),
+            status: text(row.status),
+            check: text(row.checkId),
+            // A failed or refused action's reason is the point of reading history.
+            why: [text(row.errorCode, ''), brief(row.errorMessage ?? row.reason)]
+                .filter(Boolean)
+                .join(' · '),
+        })), [
+            { key: 'when', header: 'WHEN' },
+            { key: 'type', header: 'ACTION' },
+            { key: 'status', header: 'STATUS' },
+            { key: 'check', header: 'CHECK' },
+            { key: 'why', header: 'WHY', maxWidth: 100 },
+        ], log);
+    }
+    (0, commitments_1.renderListPageHint)(page, log);
+}
+function renderReflection(review, log) {
+    const metrics = (review?.metrics ?? {});
+    const proposals = Array.isArray(review?.proposals) ? review.proposals : [];
+    if (proposals.length === 0) {
+        log('No reflection proposals recorded.');
+    }
+    else {
+        log(`Reflection proposals: ${text(metrics.total, String(proposals.length))} total · ` +
+            `${text(metrics.awaitingApproval, '0')} awaiting approval · ${text(metrics.applied, '0')} applied · ` +
+            `${text(metrics.rejected, '0')} rejected · ${text(metrics.failed, '0')} failed`);
+    }
+    if (review?.lastReflectionAt)
+        log(`Last reflection: ${text(review.lastReflectionAt)}`);
+    const held = Array.isArray(review?.activeProposalKeys)
+        ? review.activeProposalKeys
+        : [];
+    if (held.length > 0)
+        log(`Held proposal keys: ${held.map((key) => text(key)).join(', ')}`);
+    if (proposals.length === 0)
+        return;
+    (0, format_1.renderTable)(proposals.map((row) => {
+        const proposal = (row.proposal ?? {});
+        const decision = (row.decision ?? {});
+        return {
+            when: text(row.occurredAt),
+            status: text(row.status),
+            type: text(proposal.type),
+            subject: brief(proposal.subject, 60),
+            decision: [text(decision.decision, ''), brief(decision.reason, 50)]
+                .filter(Boolean)
+                .join(' · '),
+            check: text(row.checkId),
+        };
+    }), [
+        { key: 'when', header: 'WHEN' },
+        { key: 'status', header: 'STATUS' },
+        { key: 'type', header: 'TYPE' },
+        { key: 'subject', header: 'SUBJECT', maxWidth: 60 },
+        { key: 'decision', header: 'DECISION', maxWidth: 70 },
+        { key: 'check', header: 'CHECK' },
+    ], log);
+}
+function renderCadenceDecisions(list, log) {
+    const rows = (Array.isArray(list?.data) ? list.data : []);
+    if (rows.length === 0) {
+        log('No cadence decisions recorded.');
+        return;
+    }
+    (0, format_1.renderTable)(rows.map((row) => ({
+        when: text(row.decidedAt),
+        mode: text(row.mode),
+        disposition: text(row.disposition),
+        direction: text(row.direction),
+        interval: `${minutes(row.currentIntervalMs)} → ${minutes(row.candidateIntervalMs)}`,
+        confidence: typeof row.confidence === 'number' ? row.confidence.toFixed(2) : '-',
+        reason: brief(row.reason, 70),
+    })), [
+        { key: 'when', header: 'DECIDED' },
+        { key: 'mode', header: 'MODE' },
+        { key: 'disposition', header: 'DISPOSITION' },
+        { key: 'direction', header: 'DIRECTION' },
+        { key: 'interval', header: 'INTERVAL' },
+        { key: 'confidence', header: 'CONFIDENCE' },
+        { key: 'reason', header: 'REASON', maxWidth: 70 },
+    ], log);
+}

package/dist/lib/commitments.d.ts

@@ -18,7 +18,7 @@ import { type CommitmentObservationsQuery, type CommitmentObservationsResponse }
  * "hold this state", derived from a Compass invariant — not authored here).
  */
 import { COMMITMENT_WATCHED_SOURCES, COMMITMENT_TEMPLATE_IDS, COMMITMENT_CADENCE_MODES, COMMITMENT_CADENCE_TIME_PATTERN, COMMITMENT_CADENCE_MAX_TIMES, COMMITMENT_EXECUTION_ISOLATION_MODES, COMMITMENT_STATUSES, COMMITMENT_KIND_VALUES } from '@skrr-ai/data-provider';
-import type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentActionProposal, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink, CommitmentExecutionReceiptListResponse, CommitmentExecutionReceiptQuarterlyMetricsResponse, CommitmentCapabilitySource, CommitmentDeliveryPatchResponse, CommitmentDeliveryBundleResponse, CommitmentCyclesResponse, CommitmentExplanationResponse, CommitmentRunPermissions, CommitmentLoopStatus, CommitmentRoster } from '@skrr-ai/data-provider';
+import type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentActionProposal, CommitmentListResponse, CommitmentPlanResponse, CommitmentScheduleIssue, CommitmentStatusResponse, CommitmentWorkLink, CommitmentExecutionReceiptListResponse, CommitmentExecutionReceiptQuarterlyMetricsResponse, CommitmentCapabilitySource, CommitmentDeliveryPatchResponse, CommitmentDeliveryBundleResponse, CommitmentCyclesResponse, CommitmentExplanationResponse, CommitmentRunPermissions, CommitmentLoopStatus, CommitmentRoster } from '@skrr-ai/data-provider';
 import { withQuery } from './triggers';
 export { COMMITMENT_WATCHED_SOURCES, COMMITMENT_TEMPLATE_IDS, COMMITMENT_CADENCE_MODES, COMMITMENT_CADENCE_TIME_PATTERN, COMMITMENT_CADENCE_MAX_TIMES, COMMITMENT_STATUSES, COMMITMENT_KIND_VALUES, };
 export type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentActionProposal, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink, };
@@ -105,6 +105,13 @@ export type CommitmentPreflightReport = {
  * report it) prints nothing rather than a guess.
  */
 export declare function permissionLines(permissions: CommitmentRunPermissions | null | undefined): string[];
+/**
+ * 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.
+ */
+export declare function scheduleIssueLines(issues: CommitmentScheduleIssue[] | null | undefined): string[];
 /**
  * One line naming fields that are still in the JSON but decide nothing any
  * more. Deprecation, not removal: `--json` keeps them for scripts.
@@ -568,6 +575,36 @@ export interface CommitmentCostWindow {
     unavailableRunCount?: number;
     costStatus?: 'reported' | 'partial' | 'unavailable' | 'not_applicable';
 }
+/**
+ * The event-wake block of a Commitment's trigger status (`eventCapabilities`), as the server sends
+ * it. Rendered by `eventWakeLines` for both `trigger-status` and `wake-capabilities`.
+ */
+export type EventWakeCapabilities = {
+    requested?: boolean;
+    configuredSources?: string[];
+    eligibleSources?: string[];
+    materializedSources?: string[];
+    dormantSources?: string[];
+    unroutableSources?: {
+        source?: string;
+        reason?: string;
+    }[];
+    /** Sources whose upstream producer was positively verified to route events here. */
+    verifiedSources?: string[];
+    /** Sources whose upstream could not be read: "cannot see", never "fine" (OSK-16209). */
+    unverifiedSources?: {
+        source?: string;
+        reason?: string;
+    }[];
+    permissionGaps?: {
+        source?: string;
+        permission?: string;
+        capability?: string;
+        events?: string[];
+        impact?: string;
+    }[];
+    degradedReason?: string;
+};
 /** Shape of `GET /:id/wake-capabilities`. */
 export interface CommitmentWakeCapabilities {
     eligibleCapabilities: Array<{
@@ -580,6 +617,17 @@ export interface CommitmentWakeCapabilities {
         kind?: string;
         source?: string;
     }>;
+    /**
+     * The event-wake facts `trigger-status` reports, verbatim, plus the Agent's own enabled event
+     * waits. Absent from a server that predates it, or when the status could not be read: "no
+     * statement", never "nothing is bound".
+     */
+    standingEventWakes?: {
+        commitmentStatus: string;
+        cadenceMode?: string;
+        eventCapabilities: EventWakeCapabilities;
+        agentChosenEventWaits: number;
+    } | null;
 }
 /** One-tap check feedback. `handled` means "I dealt with it", not "good nudge". */
 export declare const COMMITMENT_FEEDBACK_KINDS: readonly ["useful", "noisy", "wrong", "handled"];
@@ -624,6 +672,12 @@ export declare function commitmentConcurrencyEnvelopePatch({ rawValue, reason, a
     reason?: string;
     autonomous?: boolean;
 }): Record<string, unknown> | undefined;
+/**
+ * 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.
+ */
+export declare function describeEvidenceGate(commitment: CommitmentView): string;
 export declare function describeCommitmentConcurrency(commitment: CommitmentView): string;
 export declare function parseIntervalToMs(input: string): number;
 /**
@@ -699,6 +753,11 @@ export declare function buildSuccessCriteria(labels: string[], opts?: {
     measureId?: string;
     source?: string;
 }): SuccessCriterionInput[];
+/**
+ * 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).
+ */
+export declare function pendingCadenceRequestLines(commitment: unknown): string[];
 export declare function cadenceLabel(commitment: CommitmentView): string;
 export declare function renderCommitmentList(commitments: CommitmentView[], log: (line: string) => void): void;
 /**
@@ -741,6 +800,31 @@ export declare function extractStandstillFromCheck(check?: {
  * null rather than printing a guess.
  */
 export declare function describeExecutorBlocked(commitment: CommitmentView): string | null;
+/**
+ * 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.
+ */
+export declare function describeOperation(operation: string | null | undefined, reason: string | null | undefined): string;
+/**
+ * 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.
+ */
+export declare function describeOperationFix(commitment: CommitmentView, operation: string | null | undefined): string | null;
+/**
+ * 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.
+ */
+export declare function describeStoppedBy(commitment: CommitmentView): string | null;
 /**
  * The commitment `show` should render: its stored contract, with the
  * assessment replaced by the one the operating state recomputed for this read
@@ -751,6 +835,8 @@ export declare function describeExecutorBlocked(commitment: CommitmentView): str
  */
 export declare function withLiveAssessment(commitment: CommitmentView, operatingState?: {
     assessment?: unknown;
+    executorBlocked?: unknown;
+    firstActionableBlocker?: unknown;
 } | null): CommitmentView;
 export declare function renderCommitmentSummary(commitment: CommitmentView, log: (line: string) => void, 
 /**
@@ -765,7 +851,13 @@ latestCheck?: {
     decision?: {
         policyTrace?: Array<Record<string, unknown>>;
     } | null;
-} | null): void;
+} | null, 
+/**
+ * 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?: CommitmentScheduleIssue[] | null): void;
 /**
  * Whether a check woke the agent, in plain words (OSK-4884).
  *
@@ -820,6 +912,14 @@ export declare function renderListPageHint(page: {
  * `other`. `--json` carries each artifact's `ref`, `locator` and `originalRef`.
  */
 export declare function describeObservationArtifacts(artifacts: unknown): string;
+/**
+ * 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.
+ */
+export declare function observationLegend(data: ReadModelRecord[]): string[];
 export declare function renderCommitmentObservations(response: ReadModelRecord, log: (line: string) => void, options?: {
     emptyMessage?: string;
 }): void;

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 = {}) {