@skrr-ai/cli 0.1.46 → 0.1.48

package/dist/lib/commitments.js

@@ -1,6 +1,6 @@
 "use strict";
 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_AUTONOMY_MODES = exports.COMMITMENT_AUTONOMY_MODES = exports.COMMITMENT_STATUSES = exports.COMMITMENT_AUTHORABLE_CADENCE_MODES = 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.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_AUTONOMY_MODES = exports.COMMITMENT_AUTONOMY_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.storedAutonomyModeForAuthoring = storedAutonomyModeForAuthoring;
 exports.authoringAutonomyModeForStored = authoringAutonomyModeForStored;
 exports.commitmentAutonomyLabel = commitmentAutonomyLabel;
@@ -12,6 +12,7 @@ exports.describeCommitmentConcurrency = describeCommitmentConcurrency;
 exports.parseIntervalToMs = parseIntervalToMs;
 exports.buildWatchedSources = buildWatchedSources;
 exports.describeEvidenceHealth = describeEvidenceHealth;
+exports.describeStalledHealth = describeStalledHealth;
 exports.describeIntervalMs = describeIntervalMs;
 exports.buildSuccessCriteria = buildSuccessCriteria;
 exports.cadenceLabel = cadenceLabel;
@@ -25,10 +26,15 @@ exports.describeWakeDecision = describeWakeDecision;
 exports.renderCheckList = renderCheckList;
 exports.renderCommitmentLedger = renderCommitmentLedger;
 exports.renderCommitmentTrace = renderCommitmentTrace;
+exports.renderListPageHint = renderListPageHint;
 exports.renderCommitmentObservations = renderCommitmentObservations;
 exports.renderCommitmentHypotheses = renderCommitmentHypotheses;
 exports.renderCommitmentLineage = renderCommitmentLineage;
 exports.renderCommitmentMetrics = renderCommitmentMetrics;
+exports.renderCommitmentCases = renderCommitmentCases;
+exports.renderCommitmentCaseDetail = renderCommitmentCaseDetail;
+exports.renderCommitmentRemediationProposals = renderCommitmentRemediationProposals;
+exports.renderCommitmentRemediationProposal = renderCommitmentRemediationProposal;
 /**
  * commitments.ts — request-based client for the Commitments subsystem
  * (`/api/commitments/*`).
@@ -55,6 +61,8 @@ Object.defineProperty(exports, "COMMITMENT_CADENCE_TIME_PATTERN", { enumerable:
 Object.defineProperty(exports, "COMMITMENT_CADENCE_MAX_TIMES", { enumerable: true, get: function () { return data_provider_1.COMMITMENT_CADENCE_MAX_TIMES; } });
 Object.defineProperty(exports, "COMMITMENT_AUTONOMY_MODES", { enumerable: true, get: function () { return data_provider_1.COMMITMENT_AUTONOMY_MODES; } });
 Object.defineProperty(exports, "COMMITMENT_EXECUTION_ISOLATION_MODES", { enumerable: true, get: function () { return data_provider_1.COMMITMENT_EXECUTION_ISOLATION_MODES; } });
+Object.defineProperty(exports, "COMMITMENT_STATUSES", { enumerable: true, get: function () { return data_provider_1.COMMITMENT_STATUSES; } });
+Object.defineProperty(exports, "COMMITMENT_KIND_VALUES", { enumerable: true, get: function () { return data_provider_1.COMMITMENT_KIND_VALUES; } });
 const commitment_product_1 = require("./commitment-product");
 const instruction_input_1 = require("./instruction-input");
 const format_1 = require("./format");
@@ -62,22 +70,6 @@ const triggers_1 = require("./triggers");
 /** Derived from the installed compatibility vocabulary so the CLI remains
  * safe even while data-provider and CLI packages roll out separately. */
 exports.COMMITMENT_AUTHORABLE_CADENCE_MODES = data_provider_1.COMMITMENT_CADENCE_MODES.filter((mode) => mode !== 'sampled');
