@prohost/cli 0.16.5 → 0.16.7

package/dist/codehost/ready.js

@@ -8,27 +8,151 @@
  * screen, is what lets a relayed reply be typed: before it, the dialog may be
  * up or about to be drawn, and an Enter would answer it. The mark is a file,
  * so it outlives a daemon restart.
+ *
+ * A window's Claude Code can be replaced (a restart), and a hook of the old one
+ * may still be running when it is: one that writes the mark after the restart
+ * dropped it would say the new process is past screens it hasn't reached. So
+ * each launch has an id ({@link LAUNCH_ENV} in the process's environment, which
+ * its hooks inherit), recorded in `<state>/<terminal>.launch` as pending until
+ * the new process's own first hook runs; meanwhile no other hook marks the
+ * window, however late it runs. A launch the daemon couldn't confirm stays
+ * pending (no reply types) until its own hook runs or the window is restarted
+ * again. A window with no launch record (one an older build started) is judged
+ * by the mark alone, as before.
  */
-import { closeSync, openSync, readdirSync, readSync, realpathSync, rmSync, statSync } from 'node:fs';
+import { closeSync, openSync, readdirSync, readFileSync, readSync, realpathSync, rmSync, statSync } from 'node:fs';
 import path from 'node:path';
+import { withFileLock } from './filelock.js';
 import { codeHostDir, writePrivateJson } from './settings.js';
 import { isValidId } from './tmux.js';
+/** The launch id a window's agent process runs under, in its environment (and so its hooks'). */
+export const LAUNCH_ENV = 'PROHOST_LAUNCH_ID';
 export function readyPath(terminalId, env = process.env) {
     if (!isValidId(terminalId))
         throw new Error('invalid terminal id');
     return path.join(codeHostDir(env), 'state', `${terminalId}.ready`);
 }
