@skrr-ai/cli 0.1.36 → 0.1.38

package/dist/commands/followups/cancel.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const followups_1 = require("../../lib/followups");
+/**
+ * `skrr followups cancel <id>` — "never mind". It records exactly what
+ * `resolve --outcome abandoned` records (terminal `abandoned`, the reason as
+ * the note); it exists so calling one off does not require knowing the
+ * terminal vocabulary. Neither help text used to say so, and a user had to
+ * read the service to choose between them (OSK-9679).
+ */
+class FollowupsCancel extends base_command_1.BaseCommand {
+    static description = 'Call off a follow-up you no longer want (same record as resolve --outcome abandoned)';
+    static examples = [
+        '<%= config.bin %> followups cancel fu_abc',
+        '<%= config.bin %> followups cancel fu_abc --reason "handled it by hand"',
+        '# If what you were waiting for happened, record that instead:',
+        '<%= config.bin %> followups resolve fu_abc --outcome resolved',
+    ];
+    static args = {
+        id: followups_1.followUpIdArg,
+    };
+    static flags = {
+        reason: core_1.Flags.string({
+            description: 'Why it is being called off — stored as the note (default: "cancelled")',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(FollowupsCancel);
+        let result;
+        try {
+            result = (await followups_1.followupsApi.cancel(args.id, {
+                ...(flags.reason ? { reason: flags.reason } : {}),
+            }));
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Follow-up ${args.id} cancelled.`);
+    }
+}
+exports.default = FollowupsCancel;

package/dist/commands/followups/checkin.d.ts

@@ -0,0 +1,27 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr followups checkin` — a `checkin` follow-up: the agent decides to come
+ * back later. `--in` arms the `once` form (the agent's pick); `--frequency`
+ * arms `recurring` (a cadence the user picked).
+ *
+ * This is permission AND restraint: a check-in may stay silent on wake when
+ * there is nothing worth saying — silence is the designed outcome, not a
+ * failure.
+ */
+export default class FollowupsCheckin extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        subject: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        why: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        in: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        frequency: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        timezone: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        endpoint: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'endpoint-target': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        pin: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/followups/checkin.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const followups_1 = require("../../lib/followups");
+const agent_resolver_1 = require("../../lib/agent-resolver");
+/**
+ * `skrr followups checkin` — a `checkin` follow-up: the agent decides to come
+ * back later. `--in` arms the `once` form (the agent's pick); `--frequency`
+ * arms `recurring` (a cadence the user picked).
+ *
+ * This is permission AND restraint: a check-in may stay silent on wake when
+ * there is nothing worth saying — silence is the designed outcome, not a
+ * failure.
+ */
+class FollowupsCheckin extends base_command_1.BaseCommand {
+    static description = 'Come back to this later — the check-in follow-up';
+    static examples = [
+        '<%= config.bin %> followups checkin --subject conversation:conv_9 --why "waiting on their answer about the move" --in 90m',
+        '<%= config.bin %> followups checkin --subject task:OSK-42 --why "weekly touch-base" --frequency "0 9 * * MON" --timezone America/New_York',
+    ];
+    static flags = {
+        subject: core_1.Flags.string({ description: 'Subject ref: type:externalKey', required: true }),
+        why: core_1.Flags.string({ description: 'Why this wake exists, in one line', required: true }),
+        in: core_1.Flags.string({
+            description: 'Duration from now (90m, 2h) — the once form',
+            exclusive: ['frequency'],
+        }),
+        frequency: core_1.Flags.string({
+            description: 'Cron cadence — the recurring form (user-picked)',
+            exclusive: ['in'],
+        }),
+        timezone: core_1.Flags.string({
+            description: 'IANA timezone for --frequency',
+            dependsOn: ['frequency'],
+        }),
+        agent: core_1.Flags.string({ description: 'Agent ID (default: bound session agent)' }),
+        endpoint: core_1.Flags.string({ description: 'Delivery endpoint id (EndpointRegistry)' }),
+        'endpoint-target': core_1.Flags.string({ description: 'Channel target for channel endpoints' }),
+        pin: core_1.Flags.string({ description: 'Conversation id the check-in was authored in' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(FollowupsCheckin);
+        if (!flags.in && !flags.frequency) {
+            this.failWithCliError({
+                message: 'Either --in <duration> or --frequency <cron> is required.',
+                code: 'FOLLOWUP_KIND_FIELD_MISSING',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        let agent;
+        try {
+            agent = (0, followups_1.resolveFollowUpAgent)(flags.agent);
+        }
+        catch (err) {
+            const failure = (0, agent_resolver_1.agentResolutionFailure)(err);
+            this.failWithCliError({
+                message: failure.message,
+                code: failure.code,
+                exit: 2,
+                retryable: false,
+                details: { suggestion: failure.suggestion, context: failure.details },
+            });
+        }
+        let response;
+        try {
+            response = await followups_1.followupsApi.create({
+                kind: 'checkin',
+                producer: agent.boundToSession ? 'agent_in_turn' : 'user_explicit',
+                agentId: agent.id,
+                subject: (0, followups_1.parseSubjectRef)(flags.subject),
+                why: flags.why,
+                ...(flags.in ? { form: 'once', in: flags.in } : {}),
+                ...(flags.frequency
+                    ? { form: 'recurring', frequency: flags.frequency, timezone: flags.timezone }
+                    : {}),
+                ...(flags.endpoint ? { endpointId: flags.endpoint } : {}),
+                ...(flags['endpoint-target'] ? { endpointTarget: flags['endpoint-target'] } : {}),
+                ...(flags.pin ? { pinnedConversationId: flags.pin } : {}),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            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.`);
+            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.
+            this.log('Dropped by the daily check-in budget — staying quiet is the correct outcome.');
+            return;
+        }
+        this.log(`Check-in armed: ${row?.id} at ${row?.nextRunAt ?? flags.in ?? flags.frequency}.`);
+    }
+}
+exports.default = FollowupsCheckin;

package/dist/commands/followups/list.d.ts

@@ -0,0 +1,24 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr followups list` — what is still owed, one row per follow-up across
+ * all four kinds.
+ *
+ * Default scope is ONE agent (the session's, or `--agent`) — "what do I still
+ * owe" is the question an agent asks. `--all-agents` is the human's view and
+ * is opt-in, so an agent cannot accidentally read another agent's
+ * obligations and start reasoning about them.
+ */
+export default class FollowupsList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'all-agents': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        kind: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        subject: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        state: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/followups/list.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const followups_1 = require("../../lib/followups");
+const agent_resolver_1 = require("../../lib/agent-resolver");
+/**
+ * `skrr followups list` — what is still owed, one row per follow-up across
+ * all four kinds.
+ *
+ * Default scope is ONE agent (the session's, or `--agent`) — "what do I still
+ * owe" is the question an agent asks. `--all-agents` is the human's view and
+ * is opt-in, so an agent cannot accidentally read another agent's
+ * obligations and start reasoning about them.
+ */
+class FollowupsList extends base_command_1.BaseCommand {
+    static description = 'List follow-ups — armed, proposed, paused, or settled';
+    static examples = [
+        '<%= config.bin %> followups list',
+        '<%= config.bin %> followups list --agent agent_1 --kind watch --state armed',
+        '<%= config.bin %> followups list --all-agents --kind checkin',
+        '<%= config.bin %> followups list --subject task:OSK-42 --json',
+    ];
+    static flags = {
+        agent: core_1.Flags.string({
+            description: 'Agent ID (default: bound session agent)',
+            exclusive: ['all-agents'],
+        }),
+        'all-agents': core_1.Flags.boolean({
+            description: 'List across every agent — the human view',
+            exclusive: ['agent'],
+            default: false,
+        }),
+        kind: core_1.Flags.string({ description: 'Filter by kind', options: [...followups_1.FOLLOWUP_KINDS] }),
+        subject: core_1.Flags.string({ description: 'Filter by subject ref: type:externalKey' }),
+        state: core_1.Flags.string({ description: 'Filter by state', options: [...followups_1.FOLLOWUP_STATES] }),
+        limit: core_1.Flags.integer({ description: 'Max results (1..500)', min: 1, max: 500 }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(FollowupsList);
+        let agentId;
+        if (!flags['all-agents']) {
+            try {
+                agentId = (0, followups_1.resolveFollowUpAgent)(flags.agent).id;
+            }
+            catch (err) {
+                const failure = (0, agent_resolver_1.agentResolutionFailure)(err);
+                this.failWithCliError({
+                    message: failure.message,
+                    code: failure.code,
+                    exit: 2,
+                    retryable: false,
+                    details: { suggestion: failure.suggestion, context: failure.details },
+                });
+            }
+        }
+        let response;
+        try {
+            response = await followups_1.followupsApi.list({
+                ...(agentId ? { agentId } : {}),
+                ...(flags['all-agents'] ? { allAgents: true } : {}),
+                ...(flags.kind ? { kind: flags.kind } : {}),
+                ...(flags.subject ? { subject: flags.subject } : {}),
+                ...(flags.state ? { state: flags.state } : {}),
+                ...(flags.limit ? { limit: flags.limit } : {}),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        const rows = response.followups ?? [];
+        if (rows.length === 0) {
+            this.log('No follow-ups.');
+            return;
+        }
+        for (const row of rows) {
+            this.log((0, followups_1.followupSummaryLine)(row));
+            if (row.why)
+                this.log(`    why: ${row.why}`);
+        }
+    }
+}
+exports.default = FollowupsList;

package/dist/commands/followups/observability.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr followups observability` — how follow-ups are doing, per (agent, kind).
+ *
+ * `list` answers "what is still owed", one row per follow-up. This answers the
+ * question a page of rows cannot: how many were created, how they ended, how
+ * often they escalated, today's budget, and how often a check-in chose to stay
+ * quiet. The API served this rollup from the day the service shipped and no
+ * command reached it (OSK-9678).
+ *
+ * Scope follows `list`: one agent by default (the session's, or `--agent`),
+ * every agent only with `--all-agents`.
+ */
+export default class FollowupsObservability extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'all-agents': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/followups/observability.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const format_1 = require("../../lib/format");
+const followups_1 = require("../../lib/followups");
+const agent_resolver_1 = require("../../lib/agent-resolver");
+const rate = (value) => value === null ? '—' : `${Math.round(value * 100)}%`;
+/** `resolved 3 · abandoned 1` — the outcomes that happened, not five zeros. */
+const outcomes = (terminal) => Object.entries(terminal)
+    .filter(([, count]) => count > 0)
+    .map(([outcome, count]) => `${outcome} ${count}`)
+    .join(' · ') || '—';
+/**
+ * `skrr followups observability` — how follow-ups are doing, per (agent, kind).
+ *
+ * `list` answers "what is still owed", one row per follow-up. This answers the
+ * question a page of rows cannot: how many were created, how they ended, how
+ * often they escalated, today's budget, and how often a check-in chose to stay
+ * quiet. The API served this rollup from the day the service shipped and no
+ * command reached it (OSK-9678).
+ *
+ * Scope follows `list`: one agent by default (the session's, or `--agent`),
+ * every agent only with `--all-agents`.
+ */
+class FollowupsObservability extends base_command_1.BaseCommand {
+    static description = 'Per-agent, per-kind rollup — created, outcomes, escalation, budget, check-in silence';
+    static examples = [
+        '<%= config.bin %> followups observability',
+        '<%= config.bin %> followups observability --agent agent_1',
+        '<%= config.bin %> followups observability --all-agents --json',
+    ];
+    static flags = {
+        agent: core_1.Flags.string({
+            description: 'Agent ID (default: bound session agent)',
+            exclusive: ['all-agents'],
+        }),
+        'all-agents': core_1.Flags.boolean({
+            description: 'Roll up every agent — the human view',
+            exclusive: ['agent'],
+            default: false,
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(FollowupsObservability);
+        let agentId;
+        if (!flags['all-agents']) {
+            try {
+                agentId = (0, followups_1.resolveFollowUpAgent)(flags.agent).id;
+            }
+            catch (err) {
+                const failure = (0, agent_resolver_1.agentResolutionFailure)(err);
+                this.failWithCliError({
+                    message: failure.message,
+                    code: failure.code,
+                    exit: 2,
+                    retryable: false,
+                    details: { suggestion: failure.suggestion, context: failure.details },
+                });
+            }
+        }
+        let report;
+        try {
+            report = await followups_1.followupsApi.observability(agentId ? { agentId } : {});
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        const agents = (report.agents ?? []).filter((agent) => agent.kinds.length > 0);
+        if (agents.length === 0) {
+            this.log('No follow-ups.');
+            return;
+        }
+        // One heading per agent rather than an AGENT column: an agent id repeated
+        // on every row pushed the table past any normal terminal width.
+        agents.forEach((agent, index) => {
+            if (index > 0)
+                this.log('');
+            this.log(agent.agentId === 'user' ? 'user (reminders with no agent)' : agent.agentId);
+            (0, format_1.renderTable)(agent.kinds.map((kind) => ({
+                kind: kind.kind,
+                created: String(kind.created),
+                open: String(kind.armed),
+                proposed: String(kind.proposed),
+                settled: String(kind.settled),
+                outcomes: outcomes(kind.terminal),
+                escalated: rate(kind.escalationRate),
+                fires: String(kind.fires),
+                budget: kind.budget ? `${kind.budget.used}/${kind.budget.limit ?? '∞'}` : '—',
+                silence: rate(kind.silenceRate),
+            })), [
+                { key: 'kind', header: 'KIND' },
+                { key: 'created', header: 'CREATED' },
+                { key: 'open', header: 'OPEN' },
+                { key: 'proposed', header: 'PROPOSED' },
+                { key: 'settled', header: 'SETTLED' },
+                { key: 'outcomes', header: 'OUTCOMES' },
+                { key: 'escalated', header: 'ESCALATED' },
+                { key: 'fires', header: 'FIRES' },
+                { key: 'budget', header: 'TODAY/LIMIT' },
+                { key: 'silence', header: 'SILENT' },
+            ], (line) => this.log(line));
+        });
+        this.log(`\nAs of ${report.generatedAt ?? 'now'}. TODAY/LIMIT is the daily budget (reminders are not metered); SILENT is how often a check-in chose to stay quiet.`);
+    }
+}
+exports.default = FollowupsObservability;

package/dist/commands/followups/remind.d.ts

@@ -0,0 +1,26 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr followups remind` — a `reminder` follow-up.
+ *
+ * A passive reminder (the default) delivers the user's own words back at T
+ * and needs no agent. `--active` wakes the agent to word it, which is why it
+ * needs an agent context the passive form does not.
+ */
+export default class FollowupsRemind extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        subject: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        content: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        at: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        in: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        why: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        active: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        endpoint: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'endpoint-target': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        pin: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/followups/remind.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const followups_1 = require("../../lib/followups");
+const agent_resolver_1 = require("../../lib/agent-resolver");
+/**
+ * `skrr followups remind` — a `reminder` follow-up.
+ *
+ * A passive reminder (the default) delivers the user's own words back at T
+ * and needs no agent. `--active` wakes the agent to word it, which is why it
+ * needs an agent context the passive form does not.
+ */
+class FollowupsRemind extends base_command_1.BaseCommand {
+    static description = 'Remind the owner at a time — the reminder follow-up';
+    static examples = [
+        '<%= config.bin %> followups remind --subject task:OSK-42 --content "pick the deploy up" --in 2h',
+        '<%= config.bin %> followups remind --subject conversation:conv_9 --content "ask how the move went" --at 2026-09-20T09:00:00Z',
+        '<%= config.bin %> followups remind --subject task:OSK-42 --content "ping me" --at 2026-09-20T09:00:00Z --active --agent agent_1',
+    ];
+    static flags = {
+        subject: core_1.Flags.string({ description: 'Subject ref: type:externalKey', required: true }),
+        content: core_1.Flags.string({ description: "The reminder's own words", required: true }),
+        at: core_1.Flags.string({ description: 'ISO-8601 instant to remind at', exclusive: ['in'] }),
+        in: core_1.Flags.string({
+            description: 'Duration from now (90m, 2h, 3d)',
+            exclusive: ['at'],
+        }),
+        why: core_1.Flags.string({ description: 'Why this wake exists (defaults to the content)' }),
+        active: core_1.Flags.boolean({
+            description: 'Wake the agent to word the reminder (needs an agent context)',
+            default: false,
+        }),
+        agent: core_1.Flags.string({ description: 'Agent ID (default: bound session agent)' }),
+        endpoint: core_1.Flags.string({ description: 'Delivery endpoint id (EndpointRegistry)' }),
+        'endpoint-target': core_1.Flags.string({ description: 'Channel target for channel endpoints' }),
+        pin: core_1.Flags.string({ description: 'Conversation id the reminder was authored in' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(FollowupsRemind);
+        const at = flags.at ?? flags.in;
+        if (!at) {
+            this.failWithCliError({
+                message: 'Either --at <iso> or --in <duration> is required.',
+                code: 'FOLLOWUP_KIND_FIELD_MISSING',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        // A passive reminder runs no agent, so it may legitimately have none — the
+        // ONLY kind/form where the resolver is allowed to fall through empty.
+        let agent;
+        try {
+            agent = (0, followups_1.resolveFollowUpAgent)(flags.agent);
+        }
+        catch (err) {
+            if (flags.active) {
+                const failure = (0, agent_resolver_1.agentResolutionFailure)(err);
+                this.failWithCliError({
+                    message: failure.message,
+                    code: failure.code,
+                    exit: 2,
+                    retryable: false,
+                    details: { suggestion: failure.suggestion, context: failure.details },
+                });
+            }
+        }
+        let response;
+        try {
+            response = await followups_1.followupsApi.create({
+                kind: 'reminder',
+                form: flags.active ? 'active' : 'passive',
+                producer: agent?.boundToSession ? 'agent_in_turn' : 'user_explicit',
+                ...(agent ? { agentId: agent.id } : {}),
+                subject: (0, followups_1.parseSubjectRef)(flags.subject),
+                why: flags.why ?? flags.content,
+                content: flags.content,
+                at,
+                ...(flags.endpoint ? { endpointId: flags.endpoint } : {}),
+                ...(flags['endpoint-target'] ? { endpointTarget: flags['endpoint-target'] } : {}),
+                ...(flags.pin ? { pinnedConversationId: flags.pin } : {}),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            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} — the same reminder exists and was not duplicated.`);
+            return;
+        }
+        if (response.dropped) {
+            this.log('Dropped by the daily budget — no reminder was armed.');
+            return;
+        }
+        this.log(`Reminder armed: ${row?.id} at ${row?.nextRunAt ?? at}.`);
+    }
+}
+exports.default = FollowupsRemind;

package/dist/commands/followups/reschedule.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command';
+/** `skrr followups reschedule <id>` — move a pending wake to a new time. */
+export default class FollowupsReschedule extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        at: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        in: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/followups/reschedule.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const followups_1 = require("../../lib/followups");
+/** `skrr followups reschedule <id>` — move a pending wake to a new time. */
+class FollowupsReschedule extends base_command_1.BaseCommand {
+    static description = 'Reschedule a pending follow-up';
+    static examples = [
+        '<%= config.bin %> followups reschedule fu_abc --in 2h',
+        '<%= config.bin %> followups reschedule fu_abc --at 2026-09-20T09:00:00Z',
+    ];
+    static args = {
+        id: followups_1.followUpIdArg,
+    };
+    static flags = {
+        at: core_1.Flags.string({ description: 'New instant (ISO-8601)', exclusive: ['in'] }),
+        in: core_1.Flags.string({ description: 'New offset from now (90m, 2h)', exclusive: ['at'] }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(FollowupsReschedule);
+        const at = flags.at ?? flags.in;
+        if (!at) {
+            this.failWithCliError({
+                message: 'Either --at <iso> or --in <duration> is required.',
+                code: 'FOLLOWUP_KIND_FIELD_MISSING',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        let result;
+        try {
+            result = (await followups_1.followupsApi.reschedule(args.id, { at }));
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Follow-up ${args.id} rescheduled to ${at}.`);
+    }
+}
+exports.default = FollowupsReschedule;