-/**
- * oclif's `options:` needs runtime arrays, but data-provider models these two as
- * union TYPES only. The values live here — and both directions of drift are a
- * COMPILE error: `satisfies` rejects an invalid or extra value, and the
- * `_Exhaustive*` guards fail to resolve if a canonical value is missing.
- */
-exports.COMMITMENT_STATUSES = [
-    'draft',
-    'active',
-    'paused',
-    'completed',
-    'cancelled',
-    'archived',
-];
-const _statusDriftGuard = true;
-void _statusDriftGuard;
 exports.COMMITMENT_AUTHORABLE_AUTONOMY_MODES = ['monitor', 'prepare', 'execute'];
 function storedAutonomyModeForAuthoring(mode) {
     if (mode === 'monitor')
@@ -139,6 +131,11 @@ exports.commitmentApi = {
      * anything failing.
      */
     list: (query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)('/api/commitments', query)),
+    /**
+     * Fleet-level liveness sweep health (OSK-10958): when the reconciler last
+     * swept, how stale that is, and the tally it last persisted. Aggregate only.
+     */
+    livenessSweep: () => data_provider_1.request.get('/api/commitments/liveness/sweep'),
     manifest: (id) => data_provider_1.request.get(`${base(id)}/manifest`),
     import: (body) => data_provider_1.request.post('/api/commitments/import', body),
     fork: (id, body) => data_provider_1.request.post(`${base(id)}/fork`, body),
@@ -154,8 +151,8 @@ exports.commitmentApi = {
     detachWorkLink: (id, linkId) => data_provider_1.request.delete(`${base(id)}/links/${encodeURIComponent(linkId)}`),
     plan: (body) => data_provider_1.request.post('/api/commitments/plan', body),
     checkNow: (id) => data_provider_1.request.post(`${base(id)}/check-now`, {}),
-    checks: (id, limit) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/checks`, { limit })),
-    actionHistory: (id, limit) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/action-history`, { limit })),
+    checks: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/checks`, query)),
+    actionHistory: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/action-history`, query)),
     actionProposals: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/action-proposals`, query)),
     /**
      * Propose a prepared action for a check.
@@ -192,7 +189,7 @@ exports.commitmentApi = {
     autonomy: (id, body) => data_provider_1.request.post(`${base(id)}/autonomy`, body),
     mode: (id, body) => data_provider_1.request.post(`${base(id)}/mode`, body),
     delivery: (id, body) => data_provider_1.request.post(`${base(id)}/delivery`, body),
-    receipts: (id, limit = 1) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/receipts`, { limit })),
+    receipts: (id, query = 1) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/receipts`, typeof query === 'number' ? { limit: query } : query)),
     receiptQuarterlyMetrics: (id, year, quarter) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/receipt-metrics/quarterly`, { year, quarter })),
     deliveryPatch: (id, taskId) => data_provider_1.request.get(`${base(id)}/delivery/${encodeURIComponent(taskId)}/patch`),
     deliveryBundle: (id, taskId) => data_provider_1.request.get(`${base(id)}/delivery/${encodeURIComponent(taskId)}/bundle`),
@@ -228,12 +225,53 @@ exports.commitmentApi = {
      * reference it stay resolvable. Refused for an active or system-managed
      * commitment — see CommitmentControl.deleteCommitment.
      */
-    remove: (id, reason) => data_provider_1.request.delete((0, triggers_1.withQuery)(base(id), reason ? { reason } : {})),
+    remove: (id, reason, opts = {}) => data_provider_1.request.delete((0, triggers_1.withQuery)(base(id), {
+        ...(reason ? { reason } : {}),
+        // Only sent when the caller actually decided. Omitting it is what makes
+        // the server ask rather than guess when there is open work.
+        ...(opts.stopOpenWork === undefined ? {} : { stopOpenWork: String(opts.stopOpenWork) }),
+    })),
+    /** What a delete would leave behind. Read-only. */
+    deletionPreview: (id) => data_provider_1.request.get(`${base(id)}/deletion-preview`),
+    /** Un-delete. Returns the Commitment PAUSED, never active. */
+    restore: (id) => data_provider_1.request.post(`${base(id)}/restore`, {}),
     trace: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/trace`, query)),
     ledger: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/ledger`, query)),
     wakeCapabilities: (id) => data_provider_1.request.get(`${base(id)}/wake-capabilities`),
