@skrr-ai/cli 0.1.134 → 0.1.136

package/dist/base-command.d.ts

@@ -479,6 +479,7 @@ export declare abstract class BaseCommand extends Command {
      * bug (2026-09-18).
      */
     private lastApiRequestId?;
+    private jsonErrorWritten;
     /** E6: the server's `Retry-After` for the refused call, when it was a 429. */
     private lastRetryAfterMs?;
     private writeJsonCliError;

package/dist/base-command.js

@@ -1352,6 +1352,13 @@ class BaseCommand extends core_1.Command {
     }
     async catch(err) {
         if (isOclifExitError(err)) {
+            // oclif's default ExitError handler calls process.exit immediately.
+            // A JSON error already written to a pipe may still be buffered, so let
+            // Node drain stdout naturally while preserving the requested exit code.
+            if (this.jsonErrorWritten) {
+                process.exitCode = err.oclif?.exit ?? 1;
+                return;
+            }
             return super.catch(err);
         }
         // Canonical Task Model v1 removed several `tasks complete` flags outright,
@@ -2155,6 +2162,7 @@ class BaseCommand extends core_1.Command {
      * bug (2026-09-18).
      */
     lastApiRequestId;
+    jsonErrorWritten = false;
     /** E6: the server's `Retry-After` for the refused call, when it was a 429. */
     lastRetryAfterMs;
     writeJsonCliError({ message, code, status, exit, retryable, details, requestId, }) {
@@ -2182,6 +2190,7 @@ class BaseCommand extends core_1.Command {
                 ...(details ? { details } : {}),
             },
         }), null, 2));
