@skrr-ai/cli 0.1.128 → 0.1.130

package/dist/commands/tasks/schedule.js

@@ -5,6 +5,9 @@ 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 task_schedule_notes_1 = require("../../lib/task-schedule-notes");
+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 +24,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 +36,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 +56,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 +71,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({
@@ -81,10 +92,26 @@ class TasksSchedule extends base_command_1.BaseCommand {
         }
         const t = result;
         const ref = t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '');
-        this.log(`Scheduled task ${t.id ?? t._id ?? taskRef}${ref ? ` (${ref})` : ''} for ${payload.scheduledFor}`);
+        const paused = Boolean(t.schedulePaused);
+        this.log(`${paused ? 'Recorded the time for' : '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}`);
+        }
+        for (const line of (0, task_schedule_notes_1.scheduleResultLines)(t, String(t.id ?? t._id ?? taskRef), this.config.bin)) {
+            this.log(line);
         }
     }
 }

package/dist/commands/tasks/self-schedule.d.ts

@@ -23,8 +23,64 @@ export default class TasksSelfSchedule extends BaseCommand {
         in: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         note: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'max-per-day': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        're-enable': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         show: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         clear: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }
+/** What the server records about a return that came due (`lastDecision` on the GET). */
+export interface ReturnDecision {
+    outcome?: string;
+    /** ran | skipped | failed | waiting. Absent from a server older than this field. */
+    verdict?: 'ran' | 'skipped' | 'failed' | 'waiting';
+    reason?: string | null;
+    /** The reason in plain words, when the server has some for it. */
+    reasonText?: string | null;
+    at?: string | null;
+}
+/** The part after "the return came due and": what became of it, with the reason. */
+export declare function decisionClause(decision: ReturnDecision): string;
+/**
+ * The line `--show` prints for a return whose time has passed. "returned at" is
+ * said only when a run really started; a skipped, failed or unrecorded return
+ * says what it was.
+ */
+export declare function describeSpentReturn({ taskRef, runAt, decision, triggerId, bin, }: {
+    taskRef: string;
+    runAt: string;
+    decision?: ReturnDecision | null;
+    triggerId?: string;
+    bin?: string;
+}): string;
+/**
+ * `--in` as an instant. A value that does not parse says WHICH value, because
+ * the generic "pass --at or --in" this used to fall through to told a person who
+ * had passed `--in 1.5h` to pass `--in`.
+ *
+ * Seconds are accepted: the server owns the 60 s floor and answers
+ * `RETURN_TOO_SOON` with the bound, which is a better explanation than the CLI
+ * refusing the unit.
+ */
+export declare function resolveRelativeRunAt(relative: string, now?: number): {
+    runAt: string;
+} | {
+    error: string;
+};
+/**
+ * `--at` as a UTC instant. Any offset is accepted and normalised, so the server
+ * always receives `...Z`. A value with no zone is refused by saying so: it is a
+ * valid ISO-8601 string, and "Invalid ISO datetime" for it read as if the CLI
+ * could not parse a thing the help had just told the person to type.
+ */
+export declare function resolveAbsoluteRunAt(absolute: string): {
+    runAt: string;
+} | {
+    error: string;
+};
+/** `--at`, or `--in`, or neither (undefined). Absolute wins when both are given. */
+export declare function resolveRunAt(at?: string, relative?: string, now?: number): {
+    runAt: string;
+} | {
+    error: string;
+} | undefined;

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