-    dailyMetrics: (id, limit) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/daily-metrics`, { limit })),
+    dailyMetrics: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/daily-metrics`, query)),
     cadenceDecisions: (id, limit) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/cadence-decisions`, { limit })),
+    /**
+     * What the NEXT check would decide, computed without taking it.
+     *
+     * Every other read on this object is retrospective. This one stops at the
+     * DecisionEnvelope → Arbiter boundary — no Check row, no budget debit, no
+     * delivery gate, no contract write — so it is the only way to answer "what is
+     * this commitment about to do" before it does it. Worth its own command for
+     * the same reason `trigger-status` is: when a commitment is about to nudge
+     * somebody and nobody can say why, the posture and its policy trail are the
+     * answer, and re-running a real check to find out changes the thing you are
+     * trying to observe.
+     */
+    nextTick: (id) => data_provider_1.request.get(`${base(id)}/next-tick`),
+    /**
+     * The accounting SHADOW readout behind allowance accounting.
+     *
+     * WORKSPACE-scoped despite hanging off one commitment's id: it aggregates
+     * every closed daily metric in the workspace, because the question it answers
+     * is "does this workspace have enough closed evidence to activate" rather than
+     * "what has this commitment spent". `cost` is the per-commitment question.
+     */
+    accountingReadout: (id) => data_provider_1.request.get(`${base(id)}/accounting-readout`),
+    /**
+     * Closed-period spend for ONE commitment over a UTC day window.
+     *
+     * `costStatus` is the load-bearing field, not the dollar figure: `partial` and
+     * `unavailable` mean some runs carried no cost attribution at all, so the
+     * number understates the spend and a caller that printed it bare would be
+     * quietly wrong. The server refuses a window that is not on UTC day
+     * boundaries, so the caller builds one rather than passing a wall-clock time.
+     */
+    cost: (id, window) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/cost`, window)),
     /**
      * What this commitment's RUNS claim to have seen (agent-as-sensor).
      *
@@ -565,6 +603,45 @@ function describeEvidenceHealth(health, criteriaCount) {
     }
     return `${state}${detail}`;
 }
+/**
+ * Why a commitment is `stalled`, in the reconciler's own words.
+ *
+ * These clauses are the CLI voicing of the `details` table in
+ * `CommitmentLivenessReconciler.alertCopy` — an operator who gets the alert
+ * ("<name> is stalled — its expected checks are no longer arriving") and then
+ * runs `commitments show` must read the same sentence, or the two surfaces look
+ * like two different problems.
+ *
+ * `contract_version_mismatch` has no entry there because it is not a diagnosis;
+ * the reconciler synthesises it when the running contract is fenced behind the
+ * authored one. It still reaches `state.liveness.diagnosisKind`, so it needs a
+ * clause here or the one case with an obvious fix prints bare.
+ */
+const STALLED_DIAGNOSES = {
+    scheduler_stalled: 'its expected checks are no longer arriving',
+    work_failing: 'every recent run reached the agent and failed while doing the work',
+    observation_unreadable: 'the latest check could not read every configured source',
+    execution_budget_exhausted: 'recent planned work was skipped — the execution budget is exhausted',
+    no_advancement: 'no server-recorded advancement exists inside the declared window',
+    contract_version_mismatch: 'the running contract is older than the authored one; its triggers have not resynced',
+};
+/**
+ * `stalled` is a verdict, not a reason. Printed bare it reads like `unknown`
+ * with a harsher word, and the operator's next move is to go and read run
+ * history to find what the reconciler had already decided. Returns undefined
+ * for every other health value, including `unknown` — "nobody has judged" has
+ * no diagnosis to name.
+ */
+function describeStalledHealth(commitment) {
+    if (commitment.state?.health !== 'stalled')
+        return undefined;
+    const liveness = (commitment.state?.liveness || {});
+    const kind = typeof liveness.diagnosisKind === 'string' ? liveness.diagnosisKind : undefined;
+    const clause = (kind && STALLED_DIAGNOSES[kind]) ||
+        'this loop has stopped producing; the reconciler did not record which check failed';
+    const since = typeof liveness.unhealthySinceAt === 'string' ? ` (since ${liveness.unhealthySinceAt})` : '';
+    return `${clause}${since}`;
+}
 /** Render an interval back as a compact human string. */
 function describeIntervalMs(ms) {
     if (!ms || !Number.isFinite(ms))
@@ -801,8 +878,6 @@ latestCheck) {
     if (commitment.target?.deadlineAt)
         log(`Deadline:  ${commitment.target.deadlineAt}`);
     log(`Cadence:   ${cadenceLabel(commitment)}`);
-    if (commitment.cadence?.nextCheckAt)
-        log(`Next check:${` ${commitment.cadence.nextCheckAt}`}`);
     log(`Mode:      ${describeAutonomyLine(commitment, latestCheck)}`);
     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)}`);
@@ -810,9 +885,13 @@ latestCheck) {
     const evidenceHealth = latestCheck?.inputs?.evidenceHealth;
     const evidenceLine = describeEvidenceHealth(evidenceHealth, criteria.length);
     const health = commitment.state?.health ?? 'unknown';
-    const healthExplanation = health === 'unknown' && evidenceHealth?.state === 'unevidenceable_criteria'
+    const unevidenceableExplanation = health === 'unknown' && evidenceHealth?.state === 'unevidenceable_criteria'
         ? ' — evidence cannot establish a positive health verdict as configured'
         : '';
+    // The two explanations are mutually exclusive by construction: one only fires
+    // on `unknown`, the other only on `stalled`.
+    const stalledExplanation = describeStalledHealth(commitment);
+    const healthExplanation = unevidenceableExplanation || (stalledExplanation ? ` — ${stalledExplanation}` : '');
     log(`Health:    ${health}${healthExplanation}`);
     if (commitment.state?.lastCheckedAt)
         log(`Checked:   ${commitment.state.lastCheckedAt}`);
@@ -850,6 +929,15 @@ latestCheck) {
         .map((s) => s.source);
     if (sources.length)
         log(`Watching:  ${sources.join(', ')}`);
+    // The executor-rebind audit trail was recorded but never rendered — after a
+    // handover, `show` still read as if the original agent had always run it
+    // (OSK-10963).
+    const handovers = commitment.executorHandovers || [];
+    if (handovers.length) {
+        const latest = handovers[handovers.length - 1];
+        const from = latest.fromAgentId ? `${latest.fromAgentId} → ` : '';
+        log(`Handovers: ${handovers.length} (last: ${from}${latest.toAgentId} at ${latest.at instanceof Date ? latest.at.toISOString() : text(latest.at)})`);
+    }
     // Whether the criteria below can be EVIDENCED at all.
     //
     // Without this an author reads `Health: at_risk` beside five criteria and has
@@ -1015,7 +1103,9 @@ function renderCommitmentLedger(ledger, log) {
         renderRows(checks.map((item) => {
             const decision = record(item.decision);
             return {
-                started: text(firstValue(item, ['startedAt', 'createdAt'])),
+                // `startedAt` is the reservation instant — it can precede queuedAt.
+                // `claimedAt` is when a worker actually began the check (OSK-11441).
+                started: text(firstValue(item, ['claimedAt', 'startedAt', 'createdAt'])),
                 status: text(item.status),
                 posture: text(decision?.posture),
                 loops: count(item.openLoops),
@@ -1051,6 +1141,23 @@ function renderCommitmentLedger(ledger, log) {
     if (wakeState) {
         log(`Wake state: ${wakeState.dirty === true ? 'pending' : 'clean'} (${text(wakeState.processedRev, '0')}/${text(wakeState.wakeRev, '0')} revisions processed)`);
     }
+    const auditTrail = records(ledger.auditTrail);
+    if (auditTrail.length) {
+        log('Audit trail:');
+        renderRows(auditTrail.map((item) => ({
+            at: text(item.occurredAt),
+            change: text(item.changeType),
+            actor: text(firstValue(item, ['actorAgentId', 'actorUserId'])),
+            status: `${text(item.previousStatus, '-')}→${text(item.nextStatus, '-')}`,
+            reason: text(item.reason, ''),
+        })), [
+            { key: 'at', header: 'AT', maxWidth: 24 },
+            { key: 'change', header: 'CHANGE', maxWidth: 28 },
+            { key: 'actor', header: 'ACTOR', maxWidth: 24 },
+            { key: 'status', header: 'STATUS' },
+            { key: 'reason', header: 'REASON', maxWidth: 40 },
+        ], 'No audit events recorded.', log);
+    }
 }
 /** Human view for the ordered commitment trace. */
 function renderCommitmentTrace(trace, log) {
@@ -1070,6 +1177,15 @@ function renderCommitmentTrace(trace, log) {
         log(`More events are available; continue with --cursor ${text(trace.next_cursor)}.`);
     }
 }
+/**
+ * Print the continuation hint for a paged `object:'list'` response — the line
+ * that makes history beyond the newest page reachable instead of invisible.
+ */
+function renderListPageHint(page, log) {
+    if (page?.has_more === true && page.next_cursor) {
+        log(`More rows are available; continue with --cursor ${text(page.next_cursor)}.`);
+    }
+}
 /** Human view for run-reported observations. */
 /**
  * Yes/no for a server-owned boolean verdict.
@@ -1085,7 +1201,7 @@ function yesNo(value) {
         return 'no';
     return '-';
 }
-function renderCommitmentObservations(response, log) {
+function renderCommitmentObservations(response, log, options = {}) {
     const data = records(response.data);
     renderRows(data.map((item) => ({
         at: text(firstValue(item, ['observedAt', 'createdAt', 'updatedAt'])),
@@ -1108,10 +1224,10 @@ function renderCommitmentObservations(response, log) {
         { key: 'declared', header: 'DECLARED', maxWidth: 9 },
         { key: 'access', header: 'ACCESS', maxWidth: 13 },
         { key: 'confidence', header: 'CONF', maxWidth: 6 },
-    ], 'No observations recorded.', log);
+    ], options.emptyMessage || 'No observations recorded.', log);
 }
 /** Human view for causal hypotheses. */
-function renderCommitmentHypotheses(response, log) {
+function renderCommitmentHypotheses(response, log, options = {}) {
     const data = records(response.data);
     renderRows(data.map((item) => ({
         // `proposedAt` is the domain's own "when was this recorded". Rendering
@@ -1124,19 +1240,38 @@ function renderCommitmentHypotheses(response, log) {
         // `observation_key` means the SERVER can settle this from a declared
         // observation cursor with no model call; `agent_check` means only a run
         // can. That is the whole point of the falsifiability constraint, so it
-        // belongs on the list. (A hypothesis carries no `confidence` — that is an
+        // belongs on the list — and for a key-bound falsifier the column names
+        // WHICH key settles it, because `observation_key` alone hides the
+        // difference between a real check and a degraded self-certification
+        // (OSK-10954). (A hypothesis carries no `confidence` — that is an
         // observation concept — so the column that read it was always empty.)
-        falsifier: text(record(item.falsifier)?.kind),
+        falsifier: describeFalsifier(item.falsifier),
         authority: text(item.authority),
         episode: (0, format_1.formatCell)(item.episode),
     })), [
         { key: 'at', header: 'RECORDED', maxWidth: 24 },
         { key: 'status', header: 'STATUS', maxWidth: 12 },
         { key: 'claim', header: 'CLAIM', maxWidth: 62 },
-        { key: 'falsifier', header: 'FALSIFIER', maxWidth: 16 },
+        { key: 'falsifier', header: 'FALSIFIER', maxWidth: 26 },
         { key: 'authority', header: 'AUTHORITY', maxWidth: 18 },
         { key: 'episode', header: 'EP', maxWidth: 4 },
-    ], 'No hypotheses recorded.', log);
+    ], options.emptyMessage || 'No hypotheses recorded.', log);
+}
+/**
+ * One falsifier rendered as what settles the claim, not just its kind.
+ *
+ * `observation_key` names the declared key the server settles from;
+ * `agent_check` stays the literal kind — the claim can only be settled by the
+ * same agent that proposed it, and the column should keep saying so.
+ */
+function describeFalsifier(falsifier) {
+    const f = record(falsifier);
+    if (!f)
+        return '-';
+    if (f.kind === 'observation_key' && typeof f.observationKey === 'string') {
+        return `key:${f.observationKey}`;
+    }
+    return text(f.kind);
 }
 function renderLineageRows(label, value, log) {
     const rows = records(value);
@@ -1146,10 +1281,14 @@ function renderLineageRows(label, value, log) {
     renderRows(rows.map((item) => ({
         id: text(item.id),
         status: text(item.status),
+        // Goal rows carry `linkedVia` — which link store(s) own the edge — so
+        // `links list` and this view can be reconciled by eye (OSK-10960).
+        via: Array.isArray(item.linkedVia) ? item.linkedVia.join('+') : '',
         summary: text(firstValue(item, ['title', 'summary', 'kind', 'reason']), ''),
     })), [
         { key: 'id', header: 'ID', verbatim: true },
         { key: 'status', header: 'STATUS', maxWidth: 16 },
+        { key: 'via', header: 'VIA', maxWidth: 24 },
         { key: 'summary', header: 'SUMMARY', maxWidth: 72 },
     ], `No ${label.toLowerCase()} recorded.`, log);
 }
@@ -1194,3 +1333,131 @@ function renderCommitmentMetrics(response, log) {
         { key: 'sources', header: 'SOURCES', maxWidth: 48 },
     ], 'No daily metrics recorded.', log);
 }
+/** Human view for the case list — one row per durable problem case. */
+function renderCommitmentCases(response, log) {
+    const data = records(response.data);
+    renderRows(data.map((item) => ({
+        id: text(item.id),
+        status: text(item.status),
+        severity: text(item.severity),
+        subject: text(firstValue(item, ['subjectKey', 'kind']), ''),
+        facts: text(item.factCount, '0'),
+        hypotheses: text(item.hypothesisCount, '0'),
+        receipts: text(item.receiptCount, '0'),
+        last: text(firstValue(item, ['lastObservedAt', 'updatedAt'])),
+    })), [
+        { key: 'id', header: 'ID', verbatim: true },
+        { key: 'status', header: 'STATUS', maxWidth: 12 },
+        { key: 'severity', header: 'SEV', maxWidth: 8 },
+        { key: 'subject', header: 'SUBJECT', maxWidth: 44 },
+        { key: 'facts', header: 'FACTS', maxWidth: 6 },
+        { key: 'hypotheses', header: 'HYPO', maxWidth: 6 },
+        { key: 'receipts', header: 'RCPTS', maxWidth: 6 },
+        { key: 'last', header: 'LAST OBSERVED', maxWidth: 24 },
+    ], 'No cases recorded.', log);
+}
+/**
+ * Human view for one case — a bounded digest, never the raw document.
+ *
+ * A case accumulates factRefs, hypothesisRefs, actionRefs, and receipts with
+ * no per-case bound, and the route projects the whole thing again as `trace`.
+ * Printing the payload verbatim produced a 93k-line dump for a single case
+ * (OSK-10952); the summary counts and the most recent entries answer "what is
+ * this case and what happened last" in one screen, and `--json` stays the
+ * opt-in for the full document.
+ */
+function renderCommitmentCaseDetail(response, log, options = {}) {
+    const data = record(response.data);
+    if (!data) {
+        log('Case not found.');
+        return;
+    }
+    const maxEntries = options.maxEntries ?? 10;
+    log(`Case:      ${text(data.id)} (${text(data.status)})`);
+    log(`Subject:   ${text(data.subjectKey, '-')} · kind ${text(data.kind, '-')}`);
+    log(`Severity:  ${text(data.severity, '-')} · revision ${text(data.caseRevision, '-')} · epoch ${text(data.activeEpoch, '-')}`);
+    log(`Detected:  ${text(data.firstDetectedAt, '-')} · last observed ${text(data.lastObservedAt, '-')}`);
+    log(`Contents:  ${text(data.factCount, '0')} facts · ${text(data.hypothesisCount, '0')} hypotheses · ${text(data.actionCount, '0')} actions · ${text(data.receiptCount, '0')} receipts`);
+    const verification = record(data.verification);
+    if (verification) {
+        log(`Verification: ${text(verification.verdict, '-')}${verification.reason ? ` — ${text(verification.reason)}` : ''}`);
+    }
+    const resolution = record(data.resolution);
+    if (resolution)
+        log(`Resolution: ${text(resolution.kind, '-')} at ${text(resolution.at, '-')}`);
+    const facts = records(data.factRefs);
+    if (facts.length) {
+        const shown = facts.slice(-maxEntries);
+        log('');
+        log(`Latest facts (${shown.length} of ${facts.length}):`);
+        for (const fact of shown) {
+            const label = text(firstValue(fact, ['kind', 'adapter']), 'fact');
+            log(`  - ${text(firstValue(fact, ['occurredAt', 'observedAt']))} ${label} ${text(fact.subjectKey, '')} ${text(fact.trust, '')}`.trimEnd());
+        }
+        if (facts.length > shown.length)
+            log(`  … ${facts.length - shown.length} earlier facts — use --json for the full document`);
+    }
+    const receipts = records(data.receipts);
+    if (receipts.length) {
+        const shown = receipts.slice(-maxEntries);
+        log('');
+        log(`Latest receipts (${shown.length} of ${receipts.length}):`);
+        for (const receipt of shown) {
+            const transition = receipt.from || receipt.to
+                ? ` ${text(receipt.from, 'new')} → ${text(receipt.to, '-')}`
+                : '';
+            log(`  - ${text(receipt.at)} ${text(receipt.kind, 'receipt')}${transition}`);
+        }
+        if (receipts.length > shown.length)
+            log(`  … ${receipts.length - shown.length} earlier receipts — use --json for the full document`);
+    }
+}
+/** Human view for the remediation-proposal list. */
+function renderCommitmentRemediationProposals(response, log) {
+    const advisory = record(response.executionAdvisory);
+    if (advisory)
+        log(`Advisory:  ${text(advisory.code, '-')} — ${text(advisory.message, '')}`);
+    const data = records(response.data);
+    renderRows(data.map((item) => ({
+        id: text(item.id),
+        status: text(item.status),
+        case: text(item.caseId),
+        rev: text(item.caseRevision),
+        action: text(item.actionKind),
+        risk: text(item.riskLevel),
+        expires: text(item.expiresAt),
+    })), [
+        { key: 'id', header: 'ID', verbatim: true },
+        { key: 'status', header: 'STATUS', maxWidth: 12 },
+        { key: 'case', header: 'CASE', maxWidth: 30 },
+        { key: 'rev', header: 'REV', maxWidth: 4 },
+        { key: 'action', header: 'ACTION', maxWidth: 22 },
+        { key: 'risk', header: 'RISK', maxWidth: 8 },
+        { key: 'expires', header: 'EXPIRES', maxWidth: 24 },
+    ], 'No remediation proposals recorded.', log);
+}
+/** Human view for one frozen remediation proposal. */
+function renderCommitmentRemediationProposal(response, log) {
+    const proposal = record(response.proposal) || record(response.data) || response;
+    log(`Proposal:  ${text(proposal.id)} (${text(proposal.status)})`);
+    log(`Case:      ${text(proposal.caseId, '-')} · revision ${text(proposal.caseRevision, '-')}`);
+    log(`Action:    ${text(proposal.actionKind, '-')} · risk ${text(proposal.riskLevel, '-')}`);
+    const action = record(proposal.actionSnapshot) || record(proposal.action);
+    if (action?.title)
+        log(`Title:     ${text(action.title)}`);
+    if (proposal.expiresAt)
+        log(`Expires:   ${text(proposal.expiresAt)}`);
+    const advisory = record(response.executionAdvisory);
+    if (advisory)
+        log(`Advisory:  ${text(advisory.code, '-')} — ${text(advisory.message, '')}`);
+    const lifecycle = records(proposal.lifecycle);
+    if (lifecycle.length) {
+        log('Lifecycle:');
+        for (const entry of lifecycle.slice(-10)) {
+            const what = text(entry.status ?? entry.event ?? entry.kind, '-');
+            const reason = entry.reason ? ` — ${text(entry.reason)}` : '';
+            log(`  - ${text(entry.at)} ${what}${reason} ${text(entry.actorUserId ?? entry.by, '')}`.trimEnd());
+        }
+    }
+    log('Full detail: re-run with --json');
+}

package/dist/lib/dedicated-lease-command.js

@@ -210,6 +210,16 @@ class DedicatedLeaseCommand extends base_command_1.BaseCommand {
             return;
         }
         this.log(`Dedicated Runtime ${id || 'unknown'} ${(0, dedicated_machines_1.dedicatedLeaseState)(lease)}.`);
+        // Whether the machine paused its work and saved the workspace before this
+        // ran. Printed for every settled outcome, in the same register as the line
+        // above: a clean checkpoint and one the operation gave up waiting for are
+        // both policy-conforming, and printing only the second would make the
+        // line's presence the alarm — and teach a reader that silence means a
+        // checkpoint was taken. `requested` is the operation still asking, which is
+        // what a call without --wait sees, and it has nothing to report yet.
+        const checkpoint = (0, dedicated_machines_1.describeDedicatedCheckpoint)(lease);
+        if (checkpoint && !checkpoint.pending)
+            this.log(checkpoint.sentence);
         if (!flags.wait && goal && id) {
             this.log(`The operation continues in the background. Watch it with \`${this.config.bin} machines dedicated show ${id}\`, or pass --wait.`);
         }

