blun-king-cli 9.1.616 → 9.1.618

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # BLUN King Changelog
 
+## 9.1.618
+
+- Trifft eine Telegram-Nachricht beim Fortsetzen deiner Sitzung auf laufende Arbeit, bleibt sie in der Warteschlange und wird danach zugestellt. King zeigt dafür keine irreführende Meldung mehr an, dass bereits ein Zug läuft.
+- Unter Linux x64 nutzt das Terminal eine mitgelieferte Binärdatei. Es funktioniert damit auch, wenn npm 12 Installationsskripte sperrt; ein Compiler ist dafür nicht nötig.
+
+## 9.1.617
+
+King wartet beim Beenden auch auf Ereignisse, die beim Aufräumen laufender Arbeiten entstehen. Noch nicht abgeschlossene Arbeit wird nicht als beendet bestätigt.
+
 ## 9.1.616
 
 - Nach einer bestätigten Telegram-Antwort übernimmt King weitere an dich adressierte Nachrichten am nächsten sicheren Schritt, auch während eines laufenden Zugs. Eine bereits zugestellte Antwort hält die Warteschlange nicht mehr auf. Antworten bleiben ihrem jeweiligen Chat zugeordnet.

package/LIESMICH.txt

@@ -26,7 +26,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.616
+  npm install -g blun-king-cli@9.1.618
 
 Start
 -----

package/README.md