+export function launchPath(terminalId, env = process.env) {
+    if (!isValidId(terminalId))
+        throw new Error('invalid terminal id');
+    return path.join(codeHostDir(env), 'state', `${terminalId}.launch`);
+}
+/** The window's launch record: `null` with none (an older build's window), `undefined` when it can't be read. */
+function readLaunch(terminalId, env) {
+    let raw;
+    try {
+        raw = readFileSync(launchPath(terminalId, env), 'utf8');
+    }
+    catch (err) {
+        return err.code === 'ENOENT' ? null : undefined;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        const launch = parsed.launch;
+        if (!(launch === null || typeof launch === 'string') || typeof parsed.gen !== 'number')
+            return undefined;
+        if (parsed.next !== undefined && typeof parsed.next !== 'string')
+            return undefined;
+        return { launch, gen: parsed.gen, ...(parsed.next !== undefined ? { next: parsed.next } : {}) };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A lock whose token can't be read (its holder died writing it) and older than this is stale. */
+const LAUNCH_LOCK_STALE_MS = 10_000;
+/** How long a writer waits for the lock before it gives up (and says so). */
+const LAUNCH_LOCK_WAIT_MS = 1_000;
+/**
+ * `fn` holding the window's launch lock (`<terminal>.launch.lock`, {@link withFileLock}): hooks and
+ * the daemon are separate processes, and every read-then-write of the record goes through it, so a
+ * hook's promotion never overwrites a launch the daemon began after the hook read the record.
+ * `fallback` when the lock can't be had.
+ */
+function withLaunchLock(terminalId, env, fallback, fn) {
+    try {
+        // A holder that still runs keeps it, however long it is suspended: taken over, it would write
+        // over its successor's record on waking.
+        const held = withFileLock(`${launchPath(terminalId, env)}.lock`, fn, {
+            staleMs: LAUNCH_LOCK_STALE_MS,
+            waitMs: LAUNCH_LOCK_WAIT_MS,
+            liveHolders: true,
+        });
+        return held.ok ? held.value : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+/** A gen that is new: never equal to the one it replaces, even within one millisecond. */
+function nextGen(previous, now) {
+    return previous && now <= previous.gen ? previous.gen + 1 : now;
+}
+/**
+ * The launch the window runs now: its id, `null` for a process with no launch id or a window with no
+ * launch record, or `undefined` when the record can't be read.
+ */
+export function currentLaunch(terminalId, env = process.env) {
+    const record = readLaunch(terminalId, env);
+    return record === undefined ? undefined : (record?.launch ?? null);
+}
+/** The launch waiting for its first hook, if one is. */
+export function pendingLaunch(terminalId, env = process.env) {
+    return readLaunch(terminalId, env)?.next;
+}
 /**
- * Mark the terminal's Claude Code past its trust dialog (a hook ran). Atomic (`writePrivateJson`).
- * Returns whether it is marked afterwards; `false` means the write failed, and the caller says so.
+ * A hook of launch `launch` ran in the window (by default the caller's own, from its environment):
+ * mark the window past its trust dialog. Atomic (`writePrivateJson`).
+ *
+ * - The pending launch's own hook proves it runs: it becomes the window's launch, and is marked.
+ * - While a launch is pending, any other hook is of a process being replaced: it has no say, however
+ *   late it runs (a hook suspended while the Mac slept may resume long after).
+ * - With nothing pending, a hook of another launch is of the process the window runs (an older
+ *   build relaunched it since): its launch becomes the window's.
+ *
+ * Returns whether the window is marked afterwards, or that the hook had no say; `false` means the
+ * state couldn't be read or written, and the caller says so.
  */
-export function markReady(terminalId, env = process.env) {
+export function markReady(terminalId, env = process.env, launch = env[LAUNCH_ENV] || null, now = Date.now()) {
     if (!isValidId(terminalId))
         return false;
-    if (isReady(terminalId, env) === true)
+    // Most hooks find their window marked already: nothing to write, so no lock to take. That
+    // includes a window an older build started (no record), whose hooks run this build after an upgrade.
+    const record = readLaunch(terminalId, env);
+    const current = record === null || (record !== undefined && record.next === undefined && record.launch === launch);
+    if (current && isReady(terminalId, env) === true)
         return true;
+    return withLaunchLock(terminalId, env, false, () => markReadyLocked(terminalId, env, launch, now));
+}
+function markReadyLocked(terminalId, env, launch, now) {
+    const record = readLaunch(terminalId, env);
+    if (record === undefined)
+        return false;
     try {
-        writePrivateJson(readyPath(terminalId, env), Date.now());
+        if (record === null) {
+            // A window an older build started: the mark alone, as it always was.
+            if (isReady(terminalId, env) === true)
+                return true;
+            writePrivateJson(readyPath(terminalId, env), { launch, at: now });
+            return true;
+        }
+        let current = record;
+        if (record.next !== undefined) {
+            // Pending: only its own hook settles it (or the daemon, knowing nothing was replaced).
+            if (launch !== record.next)
+                return true;
+            current = { launch, gen: nextGen(record, now) };
+        }
+        else if (launch !== record.launch) {
+            // Nothing pending, and a hook of another launch: the window runs it (an older build relaunched
+            // it since), and a hook runs only once it is past its screens.
+            current = { launch, gen: nextGen(record, now) };
+        }
+        if (current !== record)
+            writePrivateJson(launchPath(terminalId, env), current);
+        else if (isReady(terminalId, env) === true)
+            return true;
+        writePrivateJson(readyPath(terminalId, env), { launch: current.launch, gen: current.gen, at: now });
         return true;
     }
     catch {
@@ -36,8 +160,8 @@ export function markReady(terminalId, env = process.env) {
     }
 }
 /**
- * Forget the mark: the window's Claude Code was replaced (a restart), and the new one is past its
- * dialog only once its own first hook runs. Returns whether no mark is left.
+ * Forget the mark: the window's Claude Code is being replaced, and the new one is past its dialog
+ * only once its own first hook runs. Returns whether no mark is left.
  */
 export function clearReady(terminalId, env = process.env) {
     if (!isValidId(terminalId))
@@ -50,6 +174,65 @@ export function clearReady(terminalId, env = process.env) {
         return false;
     }
 }
+/**
+ * Launch `launch` is about to run in the window (a start or a restart): pending until its own first
+ * hook runs, and no other hook marks the window meanwhile. Recorded first, then the old mark dropped.
+ * Returns whether both were done; on `false` the caller must not launch.
+ */
+export function beginLaunch(terminalId, launch, env = process.env, now = Date.now()) {
+    if (!isValidId(terminalId) || launch === '')
+        return false;
+    return withLaunchLock(terminalId, env, false, () => {
+        const record = readLaunch(terminalId, env);
+        if (record === undefined)
+            return false;
+        try {
+            writePrivateJson(launchPath(terminalId, env), { launch: record?.launch ?? null, next: launch, gen: nextGen(record, now) });
+        }
+        catch {
+            return false;
+        }
+        return clearReady(terminalId, env);
+    });
+}
+export function launchState(terminalId, env = process.env) {
+    return { record: readLaunch(terminalId, env), ready: isReady(terminalId, env) };
+}
+/**
+ * The new launch never ran (nothing was replaced): the window's old process keeps its launch and,
+ * if it had it, its readiness. If that can't be written, the launch stays pending (no reply types)
+ * until the window is restarted again.
+ */
+export function restoreLaunch(terminalId, state, env = process.env, now = Date.now()) {
+    const before = state.record;
+    if (before === undefined)
+        return;
+    withLaunchLock(terminalId, env, undefined, () => restoreLocked(terminalId, before, state.ready === true, env, now));
+}
+function restoreLocked(terminalId, previous, ready, env, now) {
+    try {
+        if (previous === null) {
+            rmSync(launchPath(terminalId, env), { force: true });
+            if (ready)
+                writePrivateJson(readyPath(terminalId, env), { launch: null, at: now });
+            return;
+        }
+        const pending = readLaunch(terminalId, env);
+        // Exactly as it was, a launch still pending included: a failed attempt never lifts its protection.
+        const record = {
+            launch: previous.launch,
+            ...(previous.next !== undefined ? { next: previous.next } : {}),
+            gen: nextGen(pending ?? previous, now),
+        };
+        writePrivateJson(launchPath(terminalId, env), record);
+        if (ready && record.next === undefined) {
+            writePrivateJson(readyPath(terminalId, env), { launch: record.launch, gen: record.gen, at: now });
+        }
+    }
+    catch {
+        /* left pending (see above): fails closed */
+    }
+}
 /** How much of a transcript is read looking for its folder (its first entries carry `cwd`). */
 const TRANSCRIPT_HEAD_BYTES = 256 * 1024;
 /**
@@ -129,13 +312,31 @@ export function claudeSessionSince(cwd, configDir, sinceMs) {
         }
     });
 }
-/** `true` past the dialog, `false` not yet, `undefined` when the state can't be read. */
+/**
+ * `true` past the dialog (a hook of the launch the window runs now ran, and no other launch is
+ * pending), `false` not yet, `undefined` when the state can't be read.
+ */
 export function isReady(terminalId, env = process.env) {
+    let raw;
     try {
-        statSync(readyPath(terminalId, env));
-        return true;
+        raw = readFileSync(readyPath(terminalId, env), 'utf8');
     }
     catch (err) {
         return err.code === 'ENOENT' ? false : undefined;
     }
+    const record = readLaunch(terminalId, env);
+    if (record === undefined)
+        return undefined;
+    if (record === null)
+        return true;
+    let mark = {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object')
+            mark = parsed;
+    }
+    catch {
+        /* an unreadable mark marks nothing */
+    }
+    return record.next === undefined && mark.gen === record.gen && (mark.launch ?? null) === record.launch;
 }

package/dist/codehost/terminals.js

@@ -35,7 +35,7 @@ import { readHistory } from './history.js';
 import { loginOf, readSession } from './session.js';
 import { CODE_THREAD_ID_ENV, TERMINAL_ID_ENV } from './hooks.js';
 import { MAX_OPEN_PTYS } from './pty.js';
-import { claudeSessionSince, claudeTranscripts, clearReady, isReady, markReady } from './ready.js';
+import { beginLaunch, claudeSessionSince, claudeTranscripts, currentLaunch, isReady, LAUNCH_ENV, launchState, markReady, restoreLaunch, } from './ready.js';
 import { defaultSizeArgs, HOLD_OPTION, holdChannel, holdCommand, resizeWindowArgs, TerminalSizing } from './sizing.js';
 import { noteInputTakeover } from './sizing.js';
 import { attachArgs, baseArgs, clampDim, DEFAULT_COLS, DEFAULT_ROWS, hasSessionArgs, isCopyModeExitKey, isHumanInput, isTypedText, isInterruptInput, isScrollGesture, leaveCopyModeArgs, mayEnterCopyMode, paneInModeArgs, isValidId, respawnPaneArgs, killSessionArgs, listWindowsArgs, newSessionArgs, newWindowArgs, parseListWindows, sendTextCommands, setWindowMetaArgs, TERMINAL_WINDOWS, DAEMON_ONLY_ENV, paneEnv, viewSessionName, windowName, windowTarget, } from './tmux.js';
@@ -443,7 +443,10 @@ export class CodeTerminals {
     adoptReadiness(record, configDir, startedAtMs) {
         if (!(this.options.claudeSessionSince ?? claudeSessionSince)(record.cwd, configDir, startedAtMs))
             return;
-        if (markReady(record.terminalId, { PROHOST_HOME: this.options.home })) {
+        // The evidence is about the process the window runs now: its launch, if it has one, is marked.
+        const env = { PROHOST_HOME: this.options.home };
+        const launch = currentLaunch(record.terminalId, env);
+        if (launch !== undefined && markReady(record.terminalId, env, launch)) {
             this.log(`    ⚙ code thread ${record.codeThreadId.slice(0, 12)}: adopted past Claude Code's trust dialog (its session exists)`);
         }
     }
@@ -526,6 +529,12 @@ export class CodeTerminals {
         const command = agentCommandLine(request.agent, { ...this.options.hookFiles, hasGoal: goal.length > 0, skipPermissions: skips });
         // A shell thread's shell waits for its first viewer's size to settle (`sizing.ts`): one prompt.
         const held = request.agent === 'shell';
+        // Its own launch (`ready.ts`): only this process's hooks mark it past its first-run screens. One
+        // that can't be recorded is a window no reply could ever be typed into: the start fails instead.
+        const launch = randomBytes(8).toString('hex');
+        if (request.agent === 'claude_code' && !beginLaunch(request.terminalId, launch, { PROHOST_HOME: this.options.home })) {
+            return fail("this Mac's code-host state can't be written ($PROHOST_HOME/code-host/state)");
+        }
         const created = await this.tmux(newWindowArgs({
             name,
             cwd: checkout.path,
@@ -534,6 +543,7 @@ export class CodeTerminals {
                 PROHOST_HOME: this.options.home,
                 [TERMINAL_ID_ENV]: request.terminalId,
                 [CODE_THREAD_ID_ENV]: request.codeThreadId,
+                [LAUNCH_ENV]: launch,
                 ...(goal ? { [GOAL_ENV]: goal } : {}),
             },
             command: held ? holdCommand(name, command) : command,
@@ -718,8 +728,9 @@ export class CodeTerminals {
         const token = randomBytes(8).toString('hex');
         const command = `tmux set-option -wu ${EXITED_OPTION} 2>/dev/null; tmux set-option -w ${RELAUNCH_OPTION} ${token} 2>/dev/null; ` +
             agentCommandLine(agent, { ...this.options.hookFiles, hasGoal: false, skipPermissions: request.skipPermissions, resume });
-        // Like a new window: replies wait for the new Claude Code's first hook (`ready.ts`). Dropped before
-        // the old process goes, so that hook's mark is never wiped after it was written.
+        // Like a new window: replies wait for the new Claude Code's first hook (`ready.ts`). Its launch is
+        // recorded (and the old mark dropped) before the old process goes, so that hook's mark is never
+        // wiped after it was written, and a late hook of the old process can't mark the new one.
         // The switch once more, as late as it can be: nothing awaits between here and `respawn-pane`, so a
         // `remote off` that landed during the looks above stops it before anything is claimed or touched.
         if (request.skipPermissions && !this.canType())
@@ -736,9 +747,15 @@ export class CodeTerminals {
             return false;
         }
         const before = this.panePids.get(record.terminalId);
-        const wasReady = agent === 'claude_code' && this.isReady(record.terminalId) === true;
-        if (agent === 'claude_code')
-            clearReady(record.terminalId, env);
+        const previous = agent === 'claude_code' ? launchState(record.terminalId, env) : undefined;
+        if (previous && !beginLaunch(record.terminalId, token, env)) {
+            // Nothing was replaced, and nothing may be until the new launch can be told from the old one.
+            restoreLaunch(record.terminalId, previous, env);
+            this.log(`    ! code thread ${short} not restarted yet: its launch could not be recorded`);
+            outcome.retry = true;
+            outcome.release = true;
+            return false;
+        }
         // The restart's own `stop` is stamped now, before the new pane exists: any hook the new agent
         // sends is strictly newer and wins under the server's host-event ordering, never this one.
         const stopAt = this.now();
@@ -750,13 +767,14 @@ export class CodeTerminals {
                 PROHOST_HOME: this.options.home,
                 [TERMINAL_ID_ENV]: record.terminalId,
                 [CODE_THREAD_ID_ENV]: record.codeThreadId,
+                [LAUNCH_ENV]: token,
             },
             command,
         }));
         if (!respawned.ok && !respawned.uncertain) {
-            // Nothing was replaced: the old process (and its readiness) stays, and it is worth sending again.
-            if (wasReady)
-                markReady(record.terminalId, env);
+            // Nothing was replaced: the old process (its launch and readiness) stays, and it is worth sending again.
+            if (previous)
+                restoreLaunch(record.terminalId, previous, env);
             this.log(`    ! code thread ${short} not restarted: tmux said ${respawned.stderr.trim()}`);
             outcome.retry = true;
             outcome.release = true;
@@ -767,9 +785,9 @@ export class CodeTerminals {
         // prompts are off.
         const after = await this.panePidNow(record.terminalId);
         if (after !== undefined && after === before) {
-            // The same process still runs: nothing was replaced. It keeps its readiness, and is sent again.
-            if (wasReady)
-                markReady(record.terminalId, env);
+            // The same process still runs: nothing was replaced. It keeps its launch and readiness, and is sent again.
+            if (previous)
+                restoreLaunch(record.terminalId, previous, env);
             this.log(`    ! code thread ${short} not restarted: its window still runs the same process`);
             outcome.retry = true;
             outcome.release = true;

package/dist/host/api.js

@@ -36,7 +36,7 @@ export async function callJson(options, path, body, method = 'POST') {
             parsed = undefined;
         }
         const ok = response.status >= 200 && response.status < 300;
-        return { status: response.status, body: parsed, ...(ok ? {} : { error: text.slice(0, 300) }) };
+        return { status: response.status, body: parsed, ...(ok ? {} : { error: text.slice(0, 500) }) };
     }
     catch (err) {
         if (controller.signal.aborted)

package/dist/host/command.d.ts

@@ -11,7 +11,7 @@
  *     prohost host pause | resume
  *     prohost host migrate [--from <home>]… [--home <dir,…>] [--keep-services] [--dry-run] [--json]
  */
-import type { InstallIo } from './install.js';
+import type { InstallIo, ServiceSpec } from './install.js';
 import type { LoginInfo } from './logins.js';
 import { runMigrate } from './migrate.js';
 type Flags = Record<string, string | boolean>;
@@ -63,5 +63,12 @@ export declare function statusJson(env: NodeJS.ProcessEnv, now?: number, options
 export declare function signInSpawn(command: string, args: string[], platform?: NodeJS.Platform): [string, string[], {
     windowsVerbatimArguments?: boolean;
 }];
+/** Whether the service manager still has `spec`'s dedicated service (loaded / active / a task). */
+export declare function serviceStillLoaded(spec: ServiceSpec, serviceIo: InstallIo, pidAlive?: (pid: number) => boolean): boolean;
+/**
+ * Remove every copy of the key a dedicated install made (the service home's, and on Windows the
+ * administrators' copy), each attempted on its own: the files that are still there, named.
+ */
+export declare function removeCopiedKeys(spec: ServiceSpec, serviceIo: InstallIo): string[];
 export declare function runHost(subcommand: string | undefined, flags: Flags, printHelp: () => void, io?: HostIo): Promise<number>;
 export {};

package/dist/host/command.js

@@ -29,7 +29,7 @@ import { addAccount, isValidLabel, loadAccounts, parseAccountRuntime, accountEnv
 import { revokeComputer } from './api.js';
 import { readSharedObject, acquireHostLock, clearComputer, computerOs, controlPath, handoffNotice, handoffOf, hostLockPath, SERVICE_LABEL, readHandoff, readObject, statePath, tryLoadComputer, writePrivateFile, } from './computer.js';
 import { journalPath, readEvents } from './events.js';
-import { LAUNCHD_HOST_LABEL, defaultLabel, defaultServiceRunner, installService, installedDedicatedService, publishedComputer, publishedComputerId, readServiceCredential, rewriteHomeCredential, windowsServiceCredentialPath, windowsHomesDir, windowsTaskOf, serviceFilePath, serviceUserHome, sharedBase, sharedDirFor, uninstallService, } from './install.js';
+import { LAUNCHD_HOST_LABEL, defaultLabel, defaultServiceRunner, installService, installedDedicatedService, systemdUnitOf, publishedComputer, publishedComputerId, readServiceCredential, rewriteHomeCredential, windowsServiceCredentialPath, windowsHomesDir, windowsTaskOf, serviceFilePath, serviceUserHome, sharedBase, sharedDirFor, uninstallService, } from './install.js';
 import { LegacyHarnesses } from './legacy.js';
 import { detectLogins } from './logins.js';
 import { adoptComputer, loadAdopted, runMigrate } from './migrate.js';
@@ -490,6 +490,65 @@ function serviceCredential(platform, home, user, serviceIo, label) {
         return null;
     }
 }
+/** Whether the service manager still has `spec`'s dedicated service (loaded / active / a task). */
+export function serviceStillLoaded(spec, serviceIo, pidAlive = processAlive) {
+    const run = serviceIo.run ?? defaultServiceRunner;
+    try {
+        if (spec.platform === 'darwin')
+            return run('launchctl', ['print', `system/${spec.label}`]).status === 0;
+        if (spec.platform === 'win32') {
+            if (run('schtasks', ['/Query', '/TN', windowsTaskOf(spec)]).status === 0)
+                return true;
+            // Deleting a task does not stop what it started: the host's own lock names a live process.
+            // Only "no such file" means no lock; any other read error is an unknown, so still there (fail closed).
+            const lock = (serviceIo.readFile ?? ((f) => {
+                try {
+                    return readFileSync(f, 'utf8');
+                }
+                catch (e) {
+                    if (e.code === 'ENOENT')
+                        return undefined;
+                    throw e;
+                }
+            }))(path.win32.join(spec.home, 'host', 'service.lock'));
+            const pid = lock ? JSON.parse(lock).pid : undefined;
+            return typeof pid === 'number' && Number.isInteger(pid) && pid > 0 && pidAlive(pid);
+        }
+        return run('systemctl', ['is-active', '--quiet', systemdUnitOf(spec)]).status === 0;
+    }
+    catch {
+        return true;
+    }
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
+/**
+ * Remove every copy of the key a dedicated install made (the service home's, and on Windows the
+ * administrators' copy), each attempted on its own: the files that are still there, named.
+ */
+export function removeCopiedKeys(spec, serviceIo) {
+    const leftover = [];
+    const homeKey = (spec.platform === 'win32' ? path.win32 : path.posix).join(spec.home, 'host', 'computer.json');
+    if (rewriteHomeCredential(spec.platform, spec.home, undefined, serviceIo))
+        leftover.push(homeKey);
+    if (spec.platform === 'win32') {
+        const copy = windowsServiceCredentialPath(spec);
+        try {
+            (serviceIo.removeFile ?? ((f) => rmSync(f, { force: true })))(copy);
+        }
+        catch {
+            leftover.push(copy);
+        }
+    }
+    return leftover;
+}
 /** The home a dedicated install took its computer from: `--from-home`, else (under sudo `$PROHOST_HOME` is root's) `$SUDO_USER`'s. */
 function handedFromHome(flags, env, platform) {
     return str(flags, 'from-home') ?? (env.SUDO_USER && !env.PROHOST_HOME ? homeOfUser(platform, env.SUDO_USER) : prohostHome(env));
@@ -756,6 +815,8 @@ export async function runHost(subcommand, flags, printHelp, io = {}) {
                 (env.SUDO_USER && !env.PROHOST_HOME ? homeOfUser(platform, env.SUDO_USER) : ownHome);
             // The key this install takes over, read before it runs: only a copy it really made is retired.
             const handedFrom = dedicated && path.resolve(adoptFrom) !== path.resolve(home) ? tryLoadComputer({ ...env, PROHOST_HOME: adoptFrom }) : null;
+            // Whether the service home already held a key before this install (then it copies none).
+            const serviceHadKey = handedFrom ? serviceCredential(platform, home, serviceUser, io.serviceIo ?? {}, spec.label) !== null : false;
             const outcome = installService(spec, io.serviceIo, {
                 ...(tokenFile ? { claudeTokenFile: tokenFile } : {}),
                 ...(dedicated ? { adoptFrom } : {}),
@@ -790,8 +851,51 @@ export async function runHost(subcommand, flags, printHelp, io = {}) {
                     });
                     const problem = rewriteHomeCredential(platform, adoptFrom, `${JSON.stringify(note, null, 2)}\n`, io.serviceIo);
                     if (problem) {
-                        err(`  ✗ The service has the computer, but its key is still in ${adoptFrom} too (${problem}). ` +
-                            `Delete ${path.join(adoptFrom, 'host', 'computer.json')} yourself — never run \`prohost host unpair\` from that home: it would remove the computer.`);
+                        // The note is part of the takeover: without it the key would live in both homes, and an
+                        // `unpair` here would remove the computer under the service. What this install did is undone.
+                        err(`  ✗ Could not leave the hand-off note in ${adoptFrom} (${problem}).`);
+                        // What the original home holds now decides the undo (on Windows a rename can land before a
+                        // later check fails): its key still there → undo; the note there after all → handed over;
+                        // neither → the service keeps the only key.
+                        const sourceKey = tryLoadComputer({ ...env, PROHOST_HOME: adoptFrom });
+                        const sourceNote = readHandoff({ ...env, PROHOST_HOME: adoptFrom });
+                        const handedAnyway = !sourceKey && sourceNote?.handed_to.label === spec.label && sourceNote?.computer_id === handedFrom.computer_id;
+                        if (handedAnyway) {
+                            err(`  ! The note is in place after all: the computer's key is the service's alone. Check ${path.join(adoptFrom, 'host', 'computer.json')}.`);
+                        }
+                        else if (sourceKey?.computer_id !== handedFrom.computer_id) {
+                            err(`  ✗ ${adoptFrom} no longer holds this computer's key, so ${spec.label} keeps it: check ${path.join(adoptFrom, 'host', 'computer.json')}, never delete ${home}.`);
+                            return 1;
+                        }
+                        else if (!serviceHadKey) {
+                            const undone = (() => {
+                                try {
+                                    return uninstallService(spec, io.serviceIo);
+                                }
+                                catch (e) {
+                                    return { ok: false, message: e instanceof Error ? e.message : String(e) };
+                                }
+                            })();
+                            // Removed and no longer loaded, not just "nothing failed": a Windows task that would not
+                            // stop removes nothing, and a launchd / systemd service whose stop failed may still run.
+                            // (Not `undone.ok`: on Windows uninstall reports a key copy it couldn't remove as not ok
+                            // although the task is gone — that copy is named by removeCopiedKeys below.)
+                            const serviceGone = undone.message.includes('✓ Removed') && !serviceStillLoaded(spec, io.serviceIo ?? {});
+                            const leftover = serviceGone ? removeCopiedKeys(spec, io.serviceIo ?? {}) : [];
+                            err(serviceGone && leftover.length === 0
+                                ? `  ✗ Undone: ${spec.label} is uninstalled and ${home} holds no key; ${adoptFrom} keeps its key. Fix the problem above, then ` +
+                                    (platform === 'win32' ? `remove the folder ${home} and install again.` : 'install again.')
+                                : serviceGone
+                                    ? `  ✗ Partly undone: ${spec.label} is uninstalled, but its key is still in ${leftover.join(' and ')}: delete it yourself — never run \`prohost host unpair\` from ${adoptFrom} meanwhile.`
+                                    : `  ✗ Could not fully undo it: remove ${spec.label} (sudo prohost host uninstall --label ${spec.label}) and ${path.join(home, 'host', 'computer.json')} yourself — never run \`prohost host unpair\` from ${adoptFrom} meanwhile.`);
+                            return 1;
+                        }
+                        else {
+                            err(`  ✗ ${home} already held this key before this install, so ${adoptFrom} still does too: never run \`prohost host unpair\` from that home. ` +
+                                `Fix the problem above, then install again.`);
+                        }
+                        if (!handedAnyway)
+                            return 1;
                     }
                     else {
                         out(`  The computer's key is the service's alone now: ${adoptFrom} keeps a note of where it went.`);

package/dist/host/service.d.ts

@@ -117,6 +117,10 @@ export interface HostServiceResult {
  * sends its frame first (it does when the earlier turn ends): 30 s, doubling, at most 2 min.
  */
 export declare function busyBackoffMs(waits: number): number;
+/** A refused status is logged again at most this often while refusals continue. */
+export declare const STATUS_FAILURE_LOG_MS: number;
+/** A server's error text with anything shaped like a key or token blanked out. */
+export declare function redactSecrets(text: string): string;
 /** The CLI's own entry file: when it changes on disk, an update was installed. */
 export declare function entrypointStamp(entry?: string): () => boolean;
 export declare function runHostService(options: HostServiceOptions): Promise<HostServiceResult>;

package/dist/host/service.js

@@ -89,6 +89,16 @@ const SAFE_ID = /^[A-Za-z0-9-]{1,64}$/;
 export function busyBackoffMs(waits) {
     return Math.min(30_000 * 2 ** waits, 120_000);
 }
+/** A refused status is logged again at most this often while refusals continue. */
+export const STATUS_FAILURE_LOG_MS = 10 * 60_000;
+/** A server's error text with anything shaped like a key or token blanked out. */
+export function redactSecrets(text) {
+    return text
+        .replace(/\b(pk|sk|rk|whsec)_[A-Za-z0-9_-]{8,}/g, '$1_…')
+        .replace(/\bsk-ant-[A-Za-z0-9_-]{8,}/g, 'sk-ant-…')
+        .replace(/\bgh[pousr]_[A-Za-z0-9]{8,}/g, 'gh…')
+        .replace(/\b(Bearer|token)\s+[A-Za-z0-9._-]{12,}/gi, '$1 …');
+}
 function timestamp() {
     return new Date().toISOString().slice(11, 19);
 }
@@ -260,12 +270,15 @@ async function serveHost(options) {
     // ── What is running ──────────────────────────────────────────────────────
     function runningEntries() {
         const runs = [...active.values()].map((run) => ({ ...run.entry, peak_mem_mb: peak.peakMb(run.entry.run_id) }));
+        // A terminal session is no employee's: no employee id (its runtime instead), and no start time
+        // this host knows (`started_at: null`, never '' — the server reads both as typed values).
         const terms = (codeHost?.liveTerminals?.() ?? []).map((t) => ({
             run_id: t.terminalId,
-            agent_id: t.agent,
+            agent_id: null,
+            runtime: t.agent,
             conversation_key: `code_thread:${t.codeThreadId}`,
             kind: 'terminal',
-            started_at: '',
+            started_at: null,
         }));
         return [...runs, ...terms];
     }
@@ -326,6 +339,8 @@ async function serveHost(options) {
     let statusTimer;
     let statusInFlight;
     let statusFailures = 0;
+    /** When a refused status was last logged: a repeat is logged again (with its count) at most this often. */
+    let statusFailureLoggedAt = 0;
     function statusChanged() {
         writeLocalState();
         if (statusTimer)
@@ -374,8 +389,14 @@ async function serveHost(options) {
                 return;
             }
             statusFailures += 1;
-            if (statusFailures === 1)
-                log(`${timestamp()} ! status not accepted (${response.status || response.error})`);
+            // The server's reason (a 422 names the field), at the first refusal and then every 10 minutes
+            // while it lasts, with how many there were — never only once and then silence.
+            if (statusFailures === 1 || now() - statusFailureLoggedAt >= STATUS_FAILURE_LOG_MS) {
+                statusFailureLoggedAt = now();
+                const why = redactSecrets(response.error ?? '').replace(/\s+/g, ' ').trim().slice(0, 500);
+                log(`${timestamp()} ! status not accepted (${response.status || 'no answer'}${statusFailures > 1 ? `, ${statusFailures} times in a row` : ''})` +
+                    (why ? `: ${why}` : ''));
+            }
         })().finally(() => {
             statusInFlight = undefined;
         });

package/dist/host/status.d.ts

@@ -34,13 +34,17 @@ export declare function parseConfig(body: Record<string, unknown> | undefined, p
 /** One run going on this computer. */
 export interface RunningEntry {
     run_id: string;
-    agent_id: string;
+    /** The employee's id (a UUID); null for a terminal session, which is no employee's. */
+    agent_id: string | null;
+    /** A terminal session's agent runtime (`claude_code`, `codex`, …). */
+    runtime?: string;
     agent_name?: string;
     agent_avatar_url?: string;
     title?: string;
     conversation_key?: string;
     kind: 'employee' | 'terminal';
-    started_at: string;
+    /** ISO-8601, or null when it isn't known (a terminal session). */
+    started_at: string | null;
     peak_mem_mb?: number;
     started_by_user_id?: string;
 }