package/dist/lib/dedicated-machines.d.ts

@@ -1,3 +1,5 @@
+import { type MachineCheckpointDescription } from '@skrr-ai/data-provider';
+import type { DedicatedRuntimeSignInStatus } from '@skrr-ai/data-provider';
 import type { Harness, HarnessLease } from './harnesses';
 export type DedicatedLeaseAction = 'start' | 'stop' | 'restart' | 'update-image' | 'snapshot' | 'health-check';
 export declare const DEDICATED_LEASE_ACTIONS: DedicatedLeaseAction[];
@@ -84,7 +86,23 @@ export interface DedicatedLeaseOperation {
     status?: 'in_progress' | 'succeeded' | 'failed' | 'cancelled';
     startedAt?: string | null;
     completedAt?: string | null;
+    /**
+     * Whether the machine paused its work and saved the workspace for THIS
+     * operation. Null for an action that never asks (`start`, `grow`, a create)
+     * and from a server that predates the field — which is why the renderer says
+     * nothing rather than guessing a clean checkpoint. The vocabulary is
+     * `@skrr-ai/data-provider`'s (`MachineCheckpointOutcome`); it is typed as a
+     * plain string here so a value a newer server ships still reaches the
+     * fallback copy instead of failing to parse.
+     */
+    checkpoint?: string | null;
 }
