@skrr-ai/cli 0.1.102 → 0.1.103

package/dist/commands/daemon/logs.js

@@ -5,8 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.describeLogAge = describeLogAge;
 exports.resolveLegacyDaemonLogPath = resolveLegacyDaemonLogPath;
+exports.resolveDaemonLogsProfile = resolveDaemonLogsProfile;
+exports.installedServiceLogCandidates = installedServiceLogCandidates;
+exports.chooseLegacyFallbackLog = chooseLegacyFallbackLog;
+exports.resolveForwardedLogPath = resolveForwardedLogPath;
 exports.readDaemonLogTail = readDaemonLogTail;
-exports.buildOverskyLogsArgs = buildOverskyLogsArgs;
+exports.buildDaemonLogsArgs = buildDaemonLogsArgs;
 const core_1 = require("@oclif/core");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
@@ -62,6 +66,11 @@ function describeLogAge(mtimeMs, now = Date.now()) {
     };
 }
 function resolveLegacyDaemonLogPath(flags, options = {}) {
+    const home = options.home ?? (0, node_os_1.homedir)();
+    return node_path_1.default.join(home, '.skrr', 'profiles', resolveDaemonLogsProfile(flags, options), 'logs', flags.stderr ? 'daemon.err.log' : 'daemon.log');
+}
+/** The profile `logs` addresses: --profile, then the profile environment variable, then the pin. */
+function resolveDaemonLogsProfile(flags, options = {}) {
     const home = options.home ?? (0, node_os_1.homedir)();
     const env = options.env ?? process.env;
     // An explicit --profile outranks the environment, as it does everywhere else.
@@ -81,7 +90,106 @@ function resolveLegacyDaemonLogPath(flags, options = {}) {
             // An absent/corrupt sticky selector must match the daemon's default.
         }
     }
