@skrr-ai/cli 0.1.104 → 0.1.106

package/dist/lib/commitment-event-wakes.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventWakeLines = eventWakeLines;
+/**
+ * The "Event wakes:" block, one renderer for `trigger-status` and `wake-capabilities`. The second
+ * used to word its own conclusion ("configured sources may wake the Agent", a column marked
+ * ACTIVE) and contradicted the first for the same Commitment (OSK-15428, OSK-15419); printing the
+ * same facts in the same words is the only way the two cannot disagree.
+ */
+function eventWakeLines(caps) {
+    const lines = [];
+    lines.push('Event wakes:');
+    lines.push(`  requested: ${caps.requested ? 'yes' : 'no'}`);
+    lines.push(`  configured sources: ${(caps.configuredSources ?? []).join(', ') || 'none'}`);
+    lines.push(`  eligible sources: ${(caps.eligibleSources ?? []).join(', ') || 'none'}`);
+    lines.push(`  materialized sources: ${(caps.materializedSources ?? []).join(', ') || 'none'}`);
+    if ((caps.dormantSources ?? []).length) {
+        lines.push(`  dormant sources: ${caps.dormantSources.join(', ')} (configured, but no event wake is planned for them)`);
+    }
+    if ((caps.unroutableSources ?? []).length) {
+        lines.push(`  unroutable sources: ${caps
+            .unroutableSources.map((item) => `${item.source} (${item.reason})`)
+            .join(', ')} — materialized but no upstream producer can deliver events`);
+    }
+    if ((caps.unverifiedSources ?? []).length) {
+        lines.push(`  unverified sources: ${caps
+            .unverifiedSources.map((item) => `${item.source} (${item.reason})`)
+            .join(', ')} — the upstream producer could not be read, so delivery is unknown`);
+    }
+    if ((caps.permissionGaps ?? []).length) {
+        lines.push(`  permission gaps: ${caps
+            .permissionGaps.map((gap) => `${gap.source} ${gap.capability ?? gap.permission}` +
+            ` (${gap.impact === 'evidence_read' ? 'needed by' : 'blocks'} ${(gap.events ?? []).join(', ')})`)
+            .join('; ')} — the routing GitHub installation does not hold the permission`);
+    }
+    if (caps.degradedReason)
+        lines.push(`  degraded: ${caps.degradedReason}`);
+    return lines;
+}

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;