+/**
+ * What an operation's guest checkpoint says, or null when the lease records
+ * none. One line, because the copy — and the judgement that this is a plain
+ * fact and not a warning — lives once in `@skrr-ai/data-provider`.
+ */
+export declare function describeDedicatedCheckpoint(lease: DedicatedLease | undefined | null): MachineCheckpointDescription | null;
 /**
  * A Dedicated Runtime's root image, as the server judges it (D11). The platform
  * owns the image: a machine on an older one moves onto the current image at its
@@ -339,6 +357,25 @@ export declare const DEDICATED_EXEC_DEFAULT_TIMEOUT_MS: number;
  * command twice is two intents even when the text is identical.
  */
 export declare function execDedicatedRuntime(leaseId: string, input: DedicatedRuntimeExecInput, scope?: DedicatedRuntimeScope): Promise<DedicatedRuntimeExecResult>;
+export interface DedicatedRuntimeSignInStatusResponse {
+    statuses: DedicatedRuntimeSignInStatus[];
+    /** When the machine was asked, not when this row was cached. */
+    checkedAt: string;
+}
+/**
+ * `GET /api/machines/dedicated/:leaseId/sign-in-status` — is this machine
+ * signed in to gh, Claude Code and Codex?
+ *
+ * Its own endpoint rather than a caller of `exec`, for the reason recorded
+ * beside the route: before it, the only way to find out was to START a sign-in
+ * against a credential that was already fine (OSK-10795). Read-only on the
+ * guest — three `… status` subcommands, no writes, no tokens read back.
+ *
+ * The vocabulary (`DedicatedRuntimeSignInStatus`, its states, the probe and its
+ * parser) is OWNED by `@skrr-ai/data-provider` and re-exported here. A second
+ * declaration is how a surface drifts from the server that answers it.
+ */
+export declare function getDedicatedRuntimeSignInStatus(leaseId: string, scope?: DedicatedRuntimeScope): Promise<DedicatedRuntimeSignInStatusResponse>;
 export type DedicatedRuntimeExecutionState = 'running' | 'completed' | 'failed' | 'unknown';
 /** A started command, as `GET .../executions/:id` reports it. */
 export interface DedicatedRuntimeExecution {

package/dist/lib/dedicated-machines.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEDICATED_FILE_MAX_BYTES = exports.DEDICATED_FILE_CHUNK_BYTES = exports.DEDICATED_EXEC_DEFAULT_TIMEOUT_MS = exports.DEDICATED_EXEC_MAX_TIMEOUT_MS = exports.DEDICATED_MACHINE_PRODUCT = exports.DEDICATED_LEASE_ACTIONS = void 0;
+exports.describeDedicatedCheckpoint = describeDedicatedCheckpoint;
 exports.describeDedicatedImageStanding = describeDedicatedImageStanding;
 exports.dedicatedRuntimeCreateInput = dedicatedRuntimeCreateInput;
 exports.isDedicatedRepositoryRef = isDedicatedRepositoryRef;
@@ -16,6 +17,7 @@ exports.setDedicatedRuntimeSpendingLimit = setDedicatedRuntimeSpendingLimit;
 exports.closeDedicatedRuntimeIncidentHold = closeDedicatedRuntimeIncidentHold;
 exports.destroyDedicatedRuntime = destroyDedicatedRuntime;
 exports.execDedicatedRuntime = execDedicatedRuntime;
+exports.getDedicatedRuntimeSignInStatus = getDedicatedRuntimeSignInStatus;
 exports.startDedicatedRuntimeExecution = startDedicatedRuntimeExecution;
 exports.observeDedicatedRuntimeExecution = observeDedicatedRuntimeExecution;
 exports.readDedicatedRuntimeFileChunk = readDedicatedRuntimeFileChunk;
@@ -46,6 +48,7 @@ exports.dedicatedRuntimeApiErrorCode = dedicatedRuntimeApiErrorCode;
 exports.dedicatedRuntimeApiErrorDetails = dedicatedRuntimeApiErrorDetails;
 exports.formatDedicatedRuntimeApiError = formatDedicatedRuntimeApiError;
 const auth_core_1 = require("@skrr-ai/auth-core");
+const data_provider_1 = require("@skrr-ai/data-provider");
 const api_fetch_1 = require("./api-fetch");
 const edge_error_page_1 = require("./edge-error-page");
 const harnesses_1 = require("./harnesses");
@@ -58,6 +61,17 @@ exports.DEDICATED_LEASE_ACTIONS = [
     'health-check',
 ];
 exports.DEDICATED_MACHINE_PRODUCT = 'dedicated-machine';
+/**
+ * What an operation's guest checkpoint says, or null when the lease records
+ * none. One line, because the copy — and the judgement that this is a plain
+ * fact and not a warning — lives once in `@skrr-ai/data-provider`.
+ */
+function describeDedicatedCheckpoint(lease) {
+    const operation = lease?.operation;
+    if (!operation)
+        return null;
+    return (0, data_provider_1.describeMachineCheckpointOutcome)(operation.checkpoint, { action: operation.action });
+}
 /** One line saying where a machine's image stands and what the owner can do. */
 function describeDedicatedImageStanding(image, leaseId) {
     const last = image.lastUpdate;
@@ -304,6 +318,22 @@ async function execDedicatedRuntime(leaseId, input, scope = {}) {
         },
     });
 }
