@skrr-ai/cli 0.1.109 → 0.1.110

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

@@ -30,12 +30,22 @@ class SpacesWorkflowsValidate extends base_command_1.BaseCommand {
             this.handleApiError(error);
             return;
         }
+        // The one rule (OSK-16493): an error-severity issue means invalid, whatever `valid` says. A
+        // server that predates the shared gate answered `valid: true` beside such an issue, and the
+        // text view then called the draft ready to publish and hid the issue.
+        const blocking = (0, data_provider_1.blockingWorkflowIssues)(result.issues ?? []);
+        const valid = Boolean(result.valid) && blocking.length === 0;
         if (flags.json) {
             this.log(JSON.stringify((0, space_output_1.withSpacePerspectiveUrl)(this.cliConfig.baseURL, args.spaceId, 'workflows', result), null, 2));
+            // One answer, two renderings: an invalid draft fails the command in either mode, so a
+            // script reading --json can trust the exit status exactly as a person reading text can
+            // (OSK-16473).
+            if (!valid)
+                this.exit(1);
             return;
         }
         const advisories = (result.issues ?? []).filter((issue) => issue.severity !== 'error');
-        if (result.valid) {
+        if (valid) {
             this.log('Workflow draft is valid and ready to publish.');
             if (advisories.length) {
                 this.log(`${advisories.length} warning${advisories.length === 1 ? '' : 's'} (publishing is allowed):`);
@@ -44,7 +54,7 @@ class SpacesWorkflowsValidate extends base_command_1.BaseCommand {
             }
             return;
         }
-        this.log(`Workflow draft is invalid${result.code ? ` (${result.code})` : ''}: ${result.message ?? 'Unknown validation error'}`);
+        this.log(`Workflow draft is invalid${result.code ? ` (${result.code})` : ''}: ${result.message ?? blocking[0]?.message ?? 'Unknown validation error'}`);
         // Every problem, not only the first one publish would stop at.
         const all = result.issues ?? [];
         if (all.length) {

package/dist/commands/tasks/activity.js

@@ -8,6 +8,16 @@ const base_command_1 = require("../../base-command");
 const format_1 = require("../../lib/format");
 const task_economics_1 = require("../../lib/task-economics");
 const task_legacy_1 = require("../../lib/task-legacy");
+/**
+ * A system-written embedded entry names no person (OSK-16475): it carries
+ * `details.actorKind: 'system'` instead of a `userId`, so the actor is the service.
+ */
+function systemEntryActor(details) {
+    const value = details;
+    if (value?.actorKind !== 'system')
+        return undefined;
+    return `system:${value.actorService ?? '-'}`;
+}
 function activityRow(entry) {
     const actor = entry.actor;
     const actorText = actor
@@ -18,7 +28,7 @@ function activityRow(entry) {
                 : actor.kind === 'integration'
                     ? `integration:${actor.provider}`
                     : `system:${actor.service}`
-        : (entry.userId ?? entry.actorId);
+        : (entry.userId ?? entry.actorId ?? systemEntryActor(entry.details));
     const type = entry.action ?? entry.event ?? entry.type;
     return {
         time: (0, format_1.localTime)(entry.occurredAt ?? entry.timestamp ?? entry.createdAt),

package/dist/commands/tasks/list.js

@@ -588,7 +588,9 @@ class TasksList extends base_command_1.BaseCommand {
             Array.isArray(response.data)) {
             response = {
                 ...response,
-                data: (0, data_provider_1.rankEconomicItems)(response.data),
+                // Each row carries the `economicsRank` it was sorted by, so `--json` shows the same SCORE
+                // as the table, computed once in the shared ranking (OSK-16476).
+                data: (0, data_provider_1.annotateEconomicRank)(response.data),
                 rank_applied: { key: 'economics', scope: 'fetched_page' },
             };
         }
@@ -693,7 +695,9 @@ class TasksList extends base_command_1.BaseCommand {
                     : 'Unknown',
                 effort: economics?.effortHours !== undefined ? `${economics.effortHours}h` : 'Unknown',
                 risk: economics?.risk ?? 'Unknown',
-                score: (0, task_economics_1.economicsScoreText)(economics),
+                score: t.economicsRank
+                    ? (0, task_economics_1.scoreText)(t.economicsRank.score)
+                    : (0, task_economics_1.economicsScoreText)(economics),
                 basis: economics?.basis && Object.prototype.hasOwnProperty.call(basis, economics.basis)
                     ? basis[economics.basis]
                     : 'Unknown',

package/dist/commands/tasks/rearm-recurrence.js

@@ -60,9 +60,28 @@ class TasksRearmRecurrence extends base_command_1.BaseCommand {
         const from = finished.identifier || finished.id || taskRef;
         const next = result.successor.identifier || result.successor.id;
         const when = result.successor.scheduledFor ? ` for ${result.successor.scheduledFor}` : '';
-        this.log(result.alreadyArmed
-            ? `The series from ${from} was already armed: next occurrence ${next}${when}. The failure marker is cleared.`
-            : `Re-armed the series from ${from}: next occurrence ${next} is scheduled${when}.`);
+        // The server's sentence IS the answer: it is derived with the JSON fields, so the two can
+        // never disagree (round 3 of OSK-15321 found them disagreeing). The fallback below is only
+        // for an older server that sends no `message`.
+        if (typeof result.message === 'string' && result.message) {
+            this.log(result.message);
+            return;
+        }
+        // Never call a successor with no schedule "armed": it will not fire (#4262 verification).
+        let line;
+        if (!result.successor.scheduledFor) {
+            line = `The next occurrence ${next} of the series from ${from} exists but has no schedule, so nothing will fire it on its own; start it by hand or give it a time with \`${this.config.bin} tasks schedule ${next} --at <ISO time>\`.`;
+        }
+        else if (result.rescheduled) {
+            line = `The next occurrence ${next} existed but had no schedule; it is now scheduled${when}. The failure marker is cleared.`;
+        }
+        else if (result.alreadyArmed) {
+            line = `The series from ${from} was already armed: next occurrence ${next}${when}. The failure marker is cleared.`;
+        }
+        else {
+            line = `Re-armed the series from ${from}: next occurrence ${next} is scheduled${when}.`;
+        }
+        this.log(line);
     }
 }
 exports.default = TasksRearmRecurrence;

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

@@ -69,6 +69,14 @@ export declare function labelsLine(labelIds?: string[], nameById?: Map<string, s
  * reassigning the task changes only the implied kind.
  */
 export declare function taskExecutorLabel(t: Record<string, unknown>, bin?: string): string;
+/**
+ * The `Resolution:` lines for any resolved Task: how it ended, the reason the
+ * closer recorded, who closed it, and what the close stood on. The reason used to
+ * be JSON-only, so text showed "Task workflow type is cancelled" for every
+ * cancel, and a Task its Workflow step cancelled could not be told from one a
+ * person cancelled by hand (OSK-16475). Silent for an open Task.
+ */
+export declare function resolutionLines(t: Record<string, unknown>, names?: Map<string, string>): string[];
 /**
  * The `Recurrence:` line for a series whose next occurrence was never armed.
  * Silent otherwise: a healthy series has nothing to say here.

package/dist/commands/tasks/show.js

@@ -6,6 +6,7 @@ exports.completionLines = completionLines;
 exports.reviewPolicyLine = reviewPolicyLine;
 exports.labelsLine = labelsLine;
 exports.taskExecutorLabel = taskExecutorLabel;
+exports.resolutionLines = resolutionLines;
 exports.recurrenceArmFailureLines = recurrenceArmFailureLines;
 exports.taskFailureLines = taskFailureLines;
 const core_1 = require("@oclif/core");
@@ -151,6 +152,43 @@ function taskExecutorLabel(t, bin = 'skrr') {
             return '-';
     }
 }
+function resolverLabel(by, names) {
+    if (!by || typeof by !== 'object' || !by.kind)
+        return null;
+    const kind = String(by.kind);
+    if (kind === 'human')
+        return `person ${(0, principal_display_1.displayPrincipal)(by.userId, names)}`;
+    if (kind === 'agent')
+        return `agent ${(0, principal_display_1.displayPrincipal)(by.agentId, names)}`;
+    if (kind === 'system')
+        return `system${by.service ? ` (${String(by.service)})` : ''}`;
+    if (kind === 'integration')
+        return `integration${by.provider ? ` (${String(by.provider)})` : ''}`;
+    return kind;
+}
+/**
+ * The `Resolution:` lines for any resolved Task: how it ended, the reason the
+ * closer recorded, who closed it, and what the close stood on. The reason used to
+ * be JSON-only, so text showed "Task workflow type is cancelled" for every
+ * cancel, and a Task its Workflow step cancelled could not be told from one a
+ * person cancelled by hand (OSK-16475). Silent for an open Task.
+ */
+function resolutionLines(t, names) {
+    const resolution = t.resolution;
+    if (!resolution || typeof resolution !== 'object' || !resolution.kind)
+        return [];
+    const reason = typeof resolution.reason === 'string' ? resolution.reason.trim() : '';
+    const closure = resolution.closure
+        ? (0, task_closure_1.closureSnapshotLines)(resolution.closure)
+        : [];
+    const lines = [`Resolution:  ${String(resolution.kind)}${reason ? ` — ${reason}` : ''}`];
+    if (closure.length > 0)
+        lines.push(`             ${closure.join(' ')}`);
+    const by = resolverLabel(resolution.resolvedBy, names);
+    if (by)
+        lines.push(`Resolved by: ${by}`);
+    return lines;
+}
 /**
  * The `Recurrence:` line for a series whose next occurrence was never armed.
  * Silent otherwise: a healthy series has nothing to say here.
@@ -163,10 +201,14 @@ function recurrenceArmFailureLines(t, bin = 'skrr') {
     const ref = (typeof t.identifier === 'string' && t.identifier) ||
         (typeof t.id === 'string' && t.id) ||
         '<task-id>';
+    // A finished occurrence is re-armed (`tasks schedule` refuses it, OSK-15338); a LIVE series the
+    // scheduler stopped on an unrunnable pattern is rescheduled with a valid one, which clears it.
+    const finished = ['completed', 'cancelled'].includes(String(t.statusType ?? ''));
     return [
         `Recurrence:  ${(0, data_provider_1.describeRecurrenceArmFailure)(code)} (${code})`,
-        // Not `tasks schedule`: that refuses the finished occurrence carrying this failure (OSK-15338).
-        `             ${(0, task_recurrence_outcome_1.recurrenceRearmHint)(code, ref, bin)}`,
+        finished || t.statusType === undefined
+            ? `             ${(0, task_recurrence_outcome_1.recurrenceRearmHint)(code, ref, bin)}`
+            : `             Reschedule it with \`${bin} tasks schedule ${ref} --at <ISO time> --cron "<minute hour day month weekday>"\`.`,
     ];
 }
 /**
@@ -352,6 +394,21 @@ class TasksShow extends base_command_1.BaseCommand {
             this.log(line);
         const agents = Array.isArray(t.assigneeAgentIds) ? t.assigneeAgentIds : [];
         const users = Array.isArray(t.assigneeUserIds) ? t.assigneeUserIds : [];
+        // Principals print as names, not ObjectIds — same rule as labels: a
+        // roster that cannot be read prints ids rather than failing the command.
+        const resolvedBy = t.resolution?.resolvedBy;
+        const principalIds = [
+            t.author,
+            t.dri?.resolved?.id,
+            ...(Array.isArray(t.assigneeAgentIds) ? t.assigneeAgentIds : []),
+            ...(Array.isArray(t.assigneeUserIds) ? t.assigneeUserIds : []),
+            t.economics?.confirmedBy,
+            resolvedBy?.userId,
+            resolvedBy?.agentId,
+        ];
+        const principalNames = await (0, principal_display_1.resolvePrincipalNames)(principalIds, {
+            spaceId: t.spaceId ?? null,
+        });
         this.log(`ID:          ${t.id ?? t._id ?? '-'}`);
         this.log(`Ref:         ${t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '-')}`);
         this.log(`Title:       ${t.title ?? '-'}`);
@@ -368,25 +425,12 @@ class TasksShow extends base_command_1.BaseCommand {
          * Closing is the actor's call — a Task may be `done` with work still
          * outstanding, and `resolution.closure` is where the server recorded what
          * it stood on at close. Show it so a bare "done" never reads as "clean."
+         * The closure sentences share the `tasks move` receipt's renderer, so the
+         * two cannot disagree; the reason and the closer are printed for every
+         * resolved Task (OSK-16475).
          */
-        const resolution = t.resolution;
-        /*
-         * Same renderer as the `tasks move` receipt, so the two cannot disagree
-         * about a Task they are both describing.
-         *
-         * This copy showed an owner's ordinary close as an override:
-         * `TASK_RESULT_REVIEW_REQUIRED` lands in `blockers` whenever the policy is
-         * unsatisfied — including when the owner, who is not bound by the Review
-         * they declared, closes it themselves — and this rendered it identically to
-         * a genuine forced close. So the only read surface for "was this gate
-         * overridden?" could not answer the question.
-         */
-        if (resolution?.closure) {
-            const sentences = (0, task_closure_1.closureSnapshotLines)(resolution.closure);
-            if (sentences.length > 0) {
-                this.log(`Resolution:  ${resolution.kind ?? '-'} — ${sentences.join(' ')}`);
-            }
-        }
+        for (const line of resolutionLines(t, principalNames))
+            this.log(line);
         /*
          * A Result orphaned by a spec edit is not the same as no Result.
          *
@@ -519,18 +563,6 @@ class TasksShow extends base_command_1.BaseCommand {
             }
         }
         this.log(`Labels:      ${labelsLine(labelIds, labelNames)}`);
-        // Principals print as names, not ObjectIds — same rule as labels above: a
-        // roster that cannot be read prints ids rather than failing the command.
-        const principalIds = [
-            t.author,
-            t.dri?.resolved?.id,
-            ...(Array.isArray(t.assigneeAgentIds) ? t.assigneeAgentIds : []),
-            ...(Array.isArray(t.assigneeUserIds) ? t.assigneeUserIds : []),
-            t.economics?.confirmedBy,
-        ];
-        const principalNames = await (0, principal_display_1.resolvePrincipalNames)(principalIds, {
-            spaceId: t.spaceId ?? null,
-        });
         this.log(`Author:      ${t.authorDisplayName || (0, principal_display_1.displayPrincipal)(t.author, principalNames)}`);
         const dri = t.dri;
         if (dri?.resolved) {

package/dist/commands/tasks/unschedule.js

@@ -5,7 +5,11 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const web_url_1 = require("../../lib/web-url");
 class TasksUnschedule extends base_command_1.BaseCommand {
-    static description = 'Clear the schedule on a task (no future fires)';
+    // Decision (OSK-15321, round 3): unschedule ENDS the series at this occurrence; it clears the
+    // time and the recurrence. Stopping without ending is `pause-schedule` (keeps the series,
+    // `resume-schedule` continues it). A series ended here by mistake is restored, settings and
+    // all, with `rearm-recurrence <the previous occurrence>`.
+    static description = 'Clear the schedule on a task and end its series here (no future fires). To stop without ending the series use pause-schedule; to restore an ended series run rearm-recurrence on the previous occurrence';
     static examples = [
         '<%= config.bin %> tasks unschedule <task-id>',
         '<%= config.bin %> tasks unschedule <task-id> --json',

package/dist/commands/tasks/update.js

@@ -543,7 +543,17 @@ class TasksUpdate extends base_command_1.BaseCommand {
         }
         const t = updated;
         const ref = t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '');
-        this.log(`Updated task ${t.id ?? t._id ?? taskRef}${ref ? ` (${ref})` : ''} — ${t.title ?? '(no title)'}`);
+        const label = `${t.id ?? t._id ?? taskRef}${ref ? ` (${ref})` : ''}`;
+        // The server's own answer about the estimate (OSK-16476): a no-op says so, never "Updated".
+        const unchanged = (0, task_economics_1.estimateUnchangedLine)(payload.economics, t);
+        const onlyEstimate = payloadKeys.every((key) => key === 'economics' || payload[key] === undefined);
+        if (unchanged && onlyEstimate) {
+            this.log(`Task ${label}: ${unchanged}`);
+            return;
+        }
+        this.log(`Updated task ${label} — ${t.title ?? '(no title)'}`);
+        if (unchanged)
+            this.log(unchanged);
         // `--yes` asserts the revocation; it does not erase that it happened.
         // Report the cost after the write too, or the evidence is silently gone.
         if (changesSpec && flags.yes && (settledSpecAssessments > 0 || acceptanceUnreadable)) {

package/dist/commands/triggers/audit.js

@@ -25,17 +25,25 @@ class TriggersAudit extends base_command_1.BaseCommand {
         agent: core_1.Flags.string({ description: 'Agent ID filter for owner-wide audit history' }),
         scope: core_1.Flags.string({ description: 'Scope kind filter for owner-wide audit history' }),
         outcome: core_1.Flags.string({
-            description: 'Outcome filter for owner-wide audit history (succeeded, failed, skipped, incomplete, capped, ...); an unknown value is refused with the full list',
+            description: 'Outcome filter (succeeded, failed, skipped, incomplete, capped, ...); an unknown value is refused with the full list',
         }),
         source: core_1.Flags.string({
-            description: 'Source filter for owner-wide audit history (schedule, once, event, manual, webhook, replay, ...); an unknown value is refused with the full list',
+            description: 'Source filter (schedule, once, event, manual, webhook, replay, ...); an unknown value is refused with the full list',
         }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TriggersAudit);
         const triggerId = args.id ?? flags.trigger;
-        const path = triggerId
+        // The per-trigger route takes no filters. A filter passed with a trigger id used to be
+        // dropped without a word, so `--outcome failed` listed succeeded rows and exited 0 (OSK-16474).
+        // A filter now always reaches the filtered history, narrowed to that trigger; that history
+        // covers triggers you own, which is said out loud rather than discovered.
+        const filtered = [flags.outcome, flags.source, flags.scope, flags.agent].some((value) => value !== undefined);
+        if (triggerId && filtered && !flags.json) {
+            this.warn('Filters read the fire history of triggers you own: a trigger shared with you but owned by someone else lists no rows here (omit the filters to read its own audit).');
+        }
+        const path = triggerId && !filtered
             ? (0, triggers_1.withQuery)(`/api/triggers/${encodeURIComponent(triggerId)}/audit`, {
                 limit: flags.limit,
                 before: flags.before,
@@ -47,6 +55,7 @@ class TriggersAudit extends base_command_1.BaseCommand {
                 agentId: flags.agent,
                 outcome: flags.outcome,
                 source: flags.source,
+                ...(triggerId ? { triggerId } : {}),
             });
         let response;
         try {

package/dist/commands/triggers/create.js

@@ -99,7 +99,7 @@ class TriggersCreate extends base_command_1.BaseCommand {
             description: 'ISO-8601 datetime after which a schedule stops firing',
         }),
         'stale-catchup-ms': core_1.Flags.integer({
-            description: 'How late a missed occurrence may still run, in ms (a positive number). After downtime, an occurrence more than this overdue is skipped rather than run late, and the schedule moves to its next future slot. Unset: 3600000 (1 hour).',
+            description: 'How late a missed occurrence may still run, in ms, from 1000 (1 second) to 31622400000 (366 days). After downtime, an occurrence more than this overdue is skipped rather than run late, and the schedule moves to its next future slot. Unset: 3600000 (1 hour).',
         }),
         at: core_1.Flags.string({
             description: 'ISO-8601 datetime for once triggers. --next-run-at is also accepted with --kind once for backwards compatibility.',

package/dist/commands/triggers/fire-detail.d.ts

@@ -1,4 +1,11 @@
 import { BaseCommand } from '../../base-command';
+/**
+ * The text rendering of one fire. `reason` is the typed code and `errorMessage` the sentence a
+ * person reads; the view printed whichever came first, so a fire that resolved nothing showed
+ * only `Reason: no_waiting_step` and its sentence ("No step in this Space was waiting on that
+ * event key.") was JSON-only (OSK-16474). Both are shown now when both exist.
+ */
+export declare function describeFireAuditDetail(detail: Record<string, unknown>, fireId: string, triggerId: string): string[];
 export default class TriggersFireDetail extends BaseCommand {
     static description: string;
     static examples: string[];

package/dist/commands/triggers/fire-detail.js

@@ -1,8 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeFireAuditDetail = describeFireAuditDetail;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const triggers_1 = require("../../lib/triggers");
+/**
+ * The text rendering of one fire. `reason` is the typed code and `errorMessage` the sentence a
+ * person reads; the view printed whichever came first, so a fire that resolved nothing showed
+ * only `Reason: no_waiting_step` and its sentence ("No step in this Space was waiting on that
+ * event key.") was JSON-only (OSK-16474). Both are shown now when both exist.
+ */
+function describeFireAuditDetail(detail, fireId, triggerId) {
+    const text = (value) => (typeof value === 'string' && value.trim() ? value.trim() : '');
+    const lines = [
+        `Fire:         ${String(detail._id ?? fireId)}`,
+        `Trigger:      ${String(detail.triggerId ?? triggerId)}`,
+        `Fired at:     ${String(detail.firedAt ?? '-')}`,
+        `Outcome:      ${String(detail.outcome ?? '-')}`,
+        `Source:       ${String(detail.source ?? '-')}`,
+    ];
+    const reason = text(detail.reason);
+    const message = text(detail.errorMessage);
+    if (reason)
+        lines.push(`Reason:       ${reason}`);
+    if (message && message !== reason)
+        lines.push(`${reason ? 'Detail:' : 'Reason:'}       ${message}`);
+    if (detail.durationMs !== undefined)
+        lines.push(`Duration:     ${String(detail.durationMs)}ms`);
+    if (detail.conversationId)
+        lines.push(`Conversation: ${String(detail.conversationId)}`);
+    return lines;
+}
 class TriggersFireDetail extends base_command_1.BaseCommand {
     static description = 'Show full detail for one trigger fire record';
     static examples = [
@@ -34,18 +62,8 @@ class TriggersFireDetail extends base_command_1.BaseCommand {
             this.log(JSON.stringify(detail, null, 2));
             return;
         }
-        this.log(`Fire:         ${detail._id ?? args.fireId}`);
-        this.log(`Trigger:      ${detail.triggerId ?? args.id}`);
-        this.log(`Fired at:     ${detail.firedAt ?? '-'}`);
-        this.log(`Outcome:      ${detail.outcome ?? '-'}`);
-        this.log(`Source:       ${detail.source ?? '-'}`);
-        if (detail.reason || detail.errorMessage) {
-            this.log(`Reason:       ${detail.reason ?? detail.errorMessage}`);
-        }
-        if (detail.durationMs !== undefined)
-            this.log(`Duration:     ${detail.durationMs}ms`);
-        if (detail.conversationId)
-            this.log(`Conversation: ${detail.conversationId}`);
+        for (const line of describeFireAuditDetail(detail, args.fireId, args.id))
+            this.log(line);
     }
 }
 exports.default = TriggersFireDetail;

package/dist/commands/triggers/fire.js

@@ -46,9 +46,17 @@ class TriggersFire extends base_command_1.BaseCommand {
         }
         const accepted = (0, triggers_1.fireWasAccepted)(result);
         if (flags.json) {
-            this.log(JSON.stringify(result, null, 2));
-            if (flags.strict && !accepted)
+            // `ok` and the exit status are one answer: a strict refusal prints `ok: false` and why,
+            // never the server's transport-level `ok: true` beside exit 1 (OSK-16494).
+            const refused = flags.strict && !accepted;
+            this.log(JSON.stringify(refused
+                ? { ...result, ok: false, strictRefusal: (0, triggers_1.describeStrictFireRefusal)(result) }
+                : result, null, 2));
+            if (refused) {
+                // stdout stays the one JSON document; the reason goes to stderr.
+                process.stderr.write(`${(0, triggers_1.describeStrictFireRefusal)(result)}\n`);
                 this.exit(1);
+            }
             return;
         }
         this.log(`Fire requested: outcome=${String(result.outcome ?? '-')} reason=${String(result.reason ?? '-')}`);
@@ -57,8 +65,10 @@ class TriggersFire extends base_command_1.BaseCommand {
         const note = (0, triggers_1.describeScheduledFire)(result);
         if (note)
             this.log(note);
-        if (flags.strict && !accepted)
+        if (flags.strict && !accepted) {
+            process.stderr.write(`${(0, triggers_1.describeStrictFireRefusal)(result)}\n`);
             this.exit(1);
+        }
     }
 }
 exports.default = TriggersFire;

package/dist/commands/triggers/parse-intent.js

@@ -26,7 +26,7 @@ class TriggersParseIntent extends base_command_1.BaseCommand {
             multiple: true,
         }),
         'history-json': core_1.Flags.string({
-            description: 'Parser history JSON array of {role:"user"|"assistant",content:string} objects. To answer a clarifying question, pass the `history` a previous --json run returned and add your reply with --message',
+            description: 'Parser history: an inline JSON array of {role:"user"|"assistant",content:string} objects, or @file / a path to a file holding it. To answer a clarifying question, pass the `history` a previous --json run returned and add your reply with --message',
         }),
         timezone: core_1.Flags.string({ description: 'IANA timezone used for relative times' }),
         now: core_1.Flags.string({ description: 'Override current ISO timestamp used for relative times' }),

package/dist/commands/triggers/update.js

@@ -56,7 +56,7 @@ class TriggersUpdate extends base_command_1.BaseCommand {
             description: 'ISO-8601 datetime after which a schedule stops firing',
         }),
         'stale-catchup-ms': core_1.Flags.integer({
-            description: 'How late a missed occurrence may still run, in ms (a positive number). After downtime, an occurrence more than this overdue is skipped rather than run late, and the schedule moves to its next future slot. Unset: 3600000 (1 hour).',
+            description: 'How late a missed occurrence may still run, in ms, from 1000 (1 second) to 31622400000 (366 days). After downtime, an occurrence more than this overdue is skipped rather than run late, and the schedule moves to its next future slot. Unset: 3600000 (1 hour).',
         }),
         at: core_1.Flags.string({ description: 'ISO-8601 datetime for once triggers' }),
         entity: core_1.Flags.string({

package/dist/commands/workspaces/grants.js

@@ -39,10 +39,7 @@ async function memberNames(workspaceId) {
     try {
         const members = await (0, workspaces_1.listWorkspaceMembers)(workspaceId);
         return new Map(members
-            .map((member) => [
-            String(member.userId),
-            member.user?.name || member.user?.username || member.user?.email || '',
-        ])
+            .map((member) => [member.userId, member.name ?? member.email ?? ''])
             .filter(([, name]) => name));
     }
     catch {

package/dist/commands/workspaces/members.js

@@ -36,7 +36,7 @@ class WorkspacesMembers extends base_command_1.BaseCommand {
             return;
         }
         if (flags.json) {
-            this.log(JSON.stringify(members, null, 2));
+            this.printJsonResult(members);
             return;
         }
         if (members.length === 0) {
@@ -44,11 +44,11 @@ class WorkspacesMembers extends base_command_1.BaseCommand {
             return;
         }
         (0, format_1.renderTable)(members.map((member) => ({
-            userId: String(member.userId),
-            name: member.user?.name || member.user?.username || '—',
-            email: member.user?.email || '—',
-            role: member.role || '—',
-            joined: member.joinedAt || '—',
+            userId: member.userId,
+            name: member.name ?? '—',
+            email: member.email ?? '—',
+            role: member.role ?? '—',
+            joined: member.joinedAt ?? '—',
         })), [
             { key: 'userId', header: 'USER ID', verbatim: true },
             { key: 'name', header: 'NAME', maxWidth: 28 },

package/dist/lib/commitment-product.js

@@ -62,9 +62,12 @@ function renderExecutionReceipt(receipt, log, verbose = false) {
     // restates what happened (a typed blocker's summary, which servers before
     // OSK-16429 sent as the reason) is narrative, not something to do: the actor
     // is printed without it and the narrative stays with the blocker.
+    // A bare reason code (servers before OSK-16451 sent `runtime_connection_unverifiable`
+    // there) is not an action either: the actor is printed alone.
     const narrative = [receipt.summary, receipt.blocker?.summary].filter(Boolean);
-    const action = receipt.nextActor?.reason && !narrative.includes(receipt.nextActor.reason)
-        ? receipt.nextActor.reason
+    const reason = receipt.nextActor?.reason;
+    const action = reason && !narrative.includes(reason) && !/^[A-Za-z0-9_.:-]+$/.test(reason.trim())
+        ? reason
         : '';
     if (receipt.nextActor)
         log(`Next: ${receipt.nextActor.label || receipt.nextActor.kind}${action ? ` — ${action}` : ''}`);

package/dist/lib/commitments.d.ts

@@ -832,8 +832,9 @@ export declare function describeOperation(operation: string | null | undefined,
  * under "Fix:" read as a remedy nobody wrote (OSK-16230). That narrative is
  * labelled `Blocker:` instead, and no remedy is made up for it.
  */
+type OperationFixLabel = 'Fix' | 'Blocker' | 'Last run';
 export declare function describeOperationFix(commitment: CommitmentView, operation: string | null | undefined): Array<{
-    label: 'Fix' | 'Blocker';
+    label: OperationFixLabel;
     text: string;
 }>;
 /**