@@ -1,5 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.decisionClause = decisionClause;
+exports.describeSpentReturn = describeSpentReturn;
+exports.resolveRelativeRunAt = resolveRelativeRunAt;
+exports.resolveAbsoluteRunAt = resolveAbsoluteRunAt;
+exports.resolveRunAt = resolveRunAt;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const task_extras_1 = require("../../lib/task-extras");
@@ -20,6 +25,7 @@ class TasksSelfSchedule extends base_command_1.BaseCommand {
     static examples = [
         '<%= config.bin %> tasks self-schedule <task-id> --in 2h --note "check whether the deploy settled"',
         '<%= config.bin %> tasks self-schedule <task-id> --at 2026-09-09T14:00:00Z',
+        '<%= config.bin %> tasks self-schedule <task-id> --in 90m --re-enable',
         '<%= config.bin %> tasks self-schedule <task-id> --show',
         '<%= config.bin %> tasks self-schedule <task-id> --clear',
     ];
@@ -28,8 +34,14 @@ class TasksSelfSchedule extends base_command_1.BaseCommand {
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
-        at: core_1.Flags.string({ description: 'Absolute return time (ISO-8601 UTC)' }),
-        in: core_1.Flags.string({ description: 'Relative return time such as 90m, 2h, 3d' }),
+        at: core_1.Flags.string({
+            description: 'Absolute return time: ISO-8601 with a UTC offset, such as 2026-11-05T10:00:00Z or ' +
+                '2026-11-05T10:00:00-08:00',
+        }),
+        in: core_1.Flags.string({
+            description: 'Relative return time: a number with a unit (s, m, h, d), such as 90m, 1.5h or 3d. ' +
+                'A bare number means minutes. At least 60s, at most 14 days',
+        }),
         note: core_1.Flags.string({
             // This DOES reach the run now. It is read by `buildTaskExecutionPrompt`,
             // the one place every dispatch path assembles a task prompt, and rendered
@@ -40,7 +52,13 @@ class TasksSelfSchedule extends base_command_1.BaseCommand {
                 'prompt section, and readable any time with --show',
         }),
         'max-per-day': core_1.Flags.integer({
-            description: 'Cap on self-initiated returns per day (1-24, default 4)',
+            description: 'Cap on self-initiated returns per day (1-24). Omit to keep the cap this task ' +
+                'already has (4 for a task that never had one)',
+        }),
+        're-enable': core_1.Flags.boolean({
+            description: "Switch the task's return back on if it was turned off, then park it. Without this a " +
+                'switched-off return is left off and the park is refused. A person may; an agent only ' +
+                'where its initiative policy allows autonomous loops',
         }),
         show: core_1.Flags.boolean({ description: 'Print the pending return without changing it' }),
         clear: core_1.Flags.boolean({ description: 'Cancel the pending return' }),
@@ -61,20 +79,47 @@ class TasksSelfSchedule extends base_command_1.BaseCommand {
                 result = await task_extras_1.taskSelfScheduleApi.clear(taskRef);
             }
             else {
-                const runAt = resolveRunAt(flags.at, flags.in);
-                if (!runAt) {
+                const resolved = resolveRunAt(flags.at, flags.in);
+                if (!resolved) {
                     this.error('Pass --at <ISO-8601>, --in <duration>, or one of --show / --clear.', {
                         exit: 1,
                     });
                 }
+                if ('error' in resolved) {
+                    this.failWithCliError({
+                        message: resolved.error,
+                        code: 'INVALID_RETURN_TIME',
+                        exit: 1,
+                        retryable: false,
+                    });
+                }
+                // The server's field path, read back as the flag that wrote it.
+                this.requestFieldFlags = selfScheduleFieldFlags(Boolean(flags.at));
                 result = await task_extras_1.taskSelfScheduleApi.park(taskRef, {
-                    runAt,
+                    runAt: resolved.runAt,
                     ...(flags.note ? { note: flags.note } : {}),
-                    ...(flags['max-per-day'] ? { maxFiresPerDay: flags['max-per-day'] } : {}),
+                    // `!== undefined`, not truthiness: `--max-per-day 0` is a value the server
+                    // refuses (1-24), and dropping it here parked the task with the default
+                    // while printing a cap the person never asked for.
+                    ...(flags['max-per-day'] !== undefined ? { maxFiresPerDay: flags['max-per-day'] } : {}),
+                    ...(flags['re-enable'] ? { reEnable: true } : {}),
                 });
             }
         }
         catch (err) {
+            // A return someone switched off is left off. The server's sentence is the
+            // same for the web and the API; the CLI adds the flag that answers it.
+            if ((0, base_command_1.apiRefusal)(err).code === 'TASK_RETURN_DISABLED') {
+                this.failWithCliError({
+                    message: `Task ${taskRef}'s return is switched off, so it was not parked again.\n` +
+                        "→ Ask the task's owner to switch it back on in the task's Automations. A person " +
+                        'who means to turn it back on can run this command again with --re-enable.',
+                    code: 'TASK_RETURN_DISABLED',
+                    status: 409,
+                    exit: 1,
+                    retryable: false,
+                });
+            }
             this.handleApiError(err);
         }
         if (flags.json) {
@@ -82,15 +127,35 @@ class TasksSelfSchedule extends base_command_1.BaseCommand {
             return;
         }
         const runAt = result?.runAt;
+        const decision = result?.lastDecision;
         if (!runAt) {
             this.log(`Task ${taskRef} has no pending return.`);
+            // The interim tick clears the instant after a fire, so the decision may be
+            // all there is to say about the return that just went.
+            if (decision)
+                this.log(`Its last return ${decisionClause(decision)}.`);
             return;
         }
         // `pending` is derived server-side: a return that has already fired keeps
         // its instant on the row, and printing that verbatim would report a return
         // as upcoming an hour after it happened.
         const spent = result?.pending === false;
-        this.log(`Task ${taskRef} ${spent ? 'last returned at' : 'returns at'} ${runAt}`);
+        if (!spent) {
+            this.log(`Task ${taskRef} returns at ${runAt}`);
+        }
+        else {
+            // "Spent" only means the instant passed. Whether a run started is the
+            // decision's to say; "last returned at" was printed for returns that were
+            // skipped because the task was blocked, in review, done or archived.
+            const triggerId = result?.triggerId;
+            this.log(describeSpentReturn({
+                taskRef,
+                runAt,
+                decision,
+                triggerId: typeof triggerId === 'string' ? triggerId : undefined,
+                bin: this.config.bin,
+            }));
+        }
         if (result?.note)
             this.log(`Note: ${result.note}`);
         if (!spent && result?.maxFiresPerDay) {
@@ -99,20 +164,113 @@ class TasksSelfSchedule extends base_command_1.BaseCommand {
     }
 }
 exports.default = TasksSelfSchedule;
-/** `90m` / `2h` / `3d`, or an absolute instant. Absolute wins when both are given. */
-function resolveRunAt(at, relative) {
+/** The part after "the return came due and": what became of it, with the reason. */
+function decisionClause(decision) {
+    const why = decision.reasonText || decision.reason || decision.outcome || 'no reason was recorded';
+    switch (decision.verdict) {
+        case 'ran':
+            return 'started a run';
+        case 'failed':
+            return `could not be started: ${why}`;
+        case 'waiting':
+            return `has not started yet: ${why}`;
+        default:
+            return `was skipped: ${why}`;
+    }
+}
+/**
+ * The line `--show` prints for a return whose time has passed. "returned at" is
+ * said only when a run really started; a skipped, failed or unrecorded return
+ * says what it was.
+ */
+function describeSpentReturn({ taskRef, runAt, decision, triggerId, bin = 'skrr', }) {
+    if (decision?.verdict === 'ran')
+        return `Task ${taskRef} returned at ${runAt}`;
+    if (decision)
+        return `Task ${taskRef}: the return came due at ${runAt} and ${decisionClause(decision)}.`;
+    return (`Task ${taskRef}: the return came due at ${runAt}. Whether it ran is not recorded here; ` +
+        `\`${bin} triggers audit ${triggerId ?? `task-self-schedule:${taskRef}`}\` lists every fire.`);
+}
+/**
+ * Body paths the server may name in a refusal, and the flag that wrote each. `runAt`
+ * is written by whichever of --at / --in the person used, so a "runAt must be at
+ * least 60s in the future" for `--in 0m` is not read back as a flag they never typed.
+ */
+function selfScheduleFieldFlags(usedAt) {
+    return Object.freeze({
+        runAt: usedAt ? '--at' : '--in',
+        maxFiresPerDay: '--max-per-day',
+        note: '--note',
+    });
+}
+const MS_PER_UNIT = {
+    s: 1_000,
+    m: 60_000,
+    h: 3_600_000,
+    d: 86_400_000,
+};
+/**
+ * A number, optionally fractional, with an optional unit. The unit words
+ * collapse onto their first character (`sec`/`secs`, `min`/`mins`, `hr`/`hrs`,
+ * `day`/`days`), which is unambiguous across the four units this accepts.
+ */
+const RELATIVE_PATTERN = /^(\d+(?:\.\d+)?|\.\d+)\s*(s|secs?|seconds?|m|mins?|minutes?|h|hrs?|hours?|d|days?)?$/i;
+/** What a person is told when `--in` is not a duration, in the words they would retype. */
+const RELATIVE_HELP = 'use a number with a unit (s, m, h or d), such as 90m, 1.5h or 3d. A bare number means minutes.';
+/**
+ * `--in` as an instant. A value that does not parse says WHICH value, because
+ * the generic "pass --at or --in" this used to fall through to told a person who
+ * had passed `--in 1.5h` to pass `--in`.
+ *
+ * Seconds are accepted: the server owns the 60 s floor and answers
+ * `RETURN_TOO_SOON` with the bound, which is a better explanation than the CLI
+ * refusing the unit.
+ */
+function resolveRelativeRunAt(relative, now = Date.now()) {
+    const match = RELATIVE_PATTERN.exec(relative.trim());
+    if (!match)
+        return { error: `--in ${relative}: ${RELATIVE_HELP}` };
+    const unit = (match[2] ?? 'm').toLowerCase()[0];
+    const ms = Math.round(Number(match[1]) * MS_PER_UNIT[unit]);
+    const at = new Date(now + ms);
+    if (!Number.isFinite(at.getTime())) {
+        return { error: `--in ${relative}: too far away. A return is at most 14 days out.` };
+    }
+    return { runAt: at.toISOString() };
+}
+/** An ISO-8601 date and time that names its zone: `Z`, or an offset such as `-08:00`. */
+const ISO_WITH_ZONE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}(?::?\d{2})?)$/i;
+/** The same shape with no zone, which is a real ISO-8601 value and an ambiguous instant. */
+const ISO_WITHOUT_ZONE = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?$/i;
+const ABSOLUTE_HELP = 'use an ISO-8601 date and time with a UTC offset, such as 2026-11-05T10:00:00Z or ' +
+    '2026-11-05T10:00:00-08:00.';
+/**
+ * `--at` as a UTC instant. Any offset is accepted and normalised, so the server
+ * always receives `...Z`. A value with no zone is refused by saying so: it is a
+ * valid ISO-8601 string, and "Invalid ISO datetime" for it read as if the CLI
+ * could not parse a thing the help had just told the person to type.
+ */
+function resolveAbsoluteRunAt(absolute) {
+    const value = absolute.trim();
+    if (ISO_WITH_ZONE.test(value)) {
+        const at = new Date(value);
+        if (Number.isFinite(at.getTime()))
+            return { runAt: at.toISOString() };
+        return { error: `--at ${absolute}: that is not a real date and time. ${ABSOLUTE_HELP}` };
+    }
+    if (ISO_WITHOUT_ZONE.test(value)) {
+        return {
+            error: `--at ${absolute}: no time zone, so the instant is ambiguous. Add Z for UTC or an ` +
+                'offset, such as 2026-11-05T10:00:00Z or 2026-11-05T10:00:00-08:00.',
+        };
+    }
+    return { error: `--at ${absolute}: not recognised as a date and time. ${ABSOLUTE_HELP}` };
+}
+/** `--at`, or `--in`, or neither (undefined). Absolute wins when both are given. */
+function resolveRunAt(at, relative, now = Date.now()) {
     if (at)
-        return at;
+        return resolveAbsoluteRunAt(at);
     if (!relative)
         return undefined;
-    const match = /^(\d+)\s*(m|min|mins|h|hr|hrs|d)$/i.exec(relative.trim());
-    if (!match)
-        return undefined;
-    const value = Number(match[1]);
-    const unit = match[2].toLowerCase();
-    const MS_PER_UNIT = { m: 60_000, h: 3_600_000, d: 86_400_000 };
-    // `min`/`mins`/`hr`/`hrs` collapse onto their first character, which is
-    // unambiguous across the three units this accepts.
-    const ms = value * (MS_PER_UNIT[unit[0]] ?? MS_PER_UNIT.h);
-    return new Date(Date.now() + ms).toISOString();
+    return resolveRelativeRunAt(relative, now);
 }

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`,
+    ];
+}