+/**
+ * `GET /api/machines/dedicated/:leaseId/sign-in-status` — is this machine
+ * signed in to gh, Claude Code and Codex?
+ *
+ * Its own endpoint rather than a caller of `exec`, for the reason recorded
+ * beside the route: before it, the only way to find out was to START a sign-in
+ * against a credential that was already fine (OSK-10795). Read-only on the
+ * guest — three `… status` subcommands, no writes, no tokens read back.
+ *
+ * The vocabulary (`DedicatedRuntimeSignInStatus`, its states, the probe and its
+ * parser) is OWNED by `@skrr-ai/data-provider` and re-exported here. A second
+ * declaration is how a surface drifts from the server that answers it.
+ */
+async function getDedicatedRuntimeSignInStatus(leaseId, scope = {}) {
+    return (0, api_fetch_1.apiFetch)(withDedicatedScope(`/api/machines/dedicated/${encodeURIComponent(leaseId)}/sign-in-status`, scope));
+}
 /**
  * Start one command. `requestId` is the idempotency key: the same id, for the
  * same command on the same lease, returns the execution it already started —
@@ -586,6 +616,23 @@ function describeDedicatedLease(lease, harnesses = []) {
     if (hold?.status === 'open') {
         row('incident', `hold open since ${hold.heldAt || '?'} — the failed source volume is billed until \`incident-close\``);
     }
+    // The lease's last (or current) operation, and — the reason this row exists —
+    // whether the machine saved its workspace for it. A stop that paused the work
+    // first and a stop that gave up waiting are different facts about whether the
+    // owner's last writes landed, and until OSK-11023 the server recorded the
+    // difference and no surface printed it. Dated, because on a machine that has
+    // since started again the sentence is about a past operation.
+    const operation = lease.operation;
+    if (operation?.action || operation?.status) {
+        const settledAt = operation.completedAt || operation.startedAt;
+        // The payload's own spelling, minus the underscore: this row is read by a
+        // person, and `in_progress` beside a plain English sentence reads as a code.
+        const status = operation.status === 'in_progress' ? 'in progress' : operation.status;
+        row('operation', [operation.action, status, settledAt].filter(Boolean).join(' '));
+        const checkpoint = describeDedicatedCheckpoint(lease);
+        if (checkpoint)
+            lines.push(`  ${''.padEnd(13)}${checkpoint.sentence}`);
+    }
     const engines = dedicatedLeaseHarnesses(lease, harnesses);
     if (engines.length > 0) {
         row('engines', engines.map((harness) => `${harness.provider} (${harness.status || 'unknown'})`).join(', '));