-    return node_path_1.default.join(home, '.skrr', 'profiles', profile ?? 'default', 'logs', flags.stderr ? 'daemon.err.log' : 'daemon.log');
+    return profile ?? 'default';
+}
+/**
+ * Log files the installed launchd definition for this profile sends output to
+ * (OSK-15993). The desktop supervisor starts the daemon with
+ * `--log-file ~/Library/Logs/Skrr/daemon.app.log` and redirects stderr to
+ * `daemon.stderr.log`, so the profile's `logs/` directory can hold a file
+ * nobody has written for a week. Read-only: the plist is parsed, never loaded.
+ */
+function installedServiceLogCandidates(profile, stderr, options = {}) {
+    if ((options.platform ?? process.platform) !== 'darwin')
+        return [];
+    const plist = node_path_1.default.join(options.home ?? (0, node_os_1.homedir)(), 'Library', 'LaunchAgents', `ai.skrr.daemon.${profile}.plist`);
+    let xml;
+    try {
+        xml = (0, node_fs_1.readFileSync)(plist, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const unescape = (v) => v
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, '&');
+    const stringFor = (key) => {
+        const m = new RegExp(`<key>\\s*${key}\\s*</key>\\s*<string>([\\s\\S]*?)</string>`).exec(xml);
+        return m?.[1]?.trim() ? unescape(m[1].trim()) : null;
+    };
+    if (stderr) {
+        const errPath = stringFor('StandardErrorPath');
+        return errPath ? [errPath] : [];
+    }
+    const out = [];
+    const array = /<key>\s*ProgramArguments\s*<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(xml);
+    if (array?.[1]) {
+        const args = [...array[1].matchAll(/<string>([\s\S]*?)<\/string>/g)].map((m) => unescape(m[1].trim()));
+        const at = args.lastIndexOf('--log-file');
+        if (at >= 0 && args[at + 1] && !args[at + 1].startsWith('-'))
+            out.push(args[at + 1]);
+    }
+    const stdoutPath = stringFor('StandardOutPath');
+    if (stdoutPath)
+        out.push(stdoutPath);
+    return out;
+}
+/**
+ * Pick the file the legacy fallback reads. An old daemon cannot say which file
+ * it writes, so the most recently written of the profile log and the installed
+ * service's logs is the best evidence of the live one — and whenever that is
+ * not the profile log, the choice is said out loud rather than made silently.
+ */
+function chooseLegacyFallbackLog(args) {
+    const profileMtime = args.mtimeOf(args.profilePath);
+    let best = null;
+    for (const file of args.serviceCandidates) {
+        if (node_path_1.default.resolve(file) === node_path_1.default.resolve(args.profilePath))
+            continue;
+        const mtime = args.mtimeOf(file);
+        if (mtime === null)
+            continue;
+        if (!best || mtime > best.mtime)
+            best = { file, mtime };
+    }
+    if (!best || (profileMtime !== null && profileMtime >= best.mtime)) {
+        return { path: args.profilePath, note: null };
+    }
+    return {
+        path: best.file,
+        note: `Showing ${best.file}, the installed service's log: it was written more recently than ` +
+            (profileMtime === null
+                ? `the profile log ${args.profilePath}, which does not exist.`
+                : `the profile log ${args.profilePath}, which has not been written since.`) +
+            ' This daemon predates `logs`, so it cannot name its live log itself.',
+    };
+}
+/**
+ * Ask the installed runtime which file `logs` will read — the same live-aware
+ * answer it uses itself — so the age banner describes the file actually shown.
+ * Null when the runtime cannot answer in time; the banner is then skipped
+ * rather than printed about a file that may not be the one shown.
+ */
+async function resolveForwardedLogPath(flags, capture = exec_runtime_binary_1.execRuntimeBinaryCapture) {
+    try {
+        const out = await capture(buildDaemonLogsArgs({ ...flags, path: true }), {
+            timeoutMs: 5_000,
+        });
+        if (out.code !== 0)
+            return null;
+        const lines = out.stdout
+            .split('\n')
+            .map((l) => l.trim())
+            .filter(Boolean);
+        const last = lines.at(-1);
+        return last && node_path_1.default.isAbsolute(last) ? last : null;
+    }
+    catch {
+        return null;
+    }
 }
 /** Read a bounded trailing window, so an unrotated legacy err log is safe. */
 function readDaemonLogTail(filePath, maxLines) {
@@ -114,7 +222,7 @@ function readDaemonLogTail(filePath, maxLines) {
  * `completeTaskDurably`. Every flag declared on the command must appear here,
  * or it parses successfully and is then silently dropped.
  */
-function buildOverskyLogsArgs(flags) {
+function buildDaemonLogsArgs(flags) {
     return [
         // The runtime's own global option, placed before the subcommand.
         ...(flags.profile ? ['--profile', flags.profile] : []),
@@ -174,31 +282,46 @@ class DaemonLogs extends core_1.Command {
     ];
     async run() {
         const { flags } = await this.parse(DaemonLogs);
-        const args = buildOverskyLogsArgs(flags);
-        // Before ANY log content, on stderr so it never pollutes a pipe. `--path`
-        // is exempt: its whole contract is one path on stdout.
-        if (!flags.path) {
+        const args = buildDaemonLogsArgs(flags);
+        const showAge = (filePath) => {
+            // Before ANY log content, on stderr so it never pollutes a pipe. `--path`
+            // is exempt: its whole contract is one path on stdout.
+            if (flags.path || !filePath)
+                return;
             try {
-                const candidate = resolveLegacyDaemonLogPath(flags);
-                if ((0, node_fs_1.existsSync)(candidate)) {
-                    const { line } = describeLogAge((0, node_fs_1.statSync)(candidate).mtimeMs);
-                    this.logToStderr(line);
+                if ((0, node_fs_1.existsSync)(filePath)) {
+                    this.logToStderr(`${filePath}: ${describeLogAge((0, node_fs_1.statSync)(filePath).mtimeMs).line}`);
                 }
             }
             catch {
                 // Never let the banner stop the logs from being shown.
             }
-        }
+        };
         try {
             // `oversky 0.2.x` has profiles and writes the same files, but has no
             // `logs` subcommand. Probe top-level help first so forwarding does not
             // print an unrelated "unknown option" error before the useful output.
             if ((await (0, exec_runtime_binary_1.runtimeBinarySupportsSubcommand)('logs')) === false) {
-                const logPath = resolveLegacyDaemonLogPath(flags);
+                const chosen = chooseLegacyFallbackLog({
+                    profilePath: resolveLegacyDaemonLogPath(flags),
+                    serviceCandidates: installedServiceLogCandidates(resolveDaemonLogsProfile(flags), flags.stderr === true),
+                    mtimeOf: (filePath) => {
+                        try {
+                            return (0, node_fs_1.statSync)(filePath).mtimeMs;
+                        }
+                        catch {
+                            return null;
+                        }
+                    },
+                });
+                const logPath = chosen.path;
+                if (chosen.note)
+                    this.logToStderr(chosen.note);
                 if (flags.path) {
                     this.log(logPath);
                     return;
                 }
+                showAge(logPath);
                 if (!(0, node_fs_1.existsSync)(logPath)) {
                     this.error(`No daemon log at ${logPath}. The installed daemon predates \`oversky logs\`; start it or upgrade it, then retry.`, { exit: 1 });
                 }
@@ -234,6 +357,10 @@ class DaemonLogs extends core_1.Command {
                 }
                 return;
             }
+            // The banner must describe the file the runtime will actually print —
+            // the live daemon's log (OSK-15993) — not the profile default.
+            if (!flags.path)
+                showAge(await resolveForwardedLogPath(flags));
             const code = await (0, exec_runtime_binary_1.execRuntimeBinary)(args);
             this.exit(code);
         }

package/dist/commands/followups/checkin.js

@@ -99,18 +99,32 @@ class FollowupsCheckin extends base_command_1.BaseCommand {
             this.handleApiError(err);
             return;
         }
+        const producer = agent.boundToSession ? 'agent_in_turn' : 'user_explicit';
+        // An explicit request from a person that arms nothing is a refusal, and a script reading the
+        // exit code must see it as one (OSK-15413). A check-in the AGENT chose to make is different:
+        // there, staying quiet when the budget is spent is the designed outcome.
+        if (response.dropped && producer === 'user_explicit') {
+            this.failWithCliError({
+                message: budgetRefusalMessage(agent.id, response.budget),
+                code: 'FOLLOWUP_BUDGET_EXHAUSTED',
+                exit: 1,
+                retryable: false,
+                details: { budget: response.budget ?? null, response },
+            });
+            return;
+        }
         if (flags.json) {
             this.log(JSON.stringify(response, null, 2));
             return;
         }
         const row = response.followup;
         if (response.reused) {
-            this.log(`Already armed: ${row?.id} — one pending check-in per conversation, and this is it.`);
+            this.log(reusedMessage(row, subject, flags.why));
             return;
         }
         if (response.dropped) {
-            // silent_drop is the check-in budget's contract: the answer to "one
-            // greeting too many" is quiet, not an error the caller can retry.
+            // silent_drop is the check-in budget's contract for an agent's own check-in: the answer to
+            // "one greeting too many" is quiet, not an error the caller can retry.
             this.log('Dropped by the daily check-in budget — staying quiet is the correct outcome.');
             return;
         }
@@ -118,3 +132,32 @@ class FollowupsCheckin extends base_command_1.BaseCommand {
     }
 }
 exports.default = FollowupsCheckin;
+/**
+ * What a reused answer means for the person who asked: a second check-in on a subject that already
+ * has one arms nothing and changes nothing, so the note and time they typed were NOT applied. Say
+ * so, show what is armed, and name the two ways forward (OSK-15411). Exit stays 0: the follow-up
+ * they wanted to exist does exist.
+ */
+function reusedMessage(row, subject, requestedWhy) {
+    const lines = [
+        `Already armed: ${row?.id} — one pending check-in per subject (${subject.type}:${subject.externalKey}), and this is it.`,
+        'Nothing in this request was applied: it armed no new check-in and changed neither the note nor the time.',
+    ];
+    if (row) {
+        const sameNote = row.why === requestedWhy;
+        lines.push(`Armed: ${row.why ? `"${row.why}"` : '(no note)'}, next ${row.nextRunAt ?? 'when its schedule says'}${sameNote ? ' (the same note you gave)' : ''}.`);
+    }
+    lines.push(`To change the time: skrr followups reschedule ${row?.id ?? '<id>'} --at <instant> or --in <offset>.`, "To change the note: cancel it and create it again (a cancelled check-in still counts against today's check-in budget).");
+    return lines.join('\n');
+}
+/** The refusal for an explicit check-in the daily budget will not take, with the number and the way to raise it. */
+function budgetRefusalMessage(agentId, budget) {
+    const { used, limit } = (budget && typeof budget === 'object' ? budget : {});
+    const spent = typeof used === 'number' && typeof limit === 'number'
+        ? `${agentId} has used ${used} of its ${limit} check-ins today`
+        : `${agentId} has used its daily check-in budget`;
+    return [
+        `No check-in was armed: ${spent}. The day resets at 00:00 UTC, and a cancelled check-in still counts.`,
+        `Raise the limit with: skrr agents triggers policy ${agentId} --followup-budget checkin=<count>`,
+    ].join(' ');
+}

package/dist/commands/tasks/approvals/resolve.d.ts

@@ -1,4 +1,16 @@
+import { type TaskApprovalResolveParams } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../../base-command';
+/**
+ * The request body for resolving an approval. The server's field is `comment`
+ * (`TaskApprovalResolveParams`); `--reason` is only the flag's name. It was sent
+ * as `reason` through an `as unknown as` cast, so the type checker could not see
+ * the mismatch and the server's non-strict schema dropped the key: the command
+ * succeeded and the reason was stored nowhere (OSK-15362).
+ */
+export declare function approvalResolutionBody(flags: {
+    status: 'approved' | 'rejected';
+    reason?: string;
+}): TaskApprovalResolveParams;
 export default class TasksApprovalsResolve extends BaseCommand {
     static description: string;
     static examples: string[];

package/dist/commands/tasks/approvals/resolve.js

@@ -1,8 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.approvalResolutionBody = approvalResolutionBody;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
+/**
+ * The request body for resolving an approval. The server's field is `comment`
+ * (`TaskApprovalResolveParams`); `--reason` is only the flag's name. It was sent
+ * as `reason` through an `as unknown as` cast, so the type checker could not see
+ * the mismatch and the server's non-strict schema dropped the key: the command
+ * succeeded and the reason was stored nowhere (OSK-15362).
+ */
+function approvalResolutionBody(flags) {
+    const body = { status: flags.status };
+    if (flags.reason)
+        body.comment = flags.reason;
+    return body;
+}
 class TasksApprovalsResolve extends base_command_1.BaseCommand {
     static description = 'Resolve (approve or reject) a task approval';
     static examples = [
@@ -27,15 +41,15 @@ class TasksApprovalsResolve extends base_command_1.BaseCommand {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksApprovalsResolve);
         const taskRef = await this.resolveEntityRef('task', args.id);
-        const data = { status: flags.status };
-        if (flags.reason)
-            data.reason = flags.reason;
         let result;
         try {
             result = await data_provider_1.dataService.resolveTaskApproval({
                 taskId: taskRef,
                 approvalId: args.approvalId,
-                data: data,
+                data: approvalResolutionBody({
+                    status: flags.status,
+                    reason: flags.reason,
+                }),
             });
         }
         catch (err) {
@@ -46,7 +60,9 @@ class TasksApprovalsResolve extends base_command_1.BaseCommand {
             return;
         }
         const a = result;
-        this.log(`Approval ${a.id ?? a._id ?? args.approvalId} → ${flags.status}`);
+        // Say what was recorded, so a reason that was not stored cannot pass unseen.
+        const recorded = typeof a.comment === 'string' && a.comment ? ` (reason: ${a.comment})` : '';
+        this.log(`Approval ${a.id ?? a._id ?? args.approvalId} → ${flags.status}${recorded}`);
     }
 }
 exports.default = TasksApprovalsResolve;

package/dist/commands/triggers/create.js

@@ -91,7 +91,9 @@ class TriggersCreate extends base_command_1.BaseCommand {
             multiple: true,
         }),
         timezone: core_1.Flags.string({ description: 'IANA timezone for schedule triggers' }),
-        'max-fires-per-day': core_1.Flags.integer({ description: 'Daily fire cap' }),
+        'max-fires-per-day': core_1.Flags.integer({
+            description: 'Daily fire cap (schedule, stochastic and self_scheduled triggers only)',
+        }),
         'max-runs': core_1.Flags.integer({ description: 'Lifetime fire cap for schedule triggers' }),
         'end-at': core_1.Flags.string({
             description: 'ISO-8601 datetime after which a schedule stops firing',
@@ -192,6 +194,9 @@ class TriggersCreate extends base_command_1.BaseCommand {
         let payload;
         try {
             payload = await (0, prompt_1.readJsonBody)(flags['from-json']);
+            // A flag for a kind other than --kind is refused, not dropped: the block it fills is not
+            // sent, so the caller would believe a limit was set that nothing holds (OSK-15491).
+            (0, triggers_1.assertKindFlagsApply)(flags.kind ?? payload.kind, flags);
             const refs = (0, triggers_1.parseKeyValueFlags)(flags.ref, '--ref', flags.scope ?? payload.scope?.kind);
             if (flags.scope || Object.keys(refs).length > 0) {
                 payload.scope = {
@@ -267,22 +272,8 @@ class TriggersCreate extends base_command_1.BaseCommand {
                 filterField: flags['filter-field'],
                 filterValues,
             });
-            (0, triggers_1.setDefined)(event, {
-                entityType: flags.entity,
-                eventType: flags.event,
-                filterMode: flags['filter-mode'],
-                filterField: flags['filter-field'],
-                filterValue: filterValues && filterValues.length > 1 ? filterValues : filterValues?.[0],
-                debounceMs: flags['debounce-ms'],
-                maxPerHour: flags['max-per-hour'],
-            });
-            const stochastic = {};
-            (0, triggers_1.setDefined)(stochastic, {
-                probability: flags.probability === undefined ? undefined : Number(flags.probability),
-                jitterMs: flags['jitter-ms'],
-                maxFiresPerDay: flags['max-fires-per-day'],
-                evalIntervalMinutes: flags['eval-interval-minutes'],
-            });
+            Object.assign(event, (0, triggers_1.buildEventConfigFromFlags)(flags, filterValues));
+            const stochastic = (0, triggers_1.buildStochasticConfigFromFlags)(flags);
             const selfScheduled = (0, triggers_1.buildSelfScheduledConfigFromFlags)(flags);
             const form = (0, triggers_1.buildFormConfigFromFlags)(flags);
             const chatMessage = (0, triggers_1.buildChatMessageConfigFromFlags)(flags);

package/dist/commands/triggers/fire.js

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

package/dist/commands/triggers/update.js

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

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

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