@skrr-ai/cli 0.1.101 → 0.1.103

package/dist/commands/triggers/fire.js

@@ -41,6 +41,9 @@ class TriggersFire extends base_command_1.BaseCommand {
             return;
         }
         this.log(`Fire requested: outcome=${String(result.outcome ?? '-')} reason=${String(result.reason ?? '-')}`);
+        const note = (0, triggers_1.describeScheduledFire)(result);
+        if (note)
+            this.log(note);
     }
 }
 exports.default = TriggersFire;

package/dist/commands/triggers/update.js

@@ -48,7 +48,9 @@ class TriggersUpdate extends base_command_1.BaseCommand {
             multiple: true,
         }),
         timezone: core_1.Flags.string({ description: 'IANA timezone for schedule triggers' }),
-        'max-fires-per-day': core_1.Flags.integer({ description: 'Daily fire cap' }),
+        'max-fires-per-day': core_1.Flags.integer({
+            description: 'Daily fire cap (schedule, stochastic and self_scheduled triggers only)',
+        }),
         'max-runs': core_1.Flags.integer({ description: 'Lifetime fire cap for schedule triggers' }),
         'end-at': core_1.Flags.string({
             description: 'ISO-8601 datetime after which a schedule stops firing',
@@ -150,6 +152,29 @@ class TriggersUpdate extends base_command_1.BaseCommand {
                 throw new Error('Trigger kind cannot be changed after creation. ' +
                     'Remove `kind` from --from-json, or delete and recreate the trigger.');
             }
+        }
+        catch (err) {
+            this.error(err.message, { exit: 1 });
+        }
+        // The kind is the server's to say and cannot change, so the flags are checked against it and
+        // only the config block it owns is sent. Every block used to go: `--max-fires-per-day` wrote
+        // `stochastic` and `selfScheduled` onto a schedule trigger, and onto an on_demand one a cap
+        // nothing reads (OSK-15491).
+        let existing;
+        try {
+            existing = await triggers_1.triggerApi.get(args.id);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const existingKind = existing?.kind;
+        if (typeof existingKind !== 'string') {
+            this.error(`Trigger ${args.id} did not report its kind, so its settings cannot be checked.`, {
+                exit: 1,
+            });
+        }
+        try {
+            (0, triggers_1.assertKindFlagsApply)(existingKind, flags, { kindIsFixed: true });
             const execution = {};
             const builtinAction = (0, triggers_1.buildBuiltinActionPayload)({
                 builtinAction: flags['builtin-action'],
@@ -169,7 +194,10 @@ class TriggersUpdate extends base_command_1.BaseCommand {
             });
             const schedule = (0, triggers_1.buildScheduleConfigFromFlags)(flags);
             (0, triggers_1.assertScheduleTimingShape)(schedule);
-            const once = (0, triggers_1.buildOnceConfigFromFlags)(flags);
+            const once = (0, triggers_1.buildOnceConfigFromFlags)(flags, {
+                kind: existingKind,
+                allowNextRunAtAlias: true,
+            });
             const filterValues = (0, triggers_1.splitRepeated)(flags['filter-value']);
             // Consult the authoritative server catalog before warning about a local
             // snapshot miss; server validation remains final when it is unavailable.
@@ -188,22 +216,8 @@ class TriggersUpdate extends base_command_1.BaseCommand {
                 filterValues,
             });
             const event = {};
-            (0, triggers_1.setDefined)(event, {
-                entityType: flags.entity,
-                eventType: flags.event,
-                filterMode: flags['filter-mode'],
-                filterField: flags['filter-field'],
-                filterValue: filterValues && filterValues.length > 1 ? filterValues : filterValues?.[0],
-                debounceMs: flags['debounce-ms'],
-                maxPerHour: flags['max-per-hour'],
-            });
-            const stochastic = {};
-            (0, triggers_1.setDefined)(stochastic, {
-                probability: flags.probability === undefined ? undefined : Number(flags.probability),
-                jitterMs: flags['jitter-ms'],
-                maxFiresPerDay: flags['max-fires-per-day'],
-                evalIntervalMinutes: flags['eval-interval-minutes'],
-            });
+            Object.assign(event, (0, triggers_1.buildEventConfigFromFlags)(flags, filterValues));
+            const stochastic = (0, triggers_1.buildStochasticConfigFromFlags)(flags);
             const selfScheduled = (0, triggers_1.buildSelfScheduledConfigFromFlags)(flags);
             const form = (0, triggers_1.buildFormConfigFromFlags)(flags);
             const chatMessage = (0, triggers_1.buildChatMessageConfigFromFlags)(flags);
@@ -215,15 +229,15 @@ class TriggersUpdate extends base_command_1.BaseCommand {
                 idempotencyWindow: flags['idempotency-window'],
             });
             (0, triggers_1.mergeObjectField)(payload, 'execution', execution);
-            (0, triggers_1.mergeObjectField)(payload, 'schedule', schedule);
-            (0, triggers_1.mergeObjectField)(payload, 'once', once);
-            (0, triggers_1.mergeObjectField)(payload, 'event', event);
-            // `kind` is immutable on update (rejected above), so there is no kind to
-            // gate on here; stochastic is only non-empty when stochastic flags were passed.
-            (0, triggers_1.mergeObjectField)(payload, 'stochastic', stochastic);
-            (0, triggers_1.mergeObjectField)(payload, 'selfScheduled', selfScheduled);
-            (0, triggers_1.mergeObjectField)(payload, 'form', form);
-            (0, triggers_1.mergeObjectField)(payload, 'chatMessage', chatMessage);
+            (0, triggers_1.mergeTriggerKindConfig)(payload, existingKind, {
+                schedule,
+                once,
+                event,
+                stochastic,
+                selfScheduled,
+                form,
+                chatMessage,
+            });
         }
         catch (err) {
             this.error(err.message, { exit: 1 });

package/dist/commands/widgets/check.d.ts

@@ -0,0 +1,39 @@
+import { Command } from '@oclif/core';
+/**
+ * `skrr widgets check` — the offline self-check a harness runs in Bash BEFORE it
+ * replies, because a rejected widget is only discovered after the message is sent.
+ *
+ * It extends `Command`, not `BaseCommand`, on purpose: it reads a file or stdin and
+ * prints, so it must work with no sign-in, no network and no daemon credential
+ * (a sandboxed harness has none, and `BaseCommand.init()` resolves one before any
+ * command body runs). The same reason `instructions guide` does it.
+ *
+ * It reaches NO API. There is no route behind it, so there is nothing for the
+ * CLI/API parity spec (`domain-api-parity.spec.ts`) to hold it to: it adds nothing
+ * to `api-endpoints.ts` or `dataService`, and it is safe to run anywhere.
+ *
+ * Exit codes: 0 every widget would be accepted and has no error finding; 1 at
+ * least one would be refused or has an error finding (or none was found); 2 the
+ * input could not be read.
+ */
+export declare const WIDGETS_CHECK_EXIT: {
+    readonly ok: 0;
+    readonly notOk: 1;
+    readonly unreadable: 2;
+};
+export default class WidgetsCheck extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        file: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        strict: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'render-fence': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private readInput;
+    private emitInputError;
+}

package/dist/commands/widgets/check.js

@@ -0,0 +1,179 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WIDGETS_CHECK_EXIT = void 0;
+const core_1 = require("@oclif/core");
+const fs = __importStar(require("node:fs"));
+const prompt_1 = require("../../lib/prompt");
+const widgetCheck_1 = require("../../lib/widgetCheck");
+/**
+ * `skrr widgets check` — the offline self-check a harness runs in Bash BEFORE it
+ * replies, because a rejected widget is only discovered after the message is sent.
+ *
+ * It extends `Command`, not `BaseCommand`, on purpose: it reads a file or stdin and
+ * prints, so it must work with no sign-in, no network and no daemon credential
+ * (a sandboxed harness has none, and `BaseCommand.init()` resolves one before any
+ * command body runs). The same reason `instructions guide` does it.
+ *
+ * It reaches NO API. There is no route behind it, so there is nothing for the
+ * CLI/API parity spec (`domain-api-parity.spec.ts`) to hold it to: it adds nothing
+ * to `api-endpoints.ts` or `dataService`, and it is safe to run anywhere.
+ *
+ * Exit codes: 0 every widget would be accepted and has no error finding; 1 at
+ * least one would be refused or has an error finding (or none was found); 2 the
+ * input could not be read.
+ */
+exports.WIDGETS_CHECK_EXIT = { ok: 0, notOk: 1, unreadable: 2 };
+class WidgetsCheck extends core_1.Command {
+    static description = 'Check a generative-UI widget offline before sending it: grammar, size limits, JavaScript syntax and likely sandbox failures. Runs entirely offline: it reaches no API, so it needs no sign-in and has no route to keep in parity.';
+    static examples = [
+        '<%= config.bin %> widgets check reply.md',
+        '<%= config.bin %> widgets check - < reply.md',
+        '<%= config.bin %> widgets check widget.json --json',
+        '<%= config.bin %> widgets check widget.json --render-fence > block.txt',
+    ];
+    static args = {
+        file: core_1.Args.string({
+            description: 'File to check, or - for stdin. Text containing a widget block, or a JSON widget (a payload, a ui_widget part, or the ui_widget_render arguments, one or an array).',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({
+            description: 'Output the report as JSON: { ok, widgets: [{ id, title, bytes, limits, complete, accepted, ok, issues }], errors, warnings, summary }',
+        }),
+        format: core_1.Flags.string({
+            description: 'How to read the input: auto (JSON if it parses as JSON, otherwise text that contains a widget block), fence, or json',
+            options: ['auto', 'fence', 'json'],
+            default: 'auto',
+        }),
+        strict: core_1.Flags.boolean({
+            description: 'Also fail (exit 1) on warnings',
+            default: false,
+        }),
+        'render-fence': core_1.Flags.boolean({
+            description: 'For a JSON widget: print the correctly delimited block to stdout (the report goes to stderr), verified by parsing it back',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(WidgetsCheck);
+        const read = await this.readInput(args.file);
+        if (!read.ok) {
+            this.emitInputError(flags.json, read.error);
+            this.exit(exports.WIDGETS_CHECK_EXIT.unreadable);
+        }
+        const result = (0, widgetCheck_1.checkWidgetInput)(read.text, {
+            format: flags.format,
+            strict: flags.strict,
+        });
+        if (flags['render-fence']) {
+            const rendered = (0, widgetCheck_1.renderWidgetFences)(result);
+            const report = {
+                ...result.report,
+                errors: [...result.report.errors, ...rendered.errors],
+            };
+            report.ok = report.ok && rendered.errors.length === 0;
+            report.summary = {
+                ...report.summary,
+                errors: report.summary.errors + rendered.errors.length,
+            };
+            if (flags.json) {
+                this.log(JSON.stringify({ ...report, fences: rendered.fences }, null, 2));
+            }
+            else {
+                for (const fence of rendered.fences) {
+                    this.log(fence);
+                }
+                process.stderr.write(`${(0, widgetCheck_1.formatWidgetCheckReport)(report).join('\n')}\n`);
+            }
+            this.exit(report.ok ? exports.WIDGETS_CHECK_EXIT.ok : exports.WIDGETS_CHECK_EXIT.notOk);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result.report, null, 2));
+        }
+        else {
+            this.log((0, widgetCheck_1.formatWidgetCheckReport)(result.report).join('\n'));
+        }
+        this.exit(result.report.ok ? exports.WIDGETS_CHECK_EXIT.ok : exports.WIDGETS_CHECK_EXIT.notOk);
+    }
+    async readInput(source) {
+        try {
+            if (source === '-') {
+                if (process.stdin.isTTY) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: 'input/no-stdin',
+                            message: 'No input on stdin: it is a terminal, so there is nothing to read.',
+                            fix: `Pipe the widget in (${this.config.bin} widgets check - < reply.md) or pass a file path.`,
+                        },
+                    };
+                }
+                return { ok: true, text: await (0, prompt_1.readStdin)() };
+            }
+            const size = fs.statSync(source).size;
+            if (size > widgetCheck_1.WIDGET_CHECK_MAX_INPUT_CHARS * 4) {
+                return {
+                    ok: false,
+                    error: {
+                        code: 'input/too-large',
+                        message: `${source} is ${size} bytes, far more than a message can carry.`,
+                    },
+                };
+            }
+            return { ok: true, text: fs.readFileSync(source, 'utf8') };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: {
+                    code: 'input/unreadable',
+                    message: `Could not read ${source}: ${err?.message ?? String(err)}`,
+                    fix: 'Pass the path of a readable file, or - to read stdin.',
+                },
+            };
+        }
+    }
+    emitInputError(json, error) {
+        if (json) {
+            this.log(JSON.stringify((0, widgetCheck_1.inputErrorReport)(error), null, 2));
+            return;
+        }
+        process.stderr.write(`error: ${error.message}\n${error.fix ? `  fix: ${error.fix}\n` : ''}`);
+    }
+}
+exports.default = WidgetsCheck;

