@skrr-ai/cli 0.1.43 → 0.1.44

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/firstPartyHarness.d.ts

@@ -213,7 +213,8 @@ export declare function firstPartyHarnessBinaryNames(platform?: string): readonl
  * the managed `AGENTS.md` from `<home>`. Deriving it from the provider would, on
  * a fresh install after a provider rename, create a second directory the engine
  * never reads — managed instructions would stop applying with no error. It moves
- * when the engine's namespace moves, and not before.
+ * when the engine's namespace moves, and not before; it did in OSK-8674, and
+ * `migrateFirstPartyHarnessHome` moves a home under a legacy name onto it.
  */
 export declare function firstPartyHarnessHomeDirname(): string;
 /** Signed release manifest file name. */
@@ -250,7 +251,8 @@ export interface FirstPartyHarnessEnvName {
  * (OSK-8663) and are not read at all now. The ENGINE's own variables are a
  * different namespace (`FIRST_PARTY_HARNESS_ENGINE.env`): the fork reads them,
  * so a platform reader that must agree with the engine consults the engine's
- * name explicitly — the engine home is the one case (`home` below).
+ * names explicitly (`readFirstPartyHarnessEngineEnv`) — the engine home is the
+ * one case (`home` below).
  */
 export declare const FIRST_PARTY_HARNESS_ENV: Readonly<{
     /** Absolute path to an engine binary, overriding resolution. */
@@ -266,10 +268,11 @@ export declare const FIRST_PARTY_HARNESS_ENV: Readonly<{
     /** Engine version the desktop build bundles. */
     bundleVersion: FirstPartyHarnessEnvName;
     /**
-     * Engine home override. The engine reads only its own variable
-     * (`FIRST_PARTY_HARNESS_ENGINE.env.home`), so a reader that resolves the home
-     * the engine will use reads that one second, and a launcher hands the engine
-     * the resolved path under it.
+     * Engine home override. The engine reads only its own variable, under every
+     * name it has had (`readFirstPartyHarnessEngineEnv(env, 'home')`), so a reader
+     * that resolves the home the engine will use reads those second, and a
+     * launcher hands the engine the resolved path under every one of them
+     * (`firstPartyHarnessEngineEnvEntries`).
      */
     home: FirstPartyHarnessEnvName;
     /** Engine version baked into the cloud-coding image. */
@@ -294,36 +297,84 @@ export interface FirstPartyHarnessEnvReading {
 }
 /** Read one purpose's variable. A blank value counts as unset. */
 export declare function readFirstPartyHarnessEnv(env: Readonly<Record<string, string | undefined>>, key: FirstPartyHarnessEnvKey): FirstPartyHarnessEnvReading;
+/**
+ * Every variable the engine reads, by purpose, as the suffix after the app
+ * name's prefix (`skrr-code` → `SKRR_CODE_<suffix>`). The fork names all of its
+ * own variables this way, so the names follow the namespace rather than being
+ * written out once per spelling.
+ */
+declare const ENGINE_ENV_SUFFIXES: Readonly<{
+    serverPassword: "SERVER_PASSWORD";
+    serverUsername: "SERVER_USERNAME";
+    home: "HOME";
+    config: "CONFIG";
+    appName: "APP_NAME";
+    scriptName: "SCRIPT_NAME";
+    allowUpstreamEgress: "ALLOW_UPSTREAM_EGRESS";
+    compatOpencode: "COMPAT_OPENCODE";
+    noCompatPrompts: "NO_COMPAT_PROMPTS";
+}>;
+export type FirstPartyHarnessEngineEnvKey = keyof typeof ENGINE_ENV_SUFFIXES;
 /**
  * Names the ENGINE itself defines and reads. The platform sets or reads them
  * across the daemon↔engine boundary, so they are recorded here as values rather
- * than scattered as literals — but they are the fork's to change, and moving
- * one is a two-sided change (contract §6). Not part of this identity's rename.
+ * than scattered as literals. They are the fork's names, and moving one is a
+ * two-sided change: the engine reads the new name first and every legacy name
+ * second, and while engine and platform releases can arrive in either order the
+ * platform SETS every name and READS new-then-legacy (contract §6, OSK-8674).
  */
 export declare const FIRST_PARTY_HARNESS_ENGINE: Readonly<{
     /**
      * The engine's state namespace: XDG dirs, project marker, config basename, and
      * the engine home under the skrr root (`firstPartyHarnessHomeDirname`).
      */
-    appName: "sky-code";
+    appName: string;
     /**
-     * Earlier `appName`s whose home directory `migrateFirstPartyHarnessHome` moves
-     * onto the current one. Empty until the engine's namespace is renamed.
+     * Earlier `appName`s, newest first. `migrateFirstPartyHarnessHome` moves a home
+     * under one of them onto the current name and leaves a symlink; readers of
+     * engine state look under them after the current name.
      */
     legacyAppNames: readonly string[];
     /** Project-local configuration directory inside a user's repository. */
-    projectDirectory: ".sky-code";
-    /** Environment variables the engine reads. */
-    env: Readonly<{
-        serverPassword: "SKY_CODE_SERVER_PASSWORD";
-        serverUsername: "SKY_CODE_SERVER_USERNAME";
-        home: "SKY_CODE_HOME";
-        config: "SKY_CODE_CONFIG";
-        appName: "SKY_CODE_APP_NAME";
-        scriptName: "SKY_CODE_SCRIPT_NAME";
-        allowUpstreamEgress: "SKY_CODE_ALLOW_UPSTREAM_EGRESS";
-        compatOpencode: "SKY_CODE_COMPAT_OPENCODE";
-        noCompatPrompts: "SKY_CODE_NO_COMPAT_PROMPTS";
-    }>;
+    projectDirectory: `.${string}`;
+    /**
+     * Earlier project directories, newest first. The engine still reads them and
+     * the platform never rewrites a user's repository to move one, so a reader
+     * looks here after `projectDirectory`, and a writer adopts an existing file
+     * here rather than creating a second one beside it.
+     */
+    legacyProjectDirectories: readonly string[];
+    /**
+     * Environment variables the engine reads, under the CURRENT namespace. The
+     * engine also reads each one under every legacy namespace, second — use
+     * `readFirstPartyHarnessEngineEnv` to read one the way the engine does and
+     * `firstPartyHarnessEngineEnvEntries` to set one every engine build honours.
+     */
+    env: Readonly<Record<"appName" | "serverPassword" | "serverUsername" | "home" | "config" | "scriptName" | "allowUpstreamEgress" | "compatOpencode" | "noCompatPrompts", string>>;
 }>;
+/**
+ * Every name the engine reads for one purpose, current namespace first — the
+ * engine's own lookup order.
+ */
+export declare function firstPartyHarnessEngineEnvNames(key: FirstPartyHarnessEngineEnvKey): readonly string[];
+/**
+ * Read one engine variable the way the engine reads it: the current name, then
+ * every legacy name. A blank value counts as unset.
+ */
+export declare function readFirstPartyHarnessEngineEnv(env: Readonly<Record<string, string | undefined>>, key: FirstPartyHarnessEngineEnvKey): FirstPartyHarnessEnvReading;
+/**
+ * One engine variable set under EVERY name the engine has read, for a process
+ * that spawns the engine. An engine binary is installed on its own schedule, so
+ * a launcher cannot know whether the one it starts reads the current name or a
+ * legacy one; setting both means either build receives the value.
+ */
+export declare function firstPartyHarnessEngineEnvEntries(key: FirstPartyHarnessEngineEnvKey, value: string): Record<string, string>;
+/** Every engine project directory, current first — the engine's read order. */
+export declare function firstPartyHarnessEngineProjectDirectories(): readonly string[];
+/**
+ * Every engine home directory name under a config root, current first: where an
+ * engine home may exist on disk. `firstPartyHarnessHomeDirname` is the one the
+ * platform writes.
+ */
+export declare function firstPartyHarnessEngineHomeDirnames(): readonly string[];
 export {};

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/firstPartyHarness.js

@@ -290,7 +290,8 @@ export function firstPartyHarnessBinaryNames(platform) {
  * the managed `AGENTS.md` from `<home>`. Deriving it from the provider would, on
  * a fresh install after a provider rename, create a second directory the engine
  * never reads — managed instructions would stop applying with no error. It moves
- * when the engine's namespace moves, and not before.
+ * when the engine's namespace moves, and not before; it did in OSK-8674, and
+ * `migrateFirstPartyHarnessHome` moves a home under a legacy name onto it.
  */
 export function firstPartyHarnessHomeDirname() {
     return FIRST_PARTY_HARNESS_ENGINE.appName;
@@ -338,7 +339,8 @@ function envName(name) {
  * (OSK-8663) and are not read at all now. The ENGINE's own variables are a
  * different namespace (`FIRST_PARTY_HARNESS_ENGINE.env`): the fork reads them,
  * so a platform reader that must agree with the engine consults the engine's
- * name explicitly — the engine home is the one case (`home` below).
+ * names explicitly (`readFirstPartyHarnessEngineEnv`) — the engine home is the
+ * one case (`home` below).
  */
 export const FIRST_PARTY_HARNESS_ENV = Object.freeze({
     /** Absolute path to an engine binary, overriding resolution. */
@@ -354,10 +356,11 @@ export const FIRST_PARTY_HARNESS_ENV = Object.freeze({
     /** Engine version the desktop build bundles. */
     bundleVersion: envName('SKRR_FIRST_PARTY_HARNESS_BUNDLE_VERSION'),
     /**
-     * Engine home override. The engine reads only its own variable
-     * (`FIRST_PARTY_HARNESS_ENGINE.env.home`), so a reader that resolves the home
-     * the engine will use reads that one second, and a launcher hands the engine
-     * the resolved path under it.
+     * Engine home override. The engine reads only its own variable, under every
+     * name it has had (`readFirstPartyHarnessEngineEnv(env, 'home')`), so a reader
+     * that resolves the home the engine will use reads those second, and a
+     * launcher hands the engine the resolved path under every one of them
+     * (`firstPartyHarnessEngineEnvEntries`).
      */
     home: envName('SKRR_FIRST_PARTY_HARNESS_HOME'),
     /** Engine version baked into the cloud-coding image. */
@@ -383,35 +386,136 @@ export function readFirstPartyHarnessEnv(env, key) {
     return { value: undefined, name: undefined };
 }
 /* ── The ENGINE's own namespace (defined inside the fork) ───────────────── */
+/**
+ * The engine's state namespace today. Moved from `sky-code` by OSK-8674: XDG
+ * dirs, project directory, config basename, the engine home under the skrr
+ * root, and every variable the engine reads all derive from it.
+ */
+const ENGINE_APP_NAME = 'skrr-code';
+/**
+ * Earlier engine namespaces, newest first. Still READ on both sides of the
+ * daemon↔engine boundary: an engine binary, a daemon, a CLI and a desktop app
+ * each ship on their own schedule, and a machine holds state written under
+ * every name it has run.
+ */
+const ENGINE_LEGACY_APP_NAMES = ['sky-code'];
+/**
+ * Every variable the engine reads, by purpose, as the suffix after the app
+ * name's prefix (`skrr-code` → `SKRR_CODE_<suffix>`). The fork names all of its
+ * own variables this way, so the names follow the namespace rather than being
+ * written out once per spelling.
+ */
+const ENGINE_ENV_SUFFIXES = Object.freeze({
+    serverPassword: 'SERVER_PASSWORD',
+    serverUsername: 'SERVER_USERNAME',
+    home: 'HOME',
+    config: 'CONFIG',
+    appName: 'APP_NAME',
+    scriptName: 'SCRIPT_NAME',
+    allowUpstreamEgress: 'ALLOW_UPSTREAM_EGRESS',
+    compatOpencode: 'COMPAT_OPENCODE',
+    noCompatPrompts: 'NO_COMPAT_PROMPTS',
+});
+function engineEnvName(appName, key) {
+    return `${appName.toUpperCase().replace(/-/g, '_')}_${ENGINE_ENV_SUFFIXES[key]}`;
+}
+function engineEnvTable(appName) {
+    return Object.freeze(Object.fromEntries(Object.keys(ENGINE_ENV_SUFFIXES).map((key) => [
+        key,
+        engineEnvName(appName, key),
+    ])));
+}
+function defineEngineNamespace(appName, legacyAppNames) {
+    const every = [appName, ...legacyAppNames];
+    for (const name of every) {
+        if (!SLUG.test(name)) {
+            throw new Error(`first-party harness engine app name ${JSON.stringify(name)} is not a slug; it becomes a ` +
+                'directory name and a variable prefix');
+        }
+    }
+    if (new Set(every).size !== every.length) {
+        throw new Error('first-party harness engine appName and legacyAppNames must be distinct');
+    }
+    return Object.freeze({
+        /**
+         * The engine's state namespace: XDG dirs, project marker, config basename, and
+         * the engine home under the skrr root (`firstPartyHarnessHomeDirname`).
+         */
+        appName,
+        /**
+         * Earlier `appName`s, newest first. `migrateFirstPartyHarnessHome` moves a home
+         * under one of them onto the current name and leaves a symlink; readers of
+         * engine state look under them after the current name.
+         */
+        legacyAppNames: Object.freeze([...legacyAppNames]),
+        /** Project-local configuration directory inside a user's repository. */
+        projectDirectory: `.${appName}`,
+        /**
+         * Earlier project directories, newest first. The engine still reads them and
+         * the platform never rewrites a user's repository to move one, so a reader
+         * looks here after `projectDirectory`, and a writer adopts an existing file
+         * here rather than creating a second one beside it.
+         */
+        legacyProjectDirectories: Object.freeze(legacyAppNames.map((name) => `.${name}`)),
+        /**
+         * Environment variables the engine reads, under the CURRENT namespace. The
+         * engine also reads each one under every legacy namespace, second — use
+         * `readFirstPartyHarnessEngineEnv` to read one the way the engine does and
+         * `firstPartyHarnessEngineEnvEntries` to set one every engine build honours.
+         */
+        env: engineEnvTable(appName),
+    });
+}
 /**
  * Names the ENGINE itself defines and reads. The platform sets or reads them
  * across the daemon↔engine boundary, so they are recorded here as values rather
- * than scattered as literals — but they are the fork's to change, and moving
- * one is a two-sided change (contract §6). Not part of this identity's rename.
+ * than scattered as literals. They are the fork's names, and moving one is a
+ * two-sided change: the engine reads the new name first and every legacy name
+ * second, and while engine and platform releases can arrive in either order the
+ * platform SETS every name and READS new-then-legacy (contract §6, OSK-8674).
  */
-export const FIRST_PARTY_HARNESS_ENGINE = Object.freeze({
-    /**
-     * The engine's state namespace: XDG dirs, project marker, config basename, and
-     * the engine home under the skrr root (`firstPartyHarnessHomeDirname`).
-     */
-    appName: 'sky-code',
-    /**
-     * Earlier `appName`s whose home directory `migrateFirstPartyHarnessHome` moves
-     * onto the current one. Empty until the engine's namespace is renamed.
-     */
-    legacyAppNames: Object.freeze([]),
-    /** Project-local configuration directory inside a user's repository. */
-    projectDirectory: '.sky-code',
-    /** Environment variables the engine reads. */
-    env: Object.freeze({
-        serverPassword: 'SKY_CODE_SERVER_PASSWORD',
-        serverUsername: 'SKY_CODE_SERVER_USERNAME',
-        home: 'SKY_CODE_HOME',
-        config: 'SKY_CODE_CONFIG',
-        appName: 'SKY_CODE_APP_NAME',
-        scriptName: 'SKY_CODE_SCRIPT_NAME',
-        allowUpstreamEgress: 'SKY_CODE_ALLOW_UPSTREAM_EGRESS',
-        compatOpencode: 'SKY_CODE_COMPAT_OPENCODE',
-        noCompatPrompts: 'SKY_CODE_NO_COMPAT_PROMPTS',
-    }),
-});
+export const FIRST_PARTY_HARNESS_ENGINE = defineEngineNamespace(ENGINE_APP_NAME, ENGINE_LEGACY_APP_NAMES);
+/**
+ * Every name the engine reads for one purpose, current namespace first — the
+ * engine's own lookup order.
+ */
+export function firstPartyHarnessEngineEnvNames(key) {
+    return [FIRST_PARTY_HARNESS_ENGINE.appName, ...FIRST_PARTY_HARNESS_ENGINE.legacyAppNames].map((appName) => engineEnvName(appName, key));
+}
+/**
+ * Read one engine variable the way the engine reads it: the current name, then
+ * every legacy name. A blank value counts as unset.
+ */
+export function readFirstPartyHarnessEngineEnv(env, key) {
+    for (const name of firstPartyHarnessEngineEnvNames(key)) {
+        const raw = env[name];
+        if (typeof raw === 'string' && raw.trim() !== '') {
+            return { value: raw.trim(), name };
+        }
+    }
+    return { value: undefined, name: undefined };
+}
+/**
+ * One engine variable set under EVERY name the engine has read, for a process
+ * that spawns the engine. An engine binary is installed on its own schedule, so
+ * a launcher cannot know whether the one it starts reads the current name or a
+ * legacy one; setting both means either build receives the value.
+ */
+export function firstPartyHarnessEngineEnvEntries(key, value) {
+    return Object.fromEntries(firstPartyHarnessEngineEnvNames(key).map((name) => [name, value]));
+}
+/** Every engine project directory, current first — the engine's read order. */
+export function firstPartyHarnessEngineProjectDirectories() {
+    return [
+        FIRST_PARTY_HARNESS_ENGINE.projectDirectory,
+        ...FIRST_PARTY_HARNESS_ENGINE.legacyProjectDirectories,
+    ];
+}
+/**
+ * Every engine home directory name under a config root, current first: where an
+ * engine home may exist on disk. `firstPartyHarnessHomeDirname` is the one the
+ * platform writes.
+ */
+export function firstPartyHarnessEngineHomeDirnames() {
+    return [FIRST_PARTY_HARNESS_ENGINE.appName, ...FIRST_PARTY_HARNESS_ENGINE.legacyAppNames];
+}

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/legacyStatePreflight.d.ts

@@ -55,4 +55,24 @@ export interface LegacyStateReport {
  * real `~` passes or fails based on who runs it.
  */
 export declare function findLegacyLocalState(home?: string): LegacyStateReport;
-export declare function describeLegacyState(report: LegacyStateReport, binaryName: string): string;
+/**
+ * Where the full procedure lives, by repository path. The refusal used to say
+ * "follow the team cutover runbook" without naming one, which stopped a person
+ * at a pointer they could not follow (OSK-6895). The steps the refusal prints
+ * are the runbook's own, so the path is for the parts a terminal message cannot
+ * carry: Linux and Windows service removal, Keychain entries, the old app.
+ */
+export declare const LEGACY_CUTOVER_RUNBOOK = "docs/runbooks/skrr-cutover-dev-machine.md";
+/**
+ * The message shown when preflight refuses.
+ *
+ * Written for someone who has just been stopped and wants to know why and what
+ * to do — so it names the exact paths, says explicitly that nothing was touched,
+ * and prints the cutover as commands to run rather than a pointer to follow. It
+ * does NOT offer a `--force`: the operator's next step is the backup, and a flag
+ * that skips a safety check is the flag everyone learns to paste.
+ *
+ * `command` is what the operator re-runs to install — `skrrd` when the runtime
+ * refused, `skrr daemon` when the CLI refused before fetching one.
+ */
+export declare function describeLegacyState(report: LegacyStateReport, command: string, platform?: NodeJS.Platform): string;

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/legacyStatePreflight.js

@@ -43,22 +43,69 @@ export function findLegacyLocalState(home = os.homedir()) {
     return { findings, hasLegacyState: findings.length > 0 };
 }
 /**
- * The message shown when preflight refuses.
- *
- * Written for someone who has just been stopped and wants to know why and what
- * to do — so it names the exact paths, says explicitly that nothing was touched,
- * and points at the runbook rather than improvising a fix. It does NOT offer a
- * `--force`: the operator's next step is the backup the runbook specifies, and
- * a flag that skips a safety check is the flag everyone learns to paste.
- */
-/**
- * The pre-rename runtime binary. Named in the refusal above because deregistering
+ * The pre-rename runtime binary. Named in the refusal below because deregistering
  * the OLD service is the one step the NEW binary cannot do: `uninstall` resolves
  * the current profile's label (`ai.skrr.daemon.*`), and the legacy sweep is wired
  * only into the install path.
  */
 const LEGACY_BINARY_NAME = 'oversky';
-export function describeLegacyState(report, binaryName) {
+/**
+ * Where the full procedure lives, by repository path. The refusal used to say
+ * "follow the team cutover runbook" without naming one, which stopped a person
+ * at a pointer they could not follow (OSK-6895). The steps the refusal prints
+ * are the runbook's own, so the path is for the parts a terminal message cannot
+ * carry: Linux and Windows service removal, Keychain entries, the old app.
+ */
+export const LEGACY_CUTOVER_RUNBOOK = 'docs/runbooks/skrr-cutover-dev-machine.md';
+/** Credential file patterns the runbook strips from its backup (§5.5). */
+const BACKUP_CREDENTIAL_PATTERNS = ['auth.json', 'cli-auth.json', '*token*'];
+function posixQuote(value) {
+    return `'${value.split("'").join(`'\\''`)}'`;
+}
+function powershellQuote(value) {
+    return `'${value.split("'").join("''")}'`;
+}
+/**
+ * The commands for the three steps a person runs by hand, in the shell they are
+ * actually in. A POSIX `rm -rf` pasted into PowerShell is not an instruction.
+ */
+function cutoverCommands(paths, platform) {
+    if (platform === 'win32') {
+        const backupDir = '"$HOME\\skrr-cutover-backup"';
+        return {
+            backup: [
+                `New-Item -ItemType Directory -Force ${backupDir} | Out-Null`,
+                ...paths.map((p) => `Copy-Item -Recurse ${powershellQuote(p)} ${backupDir}`),
+                `Get-ChildItem -Recurse -File ${backupDir} -Include ${BACKUP_CREDENTIAL_PATTERNS.join(',')} | Remove-Item`,
+            ],
+            remove: paths.map((p) => `Remove-Item -Recurse -Force ${powershellQuote(p)}`),
+        };
+    }
+    const names = BACKUP_CREDENTIAL_PATTERNS.map((n) => `-name '${n}'`).join(' -o ');
+    return {
+        backup: [
+            'mkdir -p ~/skrr-cutover-backup && chmod 700 ~/skrr-cutover-backup',
+            `cp -a ${paths.map(posixQuote).join(' ')} ~/skrr-cutover-backup/`,
+            `find ~/skrr-cutover-backup -type f \\( ${names} \\) -delete`,
+        ],
+        remove: [`rm -rf ${paths.map(posixQuote).join(' ')}`],
+    };
+}
+/**
+ * The message shown when preflight refuses.
+ *
+ * Written for someone who has just been stopped and wants to know why and what
+ * to do — so it names the exact paths, says explicitly that nothing was touched,
+ * and prints the cutover as commands to run rather than a pointer to follow. It
+ * does NOT offer a `--force`: the operator's next step is the backup, and a flag
+ * that skips a safety check is the flag everyone learns to paste.
+ *
+ * `command` is what the operator re-runs to install — `skrrd` when the runtime
+ * refused, `skrr daemon` when the CLI refused before fetching one.
+ */
+export function describeLegacyState(report, command, platform = process.platform) {
+    const paths = report.findings.map((f) => f.path);
+    const { backup, remove } = cutoverCommands(paths, platform);
     const lines = [];
     lines.push('Found state from the previous product identity on this machine:');
     lines.push('');
@@ -69,20 +116,28 @@ export function describeLegacyState(report, binaryName) {
     lines.push('Installing beside it risks two runtimes holding two different service');
     lines.push('labels, each believing it owns the single-instance lock.');
     lines.push('');
-    lines.push('Nothing above has been read, copied or removed. Follow the team cutover');
-    lines.push('runbook — it takes a backup first — and then run this again:');
+    lines.push('Nothing above has been read, copied or removed, and no service was registered.');
+    lines.push('To finish the cutover:');
     lines.push('');
+    lines.push('  1. Keep a copy, with its credentials removed, in case you need an old setting:');
+    for (const line of backup)
+        lines.push(`       ${line}`);
     // The OLD binary, deliberately: it is the one that knows the old service
     // label. `<current> uninstall` resolves the CURRENT profile's label and would
     // report success while leaving the pre-rename service registered. Guarded by
     // "only if" rather than omitted, because this module inspects directories and
     // has no way to know whether that binary is still on PATH.
-    lines.push(`  ${LEGACY_BINARY_NAME} uninstall     # only if the old runtime is still installed —`);
-    lines.push(`                        # it is the one that knows the old service label`);
-    lines.push('  # then remove the directories listed above, per the runbook');
+    lines.push('  2. If the old runtime is still installed, deregister it with the old binary —');
+    lines.push('     it is the one that knows the old service label:');
+    lines.push(`       ${LEGACY_BINARY_NAME} uninstall`);
+    lines.push('  3. Remove the directories listed above:');
+    for (const line of remove)
+        lines.push(`       ${line}`);
+    lines.push('  4. Run this again:');
+    lines.push(`       ${command} install`);
     lines.push('');
-    lines.push(`Any pre-rename service still registered is swept by \`${binaryName} install\``);
-    lines.push('once those directories are gone, so re-running the install completes the');
-    lines.push('cutover either way.');
+    lines.push(`Any pre-rename service still registered is swept by \`${command} install\``);
+    lines.push('once those directories are gone, so step 4 completes the cutover either way.');
+    lines.push(`Full runbook, including Keychain entries and the old app: ${LEGACY_CUTOVER_RUNBOOK}`);
     return lines.join('\n');
 }

package/dist/node_modules/@skrr-ai/auth-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skrr-ai/auth-core",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "main": "dist/cjs/index.js",
   "types": "dist/esm/index.d.ts",
   "exports": {