@skrr-ai/cli 0.1.113 → 0.1.115

package/dist/lib/agentic-stream.js

@@ -740,6 +740,7 @@ class AgenticStreamClient {
     textJoiner = (0, data_provider_1.createAssistantTextJoiner)();
     /** Highest envelope `__seq` folded into `accumulated`, for gap detection. */
     highestSeq = 0;
+    publicProjection;
     pendingEnvelopes = new Map();
     replayTimer = null;
     replayFlight = null;
@@ -972,6 +973,7 @@ class AgenticStreamClient {
             reason,
             ...(terminal.error ? { message: terminal.error, error: terminal.error } : {}),
             ...(typeof terminal.text === 'string' ? { result: terminal.text } : {}),
+            ...(terminal.publicProjection ? { publicProjection: terminal.publicProjection } : {}),
         });
         return true;
     }
@@ -1129,6 +1131,7 @@ class AgenticStreamClient {
                 type: 'execution:complete',
                 sessionId: this.options.sessionId,
                 result: reading.text,
+                ...(reading.publicProjection ? { publicProjection: reading.publicProjection } : {}),
                 repaired: true,
                 repairedFrom: 'durable_record',
                 overturned: { code: exports.WORKER_REPLACED_CODE, reason: exports.DAEMON_HANDOVER_REASON },
@@ -1146,6 +1149,7 @@ class AgenticStreamClient {
             message: reading.error,
             errors: [reading.error],
             ...(typeof reading.text === 'string' && reading.text ? { result: reading.text } : {}),
+            ...(reading.publicProjection ? { publicProjection: reading.publicProjection } : {}),
             handover: { outcome: 'machine_failed', waitedMs },
         });
         return true;