package/dist/lib/agent-mailbox.d.ts

@@ -3,7 +3,6 @@ export interface AgentMailboxMetadata {
     id: string;
     agentId: string;
     workspaceId: string;
-    handle: string;
     address: string;
     status: string;
     sending: string;

package/dist/lib/agent-mailbox.js

@@ -20,7 +20,6 @@ async function getAgentMailboxMetadata(agentId) {
                 id: mailbox.id,
                 agentId: mailbox.agentId,
                 workspaceId: mailbox.workspaceId,
-                handle: mailbox.handle,
                 address: mailbox.address,
                 status: mailbox.status,
                 sending: mailbox.sending,

package/dist/lib/commitment-loop-status.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Text rendering for `skrr commitments roster` / `skrr commitments status`.
+ *
+ * The loop state is DERIVED server-side (`CommitmentLoopStatus`); this file
+ * only words it. Two rules it must keep:
+ *  - paused, unarmed and degraded read differently — "you paused it", "nothing
+ *    will wake it" and "it cannot see" have different fixes;
+ *  - `unknown` never borrows the healthy wording or an OK mark. "Cannot see"
+ *    is not "fine".
+ */
+import { type CommitmentLoopStatus, type CommitmentRoster } from '@skrr-ai/data-provider';
+export declare function loopStateLabel(state: unknown): string;
+/** Roster table: one row per Commitment. */
+export declare function formatCommitmentRoster(roster: Partial<CommitmentRoster>): string[];
+/** One Commitment's loop, in full. */
+export declare function formatCommitmentLoopStatus(status: CommitmentLoopStatus): string[];

package/dist/lib/commitment-loop-status.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loopStateLabel = loopStateLabel;
+exports.formatCommitmentRoster = formatCommitmentRoster;
+exports.formatCommitmentLoopStatus = formatCommitmentLoopStatus;
+/**
+ * Text rendering for `skrr commitments roster` / `skrr commitments status`.
+ *
+ * The loop state is DERIVED server-side (`CommitmentLoopStatus`); this file
+ * only words it. Two rules it must keep:
+ *  - paused, unarmed and degraded read differently — "you paused it", "nothing
+ *    will wake it" and "it cannot see" have different fixes;
+ *  - `unknown` never borrows the healthy wording or an OK mark. "Cannot see"
+ *    is not "fine".
+ */
+const data_provider_1 = require("@skrr-ai/data-provider");
+const format_1 = require("./format");
+/** One word per state, with a mark only `healthy` may use. */
+const STATE_LABEL = {
+    healthy: '✓ healthy',
+    blocked: '! blocked',
+    paused: '‖ paused',
+    unarmed: '! unarmed',
+    degraded: '! degraded',
+    inactive: '- inactive',
+    unknown: '? unknown',
+};
+function loopStateLabel(state) {
+    return typeof state === 'string' && state in STATE_LABEL
+        ? STATE_LABEL[state]
+        : STATE_LABEL.unknown;
+}
+function when(value) {
+    if (typeof value !== 'string')
+        return '-';
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return '-';
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+function count(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? String(value) : '?';
+}
+function runs(status) {
+    const used = count(status.cost?.runsToday);
+    const max = status.cost?.maxRunsPerDay;
+    return typeof max === 'number' ? `${used}/${max}` : used;
+}
+function spend(status) {
+    const value = status.cost?.spendTodayUsd;
+    if (typeof value !== 'number')
+        return 'not metered';
+    const amount = `$${value.toFixed(2)}`;
+    // A partial ledger is a lower bound; never print it as the whole answer.
+    return status.cost?.spendKnown ? amount : `≥ ${amount} (some runs unpriced)`;
+}
+function nextWake(status) {
+    const wake = status.nextWakes?.[0];
+    return wake ? `${when(wake.at)} ${wake.kind}` : '-';
+}
+function watchSummary(status) {
+    const rows = Array.isArray(status.watching) ? status.watching : [];
+    if (!rows.length)
+        return '-';
+    return rows
+        .map((row) => {
+        const mark = row.access === 'blocked'
+            ? '✗'
+            : row.access === 'unknown'
+                ? '?'
+                : row.completeness === 'partial'
+                    ? '~'
+                    : '✓';
+        return `${row.source}${mark}`;
+    })
+        .join(' ');
+}
+/** Roster table: one row per Commitment. */
+function formatCommitmentRoster(roster) {
+    const lines = [];
+    const commitments = Array.isArray(roster.commitments) ? roster.commitments : [];
+    lines.push(`Agent ${roster.agentId ?? '-'} — ${commitments.length} commitment${commitments.length === 1 ? '' : 's'}`);
+    if (!commitments.length) {
+        lines.push('No commitments.');
+        return lines;
+    }
+    (0, format_1.renderTable)(commitments.map((status) => ({
+        state: loopStateLabel(status.loopState),
+        id: status.commitmentId,
+        title: status.systemRole ? `${status.title} [${status.systemRole}]` : status.title,
+        next: nextWake(status),
+        runs: runs(status),
+        watching: watchSummary(status),
+        reason: status.loopReason ?? '',
+    })), [
+        { key: 'state', header: 'STATE' },
+        { key: 'id', header: 'ID', verbatim: true },
+        { key: 'title', header: 'TITLE', maxWidth: 36 },
+        { key: 'next', header: 'NEXT WAKE' },
+        { key: 'runs', header: 'RUNS TODAY' },
+        { key: 'watching', header: 'WATCHING', maxWidth: 40 },
+        { key: 'reason', header: 'REASON', maxWidth: 40 },
+    ], (line) => lines.push(line));
+    const attention = commitments.filter((status) => !['healthy', 'paused', 'inactive'].includes(String(status.loopState))).length;
+    if (attention) {
+        lines.push(`${attention} need${attention === 1 ? 's' : ''} attention — run \`skrr commitments status <id>\` for why.`);
+    }
+    if (roster.truncated) {
+        lines.push('More commitments exist than this roster shows.');
+    }
+    return lines;
+}
+/** One Commitment's loop, in full. */
+function formatCommitmentLoopStatus(status) {
+    const lines = [];
+    lines.push(`${status.title} (${status.commitmentId})${status.systemRole ? ` [${status.systemRole}]` : ''}`);
+    lines.push(`  Loop:        ${loopStateLabel(status.loopState)}${status.loopReason ? ` (${status.loopReason})` : ''}`);
+    lines.push(`               ${status.loopDetail || (0, data_provider_1.describeCommitmentLoopState)(status.loopState)}`);
+    lines.push(`  Lifecycle:   ${status.lifecycleStatus}`);
+    lines.push(`  Last check:  ${when(status.lastCheckAt)}`);
+    lines.push(`  Last seen:   ${when(status.lastSuccessfulObservationAt)}`);
+    if (status.lastStop) {
+        // `fix` is an optional contract field; read it defensively across package builds.
+        const stop = status.lastStop;
+        lines.push(`  Last stop:   ${stop.question}${stop.reason ? ` — ${stop.reason}` : ''}`);
+        if (stop.detail)
+            lines.push(`               ${stop.detail}`);
+        if (stop.fix)
+            lines.push(`  Fix:         ${stop.fix}`);
+    }
+    const wakes = Array.isArray(status.nextWakes) ? status.nextWakes : [];
+    lines.push('  Next wakes:');
+    if (!wakes.length) {
+        lines.push(status.loopState === 'unknown'
+            ? '    (could not be read)'
+            : '    none — nothing is scheduled to wake it');
+    }
+    for (const wake of wakes) {
+        lines.push(`    ${when(wake.at)}  ${wake.kind}${wake.reason ? ` (${wake.reason})` : ''}`);
+    }
+    const watching = Array.isArray(status.watching) ? status.watching : [];
+    lines.push('  Watching:');
+    if (!watching.length)
+        lines.push('    nothing declared');
+    for (const row of watching) {
+        const access = row.access === 'readable'
+            ? row.completeness === 'partial'
+                ? 'readable, PARTIAL read'
+                : 'readable'
+            : row.access === 'blocked'
+                ? 'CANNOT READ'
+                : 'not known';
+        lines.push(`    ${row.source}${row.scope ? ` (${row.scope})` : ''}: ${access}${row.reason ? ` — ${row.reason}` : ''}`);
+        // Optional contract field; read defensively across package builds.
+        const limitations = row.limitations;
+        if (Array.isArray(limitations) && limitations.length) {
+            lines.push(`      not watched: ${limitations.join(', ')}`);
+        }
+    }
+    lines.push(`  Open loops:  ${count(status.pendingWork?.openLoops)}   Pending runs: ${count(status.pendingWork?.pendingRuns)}`);
+    lines.push(`  Runs today:  ${runs(status)}   Spend today: ${spend(status)}`);
+    return lines;
+}

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 } 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 { 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, };
@@ -223,6 +223,10 @@ export declare const commitmentApi: {
      * swept, how stale that is, and the tally it last persisted. Aggregate only.
      */
     livenessSweep: () => Promise<Record<string, unknown>>;
+    /** One agent's Commitments, system roles included, each with its loop status. */
+    roster: (agentId: string) => Promise<CommitmentRoster>;
+    /** Is this Commitment's loop installed and working. */
+    loopStatus: (id: string) => Promise<CommitmentLoopStatus>;
     manifest: (id: string) => Promise<Record<string, unknown>>;
     import: (body: Record<string, unknown>) => Promise<{
         commitment: {
@@ -247,6 +251,23 @@ export declare const commitmentApi: {
         };
     }>;
     get: (id: string) => Promise<CommitmentStatusResponse>;
+    controlPreview: (id: string, query: Parameters<typeof withQuery>[1]) => Promise<Record<string, unknown>>;
+    applyControl: (id: string, body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    controlReceipt: (id: string, controlId: string) => Promise<Record<string, unknown>>;
+    workPlan: (id: string) => Promise<Record<string, unknown>>;
+    observationSummary: (query?: {
+        agentId?: string;
+    }) => Promise<Record<string, unknown>>;
+    draftObservationProbe: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    observationProbe: (id: string, body?: {
+        expectedVersion?: number;
+        timeoutMs?: number;
+    }) => Promise<Record<string, unknown>>;
+    verifyReadiness: (id: string, body: {
+        expectedVersion: number;
+        timeoutMs?: number;
+    }) => Promise<Record<string, unknown>>;
+    readinessReceipt: (id: string, receiptId: string) => Promise<Record<string, unknown>>;
     create: (body: Record<string, unknown>) => Promise<Commitment>;
     update: (id: string, body: Record<string, unknown>) => Promise<Commitment>;
     draftPreflight: (body: Record<string, unknown>) => Promise<CommitmentPreflightReport>;
@@ -629,6 +650,8 @@ export type WatchFlagInputs = {
     spaceIds?: string[];
     monitorIds?: string[];
 };
+/** Keep the canonical one-binding-per-source contract without discarding conflicting intent. */
+export declare function normalizeWatchedSourceDeclarations<T>(declarations: T[]): T[];
 export declare function buildWatchedSources(inputs: WatchFlagInputs): Array<Record<string, unknown>> | undefined;
 /** The evidence-health shape carried on a check's `inputs`. */
 export type EvidenceHealthView = {
@@ -718,6 +741,17 @@ export declare function extractStandstillFromCheck(check?: {
  * null rather than printing a guess.
  */
 export declare function describeExecutorBlocked(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
+ * when the server sent one (OSK-15989). The stored `commitment.assessment` is
+ * what the LAST check wrote; while a run is in flight it can still say
+ * `blocked`, and printing it above "Agent is working" made the header
+ * contradict the rest of the page. `doctor` already reads the live one first.
+ */
+export declare function withLiveAssessment(commitment: CommitmentView, operatingState?: {
+    assessment?: unknown;
+} | null): CommitmentView;
 export declare function renderCommitmentSummary(commitment: CommitmentView, log: (line: string) => void, 
 /**
  * The most recent check, when the caller has one. Optional because pause /
@@ -757,6 +791,7 @@ type ReadModelRecord = Record<string, unknown>;
 /** Human view for `commitments ledger`; JSON remains the automation surface. */
 export declare function renderCommitmentLedger(ledger: ReadModelRecord, log: (line: string) => void): void;
 export declare function renderCommitmentTrace(trace: ReadModelRecord, log: (line: string) => void): void;
+export declare function renderProactivenessScorecard(scorecard: ReadModelRecord, log: (line: string) => void): void;
 /**
  * One line per Cycle:
  * `09-22 12:04  ● stopped    act  commitment_execution_budget_exhausted — Raise maxRunsPerDay…`
@@ -774,6 +809,17 @@ export declare function renderListPageHint(page: {
     has_more?: boolean;
     next_cursor?: string | null;
 } | undefined, log: (line: string) => void): void;
+/**
+ * Whether a row's retained evidence can still be reopened (OSK-16125).
+ *
+ * The count alone read as evidence even when every path pointed into a
+ * worktree the daemon had already deleted. `retained` artifacts are git
+ * locators on the run's delivery commit; `ephemeral` ones cannot be counted
+ * on; `unconfirmed` are locators for a path the run did not change. Refs the
+ * server classified as none of these (URLs, hashes, legacy rows) count as
+ * `other`. `--json` carries each artifact's `ref`, `locator` and `originalRef`.
+ */
+export declare function describeObservationArtifacts(artifacts: unknown): string;
 export declare function renderCommitmentObservations(response: ReadModelRecord, log: (line: string) => void, options?: {
     emptyMessage?: string;
 }): void;