@@ -9,7 +9,7 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.616
+npm install -g blun-king-cli@9.1.618
 ```
 
 ### Windows: Node.js, npm und Git Bash

package/bin/core-bootstrap.js

@@ -4,7 +4,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { pathToFileURL } = require('node:url');
 
-const { acquireSharedRuntimeLease } = require('./update-lease');
+const { acquireSharedRuntimeLease, tryAcquireUpdateLease } = require('./update-lease');
 const { installWindowsNodeCrashDump } = require('./windows-node-crash-dump.cjs');
 const { recordRuntimeExit } = require('./runtime-exit-ledger.cjs');
 const { isStandaloneHelpRequest } = require('./launcher-mode');
@@ -19,15 +19,25 @@ async function runCoreBootstrap() {
   }
   const packageRoot = path.resolve(__dirname, '..');
   const mainPath = path.join(packageRoot, 'blun.mjs');
-  let leaseResult;
+  let leaseResult;
+  let profileLease;
 
   try {
     leaseResult = await acquireSharedRuntimeLease({ packageRoot });
     if (!leaseResult.acquired) throw new Error('RUNTIME_PROTECTION_UNAVAILABLE');
-    leaseResult.lease.assertOwned();
+    leaseResult.lease.assertOwned();
+    if (process.env.BLUN_PROFILE_HANDOFF === '1') {
+      if (!path.isAbsolute(process.env.BLUN_HOME || '')) throw new Error('PROFILE_RUNTIME_UNAVAILABLE');
+      const result = await tryAcquireUpdateLease({ packageRoot: process.env.BLUN_HOME, role: 'profile' });
+      if (!result.acquired) throw Object.assign(new Error(`PROFILE_RUNTIME_${result.reason.toUpperCase()}`),
+        { code: result.reason === 'busy' ? 'PROFILE_RUNTIME_BUSY' : 'PROFILE_RUNTIME_UNAVAILABLE' });
+      profileLease = result.lease;
+      profileLease.assertOwned();
+    }
     process.argv = [process.execPath, mainPath, ...process.argv.slice(2)];
     await import(pathToFileURL(mainPath).href);
-    leaseResult.lease.assertOwned();
+    leaseResult.lease.assertOwned();
+    profileLease?.assertOwned();
   } catch (error) {
     if (!informational) {
       try {
@@ -36,7 +46,8 @@ async function runCoreBootstrap() {
           kind: 'bootstrap-failure', phase: 'startup', error });
       } catch {}
     }
-    try { diagnostics?.dispose(); } catch {}
+    try { diagnostics?.dispose(); } catch {}
+    try { await profileLease?.release(); } catch {}
     try { await leaseResult?.lease?.release(); }
     catch (leaseError) {
       if (!informational) {
@@ -52,11 +63,16 @@ async function runCoreBootstrap() {
   // The bundled CLI loads package assets lazily after module evaluation. Keep
   // the install lease for this process's lifetime, without keeping print/help
   // commands alive solely because of the owner server.
-  leaseResult.lease.unref();
+  leaseResult.lease.unref();
+  profileLease?.unref();
 
   if (process.connected) {
     try {
-      process.send({ type: CORE_LOADED_MESSAGE }, () => {
+      process.send({ type: CORE_LOADED_MESSAGE }, () => {
+        if (process.env.BLUN_PROFILE_HANDOFF === '1') {
+          process.channel?.unref();
+          return;
+        }
         try {
           process.disconnect();
         } catch {}
@@ -70,7 +86,7 @@ if (require.main === module) {
   void runCoreBootstrap().catch((error) => {
     const message = error && error.message ? error.message : String(error);
     fs.writeSync(process.stderr.fd, `BLUN Start fehlgeschlagen: ${message}\n`);
-    process.exit(1);
+    process.exit(error?.code === 'PROFILE_RUNTIME_BUSY' ? 75 : 1);
   });
 }
 

package/bin/launcher-runtime.js

@@ -39,6 +39,7 @@ const {
   writePrivateFile,
 } = require('./private-paths');
 const { parseProfileLaunchArgs, resolveSelectedProfile } = require('./profile-launch.cjs');
+const { createProfileHandoff, PROFILE_HANDOFF_READY, PROFILE_HANDOFF_EXIT } = require('./profile-handoff.cjs');
 
 const PKG = path.resolve(__dirname, '..');
 const PROFILE = parseProfileLaunchArgs(process.argv.slice(2), launcherModeFromArgv(process.argv));
@@ -153,7 +154,7 @@ function shouldDetachProtectedCore(options = {}) {
   return platform !== 'win32' || stdinIsTTY !== true;
 }
 
-function spawnProtectedCore(args, env, cwd) {
+function spawnProtectedCore(args, env, cwd, onProfileMessage) {
   const child = spawn(
     process.execPath,
     [path.join(PKG, 'bin', 'core-bootstrap.js'), ...args],
@@ -167,7 +168,8 @@ function spawnProtectedCore(args, env, cwd) {
   );
   let loadedSettled = false;
   let completedSettled = false;
-  let operatorSignal;
+  let operatorSignal;
+  let profileReady = false;
   let resolveLoaded;
   let resolveCompleted;
   const loadTimer = setTimeout(() => {
@@ -201,16 +203,29 @@ function spawnProtectedCore(args, env, cwd) {
     signalHandlers.set(signal, handler);
     process.once(signal, handler);
   }
-  child.on('message', (message) => {
-    if (message?.type !== CORE_LOADED_MESSAGE) return;
-    settleLoaded(true);
-    try {
-      child.disconnect();
-    } catch {}
+  child.on('message', (message) => {
+    if (message?.type !== CORE_LOADED_MESSAGE) {
+      if (completedSettled || !onProfileMessage) return;
+      if (message?.type === PROFILE_HANDOFF_READY && Object.keys(message).length === 1) {
+        profileReady = true;
+        return;
+      }
+      if (!loadedSettled) return;
+      const reply = onProfileMessage(message);
+      if (reply) {
+        try { child.send(reply, () => {}); } catch {}
+      }
+      return;
+    }
+    settleLoaded(true);
+    if (onProfileMessage) child.channel?.unref();
+    else {
+      try { child.disconnect(); } catch {}
+    }
   });
   child.once('error', (error) => settleCompleted({ error }));
   child.once('exit', (code, signal) => settleCompleted({ code, signal }));
-  return { child, completed, loaded };
+  return { child, completed, loaded, isProfileReady: () => profileReady };
 }
 
 async function runInformationalCore(args, env, cwd, releaseNotice) {
@@ -222,10 +237,14 @@ async function runInformationalCore(args, env, cwd, releaseNotice) {
   return Number.isInteger(result.code) ? result.code : exitCodeForChild(result, false);
 }
 
-async function superviseProtectedCore(args, env, cwd, releaseNotice) {
-  let noticeReleased = false;
-  for (;;) {
-    const core = spawnProtectedCore(args, env, cwd);
+async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {}) {
+  let noticeReleased = false;
+  let rollback;
+  let recoveryAttempted = false;
+  for (;;) {
+    const handoff = options.prepareProfile
+      ? createProfileHandoff(env, target => runningTuiPid(target) !== null) : undefined;
+    const core = spawnProtectedCore(args, env, cwd, handoff && ((message) => handoff.prepare(message)));
     const loaded = await core.loaded;
     if (!noticeReleased) {
       noticeReleased = true;
@@ -236,12 +255,47 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice) {
     const intentionalStop = consumeIntentionalStopMarker({
       homeDir: env.BLUN_HOME, childPid: core.child.pid, nowMs: Date.now(),
     });
-    recordRuntimeExit({
+    recordRuntimeExit({
       homeDir: env.BLUN_HOME, source: 'launcher', kind: result.error ? 'child-error' : 'child-exit',
       exitCode, signal: result.signal, phase: loaded ? 'runtime' : 'startup',
       cliVersion: env.BLUN_PUBLIC_PACKAGE_VERSION, profile: env.BLUN_PROFILE,
-      loaded, childPid: core.child.pid, error: result.error,
-    });
+      loaded, childPid: core.child.pid, error: result.error,
+    });
+    // A profile transition is committed only after the old process exits cleanly.
+    // Failed target startup restores the previous owner, never the previous PID.
+    if (rollback && (!loaded || !core.isProfileReady()) && !result.signal) {
+      ({ args, env } = rollback);
+      rollback = undefined;
+      continue;
+    }
+    if (loaded && core.isProfileReady()) {
+      rollback = undefined;
+      recoveryAttempted = false;
+    }
+    if (handoff && loaded && !intentionalStop && !result.error && !result.signal
+      && result.code === PROFILE_HANDOFF_EXIT) {
+      if (!handoff.hasPending()) return 1;
+      const sourceSessionId = handoff.getSourceSessionId();
+      const recoveryArgs = sourceSessionId === undefined ? ['-c'] : ['-r', sourceSessionId];
+      try {
+        const selected = handoff.commit();
+        const nextEnv = await options.prepareProfile(selected);
+        handoff.commit();
+        rollback = { args: recoveryArgs, env };
+        args = ['-c'];
+        env = { ...nextEnv, BLUN_PROFILE_HANDOFF: '1' };
+        continue;
+      } catch (error) {
+        recordRuntimeExit({ homeDir: env.BLUN_HOME, source: 'launcher', kind: 'profile-handoff-failure',
+          phase: 'startup', cliVersion: env.BLUN_PUBLIC_PACKAGE_VERSION, profile: env.BLUN_PROFILE,
+          exitCode: 1, error });
+        if (recoveryAttempted) return 1;
+        recoveryAttempted = true;
+        // Reopen the original owner when the selection became unavailable.
+        args = recoveryArgs;
+        continue;
+      }
+    }
     if (intentionalStop || !isAbnormalCoreExit(result, loaded)) {
       if (result.error) throw result.error;
       return exitCode;
@@ -272,7 +326,7 @@ function exitCodeForChild(result, loaded) {
   return 1;
 }
 
-function installTelegramForProfile(packageRoot, blunDir) {
+function installTelegramForProfile(packageRoot, blunDir) {
   installManagedTelegramPlugin({ packageRoot, blunDir });
   const channelsDir = path.join(blunDir, 'channels');
   const channelDir = path.join(channelsDir, 'telegram');
@@ -284,7 +338,37 @@ function installTelegramForProfile(packageRoot, blunDir) {
   } else {
     securePrivateFile(envFile);
   }
-}
+}
+
+function prepareProfileRuntime(blunDir, callerCwd, mode) {
+  ensurePrivateDirectory(blunDir);
+  const cfgFile = path.join(blunDir, 'config.toml');
+  if (fs.existsSync(cfgFile)) securePrivateFile(cfgFile);
+  const standardMcpNames = availableStandardToolNames({ packageRoot: PKG })
+    .filter((name) => name !== 'telegram');
+  seedStandardTools({ packageRoot: PKG, blunDir, names: standardMcpNames });
+  seedStandardDesignSkill({ packageRoot: PKG, blunDir });
+  installManagedAgentSpinePlugin({ packageRoot: PKG, blunDir });
+  if (mode === LAUNCHER_MODES.KING) installTelegramForProfile(PKG, blunDir);
+  return repairConfiguredNativeModules({
+    blunDir, callerCwd,
+    onRepairStart() {
+      process.stdout.write('BLUN richtet native Node.js-Module fuer die neue Laufzeit ein.\n');
+    },
+  });
+}
+
+async function withProfileRuntimeReservation(homeDir, work) {
+  const result = await tryAcquireUpdateLease({ packageRoot: homeDir, role: 'profile' });
+  if (!result.acquired) throw Object.assign(new Error(`PROFILE_RUNTIME_${result.reason.toUpperCase()}`),
+    { code: result.reason === 'busy' ? 'PROFILE_RUNTIME_BUSY' : 'PROFILE_RUNTIME_UNAVAILABLE' });
+  try {
+    result.lease.assertOwned();
+    const value = await work();
+    result.lease.assertOwned();
+    return value;
+  } finally { await result.lease.release(); }
+}
 
 function spawnManagedLauncher(binary, cwd) {
   return new Promise((resolve, reject) => {
@@ -511,51 +595,42 @@ async function runLauncher(options = {}) {
   // --- 2. Bestehende Konfiguration absichern -------------------------------
   // Ein frischer Start bleibt absichtlich ohne statischen Anbieter. /login
   // provisioniert King ueber den BLUN-OAuth-Server.
-    const cfgFile = path.join(blunDir, 'config.toml');
-    if (fs.existsSync(cfgFile)) securePrivateFile(cfgFile);
-    require('./verify-bundled-agent-sources.cjs').verifyBundledAgentSources(PKG);
+    require('./verify-bundled-agent-sources.cjs').verifyBundledAgentSources(PKG);
+    const nativeModules = mode === LAUNCHER_MODES.KING && isInteractiveKingStart(ARGS)
+      ? await withProfileRuntimeReservation(blunDir, () => prepareProfileRuntime(blunDir, callerCwd, mode))
+      : prepareProfileRuntime(blunDir, callerCwd, mode);
 
-    // --- 3. BLUN-Standard-MCPs additiv im Benutzerprofil einrichten ---------
-    const standardMcpNames = availableStandardToolNames({ packageRoot: PKG })
-      .filter((name) => name !== 'telegram');
-    seedStandardTools({
-      packageRoot: PKG,
-      blunDir,
-      names: standardMcpNames,
-    });
-
-  // --- 4. Eigenes BLUN-Grunddesign als einzigen Standard-Skill installieren
-    seedStandardDesignSkill({ packageRoot: PKG, blunDir });
-    installManagedAgentSpinePlugin({ packageRoot: PKG, blunDir });
-
-    // --- 5. Telegram-Plugin + Token-Vorlage (nur King) -----------------------
-    if (mode === LAUNCHER_MODES.KING) {
-      installTelegramForProfile(PKG, blunDir);
-    }
-
-    const nativeModules = repairConfiguredNativeModules({
-      blunDir,
-      callerCwd,
-      onRepairStart() {
-        process.stdout.write('BLUN richtet native Node.js-Module fuer die neue Laufzeit ein.\n');
-      },
-    });
     if (nativeModules.repaired.length > 0) {
       process.stdout.write('Native Node.js-Module sind wieder einsatzbereit.\n');
     }
 
-    // --- 6. Start -----------------------------------------------------------
+    // --- 6. Start -----------------------------------------------------------
     const env = createLauncherEnvironment(process.env, mode, readPackageVersion(), blunDir);
     env.BLUN_HOME = blunDir;
     if (PROFILE.name !== undefined) {
       env.BLUN_SHARED_HOME = getPrivatePaths().sharedHome;
       env.BLUN_PROFILE = PROFILE.name;
     }
+    const handoffOptions = mode === LAUNCHER_MODES.KING && isInteractiveKingStart(ARGS)
+      ? { prepareProfile: async (selected) => {
+        const target = selected.homeDir;
+        await withProfileRuntimeReservation(target, () => prepareProfileRuntime(target, callerCwd, mode));
+        const next = createLauncherEnvironment(process.env, mode, readPackageVersion(), target);
+        next.BLUN_HOME = target;
+        next.BLUN_SHARED_HOME = selected.sharedHome;
+        next.BLUN_PROFILE = selected.name;
+        delete next.BLUN_TELEGRAM_STATE_DIR;
+        delete next.BLUN_PLUGIN_ROOT;
+        return next;
+      } } : {};
+    if (handoffOptions.prepareProfile) env.BLUN_PROFILE_HANDOFF = '1';
+    else delete env.BLUN_PROFILE_HANDOFF;
     process.exitCode = await superviseProtectedCore(
       ARGS,
       env,
       callerCwd,
-      releaseNotice,
+      releaseNotice,
+      handoffOptions,
     );
   } finally {
     await releaseNotice();
@@ -563,6 +638,7 @@ async function runLauncher(options = {}) {
 }
 
 module.exports = {
+  withProfileRuntimeReservation,
   resolveLauncherPrivatePaths,
   isInteractiveKingStart,
   runningTuiPid,

package/bin/profile-handoff.cjs

@@ -0,0 +1,152 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { randomUUID } = require('node:crypto');
+const { listExistingProfiles, resolveSelectedProfile } = require('./profile-launch.cjs');
+
+const PROFILE_HANDOFF_REQUEST = 'blun-profile-handoff-request';
+const PROFILE_HANDOFF_REPLY = 'blun-profile-handoff-reply';
+const PROFILE_HANDOFF_CANCEL = 'blun-profile-handoff-cancel';
+const PROFILE_HANDOFF_READY = 'blun-profile-handoff-ready';
+const PROFILE_HANDOFF_EXIT = 76;
+const REQUEST_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/u;
+const samePath = (a, b) => process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;
+const unavailable = () => Object.assign(new Error('PROFILE_HANDOFF_UNAVAILABLE'), { code: 'PROFILE_HANDOFF_UNAVAILABLE' });
+
+function createProfileHandoff(env, isBusy = () => false) {
+  let pending;
+  const validate = (name) => {
+    if (typeof env.BLUN_HOME !== 'string' || !path.isAbsolute(env.BLUN_HOME)
+      || (env.BLUN_SHARED_HOME !== undefined && !path.isAbsolute(env.BLUN_SHARED_HOME))) throw unavailable();
+    const sharedHome = path.resolve(env.BLUN_SHARED_HOME || env.BLUN_HOME);
+    const homeDir = path.resolve(env.BLUN_HOME);
+    const current = env.BLUN_PROFILE;
+    if (current !== undefined) {
+      if (!env.BLUN_SHARED_HOME || path.basename(resolveSelectedProfile(sharedHome, current)) !== current
+        || !samePath(homeDir, resolveSelectedProfile(sharedHome, current))) throw unavailable();
+    } else if (!samePath(homeDir, sharedHome)) throw unavailable();
+    const names = listExistingProfiles(sharedHome);
+    if (typeof name !== 'string' || !names.includes(name) || name === current
+      || (current !== undefined && !names.includes(current))) throw unavailable();
+    const target = resolveSelectedProfile(sharedHome, name);
+    if (isBusy(target)) throw unavailable();
+    const identities = [sharedHome, path.join(sharedHome, 'profile'), homeDir, target]
+      .map(file => ({ file, stat: fs.lstatSync(file, { bigint: true }) }));
+    if (identities.some(({ stat }) => !stat.isDirectory() || stat.isSymbolicLink())) throw unavailable();
+    return { name, sharedHome, homeDir: target, identities };
+  };
+  return {
+    hasPending: () => pending !== undefined,
+    getSourceSessionId: () => pending?.sourceSessionId,
+    prepare(message) {
+      if (message?.type === PROFILE_HANDOFF_CANCEL && typeof message.requestId === 'string'
+        && REQUEST_ID.test(message.requestId) && Object.keys(message).sort().join(',') === 'requestId,type') {
+        if (pending?.requestId === message.requestId) pending = undefined;
+        return { type: PROFILE_HANDOFF_REPLY, requestId: message.requestId, status: 'cancelled' };
+      }
+      if (!message || message.type !== PROFILE_HANDOFF_REQUEST || typeof message.requestId !== 'string' || !REQUEST_ID.test(message.requestId)) return undefined;
+      const shape = Object.keys(message).sort().join(',');
+      if (shape !== 'name,requestId,type' && shape !== 'name,requestId,sourceSessionId,type') return undefined;
+      if (shape === 'name,requestId,sourceSessionId,type'
+        && (typeof message.sourceSessionId !== 'string' || !SESSION_ID.test(message.sourceSessionId))) return undefined;
+      let status = 'rejected';
+      try {
+        if (pending) {
+          if (pending.requestId === message.requestId && pending.name === message.name
+            && pending.sourceSessionId === message.sourceSessionId) status = 'prepared';
+        } else {
+          pending = { ...validate(message.name), requestId: message.requestId, sourceSessionId: message.sourceSessionId };
+          status = 'prepared';
+        }
+      } catch {}
+      return { type: PROFILE_HANDOFF_REPLY, requestId: message.requestId, status };
+    },
+    commit() {
+      try {
+        if (!pending) throw unavailable();
+        const fresh = validate(pending.name);
+        for (let index = 0; index < pending.identities.length; index++) {
+          const before = pending.identities[index];
+          const after = fresh.identities[index];
+          if (before.file !== after.file || before.stat.dev !== after.stat.dev || before.stat.ino !== after.stat.ino) throw unavailable();
+        }
+        return Object.freeze({ name: fresh.name, sharedHome: fresh.sharedHome, homeDir: fresh.homeDir,
+          ...(pending.sourceSessionId === undefined ? {} : { sourceSessionId: pending.sourceSessionId }) });
+      } catch {
+        throw unavailable();
+      }
+    },
+  };
+}
+
+function createProfileHandoffClient(channel = process) {
+  const enabled = channel.env?.BLUN_PROFILE_HANDOFF === '1';
+  let pending;
+  let disposed = false;
+  const available = () => !disposed && enabled && channel.connected === true
+    && typeof channel.send === 'function';
+  const cancel = () => {
+    const request = pending;
+    if (!request) return;
+    pending = undefined;
+    request.finish(false);
+    if (channel.connected === true) {
+      try { channel.send({ type: PROFILE_HANDOFF_CANCEL, requestId: request.id }, () => {}); } catch {}
+    }
+  };
+  return Object.freeze({
+    isPrepared: () => available() && pending?.prepared === true,
+    cancel,
+    dispose() { cancel(); disposed = true; },
+    /** @param {string} name @param {{ signal?: AbortSignal, timeoutMs?: number, sourceSessionId?: string }} [options] */
+    prepare(name, { signal, timeoutMs = 5000, sourceSessionId } = {}) {
+      try {
+        if (!available() || pending || signal?.aborted || typeof name !== 'string'
+          || path.basename(resolveSelectedProfile(path.parse(__dirname).root, name)) !== name
+          || !Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 30000
+          || (sourceSessionId !== undefined && (typeof sourceSessionId !== 'string' || !SESSION_ID.test(sourceSessionId)))) return Promise.resolve(false);
+      } catch { return Promise.resolve(false); }
+      return new Promise(resolve => {
+        const request = { id: randomUUID(), prepared: false, finish: undefined };
+        let settled = false;
+        let timer;
+        const aborted = () => cancel();
+        const disconnected = () => cancel();
+        const message = reply => {
+          if (pending !== request || reply?.type !== PROFILE_HANDOFF_REPLY || reply.requestId !== request.id
+            || Object.keys(reply).sort().join(',') !== 'requestId,status,type') return;
+          if (reply.status === 'prepared') request.finish(true);
+          else if (reply.status === 'rejected' || reply.status === 'cancelled') cancel();
+        };
+        request.finish = prepared => {
+          if (!prepared) signal?.removeEventListener('abort', aborted);
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          channel.removeListener('message', message);
+          channel.removeListener('disconnect', disconnected);
+          try { channel.channel?.unref(); } catch {}
+          request.prepared = prepared;
+          resolve(prepared);
+        };
+        pending = request;
+        channel.on('message', message);
+        channel.once('disconnect', disconnected);
+        signal?.addEventListener('abort', aborted, { once: true });
+        timer = setTimeout(aborted, timeoutMs);
+        try {
+          channel.channel?.ref();
+          channel.send({ type: PROFILE_HANDOFF_REQUEST, requestId: request.id, name,
+            ...(sourceSessionId === undefined ? {} : { sourceSessionId }) }, error => {
+            if (error && pending === request) cancel();
+          });
+        } catch { cancel(); }
+      });
+    },
+  });
+}
+
+module.exports = { createProfileHandoff, createProfileHandoffClient, PROFILE_HANDOFF_CANCEL, PROFILE_HANDOFF_REQUEST, PROFILE_HANDOFF_REPLY,
+  PROFILE_HANDOFF_READY, PROFILE_HANDOFF_EXIT };

package/bin/update-lease.js

@@ -34,7 +34,9 @@ function canonicalPackageIdentity(packageRoot, options = {}) {
 
 function deriveUpdateLeaseEndpoint(packageRoot, options = {}) {
   const platform = options.platform || process.platform;
-  const role = options.role === 'install'
+  const role = options.role === 'profile'
+    ? 'profile'
+    : options.role === 'install'
     ? 'install'
     : options.role === 'runtime'
       ? 'runtime'