@skrr-ai/cli 0.1.132 → 0.1.133

package/dist/commands/agenda/plan.d.ts

@@ -7,10 +7,8 @@ import { BaseCommand } from '../../base-command';
  * server, and enqueues the agent turn through the canonical agentic
  * pipeline (preflight → BullMQ → AgentWorker → AgenticClient → SDK).
  *
- * The CLI returns the resolved `conversationId` + `sessionId` immediately
- * after the HTTP accept. Live streaming continues over `/ws/agentic` —
- * not subscribed here. Pair with `skrr convos show <conversationId>` to
- * inspect the resulting agenda once it persists.
+ * Interactive terminals follow the accepted session, including permission
+ * requests. JSON and non-interactive invocations remain detached by default.
  */
 export default class AgendaPlan extends BaseCommand {
     static description: string;
@@ -22,6 +20,8 @@ export default class AgendaPlan extends BaseCommand {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'space-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         timezone: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        follow: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'approve-tools': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/agenda/plan.js

@@ -3,6 +3,22 @@ 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 api_fetch_1 = require("../../lib/api-fetch");
+const agentic_stream_1 = require("../../lib/agentic-stream");
+const chat_1 = require("../agents/chat");
+function describeRuntime(runtime) {
+    if (typeof runtime === 'string')
+        return runtime;
+    if (!runtime || typeof runtime !== 'object')
+        return null;
+    const record = runtime;
+    const plan = record.executionPlan && typeof record.executionPlan === 'object'
+        ? record.executionPlan : null;
+    const selected = typeof plan?.selectedKind === 'string' ? plan.selectedKind : null;
+    if (selected)
+        return `selected ${selected}${selected === 'agent-worker' && record.daemonId ? '; local daemon available as tool bridge' : ''}`;
+    return typeof record.mode === 'string' ? record.mode : null;
+}
 /**
  * `skrr agenda plan <agent-id>` — kick off a one-shot Agenda Planning turn
  * for an agent. The server-side controller resolves the agent's persistent
@@ -11,10 +27,8 @@ const base_command_1 = require("../../base-command");
  * server, and enqueues the agent turn through the canonical agentic
  * pipeline (preflight → BullMQ → AgentWorker → AgenticClient → SDK).
  *
- * The CLI returns the resolved `conversationId` + `sessionId` immediately
- * after the HTTP accept. Live streaming continues over `/ws/agentic` —
- * not subscribed here. Pair with `skrr convos show <conversationId>` to
- * inspect the resulting agenda once it persists.
+ * Interactive terminals follow the accepted session, including permission
+ * requests. JSON and non-interactive invocations remain detached by default.
  */
 class AgendaPlan extends base_command_1.BaseCommand {
     static description = 'Trigger an Agenda Planning turn for an agent. Returns the conversation id where the streaming response will land.';
@@ -34,10 +48,17 @@ class AgendaPlan extends base_command_1.BaseCommand {
         timezone: core_1.Flags.string({
             description: 'IANA timezone hint for the agenda turn (defaults to UTC server-side)',
         }),
+        follow: core_1.Flags.boolean({ allowNo: true, description: 'Follow the session (default on an interactive terminal)' }),
+        'approve-tools': core_1.Flags.boolean({
+            description: 'Allow tool prompts; on a non-interactive follow this grants requested tools for the turn',
+        }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(AgendaPlan);
+        if (flags.json && flags.follow)
+            this.error('--json is detached; use --follow without --json to stream.', { exit: 1 });
+        const follow = flags.follow ?? (Boolean(process.stdin.isTTY) && !flags.json);
         let response;
         try {
             response = await data_provider_1.dataService.planAgenda({
@@ -57,12 +78,103 @@ class AgendaPlan extends base_command_1.BaseCommand {
         this.log(`Conversation ID: ${response.conversationId}`);
         this.log(`Session ID:      ${response.sessionId}`);
         this.log(`New conversation: ${response.isNewConversation ? 'yes' : 'no'}`);
-        if (response.runtime)
-            this.log(`Runtime:          ${response.runtime}`);
+        const runtimeDescription = describeRuntime(response.runtime);
+        if (runtimeDescription)
+            this.log(`Runtime:          ${runtimeDescription}`);
         this.log('');
-        this.log('Streaming continues over /ws/agentic. Use `skrr convos show ' +
-            response.conversationId +
-            '` to inspect the agenda once it completes.');
+        if (!follow) {
+            this.log('The turn is running detached. It may wait for permission; inspect it in the app or conversation ' + response.conversationId + '.');
+            return;
+        }
+        const readMessages = async () => {
+            const messages = await data_provider_1.dataService.getMessagesByConvoId(response.conversationId);
+            return Array.isArray(messages) ? messages : [];
+        };
+        let detach;
+        const detached = new Promise((resolve) => { detach = () => resolve('detached'); });
+        let disconnectTimer;
+        const client = new agentic_stream_1.AgenticStreamClient({
+            baseURL: this.cliConfig.baseURL,
+            token: this.resolvedCredential.token,
+            workspaceId: process.env.OVERSKY_WORKSPACE_ID,
+            sessionId: response.sessionId,
+            conversationId: response.conversationId,
+            approveTools: Boolean(process.stdin.isTTY || flags['approve-tools']),
+            onEvent: (event) => {
+                if (event.type === 'transport.connected' && disconnectTimer) {
+                    clearTimeout(disconnectTimer);
+                    disconnectTimer = undefined;
+                }
+                else if (event.type === 'transport.disconnected' && !disconnectTimer) {
+                    // An established Socket.IO connection can be disconnected without an
+                    // automatic retry. Bound the lost view and reconcile its durable row.
+                    disconnectTimer = setTimeout(detach, 30_000);
+                }
+            },
+            reconcileTerminal: async () => (0, chat_1.reconcileTerminalFromMessages)(await readMessages(), response.responseMessageId),
+            awaitHandover: {
+                read: async () => (0, chat_1.handoverStateFromMessages)(await readMessages(), response.responseMessageId),
+                responseMessageId: response.responseMessageId,
+                conversationId: response.conversationId,
+                maxWaitMs: 5 * 60_000,
+            },
+            replayEnvelopes: (from) => (0, api_fetch_1.apiFetch)(`/api/agentic/sessions/${encodeURIComponent(response.sessionId)}/envelopes?from=${from}&limit=500`, { credential: this.resolvedCredential, signal: AbortSignal.timeout(5000) }),
+        });
+        let interruptedBy = null;
+        let timer;
+        const onInterrupt = (signal) => {
+            if (interruptedBy) {
+                detach();
+                return;
+            }
+            interruptedBy = signal;
+            client.cancel();
+            if (signal !== 'SIGHUP')
+                process.stderr.write(`\nCancellation requested for ${response.sessionId}; waiting up to 10 seconds. The turn may still be running if it does not stop.\n`);
+            timer = setTimeout(detach, 10_000);
+        };
+        const onSigint = () => onInterrupt('SIGINT');
+        const onSigterm = () => onInterrupt('SIGTERM');
+        const onSighup = () => onInterrupt('SIGHUP');
+        process.on('SIGINT', onSigint);
+        process.on('SIGTERM', onSigterm);
+        process.on('SIGHUP', onSighup);
+        try {
+            const outcome = await Promise.race([
+                client.run().catch((error) => {
+                    if (error?.code === 'STREAM_ATTACH_TIMEOUT')
+                        return 'detached';
+                    throw error;
+                }),
+                detached,
+            ]);
+            const result = outcome === 'detached' && await client.probeTerminal('detach')
+                ? client.settledResult() : outcome === 'detached' ? null : outcome;
+            if (!result) {
+                process.stderr.write(`Detached from ${response.sessionId}; the turn may still be running. Check conversation ${response.conversationId}.\n`);
+                process.exitCode = interruptedBy === 'SIGTERM' ? 143 : interruptedBy === 'SIGHUP' ? 129 : interruptedBy ? 130 : 75;
+            }
+            else if (result.status === 'failed') {
+                process.exitCode = 1;
+            }
+            else if (result.status === 'aborted' && interruptedBy !== 'SIGHUP') {
+                this.log(`\nCancellation confirmed for ${response.sessionId}.`);
+            }
+            if (interruptedBy === 'SIGTERM')
+                process.exitCode = 143;
+            if (interruptedBy === 'SIGHUP')
+                process.exitCode = 129;
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            if (disconnectTimer)
+                clearTimeout(disconnectTimer);
+            process.removeListener('SIGINT', onSigint);
+            process.removeListener('SIGTERM', onSigterm);
+            process.removeListener('SIGHUP', onSighup);
+            client.close();
+        }
     }
 }
 exports.default = AgendaPlan;

package/dist/commands/agent/message/send.js

@@ -763,6 +763,10 @@ function normalizeIntentPayload({ agentId, jsonBody, merged, }) {
     const overlayChannel = optionalString(merged.channelId);
     const overlayThreadTs = optionalString(merged.threadTs);
     const destinationKind = pickDestinationKind({ bodyDestination, overlayKind });
+    if (destinationKind !== 'slack_channel' &&
+        (merged.channelId !== undefined || bodyDestination?.channelId !== undefined)) {
+        throw invalidIntent('--channel / destination.channelId only applies to slack_channel.');
+    }
     if (destinationKind !== 'slack_channel' && (overlayThreadTs || bodyDestination?.threadTs)) {
         throw invalidIntent('--thread-ts / destination.threadTs only applies to slack_channel.');
     }

package/dist/commands/agents/intuitions/generate.js

@@ -13,12 +13,31 @@ class AgentsIntuitionsGenerate extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(AgentsIntuitionsGenerate);
-        const result = await data_provider_1.dataService.generateAgentIntuitions(args.agentId, flags.force);
-        this.log(flags.json
-            ? this.agentJson(args.agentId, result)
-            : `Generated intuitions for agent ${args.agentId}`);
-        if (!flags.json)
-            this.printAgentUrl(args.agentId);
+        let result;
+        try {
+            result = await data_provider_1.dataService.generateAgentIntuitions(args.agentId, flags.force);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(this.agentJson(args.agentId, result));
+            return;
+        }
+        const response = result;
+        if (response.outcome === 'insufficient_context') {
+            this.log('No intuitions yet: add relevant agent memories or activity, then try again.');
+        }
+        else if (response.outcome === 'no_suggestions') {
+            this.log('No intuitions were suggested from the available context. Try again after more activity.');
+        }
+        else if (response.intuitions?.length === 0) {
+            this.log('No intuitions were returned. Add relevant memories or activity, then try again.');
+        }
+        else {
+            this.log(`Generated intuitions for agent ${args.agentId}`);
+        }
+        this.printAgentUrl(args.agentId);
     }
 }
 exports.default = AgentsIntuitionsGenerate;

package/dist/commands/agents/intuitions/list.js

@@ -16,8 +16,13 @@ class AgentsIntuitionsList extends base_command_1.BaseCommand {
             this.printJsonResult((0, list_output_1.listResult)(this.withAgentContext(args.agentId, result), 'intuitions'));
             return;
         }
-        const text = JSON.stringify(result.intuitions ?? result, null, 2);
-        this.log(text);
+        const intuitions = result.intuitions ?? result;
+        if (Array.isArray(intuitions) && intuitions.length === 0) {
+            this.log(`No active intuitions. Run skrr agents intuitions generate ${args.agentId} to look for suggestions.`);
+        }
+        else {
+            this.log(JSON.stringify(intuitions, null, 2));
+        }
         this.printAgentUrl(args.agentId);
     }
 }

package/dist/commands/agents/spawn.js

@@ -17,6 +17,12 @@ function proactiveInstallReadiness(result, bin) {
     if (result.warnings.length === 0) {
         return { status: 'ready', message: 'All requested setup steps completed.' };
     }
+    if (result.warnings.some((warning) => warning.code === 'always_on_off')) {
+        return {
+            status: 'degraded',
+            message: 'The Agent is off. Review the setup warnings and enable Always-On explicitly if you want it to run.',
+        };
+    }
     // A full trigger budget must not make a new persona-only Agent look broken
     // when its core system commitments, local execution policy, and Always-On
     // state installed successfully. The optional backlog watcher is deferred;

package/dist/commands/agents/todos/edit.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../../base-command';
+export default class AgentsTodosEdit extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        at: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/todos/edit.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const schedule_1 = require("../../../lib/schedule");
+class AgentsTodosEdit extends base_command_1.BaseCommand {
+    static description = 'Change the name or time of a pending to-do';
+    static examples = [
+        '<%= config.bin %> agents todos edit <todo-id> --name "Review launch"',
+        '<%= config.bin %> agents todos edit <todo-id> --at 2026-11-05T18:00:00Z',
+    ];
+    static args = { id: core_1.Args.string({ description: 'To-Do ID', required: true, ignoreStdin: true }) };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        name: core_1.Flags.string({ description: 'New name' }),
+        at: core_1.Flags.string({ description: 'New ISO-8601 run time' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(AgentsTodosEdit);
+        if (flags.name === undefined && flags.at === undefined)
+            this.error('Supply --name or --at.', { exit: 1 });
+        let todo;
+        try {
+            const current = await schedule_1.scheduleApi.getTodo(args.id);
+            if (!current.updatedAt)
+                this.error('The to-do has no version; refresh before editing.', { exit: 1 });
+            todo = await schedule_1.scheduleApi.updateTodo(args.id, {
+                ...(flags.name !== undefined ? { name: flags.name } : {}),
+                ...(flags.at !== undefined ? { runAt: flags.at } : {}),
+                expectedUpdatedAt: current.updatedAt,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json)
+            this.log(JSON.stringify(todo, null, 2));
+        else
+            this.log(`Updated to-do ${todo.id} — "${todo.name}" at ${todo.runAt}`);
+    }
+}
+exports.default = AgentsTodosEdit;

package/dist/commands/agents/triggers/fire.d.ts

@@ -2,8 +2,7 @@ import { BaseCommand } from '../../../base-command';
 /**
  * `skrr agents triggers fire <agent-id> <trigger-id>` — fire a trigger now.
  * Mirrors the Schedule Board's "Run" button (`POST /api/triggers/:id/fire-now`).
- * The fire respects the same gates a scheduled fire would (quiet hours, caps,
- * concurrency) — the response `outcome` says whether it actually ran.
+ * The response distinguishes the manual fire from a scheduled-policy preview.
  */
 export default class AgentsTriggersFire extends BaseCommand {
     static description: string;
@@ -15,6 +14,7 @@ export default class AgentsTriggersFire extends BaseCommand {
     static flags: {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'from-json': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        strict: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/agents/triggers/fire.js

@@ -7,8 +7,7 @@ const triggers_1 = require("../../../lib/triggers");
 /**
  * `skrr agents triggers fire <agent-id> <trigger-id>` — fire a trigger now.
  * Mirrors the Schedule Board's "Run" button (`POST /api/triggers/:id/fire-now`).
- * The fire respects the same gates a scheduled fire would (quiet hours, caps,
- * concurrency) — the response `outcome` says whether it actually ran.
+ * The response distinguishes the manual fire from a scheduled-policy preview.
  */
 class AgentsTriggersFire extends base_command_1.BaseCommand {
     static description = "Fire one of an agent's triggers immediately";
@@ -25,6 +24,11 @@ class AgentsTriggersFire extends base_command_1.BaseCommand {
         'from-json': core_1.Flags.string({
             description: 'Path to a JSON file (or "-" for stdin) to use as fire options',
         }),
+        strict: core_1.Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Exit nonzero if the fire was not accepted; use --no-strict for transport-only success',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -46,13 +50,26 @@ class AgentsTriggersFire extends base_command_1.BaseCommand {
                 this.error(err.message, { exit: 4 });
             this.handleApiError(err);
         }
+        const refused = flags.strict && !(0, triggers_1.fireWasAccepted)(result);
+        const refusal = refused ? (0, triggers_1.describeStrictFireRefusal)(result) : null;
         if (flags.json) {
-            this.log(JSON.stringify(result, null, 2));
+            this.log(JSON.stringify(refused ? { ...result, ok: false, strictRefusal: refusal } : result, null, 2));
+            if (refusal) {
+                process.stderr.write(`${refusal}\n`);
+                this.exit(1);
+            }
             return;
         }
         this.log(`Fire requested: outcome=${String(result.outcome ?? '-')} reason=${String(result.reason ?? '-')}`);
         for (const line of (0, triggers_1.describeFireDetail)(result))
             this.log(line);
+        const note = (0, triggers_1.describeScheduledFire)(result);
+        if (note)
+            this.log(note);
+        if (refusal) {
+            process.stderr.write(`${refusal}\n`);
+            this.exit(1);
+        }
     }
 }
 exports.default = AgentsTriggersFire;

package/dist/commands/agents/triggers/policy.d.ts

@@ -1,4 +1,9 @@
 import { BaseCommand } from '../../../base-command';
+/**
+ * `3` → 3, `0` → 0 (new lookback plans blocked), `default` → null (clears it). The server validates
+ * the range again; refusing a bad value here names the flag instead of a schema issue list.
+ */
+export declare function parseLookbackPlansPerDay(raw: string | undefined): number | null | undefined;
 export default class AgentsTriggersPolicy extends BaseCommand {
     static description: string;
     static examples: string[];
@@ -16,6 +21,7 @@ export default class AgentsTriggersPolicy extends BaseCommand {
         'working-hours': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'quiet-hours': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'followup-budget': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'lookback-plans-per-day': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/agents/triggers/policy.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLookbackPlansPerDay = parseLookbackPlansPerDay;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../../base-command");
 const prompt_1 = require("../../../lib/prompt");
@@ -30,6 +31,21 @@ function parseFollowUpBudget(values) {
     }
     return budget;
 }
+/**
+ * `3` → 3, `0` → 0 (new lookback plans blocked), `default` → null (clears it). The server validates
+ * the range again; refusing a bad value here names the flag instead of a schema issue list.
+ */
+function parseLookbackPlansPerDay(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (raw === 'default')
+        return null;
+    const count = Number(raw);
+    if (raw.trim() === '' || !Number.isInteger(count) || count < 0 || count > 1000) {
+        throw new Error('--lookback-plans-per-day must be an integer from 0 to 1000, or "default"');
+    }
+    return count;
+}
 class AgentsTriggersPolicy extends base_command_1.BaseCommand {
     static description = "Show or update an agent's initiative policy for agent-scoped triggers";
     static examples = [
@@ -66,6 +82,9 @@ class AgentsTriggersPolicy extends base_command_1.BaseCommand {
             description: 'Daily follow-up creation cap for this agent, as pool=count (pools: watch, checkin, act; count "default" clears it). Repeatable',
             multiple: true,
         }),
+        'lookback-plans-per-day': core_1.Flags.string({
+            description: 'Daily lookback plan allowance for this agent: an integer from 0 to 1000 (0 blocks new plans) or "default" to clear it. `followups plans capacity --agent <id>` reads what applies today',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -81,6 +100,7 @@ class AgentsTriggersPolicy extends base_command_1.BaseCommand {
                 workingHours: (0, triggers_1.parseJsonObject)(flags['working-hours'], '--working-hours'),
                 quietHours: (0, triggers_1.parseJsonObject)(flags['quiet-hours'], '--quiet-hours'),
                 followUpBudget: parseFollowUpBudget(flags['followup-budget']),
+                lookbackPlansPerDay: parseLookbackPlansPerDay(flags['lookback-plans-per-day']),
             });
         }
         catch (err) {
@@ -111,6 +131,8 @@ class AgentsTriggersPolicy extends base_command_1.BaseCommand {
         this.log(`Follow-up caps:   ${budgetEntries.length > 0
             ? budgetEntries.map(([pool, cap]) => `${pool} ${String(cap)}/day`).join(', ')
             : 'defaults'}`);
+        const lookbackPlans = policy.lookbackPlansPerDay;
+        this.log(`Lookback plans:   ${typeof lookbackPlans === 'number' ? `${lookbackPlans}/day` : 'default'}`);
         if (Object.keys(counts).length > 0) {
             this.log(`Triggers:         ${String(counts.total ?? 0)} total, ${String(counts.enabled ?? 0)} enabled`);
         }

package/dist/commands/goals/briefing/enable.js

@@ -28,8 +28,7 @@ class GoalsBriefingEnable extends base_command_1.BaseCommand {
             this.log(JSON.stringify(result, null, 2));
             return;
         }
-        const cron = flags.cron ?? '0 8 * * *';
-        this.log(`Morning briefing enabled (cron: ${cron})`);
+        this.log(`Morning briefing enabled (cron: ${result.cron})`);
     }
 }
 exports.default = GoalsBriefingEnable;

package/dist/commands/goals/briefing/status.d.ts

@@ -0,0 +1,8 @@
+import { BaseCommand } from '../../../base-command';
+export default class GoalsBriefingStatus extends BaseCommand {
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/goals/briefing/status.js

@@ -0,0 +1,35 @@
+"use strict";
+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");
+class GoalsBriefingStatus extends base_command_1.BaseCommand {
+    static description = 'Show the morning briefing schedule and delivery preference';
+    static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(GoalsBriefingStatus);
+        let status;
+        try {
+            status = await data_provider_1.dataService.getGoalBriefingStatus();
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        this.log(`Morning briefing: ${status.enabled ? 'enabled' : 'disabled'}`);
+        if (status.cron)
+            this.log(`Schedule: ${status.cron} (${status.timezone || 'timezone unknown'})`);
+        if (status.nextRunAt)
+            this.log(`Next run: ${status.nextRunAt}`);
+        this.log(`Delivery preference: ${status.delivery.categoryLevel}`);
+        if (status.delivery.preferenceEligibleChannels.length) {
+            this.log(`Preference-eligible channels: ${status.delivery.preferenceEligibleChannels.join(', ')}`);
+            this.log('Actual delivery also depends on connected destinations and other notification settings.');
+        }
+    }
+}
+exports.default = GoalsBriefingStatus;

package/dist/commands/memory/list.js

@@ -7,7 +7,7 @@ const base_command_1 = require("../../base-command");
 const format_1 = require("../../lib/format");
 const memory_scope_1 = require("../../lib/memory-scope");
 class MemoryList extends base_command_1.BaseCommand {
-    static description = 'List memories in a pool (owner, an agent, user, or workspace)';
+    static description = 'List compatibility-pool memories (canonical topics are listed separately)';
     static examples = [
         '<%= config.bin %> memory list',
         '<%= config.bin %> memory list --json',
@@ -30,15 +30,21 @@ class MemoryList extends base_command_1.BaseCommand {
         catch (err) {
             this.handleApiError(err);
         }
+        const canonicalHint = flags.agent
+            ? 'Canonical Agent Memory topics are separate. Run skrr memory topics list with the same --agent and --scope agent:<agent-id>.'
+            : 'This is a compatibility pool. Canonical Memory topics are listed separately with skrr memory topics list.';
         if (flags.json) {
-            this.printJsonResult((0, list_output_1.listResult)(response, 'memories'));
+            this.printJsonResult((0, list_output_1.listResult)({ ...response, memorySource: 'compatibility_pool', canonicalTopicsHint: canonicalHint }, 'memories'));
             return;
         }
         const memories = response.memories ?? [];
         if (memories.length === 0) {
-            this.log('No memories.');
+            this.log('No compatibility-pool memories.');
+            this.log(canonicalHint);
             return;
         }
+        this.log('Compatibility-pool memories:');
+        this.log(canonicalHint);
         const rows = memories.map((m) => ({
             key: m.key,
             value: m.value,

package/dist/lib/schedule.d.ts

@@ -19,6 +19,7 @@ export interface Todo {
     rationale?: string;
     confidence?: TodoConfidence;
     triggerId?: string;
+    updatedAt?: string;
     firedAt?: string;
     result?: {
         conversationId?: string;
@@ -179,6 +180,11 @@ export declare const scheduleApi: {
     listTodos: (agentId: string, date?: string, timezone?: string) => Promise<ListTodosResponse>;
     getTodo: (todoId: string) => Promise<Todo>;
     createTodo: (input: CreateTodoInput) => Promise<Todo>;
+    updateTodo: (todoId: string, patch: {
+        name?: string;
+        runAt?: string;
+        expectedUpdatedAt?: string;
+    }) => Promise<Todo>;
     /** Cancel a To-Do (DELETE soft-cancels pending; see todos.js). */
     cancelTodo: (todoId: string) => Promise<Todo>;
     proposeSmartSchedule: (input: {

package/dist/lib/schedule.js

@@ -61,6 +61,7 @@ exports.scheduleApi = {
     listTodos: (agentId, date, timezone) => data_provider_1.request.get(todoListPath(agentId, date, timezone)),
     getTodo: (todoId) => data_provider_1.request.get(`/api/todos/${encodeURIComponent(todoId)}`),
     createTodo: (input) => data_provider_1.request.post('/api/todos', input),
+    updateTodo: (todoId, patch) => data_provider_1.request.patch(`/api/todos/${encodeURIComponent(todoId)}`, patch),
     /** Cancel a To-Do (DELETE soft-cancels pending; see todos.js). */
     cancelTodo: (todoId) => data_provider_1.request.delete(`/api/todos/${encodeURIComponent(todoId)}`),
     proposeSmartSchedule: (input) => data_provider_1.request.post('/api/todos/smart-schedule/propose', input),

package/dist/lib/scoped-memory-command.d.ts

@@ -82,6 +82,16 @@ export declare function parseMemoryApiError(error: ApiFetchError): {
     retryable: boolean;
     details?: Record<string, unknown>;
 };
+/** A gateway timeout can arrive after the canonical mutation committed. */
+export declare function uncertainMemoryMutationRecovery(path: string, options: ApiFetchOptions, status: number): {
+    message: string;
+    details: {
+        spaceId?: string | undefined;
+        outcome: string;
+        targetStoreId: string;
+        idempotencyKey: string;
+    };
+} | null;
 export declare abstract class ScopedMemoryCommand extends BaseCommand {
     protected endpoint(agentId: string, suffix?: string): string;
     protected memoryApi<T>(agentId: string, suffix: string, options?: ApiFetchOptions): Promise<T>;