@skrr-ai/cli 0.1.128 → 0.1.129

package/dist/commands/tasks/list.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveListWorkspace = resolveListWorkspace;
 exports.agentSessionOpenDefault = agentSessionOpenDefault;
 exports.emptyTasksMessage = emptyTasksMessage;
 exports.externalKeyPrefixWarnings = externalKeyPrefixWarnings;
 exports.nextActionText = nextActionText;
 exports.nextColumnWidth = nextColumnWidth;
 exports.taskRef = taskRef;
+exports.calendarJsonRow = calendarJsonRow;
+exports.calendarJsonResponse = calendarJsonResponse;
 exports.taskExecution = taskExecution;
 exports.taskPageSummary = taskPageSummary;
 exports.taskExecutionText = taskExecutionText;
@@ -18,7 +21,9 @@ const web_url_1 = require("../../lib/web-url");
 const format_1 = require("../../lib/format");
 const list_output_1 = require("../../lib/list-output");
 const tasks_1 = require("../../lib/tasks");
+const workspaces_1 = require("../../lib/workspaces");
 const task_economics_1 = require("../../lib/task-economics");
+const task_calendar_1 = require("../../lib/task-calendar");
 /**
  * Names of `tasks list` flags that narrow the result set. Used to distinguish
  * "no tasks anywhere" from "no tasks matching your filters" — the first case
@@ -63,6 +68,55 @@ const FILTER_FLAGS = new Set([
     'q',
     'view',
 ]);
+/**
+ * A plain `tasks list` named no workspace, and the server answers that with a list across EVERY
+ * workspace the person belongs to. Its access filter has branches that belong to no single
+ * workspace, so no index can serve it in order: on production it timed out after about 6 s while
+ * the same list naming a workspace answered in about a second. `skrr workspaces list` already says
+ * an unselected session "resolves to your default workspace"; a list now reads it too.
+ *
+ *   --all-workspaces   the old, wider list, asked for by name (`workspaceScope=all`)
+ *   a selected workspace, `--workspace`, or `skrr workspaces use`   untouched: the choice stands
+ *   an autonomous Agent session   untouched: a workspace-less Agent session stays personal
+ *   `--space`, `--calendar`   untouched: a Space names its own scope
+ *
+ * Returns nothing when there is nothing to apply, and `source: 'default'` when the caller's
+ * default workspace should be used. `lookupDefault` is injected so the rule is tested without the
+ * network; a lookup that fails or finds no default changes nothing.
+ */
+async function resolveListWorkspace(flags, env, lookupDefault) {
+    if (flags['all-workspaces'])
+        return { source: 'all' };
+    if (env.OVERSKY_WORKSPACE_ID?.trim())
+        return undefined;
+    if (env.OVERSKY_AUTONOMOUS_SESSION === '1')
+        return undefined;
+    if (flags.space || flags.calendar)
+        return undefined;
+    let found = null;
+    try {
+        found = await lookupDefault();
+    }
+    catch {
+        return undefined;
+    }
+    if (!found?.id)
+        return undefined;
+    return {
+        source: 'default',
+        workspaceId: found.id,
+        ...(found.name ? { workspaceName: found.name } : {}),
+        workspaceCount: found.count,
+    };
+}
+/** The default workspace the signed-in person's `skrr workspaces list` reports. */
+async function lookupDefaultWorkspace() {
+    const listing = await (0, workspaces_1.listWorkspaceListing)();
+    if (!listing.defaultWorkspaceId)
+        return null;
+    const row = listing.rows.find((entry) => entry.id === listing.defaultWorkspaceId);
+    return { id: listing.defaultWorkspaceId, ...(row?.name ? { name: row.name } : {}), count: listing.rows.length };
+}
 /**
  * E12: inside an agent session an unfiltered `tasks list --json` returned the
  * first page of EVERYTHING, which in practice was cancelled test tasks. When the
@@ -234,6 +288,43 @@ function nextColumnWidth(rows) {
 function taskRef(t) {
     return String(t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '-'));
 }
+/**
+ * A calendar row in `--json`: the Task it places, by the names `tasks show` resolves.
+ *
+ * The server's occurrence `id` is `<taskId>:<kind>:<instant>`, a key for the occurrence, and the
+ * list shaping every other `tasks list` row gets (`ref` and `url` read off the row itself, and
+ * `nextAction` off its actionability) turned it into an `id`, a `url` and a `ref` that named
+ * nothing: `tasks show` refused the first two and the third was "-" (OSK-21586, OSK-21587). So the
+ * row's `id`, `ref` and `url` are the Task's, and the occurrence key is `occurrenceId`. A missing
+ * answer is `null`, never a placeholder.
+ */
+function calendarJsonRow(baseURL, row) {
+    const task = (row.task ?? {});
+    const taskId = (row.taskId ?? task.id);
+    const next = nextActionText(task);
+    return {
+        ...row,
+        id: taskId ?? row.id,
+        occurrenceId: row.id,
+        ref: task.identifier ?? null,
+        nextAction: next === '-' ? null : next,
+        url: taskId ? (0, web_url_1.taskUrlFrom)(baseURL, { id: taskId, spaceId: task.spaceId }) : null,
+    };
+}
+/** The calendar response with its rows made addressable; everything else stays as the server sent it. */
+function calendarJsonResponse(baseURL, response) {
+    if (!response || typeof response !== 'object')
+        return response;
+    const calendar = response;
+    if (!Array.isArray(calendar.data))
+        return response;
+    return {
+        ...calendar,
+        data: calendar.data.map((row) => row && typeof row === 'object'
+            ? calendarJsonRow(baseURL, row)
+            : row),
+    };
+}
 /** Evidence about managed execution only; unmanaged work is outside this projection. */
 function taskExecution(t) {
     const actionability = t.actionability;
@@ -351,6 +442,7 @@ function buildListParams(flags, assigneeUserId) {
         ...(flag('explicit-only') ? { explicitOnly: true } : {}),
         ...(flag('subscribed') ? { subscribed: true } : {}),
         ...(flag('include-snoozed') ? { includeSnoozed: true } : {}),
+        ...(flag('all-workspaces') ? { workspaceScope: 'all' } : {}),
         ...(flag('external-key')
             ? { externalKey: flag('external-key') }
             : {}),
@@ -430,6 +522,7 @@ class TasksList extends base_command_1.BaseCommand {
         '<%= config.bin %> tasks list --dri me',
         '<%= config.bin %> tasks list --view <task-view-id>',
         '<%= config.bin %> tasks list --calendar 2026-08-01..2026-08-31 --json',
+        '<%= config.bin %> tasks list --calendar 2026-12-06T16:00:00Z..2026-12-07T15:59:59Z',
         '<%= config.bin %> tasks list --open --compact --json',
         '<%= config.bin %> tasks list --space <space-id> --fields id,ref,title,status --json',
         '<%= config.bin %> tasks list --open --ndjson | jq -r .ref',
@@ -543,6 +636,10 @@ class TasksList extends base_command_1.BaseCommand {
         'include-snoozed': core_1.Flags.boolean({
             description: 'Include tasks you have personally snoozed (hidden by default)',
         }),
+        'all-workspaces': core_1.Flags.boolean({
+            description: 'List across every workspace you belong to. Without it, a list with no workspace selected ' +
+                'reads your default workspace; a list across all of them is slow and may time out.',
+        }),
         'external-key': core_1.Flags.string({ description: 'Filter by external key' }),
         'external-key-prefix': core_1.Flags.string({
             description: 'Filter to tasks whose external key starts with this literal prefix, e.g. every task of one tree written under --external-key-prefix. Combine with --space; see also `tasks create-tree --verify`.',
@@ -581,7 +678,11 @@ class TasksList extends base_command_1.BaseCommand {
             description: 'Exit 2 when --status names a value that is not a built-in state id and matches nothing (instead of an empty success).',
         }),
         calendar: core_1.Flags.string({
-            description: 'Expand the human task calendar for an inclusive range (YYYY-MM-DD..YYYY-MM-DD or ISO instants). Includes due dates and agent schedule occurrences.',
+            description: 'Expand the human task calendar for an inclusive range, <from>..<to>, at most 93 days. ' +
+                'A date-only value (YYYY-MM-DD) is a whole UTC day, 00:00:00.000Z to 23:59:59.999Z, not your local day: ' +
+                'for a local day pass ISO instants, e.g. 2026-12-06T16:00:00Z..2026-12-07T15:59:59Z. ' +
+                'Rows print in UTC, and the human output names the resolved window. ' +
+                'Includes due dates and agent schedule occurrences; a result cut short by a limit says which limit.',
         }),
     };
     async run() {
@@ -633,6 +734,16 @@ class TasksList extends base_command_1.BaseCommand {
         const filterApplied = agentSessionOpenDefault(flags);
         if (filterApplied)
             flags.open = true;
+        // Which workspace this list reads. A default is applied the way `--workspace` is: the
+        // request header follows OVERSKY_WORKSPACE_ID, set for this process only.
+        const workspaceScope = await resolveListWorkspace(flags, process.env, lookupDefaultWorkspace);
+        if (workspaceScope?.source === 'default') {
+            process.env.OVERSKY_WORKSPACE_ID = workspaceScope.workspaceId;
+            if (!flags.json && !flags.ndjson && workspaceScope.workspaceCount > 1) {
+                this.logToStderr(`Workspace: ${workspaceScope.workspaceName ? `"${workspaceScope.workspaceName}"` : workspaceScope.workspaceId} ` +
+                    `(your default). Every workspace you belong to: ${this.config.bin} tasks list --all-workspaces`);
+            }
+        }
         let response;
         try {
             response = calendarRange
@@ -687,19 +798,24 @@ class TasksList extends base_command_1.BaseCommand {
             // `identifier` and `actionability` — under `--json` an agent scanning 43
             // keys could not find either (OSK-10692). Alias them to the names the
             // table prints so the machine view answers the same questions.
-            const enriched = list && Array.isArray(list.data)
+            const enriched = list && Array.isArray(list.data) && !calendarRange
                 ? {
                     ...list,
-                    ...(!calendarRange ? { summary: taskPageSummary(list.data, Boolean(list.has_more ?? list.next_cursor)) } : {}),
+                    summary: taskPageSummary(list.data, Boolean(list.has_more ?? list.next_cursor)),
                     data: list.data.map((t) => ({
                         ...t,
                         ref: taskRef(t),
                         nextAction: nextActionText(t),
-                        ...(!calendarRange ? { execution: taskExecution(t) } : {}),
+                        execution: taskExecution(t),
                     })),
                 }
                 : response;
-            const withUrls = (0, web_url_1.withDataUrls)(this.cliConfig.baseURL, enriched, web_url_1.taskUrlFrom);
+            // A calendar row is an occurrence, not a Task: it gets the Task's id, ref and url and the
+            // occurrence key as `occurrenceId`, instead of the Task list's treatment, which rebuilt the
+            // url and the ref from the occurrence's own id (OSK-21586).
+            const withUrls = calendarRange
+                ? calendarJsonResponse(this.cliConfig.baseURL, response)
+                : (0, web_url_1.withDataUrls)(this.cliConfig.baseURL, enriched, web_url_1.taskUrlFrom);
             // The calendar response is occurrences, not tasks: leave its shape alone.
             const out = calendarRange
                 ? withUrls
@@ -723,14 +839,27 @@ class TasksList extends base_command_1.BaseCommand {
                         }
                         : {}),
                 });
-            this.printList(out, Boolean(flags.ndjson));
+            // Say which workspace was read, as data, when the CLI chose it (or the caller asked for all):
+            // an agent reading JSON cannot see the stderr note.
+            this.printList(workspaceScope && out && typeof out === 'object' && !Array.isArray(out)
+                ? { ...out, workspace_scope: workspaceScope }
+                : out, Boolean(flags.ndjson));
             return;
         }
         if (calendarRange) {
             const calendar = response;
             const occurrences = calendar.data ?? [];
+            const notices = (0, task_calendar_1.calendarNoticeLines)(calendar);
+            // The resolved window goes to stderr: it is about the read, not a row, so a piped table
+            // stays a table. A date-only range is a whole UTC day (OSK-21529).
+            this.logToStderr((0, task_calendar_1.calendarWindowLine)(calendar));
             if (occurrences.length === 0) {
-                this.log('No calendar occurrences.');
+                // "No calendar occurrences." is only true of a complete read (OSK-21382).
+                this.log(notices.length === 0
+                    ? 'No calendar occurrences.'
+                    : 'No calendar occurrences were listed, but the read was cut short.');
+                for (const line of notices)
+                    this.log(line);
                 return;
             }
             (0, format_1.renderTable)(occurrences.map((item) => ({
@@ -746,8 +875,11 @@ class TasksList extends base_command_1.BaseCommand {
                 { key: 'title', header: 'TITLE', maxWidth: 50 },
                 { key: 'status', header: 'STATUS' },
             ], (line) => this.log(line));
-            if (calendar.truncated)
-                this.log('\nNote: calendar occurrence expansion reached its safety cap.');
+            if (notices.length > 0) {
+                this.log('');
+                for (const line of notices)
+                    this.log(line);
+            }
             return;
         }
         const r = response;

package/dist/commands/tasks/remind.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
+const iso_instant_1 = require("../../lib/iso-instant");
+const task_reminder_1 = require("../../lib/task-reminder");
 /** Set a one-time human reminder without changing the task's visibility or state. */
 class TasksRemind extends base_command_1.BaseCommand {
     static description = 'Set a one-time inbox reminder on a task. The task stays visible and unchanged.';
@@ -18,24 +20,27 @@ class TasksRemind extends base_command_1.BaseCommand {
         }),
     };
     static flags = {
-        at: core_1.Flags.string({ description: 'Reminder time as an ISO-8601 UTC instant', required: true }),
+        at: core_1.Flags.string({
+            description: 'Reminder time as an ISO-8601 UTC instant ending in Z (e.g. 2026-08-25T16:00:00Z); a time with no Z or a numeric offset such as +08:00 is refused',
+            required: true,
+        }),
         json: core_1.Flags.boolean({ description: 'Output the TriggerDefinition as JSON' }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksRemind);
+        // Before any lookup: a bad time costs no round trip and creates nothing. Never `new Date(flags.at)`,
+        // which reads a zoneless time in THIS machine's zone and rolls 2027-02-30 into March (OSK-21504/21506).
+        const parsed = (0, iso_instant_1.parseUtcInstant)(flags.at, '--at');
+        if (!parsed.ok)
+            this.error(parsed.message, { exit: 2 });
+        const at = parsed.date;
         const taskRef = await this.resolveEntityRef('task', args.taskId);
-        const at = new Date(flags.at);
-        if (Number.isNaN(at.getTime()) || !/^\d{4}-\d{2}-\d{2}T/.test(flags.at)) {
-            this.error('--at must be an ISO-8601 instant, for example 2026-08-25T16:00:00Z.', {
-                exit: 2,
-            });
-        }
         let task;
         let reminder;
         try {
             task = (await data_provider_1.dataService.getTask(taskRef, { enrich: false }));
-            reminder = await data_provider_1.request.post('/api/triggers', {
+            reminder = (await data_provider_1.request.post('/api/triggers', {
                 scope: {
                     kind: 'entity_reminder',
                     refs: {
@@ -47,8 +52,8 @@ class TasksRemind extends base_command_1.BaseCommand {
                 kind: 'once',
                 label: `Reminder: ${task.title || task.identifier || task.id}`.slice(0, 120),
                 execution: { mode: 'notify_user', promptTemplate: '' },
-                once: { runAt: at.toISOString() },
-            });
+                once: { runAt: parsed.iso },
+            }));
         }
         catch (err) {
             this.handleApiError(err);
@@ -58,7 +63,14 @@ class TasksRemind extends base_command_1.BaseCommand {
             this.log(JSON.stringify(reminder, null, 2));
             return;
         }
-        this.log(`Reminder set for ${task.title || task.identifier || task.id} at ${at.toLocaleString()}.`);
+        for (const line of (0, task_reminder_1.reminderReceiptLines)({
+            title: task.title || task.identifier || task.id,
+            trigger: reminder,
+            requested: at,
+            bin: this.config.bin,
+        })) {
+            this.log(line);
+        }
     }
 }
 exports.default = TasksRemind;

package/dist/commands/tasks/retry-schedule.js

@@ -5,10 +5,12 @@ 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 TasksRetrySchedule extends base_command_1.BaseCommand {
-    static description = 'Re-arm a stale/failed schedule. Optionally pin a new first-fire time';
+    static description = 'Re-arm a stale/failed schedule. After a failed or skipped start, pass --at with a new first-fire time: ' +
+        'the failed fire cleared the scheduledFor, so there is nothing left to retry against. ' +
+        'The Task must have an assigned agent, as the start will fail the same way otherwise.';
     static examples = [
-        '<%= config.bin %> tasks retry-schedule <task-id>',
         '<%= config.bin %> tasks retry-schedule <task-id> --at 2026-06-01T15:30:00Z',
+        '<%= config.bin %> tasks retry-schedule <task-id>',
     ];
     static args = {
         id: core_1.Args.string({ description: 'Task ID', required: true, ignoreStdin: true }),
@@ -16,7 +18,8 @@ class TasksRetrySchedule extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
         at: core_1.Flags.string({
-            description: 'Optional new first-fire time as ISO-8601 UTC. Omit to retry against the current scheduledFor.',
+            description: 'New first-fire time as ISO-8601 UTC. Required after a failed or skipped start (the failed fire cleared scheduledFor). ' +
+                'Omit it only to re-sync a schedule whose scheduledFor is still in the future.',
         }),
     };
     async run() {

package/dist/commands/tasks/schedule.js

@@ -5,6 +5,8 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const web_url_1 = require("../../lib/web-url");
 const prompt_1 = require("../../lib/prompt");
+const iso_instant_1 = require("../../lib/iso-instant");
+const task_recurrence_summary_1 = require("../../lib/task-recurrence-summary");
 class TasksSchedule extends base_command_1.BaseCommand {
     static description = 'Schedule a task to fire at a future time (optionally recurring)';
     static examples = [
@@ -21,10 +23,11 @@ class TasksSchedule extends base_command_1.BaseCommand {
             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)',
+            description: 'Recurrence cron pattern: minute hour day-of-month month day-of-week (UTC unless --timezone is set). ' +
+                'When both a day of the month and a weekday are set, it fires when EITHER matches',
         }),
         timezone: core_1.Flags.string({
-            description: 'IANA timezone for the cron pattern (e.g. America/Los_Angeles)',
+            description: 'IANA zone name for the cron pattern, e.g. Asia/Shanghai or America/Los_Angeles (not an offset such as UTC+8, and not "local")',
             dependsOn: ['cron'],
         }),
         'max-runs': core_1.Flags.integer({
@@ -32,7 +35,7 @@ class TasksSchedule extends base_command_1.BaseCommand {
             dependsOn: ['cron'],
         }),
         'end-date': core_1.Flags.string({
-            description: 'Stop recurrence after this ISO-8601 date',
+            description: 'Last day of the recurrence: YYYY-MM-DD (through the end of that day in --timezone, UTC if omitted) or an ISO-8601 instant with a zone (2026-12-31T17:00:00Z); must be after the first fire',
             dependsOn: ['cron'],
         }),
         'from-json': core_1.Flags.string({
@@ -52,8 +55,10 @@ class TasksSchedule extends base_command_1.BaseCommand {
         }
         const recurrence = flags.cron
             ? (0, prompt_1.mergeDefined)({}, {
-                pattern: flags.cron,
-                timezone: flags.timezone,
+                // Stored as typed otherwise: a padded pattern came back padded from `show --json`, and a blank
+                // `--timezone ""` printed a recurrence with no zone at all (OSK-21531).
+                pattern: flags.cron.trim(),
+                timezone: flags.timezone?.trim() || undefined,
                 maxRuns: flags['max-runs'],
                 endDate: flags['end-date'],
             })
@@ -65,6 +70,11 @@ class TasksSchedule extends base_command_1.BaseCommand {
         if (!payload.scheduledFor || typeof payload.scheduledFor !== 'string') {
             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 });
         }
+        // Said here, in the user's words: the server's zod issue names the REST field (`scheduledFor`) and is the same
+        // text for a missing Z, a numeric offset and a day that does not exist (OSK-21507).
+        const instant = (0, iso_instant_1.parseUtcInstant)(payload.scheduledFor, flags.at !== undefined ? '--at' : 'scheduledFor');
+        if (!instant.ok)
+            this.error(instant.message, { exit: 2 });
         let result;
         try {
             result = await data_provider_1.dataService.scheduleTask({
@@ -83,8 +93,20 @@ class TasksSchedule extends base_command_1.BaseCommand {
         const ref = t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '');
         this.log(`Scheduled task ${t.id ?? t._id ?? taskRef}${ref ? ` (${ref})` : ''} for ${payload.scheduledFor}`);
         if (t.recurrence?.pattern) {
-            const tz = t.recurrence.timezone ? ` (${t.recurrence.timezone})` : '';
-            this.log(`Recurrence: ${t.recurrence.pattern}${tz}`);
+            // Always name the zone: the pattern is read in UTC unless one was set, and a rule with no zone beside it
+            // is exactly what could not be told apart from a local-time one.
+            const tz = t.recurrence.timezone?.trim() || 'UTC';
+            this.log(`Recurrence: ${t.recurrence.pattern} (${tz})`);
+            const reading = (0, task_recurrence_summary_1.describeCronPattern)(t.recurrence.pattern);
+            if (reading) {
+                this.log(`            ${reading.text}`);
+                if (reading.dayOfMonthOrWeekday) {
+                    this.log('            With both a day of the month and a weekday, it fires when EITHER matches, not only when both do.');
+                }
+            }
+            // The instant the server resolved `--end-date` to, so a calendar date is never a guess.
+            if (t.recurrence.endDate)
+                this.log(`Ends: ${t.recurrence.endDate}`);
         }
     }
 }

package/dist/commands/tasks/show.js

@@ -23,6 +23,7 @@ const principal_display_1 = require("../../lib/principal-display");
 const task_economics_line_1 = require("../../lib/task-economics-line");
 const format_1 = require("../../lib/format");
 const task_recurrence_outcome_1 = require("../../lib/task-recurrence-outcome");
+const task_recurrence_summary_1 = require("../../lib/task-recurrence-summary");
 const record_output_1 = require("../../lib/record-output");
 /**
  * Where to look next — as COMMANDS, not as facts about the task.
@@ -441,6 +442,9 @@ class TasksShow extends base_command_1.BaseCommand {
             this.log(line);
         for (const line of recurrenceArmFailureLines(t, this.config.bin))
             this.log(line);
+        // That the Task recurs, by what rule and in which zone (OSK-21531): only `--json` carried it.
+        for (const line of (0, task_recurrence_summary_1.recurrenceSummaryLines)(t))
+            this.log(line);
         /*
          * Closing is the actor's call — a Task may be `done` with work still
          * outstanding, and `resolution.closure` is where the server recorded what

package/dist/lib/agent-trigger-listing.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `skrr agenda trigger list <agent>` and the triggers it did not show (OSK-21454).
+ *
+ * `/api/agents/:id/triggers` is the legacy per-agent facade and lists `scope: 'agent'` rows only. A
+ * passive agent (`agents create --initial-always-on off`) still owns system-managed Commitment
+ * triggers - the daily self-reflection check is `commitment-check:obj_agent_reflection_*`, scope
+ * `commitment_watcher` - so the one command whose name says "list this agent's triggers" answered
+ * "No triggers." while `triggers list --ref-entity agent:<id>` and the web Upcoming page listed it.
+ *
+ * The universal list, filtered by the agent ref, is the truth; this reads it and returns the rows the
+ * facade left out, marked so a person can tell the platform's from their own.
+ */
+export type TriggerRow = Record<string, unknown>;
+/** Created and run by the platform for a Commitment, not authored by the person. */
+export declare function isSystemManaged(row: TriggerRow): boolean;
+/**
+ * The universal-list rows the per-agent facade did not return, each tagged `systemManaged`.
+ * Rows already listed are not repeated; a row with no id cannot be matched and is kept.
+ */
+export declare function triggersMissingFromAgentList(listed: TriggerRow[], universal: TriggerRow[]): TriggerRow[];
+/** The platform marked this managed trigger suspended (Always-On is off for the agent). */
+export declare function isSuspended(row: TriggerRow): boolean;
+/** What the SOURCE column says: the platform, the scope it belongs to, a turn capture, or nothing. */
+export declare function sourceLabel(row: TriggerRow, unconfirmedTurnCapture: boolean): string;
+/** The legend printed under a table that includes platform-managed rows. */
+export declare function systemManagedLegend(agentId: string, bin?: string): string[];

package/dist/lib/agent-trigger-listing.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * `skrr agenda trigger list <agent>` and the triggers it did not show (OSK-21454).
+ *
+ * `/api/agents/:id/triggers` is the legacy per-agent facade and lists `scope: 'agent'` rows only. A
+ * passive agent (`agents create --initial-always-on off`) still owns system-managed Commitment
+ * triggers - the daily self-reflection check is `commitment-check:obj_agent_reflection_*`, scope
+ * `commitment_watcher` - so the one command whose name says "list this agent's triggers" answered
+ * "No triggers." while `triggers list --ref-entity agent:<id>` and the web Upcoming page listed it.
+ *
+ * The universal list, filtered by the agent ref, is the truth; this reads it and returns the rows the
+ * facade left out, marked so a person can tell the platform's from their own.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSystemManaged = isSystemManaged;
+exports.triggersMissingFromAgentList = triggersMissingFromAgentList;
+exports.isSuspended = isSuspended;
+exports.sourceLabel = sourceLabel;
+exports.systemManagedLegend = systemManagedLegend;
+function idOf(row) {
+    return typeof row.id === 'string' ? row.id : '';
+}
+function scopeKindOf(row) {
+    const scope = row.scope;
+    return typeof scope?.kind === 'string' ? scope.kind : '';
+}
+/** Created and run by the platform for a Commitment, not authored by the person. */
+function isSystemManaged(row) {
+    return row.producerOwned === true || /^commitment-(check|reflect):/.test(idOf(row));
+}
+/**
+ * The universal-list rows the per-agent facade did not return, each tagged `systemManaged`.
+ * Rows already listed are not repeated; a row with no id cannot be matched and is kept.
+ */
+function triggersMissingFromAgentList(listed, universal) {
+    const known = new Set(listed.map(idOf).filter(Boolean));
+    return universal
+        .filter((row) => !idOf(row) || !known.has(idOf(row)))
+        .map((row) => ({ ...row, systemManaged: isSystemManaged(row) }));
+}
+/** The platform marked this managed trigger suspended (Always-On is off for the agent). */
+function isSuspended(row) {
+    const management = row.management;
+    return management?.suspended === true;
+}
+/** What the SOURCE column says: the platform, the scope it belongs to, a turn capture, or nothing. */
+function sourceLabel(row, unconfirmedTurnCapture) {
+    if (row.systemManaged === true)
+        return isSuspended(row) ? 'system, suspended' : 'system';
+    if (unconfirmedTurnCapture)
+        return 'turn*';
+    if (row.systemManaged === false)
+        return scopeKindOf(row) || '-';
+    return '-';
+}
+/** The legend printed under a table that includes platform-managed rows. */
+function systemManagedLegend(agentId, bin = 'skrr') {
+    return [
+        'system = created and run by the platform for a Commitment, not by you (for example the daily self-reflection check every agent is seeded with, passive or not).',
+        '         "suspended" = the platform is holding it because Always-On is off for this agent.',
+        `         Find the Commitment behind one with: ${bin} commitments list --agent ${agentId} --include-system`,
+    ];
+}