@skrr-ai/cli 0.1.119 → 0.1.120

package/dist/commands/daemon/maintenance/attest.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const daemon_maintenance_command_1 = require("../../../lib/daemon-maintenance-command");
+const daemon_maintenance_1 = require("../../../lib/daemon-maintenance");
+class DaemonMaintenanceAttest extends daemon_maintenance_command_1.DaemonMaintenanceCommand {
+    static description = 'Say the machine is ready when it cannot say so itself (--ready), or proceed anyway while work is still running (--proceed). Recorded as your word, never as evidence from the machine. The hold stays in force until you resume it.';
+    static examples = [
+        '<%= config.bin %> daemon maintenance attest "Studio Mac" --ready',
+        '<%= config.bin %> daemon maintenance attest "Studio Mac" --proceed',
+        '<%= config.bin %> daemon maintenance attest rk1:7c2e…:default --ready --json',
+    ];
+    static args = {
+        machine: core_1.Args.string({
+            ignoreStdin: true,
+            required: false,
+            description: 'Machine id, name or runtimeKey of a held machine. Omit it only when exactly one machine is held.',
+        }),
+    };
+    static flags = {
+        ready: core_1.Flags.boolean({
+            description: 'I have checked: mark it ready. Only accepted when the machine cannot report what is running, or a stop was never proven.',
+        }),
+        proceed: core_1.Flags.boolean({
+            description: 'Proceed anyway: record that you are updating while the reading shows work running or unreadable, naming what was shown.',
+        }),
+        generation: core_1.Flags.integer({
+            min: 1,
+            description: 'The generation of the hold this applies to. Without it, the live one.',
+        }),
+        json: core_1.Flags.boolean({
+            description: 'Print exactly one JSON document (schema 1) and nothing else on stdout',
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DaemonMaintenanceAttest);
+        if (flags.ready === flags.proceed) {
+            this.conclude((0, daemon_maintenance_1.invalidFlagRun)('attest', flags.ready
+                ? 'Pass --ready or --proceed, not both.'
+                : 'Pass --ready (it is ready) or --proceed (update anyway).'), flags.json);
+            return;
+        }
+        const run = await (0, daemon_maintenance_1.runAttest)({
+            ref: args.machine,
+            kind: flags.ready ? 'attest_ready' : 'proceed_anyway',
+            generation: flags.generation,
+        }, (0, daemon_maintenance_1.defaultIo)((line) => this.progressLine(line)));
+        this.conclude(run, flags.json);
+    }
+}
+exports.default = DaemonMaintenanceAttest;

package/dist/commands/daemon/maintenance/hold.d.ts

@@ -0,0 +1,17 @@
+import { DaemonMaintenanceCommand } from '../../../lib/daemon-maintenance-command';
+export default class DaemonMaintenanceHold extends DaemonMaintenanceCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        machine: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        reason: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'auto-resume': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        wait: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        explain: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/daemon/maintenance/hold.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const daemon_maintenance_command_1 = require("../../../lib/daemon-maintenance-command");
+const daemon_maintenance_1 = require("../../../lib/daemon-maintenance");
+class DaemonMaintenanceHold extends daemon_maintenance_command_1.DaemonMaintenanceCommand {
+    static description = 'Hold NEW work on one of your own machines. Nothing that is running is stopped. With --wait ready, wait until the machine says it is safe to update: exit 0 ready, 1 refused, 2 still pending at the timeout, 3 unknown. A timeout never releases the hold.';
+    static examples = [
+        '<%= config.bin %> daemon maintenance hold "Studio Mac" --reason "Updating the daemon"',
+        '<%= config.bin %> daemon maintenance hold "Studio Mac" --wait ready --timeout 30m',
+        '<%= config.bin %> daemon maintenance hold "Studio Mac" --auto-resume --wait ready --json',
+        '<%= config.bin %> daemon maintenance hold rk1:7c2e…:default --wait ready --explain',
+    ];
+    static args = {
+        machine: core_1.Args.string({
+            ignoreStdin: true,
+            required: false,
+            description: 'Machine id, name or runtimeKey. A machine that runs several profiles is ambiguous: name one daemon by its runtimeKey. Omit it only when exactly one daemon qualifies.',
+        }),
+    };
+    static flags = {
+        reason: core_1.Flags.string({
+            description: `Why, at most ${data_provider_1.DAEMON_MAINTENANCE_REASON_MAX_LENGTH} characters. Anyone the machine is shared with can read it.`,
+        }),
+        'auto-resume': core_1.Flags.boolean({
+            description: 'Release the hold by itself when the machine comes back on a new process',
+            default: false,
+        }),
+        wait: core_1.Flags.string({
+            options: ['ready'],
+            description: "Wait until the machine is ready. The state it waits for is the server's, never a guess made here.",
+        }),
+        timeout: core_1.Flags.string({
+            description: 'How long --wait waits, such as 90s, 30m or 2h (default 30m, at most 24h). Reaching it does NOT release the hold.',
+        }),
+        explain: core_1.Flags.boolean({
+            description: 'Show how the state was reached: each source that was read, in order, and what it found',
+        }),
+        json: core_1.Flags.boolean({
+            description: 'Print exactly one JSON document (schema 1) and nothing else on stdout; progress goes to stderr',
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DaemonMaintenanceHold);
+        if (flags.timeout !== undefined && flags.wait === undefined) {
+            this.conclude((0, daemon_maintenance_1.invalidFlagRun)('hold', '--timeout only applies with --wait ready.'), flags.json);
+            return;
+        }
+        let wait;
+        if (flags.wait !== undefined) {
+            const timeout = (0, daemon_maintenance_1.parseTimeout)(flags.timeout);
+            if (!timeout.ok) {
+                this.conclude((0, daemon_maintenance_1.invalidFlagRun)('hold', timeout.message), flags.json);
+                return;
+            }
+            wait = { timeoutMs: timeout.ms };
+        }
+        const run = await (0, daemon_maintenance_1.runHold)({
+            ref: args.machine,
+            reason: flags.reason,
+            autoResume: flags['auto-resume'],
+            wait,
+            explain: flags.explain,
+        }, (0, daemon_maintenance_1.defaultIo)((line) => this.progressLine(line)));
+        this.conclude(run, flags.json);
+    }
+}
+exports.default = DaemonMaintenanceHold;

package/dist/commands/daemon/maintenance/index.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+/**
+ * `skrr daemon maintenance` — the topic page.
+ *
+ * Says the model once: a hold stops NEW work on a machine and never touches what is
+ * running, so an update can wait for the work to finish instead of cutting it off.
+ */
+export default class DaemonMaintenance extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/daemon/maintenance/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+/**
+ * `skrr daemon maintenance` — the topic page.
+ *
+ * Says the model once: a hold stops NEW work on a machine and never touches what is
+ * running, so an update can wait for the work to finish instead of cutting it off.
+ */
+class DaemonMaintenance extends core_1.Command {
+    static description = 'Hold new work on one of your own machines so you can update it without losing what is running: hold it, wait until it is ready, update it, resume it. A hold never stops anything that is already running.';
+    static examples = [
+        '<%= config.bin %> daemon maintenance hold "Studio Mac" --reason "Updating the daemon" --wait ready --timeout 30m',
+        '<%= config.bin %> daemon maintenance status',
+        '<%= config.bin %> daemon maintenance resume "Studio Mac"',
+        '<%= config.bin %> daemon maintenance attest "Studio Mac" --ready',
+    ];
+    async run() {
+        this.log('Hold new work on one of your own machines while you update it:');
+        this.log('  skrr daemon maintenance hold      stop NEW work on a machine; --wait ready waits for it to be safe');
+        this.log('  skrr daemon maintenance status    what is held, and whether it is ready');
+        this.log('  skrr daemon maintenance resume    release a hold; work that waited starts again');
+        this.log('  skrr daemon maintenance attest    say the machine is ready, when it cannot say so itself');
+        this.log('');
+        this.log('A hold stops starts, never what is running. Waiting that times out does NOT release it.');
+        this.log('Exit codes of `hold --wait ready`: 0 ready, 1 refused, 2 still pending at the timeout, 3 unknown.');
+        this.log('Machines managed by the platform (hosted, Dedicated) cannot be held: they are updated for you.');
+    }
+}
+exports.default = DaemonMaintenance;

package/dist/commands/daemon/maintenance/resume.d.ts

@@ -0,0 +1,13 @@
+import { DaemonMaintenanceCommand } from '../../../lib/daemon-maintenance-command';
+export default class DaemonMaintenanceResume extends DaemonMaintenanceCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        machine: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        generation: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/daemon/maintenance/resume.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const daemon_maintenance_command_1 = require("../../../lib/daemon-maintenance-command");
+const daemon_maintenance_1 = require("../../../lib/daemon-maintenance");
+class DaemonMaintenanceResume extends daemon_maintenance_command_1.DaemonMaintenanceCommand {
+    static description = 'Release a hold: new work can start on the machine again, and work that waited behind the hold starts by itself.';
+    static examples = [
+        '<%= config.bin %> daemon maintenance resume "Studio Mac"',
+        '<%= config.bin %> daemon maintenance resume "Studio Mac" --generation 3',
+        '<%= config.bin %> daemon maintenance resume rk1:7c2e…:default --json',
+    ];
+    static args = {
+        machine: core_1.Args.string({
+            ignoreStdin: true,
+            required: false,
+            description: 'Machine id, name or runtimeKey of a held machine. Omit it only when exactly one machine is held.',
+        }),
+    };
+    static flags = {
+        generation: core_1.Flags.integer({
+            min: 1,
+            description: 'Release exactly this generation of the hold (the number `status` shows). Without it, the live one. If the hold changed since, nothing is released and the current generation is named.',
+        }),
+        json: core_1.Flags.boolean({
+            description: 'Print exactly one JSON document (schema 1) and nothing else on stdout',
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DaemonMaintenanceResume);
+        const run = await (0, daemon_maintenance_1.runResume)({ ref: args.machine, generation: flags.generation }, (0, daemon_maintenance_1.defaultIo)((line) => this.progressLine(line)));
+        this.conclude(run, flags.json);
+    }
+}
+exports.default = DaemonMaintenanceResume;

package/dist/commands/daemon/maintenance/status.d.ts

@@ -0,0 +1,13 @@
+import { DaemonMaintenanceCommand } from '../../../lib/daemon-maintenance-command';
+export default class DaemonMaintenanceStatus extends DaemonMaintenanceCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        machine: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        explain: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/daemon/maintenance/status.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const daemon_maintenance_command_1 = require("../../../lib/daemon-maintenance-command");
+const daemon_maintenance_1 = require("../../../lib/daemon-maintenance");
+class DaemonMaintenanceStatus extends daemon_maintenance_command_1.DaemonMaintenanceCommand {
+    static description = 'Show what is held and whether it is ready: every hold you have, or one machine';
+    static examples = [
+        '<%= config.bin %> daemon maintenance status',
+        '<%= config.bin %> daemon maintenance status "Studio Mac"',
+        '<%= config.bin %> daemon maintenance status "Studio Mac" --explain',
+        '<%= config.bin %> daemon maintenance status rk1:7c2e…:default --json',
+    ];
+    static args = {
+        machine: core_1.Args.string({
+            ignoreStdin: true,
+            required: false,
+            description: 'Machine id, name or runtimeKey. Omit it to list every hold you have, orphaned ones included.',
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({
+            description: 'Print exactly one JSON document (schema 1) and nothing else on stdout',
+        }),
+        explain: core_1.Flags.boolean({
+            description: 'Show how the state was reached: each source that was read, in order, and what it found',
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(DaemonMaintenanceStatus);
+        const run = await (0, daemon_maintenance_1.runStatus)({ ref: args.machine, explain: flags.explain }, (0, daemon_maintenance_1.defaultIo)((line) => this.progressLine(line)));
+        this.conclude(run, flags.json);
+    }
+}
+exports.default = DaemonMaintenanceStatus;

package/dist/commands/doctor.d.ts

@@ -1,4 +1,5 @@
 import { BaseCommand } from '../base-command';
+import { type CliInstallationDiagnostics } from '../lib/cli-installation-diagnostics';
 type OclifPluginAvailability = {
     configured: string[];
     missing: string[];
@@ -25,7 +26,9 @@ export declare function configuredOclifPluginAvailability(root: string): OclifPl
  * same CLI: a named question per check, a mark, and the remedy beside the
  * failure. `--json` is unchanged.
  */
-export declare function doctorCheckLines(checks: Record<string, boolean>, issues: string[], bin: string): string[];
+export declare function doctorCheckLines(checks: Record<string, boolean>, issues: string[], bin: string, remedies?: Record<string, (bin: string) => string>): string[];
+/** Render the same installation facts as --json without hiding PATH precedence. */
+export declare function doctorInstallationLines(diagnostics: CliInstallationDiagnostics): string[];
 export default class Doctor extends BaseCommand {
     static description: string;
     static examples: string[];

package/dist/commands/doctor.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configuredOclifPluginAvailability = configuredOclifPluginAvailability;
 exports.doctorCheckLines = doctorCheckLines;
+exports.doctorInstallationLines = doctorInstallationLines;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const core_1 = require("@oclif/core");
@@ -50,6 +51,7 @@ const command_manifest_1 = require("../lib/command-manifest");
 const completion_index_1 = require("../lib/completion-index");
 const runtime_context_1 = require("../lib/runtime-context");
 const deployed_build_1 = require("../lib/deployed-build");
+const cli_installation_diagnostics_1 = require("../lib/cli-installation-diagnostics");
 const outbox_1 = require("../lib/outbox");
 /**
  * What each check actually verifies, in the words a reader thinks in.
@@ -84,6 +86,7 @@ const ISSUE_REMEDIES = {
     control_plane_unavailable_auth_not_verifiable: () => 'The server is down, not your credential — retry when it is back.',
     auth_token_present_but_user_lookup_failed: (bin) => `The server rejected the credential. Sign in again: ${bin} login`,
     not_signed_in_or_no_token_available: (bin) => `Sign in: ${bin} login — or in --bare mode, set OVERSKY_TOKEN.`,
+    cli_installation_version_drift: () => 'Inspect the installation section below before changing PATH or removing any package.',
 };
 /**
  * Oclif loads configured plugins before it dispatches a command. A stale
@@ -131,7 +134,7 @@ function configuredOclifPluginAvailability(root) {
  * same CLI: a named question per check, a mark, and the remedy beside the
  * failure. `--json` is unchanged.
  */
-function doctorCheckLines(checks, issues, bin) {
+function doctorCheckLines(checks, issues, bin, remedies = ISSUE_REMEDIES) {
     const lines = ['Checks:'];
     for (const [key, passed] of Object.entries(checks)) {
         const label = CHECK_LABELS[key] || key;
@@ -141,13 +144,37 @@ function doctorCheckLines(checks, issues, bin) {
         lines.push('', 'Issues:');
         for (const issue of issues) {
             lines.push(`  - ${issue}`);
-            const remedy = ISSUE_REMEDIES[issue];
+            const remedy = remedies[issue];
             if (remedy)
                 lines.push(`    ${remedy(bin)}`);
         }
     }
     return lines;
 }
+/** Render the same installation facts as --json without hiding PATH precedence. */
+function doctorInstallationLines(diagnostics) {
+    const lines = ['CLI installations:'];
+    if (!diagnostics.active) {
+        lines.push('  Active: could not identify this CLI package from local metadata.');
+    }
+    else {
+        lines.push(`  Active: v${diagnostics.active.version} — ${diagnostics.active.paths[0]} ` +
+            `(${diagnostics.active.owner})`);
+    }
+    for (const candidate of diagnostics.candidates) {
+        if (candidate.pathPrecedence === null)
+            continue;
+        lines.push(`  PATH #${candidate.pathPrecedence}: v${candidate.version} — ${candidate.paths[0]}` +
+            (candidate.active ? ' (active package)' : ''));
+    }
+    for (const candidate of diagnostics.unrecognisedExecutables) {
+        const location = candidate.pathPrecedence === null ? candidate.source : `PATH #${candidate.pathPrecedence}`;
+        lines.push(`  ${location}: ${candidate.path} (not recognised as @skrr-ai/cli)`);
+    }
+    if (diagnostics.remedy)
+        lines.push(`  Remedy: ${diagnostics.remedy}`);
+    return lines;
+}
 class Doctor extends base_command_1.BaseCommand {
     static description = 'Check whether the skrr CLI is ready for agent automation';
     static examples = ['<%= config.bin %> doctor', '<%= config.bin %> doctor --json'];
@@ -162,11 +189,14 @@ class Doctor extends base_command_1.BaseCommand {
         const pkgFile = path.join(root, 'package.json');
         const binFile = path.join(root, 'bin', 'run.js');
         const oclifPlugins = configuredOclifPluginAvailability(root);
-        const credential = (0, auth_storage_1.readFromBackend)(this.cliConfig.baseURL);
+        const installations = (0, cli_installation_diagnostics_1.inspectCliInstallations)({ activeRoot: root });
+        const credential = this.bareMode
+            ? { bundle: null, backend: 'none', originStatus: 'none' }
+            : (0, auth_storage_1.readFromBackend)(this.cliConfig.baseURL);
         // Completion data is auxiliary to diagnosis.  Refresh it opportunistically
         // here so normal maintenance keeps Tab data current, but do not let a
         // network outage make `skrr doctor` itself fail.
-        await (0, completion_index_1.refreshCompletionIndex)(this.config.cacheDir);
+        await (0, completion_index_1.refreshCompletionIndex)(this.config.cacheDir, this.completionCacheScope());
         let manifestLoaded = false;
         let commandCount = 0;
         let hasContext = false;
@@ -277,10 +307,12 @@ class Doctor extends base_command_1.BaseCommand {
                 ? ['auth_token_present_but_user_lookup_failed']
                 : []),
             ...(!checks.authToken ? ['not_signed_in_or_no_token_available'] : []),
+            ...(installations.hasVersionDrift ? ['cli_installation_version_drift'] : []),
             ...(credential.ownerStatus === 'foreign'
                 ? ['stored_credential_belongs_to_another_skrr_config_run_skrr_login']
                 : []),
         ];
+        const authResolution = this.authResolution();
         const payload = {
             ok: issues.length === 0,
             cli: {
@@ -290,7 +322,10 @@ class Doctor extends base_command_1.BaseCommand {
                 node: process.version,
                 command: process.argv.slice(1).join(' '),
             },
+            installations,
             server: this.cliConfig.baseURL,
+            // Additive provenance: keep the legacy `server` string unchanged.
+            serverSource: authResolution.server.source,
             // The commit the server's API image and its published web shell were
             // each built from. They differ whenever a release changed only one.
             deployed,
@@ -324,6 +359,7 @@ class Doctor extends base_command_1.BaseCommand {
                             'invalidated and re-authenticating will not help — retry once the service recovers.',
                     }
                     : null,
+                resolution: authResolution,
             },
             runtime: (0, runtime_context_1.readRuntimeContext)(),
             // OSK-2806 — the incident surface. During an outage a user is looking at
@@ -357,7 +393,7 @@ class Doctor extends base_command_1.BaseCommand {
             return;
         }
         this.log(`skrr CLI ${payload.cli.version} at ${root}`);
-        this.log(`Server: ${payload.server}`);
+        this.log(`Server: ${authResolution.server.origin ?? 'configured server (invalid URL)'} (${payload.serverSource})`);
         for (const line of (0, deployed_build_1.deployedBuildLines)(deployed))
             this.log(line);
         this.log(`Auth:   ${payload.auth.signedIn
@@ -365,6 +401,8 @@ class Doctor extends base_command_1.BaseCommand {
             : serverReachability === 'unavailable'
                 ? 'unverifiable — the server is not responding'
                 : 'not signed in'}`);
+        if (!payload.auth.signedIn)
+            this.log(`Auth resolution: ${authResolution.suggestion}`);
         const queued = payload.service.queuedWrites;
         if (queued > 0) {
             this.log(`Queued: ${queued} write(s) held locally because the API was unavailable — ` +
@@ -382,7 +420,13 @@ class Doctor extends base_command_1.BaseCommand {
             this.log(`Plugins: missing ${oclifPlugins.missing.join(', ')}`);
         }
         this.log('');
-        for (const line of doctorCheckLines(checks, issues, this.config.bin))
+        for (const line of doctorInstallationLines(installations))
+            this.log(line);
+        this.log('');
+        for (const line of doctorCheckLines(checks, issues, this.config.bin, {
+            ...ISSUE_REMEDIES,
+            cli_installation_version_drift: () => installations.remedy ?? 'Inspect the installation section below before changing PATH or removing any package.',
+        }))
             this.log(line);
         if (issues.length > 0) {
             this.exit(1);

package/dist/commands/followups/plans/cancel-batch.js

@@ -90,14 +90,17 @@ class CancelContinuityBatch extends base_command_1.BaseCommand {
             this.handleApiError(err);
             return;
         }
+        const unconfirmed = !result.complete ||
+            result.outcomes.some((outcome) => outcome.status === 'failed' || outcome.status === 'unknown');
+        // The document is printed before the exit code is set, so `ok` is decided
+        // here: a batch with a failed or unconfirmed member must not read as a success.
         if (flags.json)
-            this.log(JSON.stringify(result, null, 2));
+            this.printJsonResult(result, { ok: !unconfirmed });
         else {
             for (const outcome of result.outcomes)
                 this.log(`${outcome.id}: ${outcome.status}${outcome.plan ? ` [${outcome.plan.state}] r${outcome.plan.revision}` : ''}${outcome.code ? ` (${outcome.code})` : ''}`);
         }
-        if (!result.complete ||
-            result.outcomes.some((outcome) => outcome.status === 'failed' || outcome.status === 'unknown')) {
+        if (unconfirmed) {
             if (!flags.json)
                 this.log('Some cancellations were not confirmed. Read their current state and revisions before making another change.');
             process.exitCode = result.outcomes.some((outcome) => outcome.status === 'unknown') ? 5 : 2;

package/dist/commands/followups/plans/capacity.js

@@ -18,14 +18,18 @@ class LookbackPlansCapacity extends base_command_1.BaseCommand {
             agentId = (0, followups_1.resolveFollowUpAgent)(flags.agent).id;
         }
         catch (err) {
-            this.failWithCliError({ message: err instanceof Error ? err.message : String(err),
-                code: 'AGENT_CONTEXT_AMBIGUOUS', exit: 2, retryable: false });
+            this.failWithCliError({
+                message: err instanceof Error ? err.message : String(err),
+                code: 'AGENT_CONTEXT_AMBIGUOUS',
+                exit: 2,
+                retryable: false,
+            });
             return;
         }
         try {
             const result = await lookbackPlans_1.lookbackPlansApi.capacity({ agentId });
             if (flags.json) {
-                this.log(JSON.stringify(result, null, 2));
+                this.printJsonResult(result);
                 return;
             }
             this.log(`${result.scope.agentId}: ${result.remaining}/${result.limit} plans remaining (${result.used} admitted this UTC day).`);

package/dist/commands/followups/plans/observability.js

@@ -7,7 +7,10 @@ const followups_1 = require("../../../lib/followups");
 class LookbackPlansObservability extends base_command_1.BaseCommand {
     static description = 'Inspect bounded lookback scheduling health and evaluation outcomes';
     static flags = {
-        agent: core_1.Flags.string({ description: 'Agent ID (default: bound session agent)', exclusive: ['all-agents'] }),
+        agent: core_1.Flags.string({
+            description: 'Agent ID (default: bound session agent)',
+            exclusive: ['all-agents'],
+        }),
         'all-agents': core_1.Flags.boolean({ description: 'Inspect all owned agents', exclusive: ['agent'] }),
         limit: core_1.Flags.integer({ description: 'Maximum sampled plans (1..100)', min: 1, max: 100 }),
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
@@ -20,13 +23,18 @@ class LookbackPlansObservability extends base_command_1.BaseCommand {
             agentId = flags['all-agents'] ? undefined : (0, followups_1.resolveFollowUpAgent)(flags.agent).id;
         }
         catch (err) {
-            this.failWithCliError({ message: err instanceof Error ? err.message : String(err), code: 'AGENT_CONTEXT_AMBIGUOUS', exit: 2, retryable: false });
+            this.failWithCliError({
+                message: err instanceof Error ? err.message : String(err),
+                code: 'AGENT_CONTEXT_AMBIGUOUS',
+                exit: 2,
+                retryable: false,
+            });
             return;
         }
         try {
             const result = await lookbackPlans_1.lookbackPlansApi.observability({ agentId, limit: flags.limit });
             if (flags.json) {
-                this.log(JSON.stringify(result, null, 2));
+                this.printJsonResult(result);
                 return;
             }
             this.log(`${result.sample.plans} plans sampled${result.sample.truncated ? ' (more exist)' : ''}.`);

package/dist/commands/followups/plans/preferences/set.js

@@ -9,7 +9,10 @@ class SetContinuityPreferences extends base_command_1.BaseCommand {
     static description = 'Update conversation continuity preferences using the exact selected-scope revision';
     static flags = {
         agent: core_1.Flags.string({ description: 'Agent override scope; must agree with agentId in input' }),
-        'from-json': core_1.Flags.string({ description: 'JSON update with expectedRevision and settings or inherit:true; - reads stdin', required: true }),
+        'from-json': core_1.Flags.string({
+            description: 'JSON update with expectedRevision and settings or inherit:true; - reads stdin',
+            required: true,
+        }),
         json: core_1.Flags.boolean({ description: 'Output the authoritative preference envelope as JSON' }),
     };
     async run() {
@@ -20,7 +23,12 @@ class SetContinuityPreferences extends base_command_1.BaseCommand {
             body = (0, continuityPreferences_1.continuityPreferencesInput)(await (0, prompt_1.readJsonBody)(flags['from-json']), flags.agent);
         }
         catch (err) {
-            this.failWithCliError({ code: 'CONTINUITY_PREFERENCES_INVALID', message: err instanceof Error ? err.message : String(err), exit: 2, retryable: false });
+            this.failWithCliError({
+                code: 'CONTINUITY_PREFERENCES_INVALID',
+                message: err instanceof Error ? err.message : String(err),
+                exit: 2,
+                retryable: false,
+            });
             return;
         }
         let result;
@@ -29,19 +37,29 @@ class SetContinuityPreferences extends base_command_1.BaseCommand {
         }
         catch (err) {
             if ((0, lookbackPlans_1.isLookbackMutationOutcomeUnknown)(err)) {
-                const current = await lookbackPlans_1.lookbackPlansApi.preferences({ agentId: body.agentId }).catch(() => null);
-                this.failWithCliError({ code: 'CONTINUITY_PREFERENCES_OUTCOME_UNCONFIRMED',
+                const current = await lookbackPlans_1.lookbackPlansApi
+                    .preferences({ agentId: body.agentId })
+                    .catch(() => null);
+                this.failWithCliError({
+                    code: 'CONTINUITY_PREFERENCES_OUTCOME_UNCONFIRMED',
                     message: 'The preference update outcome could not be confirmed. Read the same scope before deciding on another change.',
-                    exit: 5, retryable: false, details: { scope: { agentId: body.agentId || null }, expectedRevision: body.expectedRevision,
-                        readback: current ? 'observed' : 'unavailable', ...(current ? { currentPreferences: current } : {}),
-                        remedy: 'Do not blindly retry. Read the selected scope and use its current revision for any deliberate new update.' } });
+                    exit: 5,
+                    retryable: false,
+                    details: {
+                        scope: { agentId: body.agentId || null },
+                        expectedRevision: body.expectedRevision,
+                        readback: current ? 'observed' : 'unavailable',
+                        ...(current ? { currentPreferences: current } : {}),
+                        remedy: 'Do not blindly retry. Read the selected scope and use its current revision for any deliberate new update.',
+                    },
+                });
                 return;
             }
             this.handleApiError(err);
             return;
         }
         if (flags.json)
-            this.log(JSON.stringify(result, null, 2));
+            this.printJsonResult(result);
         else
             for (const line of (0, continuityPreferences_1.continuityPreferencesLines)(result))
                 this.log(line);

package/dist/commands/followups/plans/preferences.js

@@ -16,7 +16,7 @@ class ContinuityPreferences extends base_command_1.BaseCommand {
         try {
             const result = await lookbackPlans_1.lookbackPlansApi.preferences({ agentId: flags.agent });
             if (flags.json)
-                this.log(JSON.stringify(result, null, 2));
+                this.printJsonResult(result);
             else
                 for (const line of (0, continuityPreferences_1.continuityPreferencesLines)(result))
                     this.log(line);

package/dist/commands/followups/plans/show.js

@@ -13,7 +13,7 @@ class LookbackPlansShow extends base_command_1.BaseCommand {
         try {
             const result = await lookbackPlans_1.lookbackPlansApi.show(args.id);
             if (flags.json) {
-                this.log(JSON.stringify(result, null, 2));
+                this.printJsonResult(result);
                 return;
             }
             this.log((0, lookbackPlans_1.lookbackPlanSummary)(result.plan));