@@ -1454,6 +1458,9 @@ class AgenticStreamClient {
             if (fresh.length === 0)
                 return; // a pure re-delivery — drop it whole
             const scoped = { ...event, envelopes: fresh };
+            if (fresh.some((env) => env?.ev?.t === 'text' &&
+                env.ev?.publicProjection === 'lookback_answer_v1'))
+                this.publicProjection = 'lookback_answer_v1';
             // Note what never arrived before folding this batch in (OSK-7631,
             // OSK-13518). Checked against the FRESH set: a re-delivery carries old
             // seqs and would read as a gap that never happened.
@@ -1539,6 +1546,8 @@ class AgenticStreamClient {
         socket.on('message:stream', (event) => {
             if (!match(event))
                 return;
+            if (event.publicProjection === 'lookback_answer_v1')
+                this.publicProjection = event.publicProjection;
             const text = typeof event.text === 'string' ? event.text : '';
             const delta = typeof event.delta === 'string' ? event.delta : '';
             if (text && text.length >= this.accumulated.length)
@@ -1574,6 +1583,7 @@ class AgenticStreamClient {
             if (!match(event))
                 return;
             this.accumulated = '';
+            this.publicProjection = undefined;
             this.textJoiner.reset();
             this.renderedText = '';
             // Seqs restart with the stream, so a fresh low seq is not a gap.
@@ -2099,7 +2109,7 @@ class AgenticStreamClient {
             const streamedText = (0, widgetTerminalText_1.widgetsAsText)(this.accumulated, { final: true });
             void this.readRecordedText().then((recorded) => {
                 this.settleGapVerdict(streamedText, recorded);
-                this.settle(status, event, recorded?.text || undefined);
+                this.settle(status, event, recorded);
             });
             return;
         }
@@ -2124,10 +2134,10 @@ class AgenticStreamClient {
             try {
                 const terminal = await reconcile();
                 if (terminal && typeof terminal.text === 'string' && terminal.text) {
-                    return { text: terminal.text };
+                    return { text: terminal.text, ...(terminal.publicProjection ? { publicProjection: terminal.publicProjection } : {}) };
                 }
                 if (terminal)
-                    empty = { text: '' };
+                    empty = { text: '', ...(terminal.publicProjection ? { publicProjection: terminal.publicProjection } : {}) };
             }
             catch {
                 // No evidence either way; try again, then settle on the stream.
@@ -2135,7 +2145,7 @@ class AgenticStreamClient {
         }
         return empty;
     }
-    settle(status, event, recordedText) {
+    settle(status, event, recorded) {
         // `execution:complete` carries the final answer as `result`, and it is
         // AUTHORITATIVE — preferred over whatever the deltas added up to, not just
         // used when they added up to nothing.
@@ -2146,6 +2156,8 @@ class AgenticStreamClient {
         // `result` whenever the server sends one makes the returned text the
         // agent's actual final message rather than however much of it arrived in
         // time.
+        if (event.publicProjection === 'lookback_answer_v1')
+            this.publicProjection = event.publicProjection;
         const finalText = typeof event.result === 'string' ? event.result : '';
         // …EXCEPT when it is a strict suffix of what we accumulated.
         //
@@ -2168,7 +2180,10 @@ class AgenticStreamClient {
             this.accumulated.length > finalText.length &&
             (this.accumulated.endsWith(finalText) ||
                 endsWithIgnoringWhitespace(this.accumulated, finalText));
-        if (finalText && finalText !== this.accumulated && !accumulationIsSuperset) {
+        if (event.publicProjection === 'lookback_answer_v1' && typeof event.result === 'string') {
+            this.accumulated = event.result;
+        }
+        else if (finalText && finalText !== this.accumulated && !accumulationIsSuperset) {
             this.accumulated = finalText;
         }
         // The record wins over a stream known to have lost chunks, unless what
@@ -2176,9 +2191,10 @@ class AgenticStreamClient {
         // other way round).
         // (Compared as the reader sees it: the record holds a widget as its fallback sentence,
         // which is shorter than the block the stream carried, and the raw length would never lose.)
-        if (recordedText &&
-            recordedText.length > (0, widgetTerminalText_1.widgetsAsText)(this.accumulated, { final: true }).length) {
-            this.accumulated = recordedText;
+        if (recorded && (recorded.publicProjection === 'lookback_answer_v1' ||
+            recorded.text.length > (0, widgetTerminalText_1.widgetsAsText)(this.accumulated, { final: true }).length)) {
+            this.accumulated = recorded.text;
+            this.publicProjection = recorded.publicProjection;
         }
         // The finished answer, as every other surface shows it: the web applies
         // this same sanitizer, so a scheduling JSON block or leaked function-call
@@ -2186,7 +2202,7 @@ class AgenticStreamClient {
         // printed as part of the agent's answer.
         // A widget is its fallback sentence in a terminal, first: the sanitizer must read
         // prose and never a widget's script (the server projects before it sanitizes, too).
-        this.accumulated = (0, data_provider_1.sanitizeFinalText)((0, widgetTerminalText_1.widgetsAsText)(this.accumulated, { final: true }));
+        this.accumulated = (0, data_provider_1.sanitizeFinalText)((0, widgetTerminalText_1.widgetsAsText)(this.accumulated, { final: true }), this.publicProjection);
         if (!this.options.quiet && !this.options.jsonl && this.accumulated) {
             const output = this.options.output ?? process.stdout;
             const { append, shown } = renderableDelta(this.renderedText, this.accumulated);

package/dist/lib/computer-use.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export declare function buildComputerUseArgs(action: string | undefined, argv: readonly string[]): string[];
+/** The runtime owns local consent, installation and lifecycle; the REST CLI only dispatches. */
+export declare function forwardComputerUseCommand(command: Command, action: string | undefined, argv: readonly string[]): Promise<void>;
+export declare abstract class ComputerUseCommand extends Command {
+    static strict: boolean;
+    protected abstract action: string | undefined;
+    run(): Promise<void>;
+}

package/dist/lib/computer-use.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComputerUseCommand = void 0;
+exports.buildComputerUseArgs = buildComputerUseArgs;
+exports.forwardComputerUseCommand = forwardComputerUseCommand;
+const core_1 = require("@oclif/core");
+const exec_runtime_binary_1 = require("./exec-runtime-binary");
+function buildComputerUseArgs(action, argv) {
+    return ['computer-use', ...(action ? [action] : []), ...argv];
+}
+/** The runtime owns local consent, installation and lifecycle; the REST CLI only dispatches. */
+async function forwardComputerUseCommand(command, action, argv) {
+    const fail = (message, code, exit) => {
+        if (argv.includes('--json')) {
+            command.log(JSON.stringify({ object: 'computer_use_control', schemaVersion: 1, action: action ?? argv[0] ?? 'help', ok: false, error: { code, message } }));
+            return command.exit(exit);
+        }
+        command.log(message);
+        return command.exit(exit);
+    };
+    try {
+        if ((await (0, exec_runtime_binary_1.runtimeBinarySupportsSubcommand)('computer-use')) === false) {
+            return fail('This local daemon does not support Computer Use. Update skrrd, then retry.', 'runtime_unsupported', 2);
+        }
+        command.exit(await (0, exec_runtime_binary_1.execRuntimeBinary)(buildComputerUseArgs(action, argv)));
+    }
+    catch (error) {
+        if (error.message === 'runtime-binary-not-installed') {
+            return fail((0, exec_runtime_binary_1.notInstalledMessage)(), 'runtime_not_installed', 127);
+        }
+        throw error;
+    }
+}
+class ComputerUseCommand extends core_1.Command {
+    static strict = false;
+    async run() {
+        // Never call parse(): unknown runtime flags must reach the authoritative parser unchanged.
+        await forwardComputerUseCommand(this, this.action, this.argv);
+    }
+}
+exports.ComputerUseCommand = ComputerUseCommand;

package/dist/lib/lookbackPlans.d.ts

@@ -1,13 +1,27 @@
-import { lookbackPlansApi, type CreateLookbackPlanRequest, type LookbackPlan, type LookbackPlanInput } from '@skrr-ai/data-provider';
-export { lookbackPlansApi };
+import { lookbackPlansApi, isLookbackMutationOutcomeUnknown, type CreateLookbackPlanRequest, type LookbackPlan, type LookbackPlanInput } from '@skrr-ai/data-provider';
+export { lookbackPlansApi, isLookbackMutationOutcomeUnknown };
 export declare function lookbackInputFailure(error: unknown): {
+    code: "LOOKBACK_INVALID_FIELD" | "LOOKBACK_INVALID_TIME" | "LOOKBACK_INVALID_TIMEZONE" | "LOOKBACK_AMBIGUOUS_TIME" | "LOOKBACK_NONEXISTENT_TIME" | "LOOKBACK_LIMIT_EXCEEDED";
+    message: string;
+    details: {
+        field?: string | undefined;
+        stage: string;
+        retryCondition: string;
+        remedy: string;
+    };
     exit: number;
     retryable: boolean;
-    details?: {
-        field: string;
-    } | undefined;
-    code: "LOOKBACK_INVALID_FIELD" | "LOOKBACK_INVALID_TIME" | "LOOKBACK_INVALID_TIMEZONE" | "LOOKBACK_AMBIGUOUS_TIME" | "LOOKBACK_NONEXISTENT_TIME" | "LOOKBACK_LIMIT_EXCEEDED";
+};
+export declare function lookbackUnconfirmedFailure(details: Record<string, unknown>): {
+    code: string;
     message: string;
+    exit: number;
+    retryable: boolean;
+    details: {
+        stage: string;
+        retryCondition: string;
+        remedy: string;
+    };
 };
 export declare const lookbackPlanIdArg: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
 /** JSON can be the plan itself or the canonical create envelope. Never copy identity fields. */

package/dist/lib/lookbackPlans.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lookbackPlanIdArg = exports.lookbackPlansApi = void 0;
+exports.lookbackPlanIdArg = exports.isLookbackMutationOutcomeUnknown = exports.lookbackPlansApi = void 0;
 exports.lookbackInputFailure = lookbackInputFailure;
+exports.lookbackUnconfirmedFailure = lookbackUnconfirmedFailure;
 exports.lookbackCreateBody = lookbackCreateBody;
 exports.lookbackInput = lookbackInput;
 exports.lookbackPlanSummary = lookbackPlanSummary;
@@ -9,6 +10,7 @@ exports.lookbackArmingLine = lookbackArmingLine;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 Object.defineProperty(exports, "lookbackPlansApi", { enumerable: true, get: function () { return data_provider_1.lookbackPlansApi; } });
+Object.defineProperty(exports, "isLookbackMutationOutcomeUnknown", { enumerable: true, get: function () { return data_provider_1.isLookbackMutationOutcomeUnknown; } });
 const followups_1 = require("./followups");
 class LookbackValidationError extends Error {
     issue;
@@ -18,12 +20,23 @@ class LookbackValidationError extends Error {
     }
 }
 function lookbackInputFailure(error) {
+    const repair = { stage: 'validation', retryCondition: 'correct_input',
+        remedy: 'Correct the indicated input field before submitting again.',
+        ...(error instanceof LookbackValidationError ? { field: error.issue.field } : {}),
+    };
     return {
         code: error instanceof LookbackValidationError ? error.issue.code : 'LOOKBACK_INVALID_FIELD',
         message: error instanceof Error ? error.message : String(error),
-        ...(error instanceof LookbackValidationError ? { details: { field: error.issue.field } } : {}),
-        exit: 2,
-        retryable: false,
+        // BaseCommand's machine envelope carries additive domain facts in details.
+        details: repair, exit: 2, retryable: false,
+    };
+}
+function lookbackUnconfirmedFailure(details) {
+    return {
+        code: 'LOOKBACK_OUTCOME_UNCONFIRMED', message: 'The plan update outcome could not be confirmed. Read the original source or known plan before submitting another change.',
+        exit: 5, retryable: false,
+        details: { stage: 'lifecycle', retryCondition: 'read_original_source_or_known_plan',
+            remedy: 'Read the known plan or original source. Do not submit a replacement source or blindly repeat this mutation.', ...details },
     };
 }
 exports.lookbackPlanIdArg = core_1.Args.string({
@@ -75,7 +88,8 @@ function lookbackInput(raw, allowPast = false) {
     return raw;
 }
 function lookbackPlanSummary(plan) {
-    const next = plan.steps.find((step) => step.state === 'pending');
+    const next = plan.steps.filter((step) => step.state === 'pending')
+        .reduce((earliest, step) => !earliest || Date.parse(step.runAt) < Date.parse(earliest.runAt) ? step : earliest, undefined);
     return `${plan.id}  [${plan.state}] r${plan.revision}  ${plan.title || plan.objective}` +
         `  ${plan.steps.length} lookbacks${next ? `  next:${next.runAt}` : ''}`;
 }

package/dist/lib/update-check.d.ts

@@ -1,4 +1,9 @@
 export type CliInstallKind = 'npm-global' | 'npm-local' | 'dev' | 'bundled' | 'image' | 'homebrew' | 'other';
+export interface CliInstallDescriptor {
+    kind: CliInstallKind;
+    writable?: boolean;
+    npmPrefix?: string;
+}
 export interface CliUpdateAttempt {
     status: 'queued' | 'running' | 'succeeded' | 'failed';
     version: string;
@@ -10,6 +15,7 @@ export interface CliUpdateAttempt {
     message?: string;
     packageRoot?: string;
     npmPath?: string;
+    npmPrefix?: string;
     coordinationVersion?: number;
     workerPid?: number;
     interrupted?: boolean;
@@ -19,10 +25,7 @@ export interface CheckCache {
     latest: string | null;
     npmPackage: string | null;
     baseURL: string;
-    install?: {
-        kind: CliInstallKind;
-        writable?: boolean;
-    };
+    install?: CliInstallDescriptor;
     packageRoot?: string;
     npmGlobalRoot?: string | null;
     autoUpdate?: {
@@ -45,6 +48,7 @@ export interface CliUpdateStatus {
     installedVersion: string | null;
     offeredVersion: string | null;
     owner: CliInstallKind;
+    npmPrefix?: string;
     state: 'up-to-date' | 'update-available' | 'pending' | 'restart-pending' | 'failed' | 'managed' | 'unknown' | 'check-failed';
     autoUpdateAllowed: boolean;
     autoUpdateReason: string | null;
@@ -76,12 +80,9 @@ export declare function resolveCliPackageDir(argv?: readonly string[]): string |
  * dir beside `dist` exists only in a checkout — published packages ship
  * `dist` and no `src`.
  */
-export declare function classifyCliInstall(env: NodeJS.ProcessEnv, argv: readonly string[], npmGlobalRoot: string | null, probeWritable?: boolean): {
-    kind: CliInstallKind;
-    writable?: boolean;
-};
-export declare function cliUpdateCommand(owner: CliInstallKind): string;
-export declare function buildNudgeLine(currentVersion: string, latest: string | null, _npmPackage: string | null, installKind?: CliInstallKind): string | null;
+export declare function classifyCliInstall(env: NodeJS.ProcessEnv, argv: readonly string[], npmGlobalRoot: string | null, probeWritable?: boolean): CliInstallDescriptor;
+export declare function cliUpdateCommand(owner: CliInstallKind, npmPrefix?: string): string;
+export declare function buildNudgeLine(currentVersion: string, latest: string | null, _npmPackage: string | null, installKind?: CliInstallKind, npmPrefix?: string): string | null;
 export type CliUpdateAction = {
     type: 'nudge';
     line: string;

package/dist/lib/update-check.js

@@ -207,6 +207,20 @@ function classifyCliInstall(env, argv, npmGlobalRoot, probeWritable = true) {
         return { kind: 'other' };
     }
     const nodeModulesDir = path.dirname(path.dirname(packageDir)); // …/node_modules
+    const npmPrefix = process.platform !== 'win32' && path.basename(path.dirname(nodeModulesDir)) === 'lib'
+        ? path.dirname(path.dirname(nodeModulesDir)) : undefined;
+    // npm's current default may differ from the prefix that installed this
+    // executable. A project directory named `lib` is insufficient evidence:
+    // the prefix's public bin must resolve to this exact installed entry.
+    let linkedGlobalPrefix = false;
+    if (npmPrefix) {
+        try {
+            linkedGlobalPrefix = !fs.existsSync(path.join(npmPrefix, 'package.json')) &&
+                fs.realpathSync(path.join(npmPrefix, 'bin', 'skrr')) ===
+                    fs.realpathSync(path.join(packageDir, 'bin', 'run.js'));
+        }
+        catch { /* no executable ownership proof */ }
+    }
     if (npmGlobalRoot) {
         let resolvedGlobal = npmGlobalRoot;
         try {
@@ -222,15 +236,13 @@ function classifyCliInstall(env, argv, npmGlobalRoot, probeWritable = true) {
         catch {
             /* compare the raw form */
         }
-        if (resolvedNodeModules !== resolvedGlobal)
+        if (resolvedNodeModules !== resolvedGlobal && !linkedGlobalPrefix)
             return { kind: 'npm-local' };
     }
-    else if (!/[/\\](lib|npm)[/\\]node_modules$/.test(nodeModulesDir)) {
+    else if (!linkedGlobalPrefix) {
         // `npm root -g` gave no answer, so prove the global shape from the path
-        // instead: npm's unix global root is always `<prefix>/lib/node_modules`
-        // (incl. nvm/volta) and on Windows `%APPDATA%\npm\node_modules`. A
-        // project-local `<project>/node_modules` never matches either — without
-        // proof we must not treat it as ours to auto-update.
+        // and matching public executable instead. Without ownership proof we
+        // must not treat a project's dependency as ours to auto-update.
         return { kind: 'npm-local' };
     }
     let writable = false;
@@ -245,7 +257,7 @@ function classifyCliInstall(env, argv, npmGlobalRoot, probeWritable = true) {
             /* read-only */
         }
     }
-    return { kind: 'npm-global', writable };
+    return { kind: 'npm-global', writable, ...(npmPrefix ? { npmPrefix } : {}) };
 }
 /**
  * Resolve `npm root -g` for install classification. Runs ONLY inside the
@@ -269,12 +281,14 @@ async function resolveNpmGlobalRoot(env = process.env) {
         return null;
     }
 }
-function cliUpdateCommand(owner) {
+function cliUpdateCommand(owner, npmPrefix) {
     switch (owner) {
         case 'npm-global':
-            return `npm install -g ${CLI_PACKAGE}@latest`;
+            return npmPrefix
+                ? `npm install --global --prefix '${npmPrefix.replace(/'/g, "'\\''")}' ${CLI_PACKAGE}@latest`
+                : `npm install -g ${CLI_PACKAGE}@latest`;
         case 'npm-local':
-            return `npm update ${CLI_PACKAGE}`;
+            return `Use npm in the project that owns ${CLI_PACKAGE}`;
         case 'dev':
             return 'npm --prefix cli run build';
         case 'bundled':
@@ -287,16 +301,18 @@ function cliUpdateCommand(owner) {
             return 'Update via your install method — see https://skrr.ai';
     }
 }
-function buildNudgeLine(currentVersion, latest, _npmPackage, installKind = 'npm-global') {
+function buildNudgeLine(currentVersion, latest, _npmPackage, installKind = 'npm-global', npmPrefix) {
     if (!latest || !isOlderVersion(currentVersion, latest))
         return null;
-    const command = installKind === 'npm-global' ? `npm update -g ${CLI_PACKAGE}` : cliUpdateCommand(installKind);
-    const context = installKind === 'npm-local'
-        ? ' in the owning project'
-        : installKind === 'dev'
-            ? ' to rebuild your checkout'
-            : '';
-    return `[skrr] Update available: ${currentVersion} → ${latest}. Run \`${command}\`${context}. Silence with OVERSKY_NO_UPDATE_NUDGE=1.\n`;
+    const command = installKind === 'npm-global' && !npmPrefix
+        ? `npm update -g ${CLI_PACKAGE}` : cliUpdateCommand(installKind, npmPrefix);
+    const context = installKind === 'dev'
+        ? ' to rebuild your checkout'
+        : '';
+    const advice = installKind === 'npm-local'
+        ? `Update ${CLI_PACKAGE} using the project that owns ${CLI_PACKAGE}.`
+        : `Run \`${command}\`${context}.`;
+    return `[skrr] Update available: ${currentVersion} → ${latest}. ${advice} Silence with OVERSKY_NO_UPDATE_NUDGE=1.\n`;
 }
 function decideCliUpdateAction(args) {
     const { currentVersion, cache, env, isTTY } = args;
@@ -327,10 +343,10 @@ function decideCliUpdateAction(args) {
         if (attempt?.status === 'failed')
             return {
                 type: 'nudge',
-                line: `[skrr] CLI update to ${cache.latest} failed. Inspect \`skrr update --status\` or run \`${cliUpdateCommand(install.kind)}\`.\n`,
+                line: `[skrr] CLI update to ${cache.latest} failed. Inspect \`skrr update --status\` or run \`${cliUpdateCommand(install.kind, install.npmPrefix)}\`.\n`,
             };
     }
-    const line = buildNudgeLine(currentVersion, cache.latest, CLI_PACKAGE, install.kind);
+    const line = buildNudgeLine(currentVersion, cache.latest, CLI_PACKAGE, install.kind, install.npmPrefix);
     return line ? { type: 'nudge', line } : null;
 }
 function readCache(env = process.env) {
@@ -462,10 +478,11 @@ function readCliUpdateStatus(opts) {
         installedVersion,
         offeredVersion,
         owner: install.kind,
+        ...(install.npmPrefix ? { npmPrefix: install.npmPrefix } : {}),
         state,
         autoUpdateAllowed: autoUpdateReason === null,
         autoUpdateReason,
-        command: cliUpdateCommand(install.kind),
+        command: cliUpdateCommand(install.kind, install.npmPrefix),
         lastCheckAt: matchingCache?.lastCheckAt ?? null,
         lastAttempt,
         logPath: path.join(directory, 'update.log'),
@@ -591,7 +608,7 @@ async function performCliUpdate(opts) {
         env.SKRR_CLI_UPDATE_SESSION_UNAVAILABLE === '1') {
         return {
             ...status,
-            message: `This CLI is owned by ${install.kind}${install.kind === 'npm-global' ? ' in a shared or external prefix' : ''}. ${cliUpdateCommand(install.kind)}.`,
+            message: `This CLI is owned by ${install.kind}${install.kind === 'npm-global' ? ' in a shared or external prefix' : ''}. ${cliUpdateCommand(install.kind, install.npmPrefix)}.`,
         };
     }
     const recoverableAttempt = status.lastAttempt && ['queued', 'running'].includes(status.lastAttempt.status);
@@ -620,6 +637,7 @@ async function performCliUpdate(opts) {
                 attemptedAt: Date.now(),
                 packageRoot: packageRoot(argv),
                 npmPath,
+                ...(install.npmPrefix ? { npmPrefix: install.npmPrefix } : {}),
                 coordinationVersion: api.COORDINATION_VERSION,
                 message: 'Waiting for active CLI sessions to exit; the next invocation uses the new version.',
             });
@@ -649,7 +667,7 @@ async function maybeWarnOutdatedCli(opts) {
             currentVersion: opts.currentVersion,
             cache: {
                 ...cache,
-                install: { kind: status.owner, writable: status.autoUpdateAllowed },
+                install: { kind: status.owner, writable: status.autoUpdateAllowed, npmPrefix: status.npmPrefix },
                 autoUpdate: status.lastAttempt
                     ? {
                         attemptedAt: status.lastAttempt.attemptedAt,