@skrr-ai/cli 0.1.98 → 0.1.100

package/dist/commands/signals/sources/list.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
-const base_command_1 = require("../../../base-command");
+const signal_command_1 = require("../../../signal-command");
 const signals_1 = require("../../../lib/signals");
-class SourcesList extends base_command_1.BaseCommand {
+class SourcesList extends signal_command_1.SignalCommand {
     static description = 'List Signal sources (read-only; credentials are never shown)';
     static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
     async run() {

package/dist/commands/signals/sources/receipts.d.ts

@@ -1,5 +1,5 @@
-import { BaseCommand } from '../../../base-command';
-export default class SourcesReceipts extends BaseCommand {
+import { SignalCommand } from '../../../signal-command';
+export default class SourcesReceipts extends SignalCommand {
     static description: string;
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;

package/dist/commands/signals/sources/receipts.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
-const base_command_1 = require("../../../base-command");
+const signal_command_1 = require("../../../signal-command");
 const signals_1 = require("../../../lib/signals");
-class SourcesReceipts extends base_command_1.BaseCommand {
+class SourcesReceipts extends signal_command_1.SignalCommand {
     static description = 'List recent redacted receipts of a Signal source';
     static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
     static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };

package/dist/commands/signals/sources/show.d.ts

@@ -1,5 +1,5 @@
-import { BaseCommand } from '../../../base-command';
-export default class SourcesShow extends BaseCommand {
+import { SignalCommand } from '../../../signal-command';
+export default class SourcesShow extends SignalCommand {
     static description: string;
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;

package/dist/commands/signals/sources/show.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
-const base_command_1 = require("../../../base-command");
+const signal_command_1 = require("../../../signal-command");
 const signals_1 = require("../../../lib/signals");
-class SourcesShow extends base_command_1.BaseCommand {
+class SourcesShow extends signal_command_1.SignalCommand {
     static description = 'Show one Signal source (read-only)';
     static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
     static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };

package/dist/commands/spaces/workflows/create.js

@@ -29,7 +29,7 @@ class SpacesWorkflowsCreate extends base_command_1.BaseCommand {
         title: core_1.Flags.string({ required: true, description: 'Workflow title' }),
         description: core_1.Flags.string({ description: 'Optional description' }),
         graph: core_1.Flags.string({
-            description: 'Required exactly once with --draft/--starter: path to graph JSON ({ nodes, edges })',
+            description: 'Required exactly once with --draft/--starter: path to graph JSON ({ nodes, edges }); inspect config with spaces workflows node-types',
             exactlyOne: ['graph', 'draft', 'starter'],
         }),
         draft: core_1.Flags.string({

package/dist/commands/spaces/workflows/node-types.d.ts

@@ -0,0 +1,45 @@
+import { type WorkflowNodeType } from '@skrr-ai/data-provider';
+import { BaseCommand } from '../../../base-command';
+export declare function workflowNodeTypeReference(type: WorkflowNodeType): {
+    type: WorkflowNodeType;
+    typeVersion: number;
+    label: string;
+    description: string;
+    requiredConfig: string[];
+    fields: {
+        path: string;
+        name: string;
+        label: string;
+        kind: import("@skrr-ai/data-provider").WorkflowNodeFieldKind;
+        placeholder?: string;
+        help?: string;
+        showWhen?: {
+            field: string;
+            equals: unknown;
+        };
+        options?: Array<{
+            value: string;
+            label: string;
+        }>;
+    }[];
+    defaultNode: {
+        key: string;
+        type: WorkflowNodeType;
+        typeVersion: number;
+        config: Record<string, unknown>;
+        join: "all";
+        bindings: {};
+    };
+    outcomes: import("@skrr-ai/data-provider").WorkflowOutcomeSpec[];
+};
+export default class SpacesWorkflowsNodeTypes extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        type: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/spaces/workflows/node-types.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowNodeTypeReference = workflowNodeTypeReference;
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+function workflowNodeTypeReference(type) {
+    const definition = data_provider_1.WORKFLOW_NODE_TYPES[type];
+    const node = {
+        key: `${definition.keyPrefix}_1`,
+        type,
+        typeVersion: definition.version,
+        config: definition.defaultConfig(),
+        join: 'all',
+        bindings: {},
+    };
+    return {
+        type,
+        typeVersion: definition.version,
+        label: definition.label,
+        description: definition.description,
+        requiredConfig: definition.requiredConfig,
+        fields: definition.fields.map((field) => ({
+            ...field,
+            path: field.name === 'join' ? 'join' : `config.${field.name}`,
+        })),
+        defaultNode: node,
+        outcomes: definition.outcomes(node),
+    };
+}
+class SpacesWorkflowsNodeTypes extends base_command_1.BaseCommand {
+    static description = 'Read node config fields, defaults and review lens preset choices from the installed CLI catalog (no server requests)';
+    static examples = [
+        '<%= config.bin %> spaces workflows node-types',
+        '<%= config.bin %> spaces workflows node-types loop --json',
+        '<%= config.bin %> spaces workflows node-types review_loop --json',
+    ];
+    static args = {
+        type: core_1.Args.string({ description: 'Node type; omit to list all types', ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output node fields, choices and default node JSON' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SpacesWorkflowsNodeTypes);
+        if (args.type && !(0, data_provider_1.isWorkflowNodeType)(args.type)) {
+            this.failWithCliError({
+                message: `Unknown node type: ${args.type}. Run skrr spaces workflows node-types to list types.`,
+                code: 'WORKFLOW_NODE_TYPE_UNKNOWN',
+                exit: 2,
+                retryable: false,
+            });
+            return;
+        }
+        const types = args.type
+            ? [args.type]
+            : Object.keys(data_provider_1.WORKFLOW_NODE_TYPES);
+        const references = types.map(workflowNodeTypeReference);
+        const note = 'Installed CLI authoring reference. Defaults may require configuration; fill required fields and agent choices, then validate the draft against your server before publishing.';
+        if (flags.json) {
+            this.log(JSON.stringify({
+                object: 'workflow_node_catalog', source: 'installed_cli', note, nodeTypes: references,
+            }, null, 2));
+            return;
+        }
+        this.log(note);
+        for (const reference of references) {
+            this.log(`\n${reference.type} · ${reference.label} · v${reference.typeVersion}`);
+            if (!args.type)
+                continue;
+            this.log(reference.description);
+            this.log(`Required config keys: ${reference.requiredConfig.join(', ') || 'none declared'}`);
+            for (const field of reference.fields) {
+                const choices = field.options?.length
+                    ? ` (${field.options.map((option) => option.value).join(', ')})` : '';
+                this.log(`  ${field.path}: ${field.label}${choices}`);
+                if (field.help)
+                    this.log(`    ${field.help}`);
+            }
+            this.log(`Default node: ${JSON.stringify(reference.defaultNode, null, 2)}`);
+        }
+        if (!args.type)
+            this.log('\nRead one type: skrr spaces workflows node-types <type> --json');
+    }
+}
+exports.default = SpacesWorkflowsNodeTypes;

package/dist/commands/spaces/workflows/update.js

@@ -51,19 +51,21 @@ class SpacesWorkflowsUpdate extends base_command_1.BaseCommand {
         title: core_1.Flags.string({ description: 'New workflow title' }),
         description: core_1.Flags.string({ description: 'New workflow description' }),
         'clear-description': core_1.Flags.boolean({ description: 'Remove the workflow description' }),
-        graph: core_1.Flags.string({ description: 'Path to graph JSON ({ nodes, edges })' }),
+        graph: core_1.Flags.string({
+            description: 'Path to graph JSON ({ nodes, edges }); inspect config with spaces workflows node-types',
+        }),
         draft: core_1.Flags.string({
             description: 'Path to complete draft JSON ({ semantic, presentation })',
         }),
         'semantic-revision': core_1.Flags.integer({
-            description: 'Expected semantic revision; defaults to the latest server value',
+            description: 'Expected semantic revision; pass with --presentation-revision. For graph/draft writes, omit both to fetch the latest server revisions',
         }),
         'max-duration': core_1.Flags.string({
             description: 'Run duration limit, e.g. 90m, 4h or 2d. A run still open past it is cancelled with WORKFLOW_RUN_DEADLINE. Applies from the next publish; runs already started keep their deadline',
         }),
         'clear-max-duration': core_1.Flags.boolean({ description: 'Remove the run duration limit' }),
         'presentation-revision': core_1.Flags.integer({
-            description: 'Expected presentation revision; defaults to the latest server value',
+            description: 'Expected presentation revision; pass with --semantic-revision. For graph/draft writes, omit both to fetch the latest server revisions',
         }),
     };
     async run() {

package/dist/commands/tasks/assign.js

@@ -196,11 +196,10 @@ class TasksAssign extends base_command_1.BaseCommand {
         if (flags.json) {
             this.log(JSON.stringify({
                 ...(0, web_url_1.withTaskUrl)(this.cliConfig.baseURL, updated),
-                // What each free-text reference actually became — so a caller can
-                // verify the resolution rather than trust it.
+                // Keep request details separate from the canonical assignee arrays
+                // returned by the server, especially when removing co-assignees.
+                assignmentAction: flags.remove ? 'remove' : flags.replace ? 'replace' : 'add',
                 resolved: [...people.resolved, ...agents.resolved],
-                assigneeUserIds: userIds,
-                assigneeAgentIds: agentIds,
             }, null, 2));
             return;
         }

package/dist/commands/tasks/complete.d.ts

@@ -10,6 +10,7 @@ export declare function describePendingReview({ statusType, taskId, resultId, bi
     }>;
 }): string | null;
 export default class TasksComplete extends BaseCommand {
+    static autonomousCredentialPolicy: "bound-session";
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/tasks/complete.js

@@ -99,6 +99,7 @@ function describePendingReview({ statusType, taskId, resultId, bin, advisories,
         'may close without one — an override is recorded on the resolution.)');
 }
 class TasksComplete extends base_command_1.BaseCommand {
+    static autonomousCredentialPolicy = 'bound-session';
     static description = 'Submit one versioned Result and advance the Task workflow';
     static examples = [
         '<%= config.bin %> tasks complete <task> --summary "Implemented and verified the fix" --deliverable <resource-link-id>',

package/dist/commands/tasks/create.js

@@ -159,9 +159,11 @@ class TasksCreate extends base_command_1.BaseCommand {
             description: 'Task priority',
             options: [...tasks_1.TASK_PRIORITIES],
         }),
-        parent: core_1.Flags.string({ description: 'Parent task ID' }),
+        parent: core_1.Flags.string({
+            description: 'Structural parent task ID. Child statuses roll up; all terminal children can automatically close the parent, with unmet obligations recorded. Use --spawned-by for supporting work without status rollup.',
+        }),
         'spawned-by': core_1.Flags.string({
-            description: 'Task whose execution produced this one (lineage). Distinct from --parent (containment) and blockers (ordering).',
+            description: 'Task whose execution produced this one (lineage only, without parent status rollup). Use --parent for structural containment and blockers for ordering.',
         }),
         'spawn-reason': core_1.Flags.string({
             description: 'Why this work exists',

package/dist/commands/tasks/deliverable/add.d.ts

@@ -10,6 +10,7 @@ export declare function defaultDeliverableIdempotencyKey(task: string, payload:
  * optional structured one.
  */
 export default class TasksDeliverableAdd extends BaseCommand {
+    static autonomousCredentialPolicy: "bound-session";
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/tasks/deliverable/add.js

@@ -59,6 +59,7 @@ function defaultDeliverableIdempotencyKey(task, payload) {
  * optional structured one.
  */
 class TasksDeliverableAdd extends base_command_1.BaseCommand {
+    static autonomousCredentialPolicy = 'bound-session';
     static description = 'Record something this task produced (a commit, a page, a URL, a file, a message, a dataset).\n' +
         '\n' +
         'IDENTITY is the part before @; LOCATION is the part after it. They are not the same ' +

package/dist/commands/tasks/result/submit.d.ts

@@ -1,5 +1,6 @@
 import { BaseCommand } from '../../../base-command';
 export default class TasksResultSubmit extends BaseCommand {
+    static autonomousCredentialPolicy: "bound-session";
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/tasks/result/submit.js

@@ -53,6 +53,7 @@ function parseJson(value, label) {
     }
 }
 class TasksResultSubmit extends base_command_1.BaseCommand {
+    static autonomousCredentialPolicy = 'bound-session';
     static description = 'Submit the Task Result; this does not self-accept it or turn a domain conclusion into a Review';
     static examples = [
         '<%= config.bin %> tasks result submit <task> --summary "NO-SHIP until Gates A-D pass" --conclusion-type release_recommendation --conclusion-json \'{"posture":"no_ship"}\'',

package/dist/commands/tasks/resume/save.d.ts

@@ -1,5 +1,6 @@
 import { BaseCommand } from '../../../base-command';
 export default class TasksResumeSave extends BaseCommand {
+    static autonomousCredentialPolicy: "bound-session";
     static description: string;
     static args: {
         task: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;

package/dist/commands/tasks/resume/save.js

@@ -9,6 +9,7 @@ const api_fetch_1 = require("../../../lib/api-fetch");
 const session_task_write_1 = require("../../../lib/session-task-write");
 const prompt_1 = require("../../../lib/prompt");
 class TasksResumeSave extends base_command_1.BaseCommand {
+    static autonomousCredentialPolicy = 'bound-session';
     static description = 'Save recovery state without publishing a visible Task Update';
     static args = {
         task: core_1.Args.string({ required: false, ignoreStdin: true, description: 'Task id or ref' }),

package/dist/commands/tasks/retry.js

@@ -4,6 +4,7 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const task_resolver_1 = require("../../lib/task-resolver");
+const start_1 = require("./start");
 /**
  * OSK-3815 — the CLI verb for the `retry_task` action.
  *
@@ -72,8 +73,9 @@ class TasksRetry extends base_command_1.BaseCommand {
         // Step 1 — clear the terminal state. `todo` rather than `backlog`: the task
         // was already triaged into the working set once, and a retry is not a
         // decision to deprioritise it.
+        let movedTask;
         try {
-            await data_provider_1.dataService.moveTask({
+            movedTask = await data_provider_1.dataService.moveTask({
                 taskId: taskRef,
                 status: 'todo',
             });
@@ -81,13 +83,23 @@ class TasksRetry extends base_command_1.BaseCommand {
         catch (err) {
             this.handleApiError(err, { subject: `Task ${taskRef}` });
         }
+        // This receipt describes the first committed transition. Dispatch may
+        // change the Task again, so it is not an overall current-state snapshot.
+        const statusTransition = { requestedStatus: 'todo', task: movedTask };
         if (flags['no-start']) {
             if (flags.json) {
-                this.log(JSON.stringify({ taskId: taskRef, status: 'todo', started: false }));
+                this.log(JSON.stringify({
+                    taskId: taskRef,
+                    status: movedTask?.status,
+                    started: false,
+                    statusTransition,
+                }));
                 return;
             }
-            this.log(`Cleared failed state on ${taskRef} — now todo, not started.`);
-            this.log(`Start it with: skrr tasks start ${taskRef}`);
+            this.log(`Cleared failed state on ${taskRef}; execution was not requested.`);
+            if (typeof movedTask?.status === 'string')
+                this.log(`Status: ${movedTask.status}`);
+            this.log(`Start it with: ${this.config.bin} tasks start ${taskRef}`);
             return;
         }
         let result;
@@ -95,12 +107,32 @@ class TasksRetry extends base_command_1.BaseCommand {
             result = await data_provider_1.dataService.startTask(taskRef, flags.skill ? { skillId: flags.skill } : undefined);
         }
         catch (err) {
+            const waiting = (0, start_1.waitingForMachine)(err);
+            if (waiting) {
+                if (flags.json) {
+                    this.log(JSON.stringify({
+                        waiting: true,
+                        code: 'TASK_WAITING_FOR_MACHINE',
+                        taskId: taskRef,
+                        started: false,
+                        statusTransition,
+                        ...waiting,
+                    }, null, 2));
+                    return;
+                }
+                this.log(`Task ${taskRef} is waiting for the machine to start; the task will run by itself once it is ready.`);
+                if (waiting.message)
+                    this.log(waiting.message);
+                return;
+            }
+            const observedStatus = typeof movedTask?.status === 'string' ? ` (returned status '${movedTask.status}')` : '';
             this.handleApiError(err, {
-                subject: `Task ${taskRef} (failed state was cleared — it is now 'todo')`,
+                subject: `Task ${taskRef} (status transition committed${observedStatus}; start was not confirmed. ` +
+                    `Check ${this.config.bin} tasks show ${taskRef}, then use ${this.config.bin} tasks start ${taskRef} if needed)`,
             });
         }
         if (flags.json) {
-            this.log(JSON.stringify({ ...result, taskId: taskRef, status: 'todo', started: true }, null, 2));
+            this.log(JSON.stringify({ ...result, taskId: taskRef, started: true, statusTransition }, null, 2));
             return;
         }
         this.log(`Retried task ${taskRef}`);

package/dist/commands/tasks/schedule.js

@@ -18,7 +18,7 @@ class TasksSchedule extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
         at: core_1.Flags.string({
-            description: 'First fire time as ISO-8601 UTC (e.g. 2026-06-01T15:30:00Z)',
+            description: 'First fire time as ISO-8601 UTC ending in Z (e.g. 2026-06-01T15:30:00Z); numeric offsets such as +00:00 are not accepted',
         }),
         cron: core_1.Flags.string({
             description: 'Recurrence cron pattern (UTC unless --timezone is set)',
@@ -36,7 +36,7 @@ class TasksSchedule extends base_command_1.BaseCommand {
             dependsOn: ['cron'],
         }),
         'from-json': core_1.Flags.string({
-            description: 'Path to a JSON file (or "-" for stdin) with the schedule body',
+            description: 'Path to a JSON file (or "-" for stdin) with the schedule body; scheduledFor must use ISO-8601 UTC ending in Z',
         }),
     };
     async run() {
@@ -63,7 +63,7 @@ class TasksSchedule extends base_command_1.BaseCommand {
             recurrence,
         });
         if (!payload.scheduledFor || typeof payload.scheduledFor !== 'string') {
-            this.error('A first-fire time is required. Pass --at <ISO-8601> or include scheduledFor in --from-json.', { exit: 1 });
+            this.error('A first-fire time is required. Pass --at <ISO-8601 UTC ending in Z> or include scheduledFor in --from-json using the same format.', { exit: 1 });
         }
         let result;
         try {

package/dist/commands/tasks/show.js

@@ -518,7 +518,9 @@ class TasksShow extends base_command_1.BaseCommand {
             : ''}`);
         const actionability = t.actionability;
         if (actionability) {
-            this.log(`Next action: ${actionability.nextActor ?? '-'} · ${actionability.state ?? '-'} · ${actionability.reasonCode ?? '-'}`);
+            this.log(actionability.state === 'terminal'
+                ? 'Workflow:    ended · no next executor'
+                : `Next action: ${actionability.nextActor ?? '-'} · ${actionability.state ?? '-'} · ${actionability.reasonCode ?? '-'}`);
             this.log(`Why:         ${actionability.reason ?? '-'}`);
             await this.printBlockerDetail(t, actionability);
         }

package/dist/commands/tasks/update.js

@@ -308,20 +308,47 @@ class TasksUpdate extends base_command_1.BaseCommand {
                 const field = expectationsPatch !== undefined || body.expectations !== undefined
                     ? 'Changing Expectations'
                     : 'Changing the description';
-                this.log(`${field} advances the Task specification, so ${count} ${noun} ` +
-                    'will stop counting and must be recorded again.');
+                const disclosure = [
+                    `${field} advances the Task specification, so ${count} ${noun} ` +
+                        'will stop counting and must be recorded again.',
+                ];
                 /*
                  * NAME them. The count alone made the warning unactionable — and it is
                  * task-WIDE, so Expectations you are not touching lose their judgements
                  * too, which a bare number actively hides.
                  */
                 for (const row of settled) {
-                    this.log(`  ${row.id}  ${row.sentence || row.text || ''}`);
+                    disclosure.push(`  ${row.id}  ${row.sentence || row.text || ''}`);
                 }
                 if (settled.length > 0) {
-                    this.log('Revocation covers every Expectation on this Task, including ones this edit ' +
+                    disclosure.push('Revocation covers every Expectation on this Task, including ones this edit ' +
                         'does not touch.');
                 }
+                if (flags.json) {
+                    // JSON callers acknowledge with --yes. Neither disclosure prose nor
+                    // an interactive prompt may precede the single machine-readable result.
+                    this.failWithCliError({
+                        message: disclosure.join('\n') +
+                            '\nNo change made — re-run with `--yes` to accept the revocation.',
+                        code: 'TASK_SPEC_CHANGE_CONFIRMATION_REQUIRED',
+                        exit: 2,
+                        retryable: false,
+                        details: {
+                            taskId: taskRef,
+                            assessmentCount: acceptanceUnreadable ? null : settled.length,
+                            acceptanceReadable: !acceptanceUnreadable,
+                            affectedExpectations: settled.map((row) => ({
+                                id: row.id,
+                                text: row.sentence || row.text || '',
+                            })),
+                            revocationScope: 'all_expectations',
+                            confirmationFlag: '--yes',
+                            disclosure,
+                        },
+                    });
+                }
+                for (const line of disclosure)
+                    this.log(line);
                 const ok = await this.confirm('Continue? [y/N] ');
                 if (!ok) {
                     /*

package/dist/commands/tasks/updates/add.d.ts

@@ -1,5 +1,6 @@
 import { BaseCommand } from '../../../base-command';
 export default class TasksUpdatesAdd extends BaseCommand {
+    static autonomousCredentialPolicy: "bound-session";
     static description: string;
     static examples: string[];
     static args: {

package/dist/commands/tasks/updates/add.js

@@ -60,6 +60,7 @@ function parseJsonObject(value, label) {
     return parsed;
 }
 class TasksUpdatesAdd extends base_command_1.BaseCommand {
+    static autonomousCredentialPolicy = 'bound-session';
     static description = 'Record a meaningful Task Update, optionally with recovery state';
     static examples = [
         '<%= config.bin %> tasks updates add <task> --type progress --summary "Migration review complete" --data \'{"completedSinceLast":["Checked migrations 001-014"],"nextActions":["Review authorization"]}\'',

package/dist/lib/commitment-terms.js

@@ -82,7 +82,7 @@ function renderCommitmentTerms(commitment, log) {
         ? `${subject.type} ${subject.label || subject.externalKey}`
         : 'standing (not about one instance)'}`);
     const sensors = commitment.sensors ?? [];
-    log(`Watches:   ${sensors.length
+    log(`Sensors:   ${sensors.length
         ? sensors
             .map((s) => `${sensorRefKey(s)}${s.sensorType ? ` (${s.sensorType})` : ''}`)
             .join(', ')

package/dist/lib/commitments.js

@@ -1037,6 +1037,23 @@ columns, empty, log) {
     }
     (0, format_1.renderTable)(rows, columns, log);
 }
+function describeRunCount(usage, key) {
+    const value = usage?.[key];
+    const status = usage?.[`${key}Status`];
+    if (status === 'unknown' ||
+        typeof value !== 'number' ||
+        !Number.isSafeInteger(value) ||
+        value < 0) {
+        return 'unknown';
+    }
+    // A native session proves a floor, not the provider's complete internal
+    // activity. Preserve that distinction in the human ledger, too.
+    if (status === 'lower_bound')
+        return `at least ${value}`;
+    if (status !== undefined && status !== null)
+        return 'unknown';
+    return String(value);
+}
 /** Human view for `commitments ledger`; JSON remains the automation surface. */
 function renderCommitmentLedger(ledger, log) {
     const checks = records(ledger.checks);
@@ -1073,12 +1090,16 @@ function renderCommitmentLedger(ledger, log) {
             id: text(item.id),
             status: text(item.status),
             attempt: `${text(item.attempt, '0')}/${text(item.maxAttempts, '-')}`,
+            turns: describeRunCount(record(item.usage), 'turns'),
+            tools: describeRunCount(record(item.usage), 'toolCallCount'),
             reason: text(firstValue(item, ['reason', 'error']), ''),
             finished: text(firstValue(item, ['completedAt', 'updatedAt', 'startedAt'])),
         })), [
             { key: 'id', header: 'RUN ID', verbatim: true },
             { key: 'status', header: 'STATUS', maxWidth: 12 },
             { key: 'attempt', header: 'ATTEMPT' },
+            { key: 'turns', header: 'TURNS' },
+            { key: 'tools', header: 'TOOLS' },
             { key: 'reason', header: 'REASON', maxWidth: 36 },
             { key: 'finished', header: 'LAST UPDATED', maxWidth: 24 },
         ], 'No runs recorded.', log);
@@ -1247,13 +1268,24 @@ function formatCommitmentCycles(page) {
  */
 function formatCycleLatency(cycle) {
     const latency = cycle.latency;
+    const history = cycle.historyDetail;
+    const disclosure = history?.state === 'compacted'
+        ? [
+            `             Detailed history was compacted${history.at ? ` at ${history.at}` : ''}; available reason and source timestamps were retained.`,
+        ]
+        : history?.state === 'unavailable'
+            ? ['             Detailed history is unavailable; why it is missing was not recorded.']
+            : [];
     const missingFor = (stage) => (latency?.pendingStages ? latency.pendingStages.includes(stage) : latency?.pending)
         ? 'pending'
         : 'unmeasurable';
     if (latency?.measured === false) {
-        return [`             latency: ${latency.pending ? 'pending' : 'unmeasurable'}`];
+        return [...disclosure, `             latency: ${latency.pending ? 'pending' : 'unmeasurable'}`];
     }
-    return Object.entries(latency?.stages || {}).map(([stage, ms]) => `             ${stage}: ${typeof ms === 'number' ? `${ms}ms` : missingFor(stage)}`);
+    return [
+        ...disclosure,
+        ...Object.entries(latency?.stages || {}).map(([stage, ms]) => `             ${stage === 'event_to_turn' ? 'event_to_turn (server handoff)' : stage}: ${typeof ms === 'number' ? `${ms}ms` : missingFor(stage)}`),
+    ];
 }
 const ANSWER_GLYPH = { yes: '✓', no: '✗', 'n/a': '–' };
 /** The six questions for the latest Cycle, the first ✗ carrying its fix. */

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

@@ -633,15 +633,13 @@ export declare function dedicatedLeaseDisplayName(lease: DedicatedLease | Harnes
 /** `$12.34` — cents are what the API speaks; dollars are what a person reads. */
 export declare function formatUsdCents(cents: number | null | undefined): string;
 /**
- * `$1.23 this month for machines of this type · $500.00 cap for this machine`,
- * or why that sentence cannot be written.
+ * Name the monthly total that the machine's configured cap is checked against.
  *
- * The two figures are different scopes and the sentence has to say so. The spend
- * is a shared pot the server computes for (owner, team, machineProduct), so every
+ * The spend is a shared pot the server computes for (owner, team, machineProduct), so every
  * lease of the same product reports the same number — a machine created minutes
- * ago with no active seconds still reports the month's total. The cap is this
- * lease's own. Printed as "$1.23 this month of $500.00 cap" the only available
- * reading was that this machine had spent it.
+ * ago with no active seconds still reports the month's total. The cap is set on
+ * this lease, but admission compares it against that shared projected total.
+ * An old response without spendScope cannot establish who owns the total.
  */
 export declare function dedicatedSpendSummary(lease: DedicatedLease): string;
 /**