+        this.jsonErrorWritten = true;
         this.exit(exit);
     }
     /**

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

@@ -133,7 +133,7 @@ class AgentMessageSend extends base_command_1.BaseCommand {
             description: 'Path to a canonical intent JSON payload, or "-" for stdin',
         }),
         'idempotency-key': core_1.Flags.string({
-            description: 'Stable retry key for this intent; auto-derived when omitted',
+            description: 'Stable retry key; overrides the key in --from-json, or is auto-derived when neither is supplied',
         }),
         kind: core_1.Flags.string({
             description: 'Semantic kind; prefer milestone, status, decision, blocker, or result (legacy progress/question accepted)',

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

@@ -113,6 +113,7 @@ class AgentsScheduleTrace extends base_command_1.BaseCommand {
             { key: 'status', header: 'STATUS' },
             { key: 'summary', header: 'SUMMARY', maxWidth: 48 },
         ], (line) => this.log(line));
+        (0, schedule_1.renderTodoPolicyTraceDetails)(events, (line) => this.log(line));
         // Which collection each column came from — the trace reconciles four
         // sources and the reader should be able to go check one.
         if (trace.sourcePolicy) {

package/dist/commands/agents/spawn.d.ts

@@ -1,10 +1,13 @@
 import { BaseCommand } from '../../base-command';
-import { type ApplyProactiveAgentResponse } from '../../lib/proactiveApi';
+import { type ProactiveAgentSpec, type ApplyProactiveAgentResponse } from '../../lib/proactiveApi';
 export type ProactiveInstallReadiness = {
     status: 'ready' | 'degraded';
     message: string;
     repairCommand?: string;
 };
+export declare function workerPolicyWindowLines(policy: NonNullable<ProactiveAgentSpec['worker']>['policy']): string[];
+/** JSON previews show the effective disabled state without mutating the input spec. */
+export declare function specWithEffectiveWindowFlags(spec: ProactiveAgentSpec): ProactiveAgentSpec;
 /**
  * Agent identity creation is intentionally forward-only, but an Agent URL must
  * not masquerade as a fully installed proactive service when a watcher or

package/dist/commands/agents/spawn.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.workerPolicyWindowLines = workerPolicyWindowLines;
+exports.specWithEffectiveWindowFlags = specWithEffectiveWindowFlags;
 exports.proactiveInstallReadiness = proactiveInstallReadiness;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
@@ -7,6 +9,40 @@ const prompt_1 = require("../../lib/prompt");
 const format_1 = require("../../lib/format");
 const web_url_1 = require("../../lib/web-url");
 const proactiveApi_1 = require("../../lib/proactiveApi");
+function workerPolicyWindowLines(policy) {
+    const lines = [];
+    for (const [label, window] of [
+        ['Working hours', policy?.workingHours],
+        ['Quiet hours', policy?.quietHours],
+    ]) {
+        if (!window)
+            continue;
+        const state = window.enabled === undefined
+            ? 'disabled; enabled not specified'
+            : window.enabled ? 'enabled' : 'disabled';
+        lines.push(`  ${label}: ${window.start}–${window.end} ${window.timezone ?? '(no zone recorded)'} (${state})`);
+    }
+    return lines;
+}
+/** JSON previews show the effective disabled state without mutating the input spec. */
+function specWithEffectiveWindowFlags(spec) {
+    const policy = spec.worker?.policy;
+    if (!spec.worker || !policy)
+        return spec;
+    const workingHours = policy.workingHours && { ...policy.workingHours, enabled: policy.workingHours.enabled ?? false };
+    const quietHours = policy.quietHours && { ...policy.quietHours, enabled: policy.quietHours.enabled ?? false };
+    return {
+        ...spec,
+        worker: {
+            ...spec.worker,
+            policy: {
+                ...policy,
+                ...(workingHours ? { workingHours } : {}),
+                ...(quietHours ? { quietHours } : {}),
+            },
+        },
+    };
+}
 /**
  * Agent identity creation is intentionally forward-only, but an Agent URL must
  * not masquerade as a fully installed proactive service when a watcher or
@@ -23,6 +59,18 @@ function proactiveInstallReadiness(result, bin) {
             message: 'The Agent is off. Review the setup warnings and enable Always-On explicitly if you want it to run.',
         };
     }
+    if (result.warnings.some((warning) => warning.code === 'compass_existing_not_replaced')) {
+        return {
+            status: 'degraded',
+            message: 'The requested standing direction was not installed. Review the existing Compass and the setup warnings.',
+        };
+    }
+    if (result.warnings.some((warning) => warning.code === 'policy_window_enabled_unspecified')) {
+        return {
+            status: 'degraded',
+            message: 'Some worker time windows are disabled because their enablement was not specified. Review the warnings.',
+        };
+    }
     // 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;
@@ -135,7 +183,7 @@ class AgentsSpawn extends base_command_1.BaseCommand {
         const spec = (body.spec ?? body);
         if (!flags.approve) {
             if (flags.json) {
-                this.log(JSON.stringify(spec, null, 2));
+                this.log(JSON.stringify(specWithEffectiveWindowFlags(spec), null, 2));
                 return;
             }
             this.renderSpec(spec);
@@ -192,7 +240,7 @@ class AgentsSpawn extends base_command_1.BaseCommand {
         const spec = plan.spec;
         if (!flags.approve) {
             if (flags.json) {
-                this.log(JSON.stringify(plan, null, 2));
+                this.log(JSON.stringify({ ...plan, spec: specWithEffectiveWindowFlags(spec) }, null, 2));
                 return;
             }
             this.renderSpec(spec);
@@ -244,6 +292,8 @@ class AgentsSpawn extends base_command_1.BaseCommand {
         if (spec.worker) {
             this.log('');
             this.log(`Worker (event-reactive) — policy: ${spec.worker.policy?.mode ?? 'ask_first'}`);
+            for (const line of workerPolicyWindowLines(spec.worker.policy))
+                this.log(line);
             (0, format_1.renderTable)(spec.worker.watchers.map((w) => ({
                 source: w.source,
                 every: `${w.intervalMinutes ?? '-'}m`,

package/dist/commands/memory/search.js

@@ -6,7 +6,7 @@ const scoped_memory_command_1 = require("../../lib/scoped-memory-command");
 const format_1 = require("../../lib/format");
 const memory_scope_1 = require("../../lib/memory-scope");
 class MemorySearch extends scoped_memory_command_1.ScopedMemoryCommand {
-    static description = 'Semantic (hybrid vector + text) search over a memory pool — the same ranking the agent sees';
+    static description = 'Search a compatibility memory pool, or specify --scope or --store for canonical Memory';
     static examples = [
         '<%= config.bin %> memory search "dark mode preference"',
         '<%= config.bin %> memory search "billing" --agent agent_abc123',
@@ -68,13 +68,18 @@ class MemorySearch extends scoped_memory_command_1.ScopedMemoryCommand {
         catch (err) {
             this.handleApiError(err);
         }
+        const canonicalHint = flags.agent
+            ? 'Canonical Agent Memory is separate. Search with the same --agent and --scope agent:<agent-id>.'
+            : 'This is a compatibility pool. Search canonical Memory with --agent and --scope agent:<agent-id> or space:<space-id>.';
         if (flags.json) {
-            this.log(JSON.stringify(response, null, 2));
+            this.log(JSON.stringify({ ...response, memorySource: 'compatibility_pool', canonicalSearchHint: canonicalHint }, null, 2));
             return;
         }
         const results = response.results ?? [];
+        this.log('Compatibility-pool memory search:');
+        this.log(canonicalHint);
         if (results.length === 0) {
-            this.log(`No memories matched "${args.query}".`);
+            this.log(`No compatibility-pool memories matched "${args.query}".`);
             return;
         }
         const rows = results.map((r) => ({

package/dist/commands/memory/versions/show.js

@@ -12,7 +12,9 @@ class MemoryVersionsShow extends scoped_memory_command_1.ScopedMemoryCommand {
         this.requireAuth();
         const { args, flags } = await this.parse(MemoryVersionsShow);
         const result = await this.memoryHistoryApi(flags, { versionId: args.id });
-        this.print(result, flags.json, `${result.id}  ${result.operation}\n${JSON.stringify(result.payloadSnapshot, null, 2)}`);
+        this.print(result, flags.json, `${result.id}  ${result.operation}\n${JSON.stringify(result.payloadSnapshot, null, 2)}${result.projection?.kind === 'legacy_episode_omitted'
+            ? '\nAn invalid historical episode reference was omitted; the content hash identifies the original stored payload.'
+            : ''}`);
     }
 }
 exports.default = MemoryVersionsShow;

package/dist/commands/spaces/autodream/status.d.ts

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

package/dist/commands/spaces/autodream/status.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const api_fetch_1 = require("../../../lib/api-fetch");
+class SpaceAutoDreamStatus extends base_command_1.BaseCommand {
+    static description = 'Show current Space AutoDream eligibility and the most recent recorded cycle';
+    static args = { id: core_1.Args.string({ description: 'Space ID or title', required: true, ignoreStdin: true }) };
+    static flags = { json: core_1.Flags.boolean({ description: 'Output as JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SpaceAutoDreamStatus);
+        const spaceId = await this.resolveSpaceReference(args.id);
+        let result;
+        try {
+            result = await (0, api_fetch_1.apiFetch)(`/api/spaces/${encodeURIComponent(spaceId)}/autodream`, {
+                credential: this.resolvedCredential,
+            });
+        }
+        catch (error) {
+            this.handleApiError(error, { subject: `space ${args.id}` });
+        }
+        if (flags.json) {
+            this.printJsonResult(result);
+            return;
+        }
+        const eligibility = {
+            principal_missing_or_revoked: 'No active execution principal is configured.',
+            principal_lead_mismatch: 'The execution principal no longer matches the Space lead.',
+            principal_configured_unverified: 'An execution principal is configured; its current access has not been verified by this status check.',
+        }[result.currentEligibility] || 'Current eligibility is unknown.';
+        this.log(`Current eligibility: ${eligibility}`);
+        this.log(`Checked at: ${result.checkedAt}`);
+        const cycle = result.latestRecordedCycle;
+        if (cycle) {
+            this.log(`Most recent recorded cycle: ${cycle.window} — ${cycle.outcome}${cycle.reason ? ` (${cycle.reason})` : ''}; completed ${cycle.completedAt}`);
+        }
+        else {
+            this.log('No recorded cycle. This does not establish whether a cycle was scheduled.');
+        }
+        this.log('Cycle receipts are best-effort; an unrecorded later cycle may exist.');
+    }
+}
+exports.default = SpaceAutoDreamStatus;

package/dist/commands/spaces/proposals/list.js

@@ -62,6 +62,10 @@ class SpacesProposalsList extends base_command_1.BaseCommand {
         if (!result.data.length) {
             for (const line of (0, space_proposals_1.emptySpaceInboxLines)(result.nextCursor))
                 this.log(line);
+            if (!result.nextCursor) {
+                const bin = this.config?.bin || 'skrr';
+                this.log(`For AutoDream status, run: ${bin} spaces autodream status ${spaceId}`);
+            }
         }
         (0, format_1.renderTable)(result.data.map(space_proposals_1.spaceProposalRow), [
             { key: 'id', header: 'PROPOSAL', verbatim: true },

package/dist/commands/triggers/authorization.d.ts

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

package/dist/commands/triggers/authorization.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const triggers_1 = require("../../lib/triggers");
+class TriggersAuthorization extends base_command_1.BaseCommand {
+    static description = 'Revoke or restore a trigger’s user-directed authorization grant';
+    static examples = [
+        '<%= config.bin %> triggers authorization <trigger-id> --revoke',
+        '<%= config.bin %> triggers authorization <trigger-id> --restore --json',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Trigger ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        revoke: core_1.Flags.boolean({ description: 'Withdraw the existing grant', exclusive: ['restore'] }),
+        restore: core_1.Flags.boolean({ description: 'Restore the existing grant', exclusive: ['revoke'] }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TriggersAuthorization);
+        if (!flags.revoke && !flags.restore) {
+            this.failWithCliError({
+                message: 'Choose --revoke or --restore for the existing authorization grant.',
+                code: 'AUTHORIZATION_ACTION_REQUIRED',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        let result;
+        try {
+            result = await triggers_1.triggerApi.setAuthorizationRevoked(args.id, flags.revoke === true);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(flags.revoke ? 'Authorization revoked.' : 'Authorization restored.');
+    }
+}
+exports.default = TriggersAuthorization;

package/dist/commands/triggers/create.d.ts

@@ -78,6 +78,7 @@ export default class TriggersCreate extends BaseCommand {
         'allow-unknown-event': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    private warnMissingSelfSchedule;
     /**
      * The server creates the trigger and then says whether something already
      * watches the same thing. Printed AFTER the summary, and the sentence itself

package/dist/commands/triggers/create.js

@@ -324,6 +324,7 @@ class TriggersCreate extends base_command_1.BaseCommand {
         }
         if (trigger.dryRun) {
             this.log('Trigger accepted by dry run.');
+            this.warnMissingSelfSchedule(trigger);
             return;
         }
         this.log('Created trigger:');
@@ -331,6 +332,15 @@ class TriggersCreate extends base_command_1.BaseCommand {
         if (url)
             this.log(`View it at ${url}`);
         this.warnDuplicateSubscriptions(trigger);
+        this.warnMissingSelfSchedule(trigger);
+    }
+    warnMissingSelfSchedule(trigger) {
+        const warnings = trigger?.warnings;
+        if (!Array.isArray(warnings))
+            return;
+        const warning = warnings.find((item) => item && typeof item === 'object' && item.code === 'self_scheduled_without_next_run');
+        if (typeof warning?.message === 'string')
+            this.warn(warning.message);
     }
     /**
      * The server creates the trigger and then says whether something already

package/dist/commands/triggers/fire-detail.js

@@ -25,10 +25,31 @@ function describeFireAuditDetail(detail, fireId, triggerId) {
         lines.push(`Reason:       ${reason}`);
     if (message && message !== reason)
         lines.push(`${reason ? 'Detail:' : 'Reason:'}       ${message}`);
+    const quietHours = (0, triggers_1.quietHoursAuditExplanation)(detail);
+    if (quietHours) {
+        lines.push(`Explanation:  ${quietHours.summary}. ${quietHours.detail}`);
+    }
     if (detail.durationMs !== undefined)
         lines.push(`Duration:     ${String(detail.durationMs)}ms`);
     if (detail.conversationId)
         lines.push(`Conversation: ${String(detail.conversationId)}`);
+    const metadata = detail.metadata;
+    if (metadata && typeof metadata === 'object' && !Array.isArray(metadata)) {
+        const record = metadata;
+        if (record.recordKind === 'schedule_end_marker') {
+            lines.push('Note:         Schedule ended after the prior fire; this is not another occurrence.');
+            if (typeof record.afterOccurrenceId === 'string')
+                lines.push(`After fire:   ${record.afterOccurrenceId}`);
+        }
+        const debounce = record.debounce;
+        if (debounce && typeof debounce === 'object' && !Array.isArray(debounce)) {
+            const { retryAt, windowMs } = debounce;
+            if (typeof retryAt === 'string' && retryAt.trim())
+                lines.push(`Retry at:     ${retryAt}`);
+            if (typeof windowMs === 'number' && Number.isFinite(windowMs))
+                lines.push(`Debounce:     ${windowMs}ms`);
+        }
+    }
     // Tool calls refused during a turn that was delivered: `triggers show` points here for the facts.
     lines.push(...(0, triggers_1.fireRefusalLines)(detail.metadata));
     return lines;

package/dist/commands/triggers/prune.js

@@ -80,8 +80,18 @@ class TriggersPrune extends base_command_1.BaseCommand {
         // number that sizes the sweep, and `perUser` the cap it frees.
         const reclaimable = ownerWide ? quota.perUserReclaimable : quota.reclaimable;
         if (flags['dry-run']) {
+            let preview;
+            try {
+                preview = await triggers_1.triggerApi.prunePreview({
+                    ...target,
+                    ...(flags.limit ? { limit: flags.limit } : {}),
+                });
+            }
+            catch (err) {
+                this.handleApiError(err);
+            }
             if (flags.json) {
-                this.log(JSON.stringify({ dryRun: true, ownerWide, wouldDelete: reclaimable, quota }, null, 2));
+                this.log(JSON.stringify({ ...preview, quota }, null, 2));
                 return;
             }
             if (ownerWide) {
@@ -92,9 +102,11 @@ class TriggersPrune extends base_command_1.BaseCommand {
                 this.log(`Scope:       ${quota.scopeKind}`);
                 this.log(`Active:      ${quota.active} / ${quota.limit} (${quota.remaining} free)`);
             }
-            this.log(`Reclaimable: ${reclaimable} disabled trigger(s)`);
+            this.log(`Would delete: ${preview.wouldDelete} disabled trigger(s)`);
+            for (const id of preview.ids)
+                this.log(`  ${id}`);
             this.log('');
-            this.log('Dry run — nothing was deleted.');
+            this.log('Dry run — nothing was deleted. Candidates can change before pruning.');
             return;
         }
         if (reclaimable === 0) {