@skrr-ai/cli 0.1.131 → 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.d.ts

@@ -118,6 +118,8 @@ export default class AgentMessageSend extends BaseCommand {
     private submitAsSession;
     private submitAsHuman;
 }
+/** Keep stdout machine-readable while making a slow delivery visible. */
+export declare function withSendWaitNotice<T>(send: () => Promise<T>): Promise<T>;
 export type NormalizedIntentPayload = {
     destination: CanonicalMessageDestination;
     content: {

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

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EXIT_DELIVERY_FAILED = exports.EXIT_DELIVERY_RETRYABLE = exports.OWNER_DM_SEGMENTATION_SOFT_LIMIT = void 0;
+exports.withSendWaitNotice = withSendWaitNotice;
 exports.messageSegmentationAdvisory = messageSegmentationAdvisory;
 exports.buildSequencedRequests = buildSequencedRequests;
 exports.deliveryExitCode = deliveryExitCode;
@@ -308,30 +309,33 @@ class AgentMessageSend extends base_command_1.BaseCommand {
                 'session claim, not the request. To change it, run the task from a space in ' +
                 'the intended workspace.');
         }
-        const envelopes = [];
-        let halt;
-        for (const [index, requestPart] of requests.entries()) {
-            const envelope = sessionContext
-                ? await this.submitAsSession({
-                    sessionContext,
-                    request: requestPart,
-                    agentIdentity: agentIdentity,
-                    principalSource,
-                })
-                : await this.submitAsHuman({
-                    request: requestPart,
-                    agentIdentity: agentIdentity,
-                    principalSource,
-                });
-            envelopes.push(envelope);
-            // A part that did not reach the user must stop the sequence. Continuing
-            // would deliver thought 3 while thought 2 sits held for approval, and the
-            // user would read the update out of order — worse than not receiving the
-            // tail at all.
-            halt = sequenceHalt({ envelope, sentCount: index + 1, totalParts: requests.length });
-            if (halt)
-                break;
-        }
+        const { envelopes, halt } = await withSendWaitNotice(async () => {
+            const envelopes = [];
+            let halt;
+            for (const [index, requestPart] of requests.entries()) {
+                const envelope = sessionContext
+                    ? await this.submitAsSession({
+                        sessionContext,
+                        request: requestPart,
+                        agentIdentity: agentIdentity,
+                        principalSource,
+                    })
+                    : await this.submitAsHuman({
+                        request: requestPart,
+                        agentIdentity: agentIdentity,
+                        principalSource,
+                    });
+                envelopes.push(envelope);
+                // A part that did not reach the user must stop the sequence. Continuing
+                // would deliver thought 3 while thought 2 sits held for approval, and the
+                // user would read the update out of order — worse than not receiving the
+                // tail at all.
+                halt = sequenceHalt({ envelope, sentCount: index + 1, totalParts: requests.length });
+                if (halt)
+                    break;
+            }
+            return { envelopes, halt };
+        });
         if (flags.json) {
             // Branch on the REQUESTED part count, not the sent count: a sequence that
             // halted on its first part still has to report the parts it skipped.
@@ -524,6 +528,18 @@ class AgentMessageSend extends base_command_1.BaseCommand {
     }
 }
 exports.default = AgentMessageSend;
+/** Keep stdout machine-readable while making a slow delivery visible. */
+async function withSendWaitNotice(send) {
+    const timer = setTimeout(() => {
+        process.stderr.write('Waiting for the message outcome; the request is still in progress.\n');
+    }, 3000);
+    try {
+        return await send();
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 // Re-export the module-scope `request.post` under a local name so the transport
 // helper stays testable without pulling the whole data-provider surface into
 // scope inside every helper file.
@@ -747,9 +763,18 @@ 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.');
     }
+    if (destinationKind !== 'agent_email' &&
+        (merged.recipients !== undefined || merged.subject !== undefined ||
+            bodyDestination?.recipients !== undefined || bodyDestination?.subject !== undefined)) {
+        throw invalidIntent('--to / destination.recipients and --subject / destination.subject only apply to agent_email.');
+    }
     const destination = buildDestination({
         kind: destinationKind,
         bodyDestination,

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/plan-day.d.ts

@@ -28,6 +28,7 @@ export default class AgentsPlanDay extends BaseCommand {
         'hours-start': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'hours-end': 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>;
+        'approve-next-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'save-hours': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
@@ -44,10 +45,9 @@ export default class AgentsPlanDay extends BaseCommand {
     private fetchPending;
     private workingHoursOverride;
     /**
-     * Statuses that mean "the request ran out of time", not "the request was
-     * refused". Only these are recoverable by reading the durable draft: a 4xx
-     * means no generation started, and a 500 means the route itself failed, so
-     * polling would just report an absence as if it were a timeout.
+     * Gateway failures can interrupt a response after the planner started.
+     * Check the durable draft before suggesting another billable request; a
+     * 502 can also mean the planner never started, so do not assert that it did.
      */
     private static readonly TIMEOUT_STATUSES;
     /** Bounded, honest recovery poll. A daemon-run plan lands in ~2-4 minutes. */

package/dist/commands/agents/plan-day.js

@@ -45,6 +45,10 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
         'hours-start': core_1.Flags.string({ description: 'Working-hours start (HH:MM) for the proposal' }),
         'hours-end': core_1.Flags.string({ description: 'Working-hours end (HH:MM) for the proposal' }),
         timezone: core_1.Flags.string({ description: 'IANA timezone for the working-hours window' }),
+        'approve-next-run': core_1.Flags.boolean({
+            description: 'With --approve, schedule the suggested next planning run',
+            dependsOn: ['approve'],
+        }),
         'save-hours': core_1.Flags.boolean({
             description: 'On --approve, persist the working-hours window as the agent default',
         }),
@@ -53,6 +57,14 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
         this.requireAuth();
         const { args, flags } = await this.parse(AgentsPlanDay);
         const agentId = args.id;
+        if (!flags.dismiss && !flags.approve && flags.timezone) {
+            try {
+                new Intl.DateTimeFormat('en', { timeZone: flags.timezone });
+            }
+            catch {
+                this.error(`Invalid IANA timezone: ${flags.timezone}`, { exit: 1 });
+            }
+        }
         try {
             if (flags.dismiss) {
                 await this.runDismiss(agentId, flags.json);
@@ -120,12 +132,11 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
         };
     }
     /**
-     * Statuses that mean "the request ran out of time", not "the request was
-     * refused". Only these are recoverable by reading the durable draft: a 4xx
-     * means no generation started, and a 500 means the route itself failed, so
-     * polling would just report an absence as if it were a timeout.
+     * Gateway failures can interrupt a response after the planner started.
+     * Check the durable draft before suggesting another billable request; a
+     * 502 can also mean the planner never started, so do not assert that it did.
      */
-    static TIMEOUT_STATUSES = new Set([408, 504, 524]);
+    static TIMEOUT_STATUSES = new Set([408, 502, 504, 524]);
     /** Bounded, honest recovery poll. A daemon-run plan lands in ~2-4 minutes. */
     static RECOVERY_ATTEMPTS = 12;
     static RECOVERY_INTERVAL_MS = 15_000;
@@ -141,9 +152,8 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
             return null;
         }
         // stderr, so `--json` stdout stays a single parseable document.
-        this.warn(`Plan generation for ${agentId} outlived the request (HTTP ${status}). ` +
-            'The run is still finishing on the agent runtime and the draft is persisted when it ' +
-            'completes — waiting for it rather than starting a second run.');
+        this.warn(`The plan request for ${agentId} was interrupted (HTTP ${status}). ` +
+            'The run may still be finishing; checking for its saved draft before starting another.');
         for (let attempt = 1; attempt <= AgentsPlanDay.RECOVERY_ATTEMPTS; attempt += 1) {
             await new Promise((resolve) => setTimeout(resolve, AgentsPlanDay.RECOVERY_INTERVAL_MS));
             let pending = null;
@@ -181,6 +191,7 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
             try {
                 generated = await schedule_1.scheduleApi.proposeSmartSchedule({
                     agentId,
+                    ...(flags.timezone ? { timezone: flags.timezone } : {}),
                     ...(this.workingHoursOverride(flags)
                         ? { workingHoursOverride: this.workingHoursOverride(flags) }
                         : {}),
@@ -216,6 +227,9 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
         this.log('');
         this.log('This is a draft — nothing is scheduled yet.');
         this.log(`  Approve:  ${this.config.bin} agents plan-day ${agentId} --approve`);
+        if (proposal.nextRunSuggestion) {
+            this.log(`  Include next run: ${this.config.bin} agents plan-day ${agentId} --approve --approve-next-run`);
+        }
         this.log(`  Discard:  ${this.config.bin} agents plan-day ${agentId} --dismiss`);
     }
     async runApprove(agentId, flags) {
@@ -224,13 +238,20 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
             this.error(`No pending plan for agent ${agentId}. Run \`${this.config.bin} agents plan-day ${agentId}\` first.`, { exit: 4 });
         }
         const todos = (0, schedule_1.proposalToApproveTodos)(proposal);
-        if (todos.length === 0) {
-            this.error('The pending proposal has no schedulable to-dos to approve.', { exit: 1 });
+        if (flags['approve-next-run'] && !proposal.nextRunSuggestion) {
+            this.error('The pending proposal has no suggested next run to approve.', { exit: 1 });
+        }
+        if (todos.length === 0 && !flags['approve-next-run']) {
+            const next = proposal.nextRunSuggestion
+                ? ` Use --approve --approve-next-run to schedule its suggested next run, or --dismiss to discard it.`
+                : ' Use --dismiss to discard it.';
+            this.error(`The pending proposal has no schedulable to-dos.${next}`, { exit: 1 });
         }
         const result = await schedule_1.scheduleApi.approveSmartSchedule({
             agentId,
             proposalId: proposal.proposalId,
             todos,
+            ...(flags['approve-next-run'] ? { approveNextRunSuggestion: true } : {}),
             ...(flags['save-hours']
                 ? { saveHoursAsDefault: true, workingHours: proposal.workingHours }
                 : {}),
@@ -254,6 +275,11 @@ class AgentsPlanDay extends base_command_1.BaseCommand {
         }
         this.log(`Approved plan ${proposal.proposalId}: created ${result.created.length} to-do(s).`);
         (0, schedule_1.renderCapacityWarning)(result.capacity, (line) => this.log(line));
+        if (flags['approve-next-run']) {
+            this.log(result.scheduledNextRun?.created
+                ? `Next planning run scheduled${result.scheduledNextRun.triggerId ? ` (${result.scheduledNextRun.triggerId})` : ''}.`
+                : `Next planning run was not created${result.scheduledNextRun?.message || result.scheduledNextRun?.skippedReason ? `: ${result.scheduledNextRun.message || result.scheduledNextRun.skippedReason}` : '.'}`);
+        }
         if (result.failed.length > 0) {
             this.log(`${result.failed.length} failed:`);
             for (const f of result.failed) {

package/dist/commands/agents/schedule-overview.d.ts

@@ -42,3 +42,17 @@ export declare function reflectionLine(reflection: TriggerDefinition): string;
  * else null. "active · next <time>" only says the loop is armed.
  */
 export declare function reflectionNoteLine(reflection: TriggerDefinition, bin: string): string | null;
+/** A trigger the Always-On control fence withholds, as `/api/upcoming` reports it. */
+export interface WithheldTrigger {
+    label?: string;
+    reason?: string;
+    reasonText?: string;
+    indeterminate?: boolean;
+}
+/**
+ * One withheld trigger as the text view prints it. The sentence the server wrote
+ * (`reasonText`: "Always-On is off for this agent") is printed rather than the code,
+ * because `disabled` alone reads as a property of the trigger when the cause is the
+ * agent's Always-On switch. A server that predates `reasonText` still prints the code.
+ */
+export declare function withheldLine(trigger: WithheldTrigger): string;

package/dist/commands/agents/schedule-overview.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.reflectionSummary = reflectionSummary;
 exports.reflectionLine = reflectionLine;
 exports.reflectionNoteLine = reflectionNoteLine;
+exports.withheldLine = withheldLine;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
@@ -126,7 +127,7 @@ class AgentsScheduleOverview extends base_command_1.BaseCommand {
             this.log('');
             this.log(`  ${blockedUpcoming.length} trigger(s) withheld — they will not fire as configured:`);
             for (const b of blockedUpcoming.slice(0, 8)) {
-                this.log(`    ${b.label ?? '(unlabeled)'} — ${b.reason ?? 'blocked'}`);
+                this.log(withheldLine(b));
             }
             if (blockedUpcoming.length > 8) {
                 this.log(`    … and ${blockedUpcoming.length - 8} more`);
@@ -214,6 +215,15 @@ function reflectionNoteLine(reflection, bin) {
     const note = (0, reflection_1.reflectionAutonomyNote)(reflection, bin);
     return note ? `  Note: ${note}` : null;
 }
+/**
+ * One withheld trigger as the text view prints it. The sentence the server wrote
+ * (`reasonText`: "Always-On is off for this agent") is printed rather than the code,
+ * because `disabled` alone reads as a property of the trigger when the cause is the
+ * agent's Always-On switch. A server that predates `reasonText` still prints the code.
+ */
+function withheldLine(trigger) {
+    return `    ${trigger.label ?? '(unlabeled)'} — ${trigger.reasonText ?? trigger.reason ?? 'blocked'}`;
+}
 function settledValue(result) {
     return result.status === 'fulfilled' ? result.value : undefined;
 }

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/todos/list.d.ts

@@ -13,6 +13,7 @@ export default class AgentsTodosList extends BaseCommand {
     static flags: {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         date: 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>;
     };
     run(): Promise<void>;
 }