beecork 1.4.8 → 1.4.10

package/dist/daemon.js

@@ -12,6 +12,7 @@ import { cleanupMedia } from './media/store.js';
 import { createNotificationProvider } from './notifications/index.js';
 import { VERSION } from './version.js';
 import { logActivity } from './timeline/index.js';
+import { findInstallRoot, getDaemonScript, writeRuntimeInfo, removeRuntimeInfo } from './util/install-info.js';
 let tabManager;
 let channelRegistry;
 let taskScheduler;
@@ -71,6 +72,21 @@ async function main() {
         fs.writeFileSync(pidPath, String(process.pid));
     }
     logger.info(`PID file written: ${process.pid}`);
+    // 3a. Write runtime.json so the CLI / postinstall can detect install-path divergence
+    try {
+        const installRoot = findInstallRoot(import.meta.url);
+        writeRuntimeInfo({
+            pid: process.pid,
+            version: VERSION,
+            installRoot,
+            daemonScript: getDaemonScript(installRoot),
+            startedAt: new Date().toISOString(),
+            nodeVersion: process.version,
+        });
+    }
+    catch (err) {
+        logger.warn('Could not write runtime.json (auto-heal may be skipped):', err);
+    }
     // 4. Create TabManager
     tabManager = new TabManager(config);
     // 5. Ensure default tab
@@ -188,6 +204,7 @@ async function main() {
         const pidPath = getPidPath();
         if (fs.existsSync(pidPath))
             fs.unlinkSync(pidPath);
+        removeRuntimeInfo();
         logActivity('system_event', 'Beecork daemon stopped');
         logger.info('Beecork daemon stopped.');
         logger.close();

package/dist/index.js

@@ -3,6 +3,18 @@ import { Command } from 'commander';
 import { platform } from 'node:os';
 import { VERSION } from './version.js';
 import { setupWizard } from './cli/setup.js';
+import { autoHealInstall } from './util/auto-heal.js';
+// Auto-heal install-path divergence: if the daemon is running from a different
+// beecork install than this CLI binary (e.g. user did `npm install -g beecork@latest`
+// to a different prefix than the launchd plist points at), rewrite the unit file
+// and signal the daemon to restart. Idempotent no-op otherwise. Never blocks the CLI.
+{
+    const heal = autoHealInstall(import.meta.url);
+    if (heal.action !== 'noop' && heal.action !== 'skip') {
+        const target = heal.newDaemonScript ?? '(running daemon)';
+        process.stderr.write(`[beecork] auto-heal: ${heal.action} → ${target}\n`);
+    }
+}
 import { startDaemon, stopDaemon, showStatus, listTabs, tailLogs, listCrons, deleteCron, listMemories, deleteMemory, sendMessage, updateBeecork, } from './cli/commands.js';
 const program = new Command();
 program

package/dist/session/manager.js

@@ -146,7 +146,7 @@ export class TabManager {
             }
         }
     }
-    async executeMessage(tab, prompt, resume, onTextChunk, onToolUse, compactionDepth) {
+    async executeMessage(tab, prompt, resume, onTextChunk, onToolUse, compactionDepth, forceFresh = false, retryDepth = 0) {
         const db = getDb();
         logActivity('task_started', 'Processing message', { tabName: tab.name, details: prompt.slice(0, 500) });
         // Budget check before spawning
@@ -177,9 +177,10 @@ export class TabManager {
         const breaker = new CircuitBreaker(tab.name);
         this.circuitBreakers.set(tab.name, breaker);
         const contextMonitor = new ContextMonitor(tab.name);
-        // Resume if: explicitly requested or DB has prior successful responses for this tab
-        const hasDbHistory = db.prepare('SELECT COUNT(*) as count FROM messages WHERE tab_id = ? AND role = ?').get(tab.id, 'assistant');
-        const shouldResume = resume || hasDbHistory.count > 0;
+        // Resume if: explicitly requested or DB has prior successful responses for this tab.
+        // forceFresh overrides both — used after a stale-session retry to guarantee --session-id, not --resume.
+        const hasDbHistory = db.prepare('SELECT COUNT(*) as count FROM messages WHERE tab_id = ? AND role = ? AND content != ?').get(tab.id, 'assistant', '');
+        const shouldResume = !forceFresh && (resume || hasDbHistory.count > 0);
         return new Promise((resolve, reject) => {
             let resultText = '';
             let resultEvent = null;
@@ -245,21 +246,35 @@ export class TabManager {
                         sessionId: subprocess.sessionId,
                         error: resultEvent?.is_error ?? (code !== 0),
                     };
-                    // Handle resume failure (session expired/not found) — retry with fresh session + context
-                    if (result.error && shouldResume && result.text.match(/session (not found|expired|invalid)/i)) {
-                        logger.info(`[${tab.name}] Session resume failed, retrying with context injection`);
-                        const recentMsgs = db.prepare('SELECT role, content FROM messages WHERE tab_id = ? ORDER BY created_at DESC LIMIT 5').all(tab.id);
+                    // Handle resume failure (Claude Code session cache rotated / never existed / expired).
+                    // Detection covers both legacy text-based errors and the modern error_during_execution
+                    // event shape ({"subtype":"error_during_execution","errors":["No conversation found..."]}).
+                    // retryDepth guards against any pathological loop.
+                    const staleSession = result.error && shouldResume && retryDepth === 0 && (result.text.match(/session (not found|expired|invalid)/i) !== null ||
+                        (resultEvent?.subtype === 'error_during_execution' &&
+                            resultEvent.errors?.some(e => /no conversation found|session.*not found|session.*expired|session.*invalid/i.test(e))));
+                    if (staleSession) {
+                        const detail = resultEvent?.errors?.[0] ?? result.text.split('\n')[0];
+                        logger.warn(`[${tab.name}] Resume session ${tab.sessionId} unavailable in Claude Code cache (${detail}). Retrying with fresh session.`);
+                        const recentMsgs = db.prepare("SELECT role, content FROM messages WHERE tab_id = ? AND content != '' ORDER BY created_at DESC LIMIT 5").all(tab.id);
                         const context = recentMsgs.reverse().map(m => `${m.role}: ${m.content.slice(0, 200)}`).join('\n');
-                        const contextPrompt = `[Previous conversation context:\n${context}\n]\n\n${enrichedPrompt}`;
-                        // Reset session ID for fresh start
+                        const contextPrompt = context
+                            ? `[Previous conversation context:\n${context}\n]\n\n${enrichedPrompt}`
+                            : enrichedPrompt;
+                        // Reset session ID for fresh start. Use --session-id (forceFresh) to bypass the
+                        // hasDbHistory shouldResume override that would otherwise --resume the new UUID
+                        // against an equally-empty Claude Code cache.
                         const newSessionId = uuidv4();
                         db.prepare('UPDATE tabs SET session_id = ?, status = ? WHERE id = ?').run(newSessionId, 'idle', tab.id);
-                        this.executeMessage({ ...tab, sessionId: newSessionId }, contextPrompt, false, onTextChunk)
+                        this.executeMessage({ ...tab, sessionId: newSessionId }, contextPrompt, false, onTextChunk, onToolUse, compactionDepth, true, retryDepth + 1)
                             .then(resolve).catch(reject);
                         return;
                     }
-                    // Store assistant response
-                    db.prepare('INSERT INTO messages (tab_id, role, content, cost_usd, tokens_in, tokens_out) VALUES (?, ?, ?, ?, ?, ?)').run(tab.id, 'assistant', result.text, result.costUsd, resultEvent?.usage?.input_tokens ?? null, resultEvent?.usage?.output_tokens ?? null);
+                    // Store assistant response. Skip empty content (typically failed/error runs) so
+                    // it doesn't trigger the hasDbHistory shouldResume override on future calls.
+                    if (result.text.trim() !== '') {
+                        db.prepare('INSERT INTO messages (tab_id, role, content, cost_usd, tokens_in, tokens_out) VALUES (?, ?, ?, ?, ?, ?)').run(tab.id, 'assistant', result.text, result.costUsd, resultEvent?.usage?.input_tokens ?? null, resultEvent?.usage?.output_tokens ?? null);
+                    }
                     // Update tab
                     db.prepare('UPDATE tabs SET status = ?, last_activity_at = ?, pid = NULL WHERE name = ?')
                         .run('idle', new Date().toISOString(), tab.name);

package/dist/tasks/scheduler.js

@@ -166,8 +166,9 @@ export class TaskScheduler {
             const result = await this.tabManager.sendMessage(job.tabName, job.message);
             this.store.update(job.id, { lastRunAt: new Date().toISOString() });
             const firstLine = result.text.split('\n')[0]?.slice(0, 200) || '(no output)';
-            // Log result
-            await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] SUCCESS: ${firstLine}\n`);
+            const status = result.error ? 'ERROR' : 'SUCCESS';
+            // Log result (status reflects subprocess exit / is_error, not just completion)
+            await fs.promises.appendFile(logFile, `[${new Date().toISOString()}] ${status}: ${firstLine}\n`);
             // Notify (separate try/catch -- notification failure shouldn't be reported as job failure)
             try {
                 if (this.onNotify) {

package/dist/types.d.ts

@@ -132,13 +132,14 @@ export interface StreamAssistant {
 }
 export interface StreamResult {
     type: 'result';
-    subtype: 'success' | 'error';
+    subtype: 'success' | 'error' | 'error_during_execution';
     is_error: boolean;
     duration_ms: number;
-    result: string;
+    result?: string;
+    errors?: string[];
     session_id: string;
-    total_cost_usd: number;
-    usage: StreamUsage;
+    total_cost_usd?: number;
+    usage?: StreamUsage;
 }
 export interface StreamUsage {
     input_tokens: number;

package/dist/util/auto-heal.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Auto-heal install-path divergence between the CLI (this process) and the
+ * running daemon. Triggered both from the npm postinstall hook and from the
+ * CLI entry on every invocation — both paths converge here so the policy is
+ * single-sourced and idempotent.
+ *
+ * What "divergence" means:
+ *   The daemon's launchd plist (or systemd unit) hard-codes an absolute path
+ *   to dist/daemon.js. If `npm install -g beecork@<new>` lands in a different
+ *   npm prefix than the one the unit file points at, the daemon keeps running
+ *   the old code while the CLI shows the new version. Bug reports get
+ *   misdiagnosed because the user thinks both are on the new version.
+ *
+ * What this function does:
+ *   1. Rewrite the unit file's daemon path if it doesn't point at us.
+ *   2. SIGTERM the running daemon (KeepAlive / Restart=always brings it back
+ *      on the new code) only when its runtime.json shows it was launched from
+ *      a different install root than ours.
+ *
+ * Returns a Result describing what happened, for the caller to surface (or not)
+ * to the user. The auto-heal NEVER throws — failures degrade to {action:'skip'}.
+ */
+export interface HealResult {
+    action: 'noop' | 'rewrote-unit' | 'signaled-daemon' | 'rewrote-and-signaled' | 'skip';
+    reason?: string;
+    unitPath?: string;
+    oldDaemonScript?: string;
+    newDaemonScript?: string;
+}
+export declare function autoHealInstall(fromFileUrl: string): HealResult;
+/**
+ * Extract the daemon-script absolute path from a launchd plist or systemd unit.
+ * Returns null if the file shape isn't recognized — caller treats that as "skip".
+ *
+ * launchd: looks inside <key>ProgramArguments</key><array> for the .js entry.
+ * systemd: looks for ExecStart=<node> <daemon.js> on a single line.
+ */
+export declare function extractDaemonScript(content: string): string | null;
+/** Rewrite-only variant used by tests and the postinstall hook in dry-run mode. */
+export declare function rewriteUnitDaemonScript(unitPath: string, newDaemonScript: string): {
+    rewrote: boolean;
+    oldDaemonScript: string | null;
+};

package/dist/util/auto-heal.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import { findInstallRoot, getDaemonScript, readRuntimeInfo, isPidAlive, getServiceUnitPath, } from './install-info.js';
+export function autoHealInstall(fromFileUrl) {
+    try {
+        const currentRoot = findInstallRoot(fromFileUrl);
+        const currentDaemonScript = getDaemonScript(currentRoot);
+        const unitPath = getServiceUnitPath();
+        if (!unitPath || !fs.existsSync(unitPath)) {
+            // No installed service — beecork has been npm-installed but `beecork setup` (or
+            // equivalent) hasn't been run yet. Nothing to heal.
+            return { action: 'skip', reason: 'no service unit file present' };
+        }
+        const unitContent = fs.readFileSync(unitPath, 'utf-8');
+        const oldDaemonScript = extractDaemonScript(unitContent);
+        let rewroteUnit = false;
+        if (oldDaemonScript && oldDaemonScript !== currentDaemonScript) {
+            // Validate the new path actually exists before rewriting — never break the daemon
+            // by pointing it at a missing file.
+            if (!fs.existsSync(currentDaemonScript)) {
+                return { action: 'skip', reason: `current install missing daemon: ${currentDaemonScript}` };
+            }
+            const next = unitContent.split(oldDaemonScript).join(currentDaemonScript);
+            const tmp = unitPath + '.tmp';
+            fs.writeFileSync(tmp, next);
+            fs.renameSync(tmp, unitPath);
+            rewroteUnit = true;
+        }
+        // Restart the daemon if it's currently running from a stale install. This is
+        // separate from the unit-file rewrite so we also catch the case where the unit
+        // file is already current but the running process predates the latest install.
+        const runtime = readRuntimeInfo();
+        let signaledDaemon = false;
+        if (runtime && runtime.installRoot !== currentRoot && isPidAlive(runtime.pid)) {
+            try {
+                process.kill(runtime.pid, 'SIGTERM');
+                signaledDaemon = true;
+            }
+            catch {
+                // Permission denied (different user, or already gone). Surface as skip;
+                // we still rewrote the unit file so the next start picks up the new path.
+            }
+        }
+        if (rewroteUnit && signaledDaemon) {
+            return { action: 'rewrote-and-signaled', unitPath, oldDaemonScript: oldDaemonScript, newDaemonScript: currentDaemonScript };
+        }
+        if (rewroteUnit)
+            return { action: 'rewrote-unit', unitPath, oldDaemonScript: oldDaemonScript, newDaemonScript: currentDaemonScript };
+        if (signaledDaemon)
+            return { action: 'signaled-daemon', unitPath };
+        return { action: 'noop' };
+    }
+    catch (err) {
+        return { action: 'skip', reason: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Extract the daemon-script absolute path from a launchd plist or systemd unit.
+ * Returns null if the file shape isn't recognized — caller treats that as "skip".
+ *
+ * launchd: looks inside <key>ProgramArguments</key><array> for the .js entry.
+ * systemd: looks for ExecStart=<node> <daemon.js> on a single line.
+ */
+export function extractDaemonScript(content) {
+    // launchd plist: pull the second <string> inside ProgramArguments
+    const launchdMatch = content.match(/<key>\s*ProgramArguments\s*<\/key>\s*<array>([\s\S]*?)<\/array>/);
+    if (launchdMatch) {
+        const args = Array.from(launchdMatch[1].matchAll(/<string>([^<]+)<\/string>/g)).map(m => m[1]);
+        const jsArg = args.find(a => a.endsWith('daemon.js'));
+        if (jsArg)
+            return jsArg;
+    }
+    // systemd unit: ExecStart=<node> <daemon.js> [args...]
+    const systemdMatch = content.match(/^ExecStart\s*=\s*(.+)$/m);
+    if (systemdMatch) {
+        const parts = systemdMatch[1].split(/\s+/);
+        const jsArg = parts.find(p => p.endsWith('daemon.js'));
+        if (jsArg)
+            return jsArg;
+    }
+    return null;
+}
+/** Rewrite-only variant used by tests and the postinstall hook in dry-run mode. */
+export function rewriteUnitDaemonScript(unitPath, newDaemonScript) {
+    if (!fs.existsSync(unitPath))
+        return { rewrote: false, oldDaemonScript: null };
+    const content = fs.readFileSync(unitPath, 'utf-8');
+    const oldDaemonScript = extractDaemonScript(content);
+    if (!oldDaemonScript)
+        return { rewrote: false, oldDaemonScript: null };
+    if (oldDaemonScript === newDaemonScript)
+        return { rewrote: false, oldDaemonScript };
+    const next = content.split(oldDaemonScript).join(newDaemonScript);
+    const tmp = unitPath + '.tmp';
+    fs.writeFileSync(tmp, next);
+    fs.renameSync(tmp, unitPath);
+    return { rewrote: true, oldDaemonScript };
+}

package/dist/util/install-info.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Metadata the daemon writes to ~/.beecork/runtime.json at startup so the CLI
+ * (and postinstall hook) can detect when daemon and CLI are running from
+ * different physical installs of beecork — the most common silent-staleness
+ * mode after `npm install -g beecork@<new>` lands in a prefix the daemon's
+ * launchd plist doesn't point at.
+ */
+export interface RuntimeInfo {
+    pid: number;
+    version: string;
+    /** The package root: <prefix>/lib/node_modules/beecork. Single canonical key. */
+    installRoot: string;
+    /** Absolute path to dist/daemon.js — derived from installRoot. */
+    daemonScript: string;
+    /** ISO timestamp. */
+    startedAt: string;
+    /** process.version (e.g. "v20.11.0") */
+    nodeVersion: string;
+}
+/**
+ * Walk up from a given file (typically import.meta.url) to find the directory
+ * containing package.json — i.e. the beecork install root. Works for both:
+ *  - source dev runs (.../src/util/install-info.ts → .../ )
+ *  - built/installed runs (.../dist/util/install-info.js → .../ )
+ */
+export declare function findInstallRoot(fromFileUrl: string): string;
+export declare function getDaemonScript(installRoot: string): string;
+export declare function writeRuntimeInfo(info: RuntimeInfo): void;
+export declare function readRuntimeInfo(): RuntimeInfo | null;
+export declare function removeRuntimeInfo(): void;
+export declare function isPidAlive(pid: number): boolean;
+/**
+ * Cross-platform path to the service-manager unit file that launches the daemon.
+ * Returns null if beecork doesn't manage one on this OS (currently Windows uses
+ * Task Scheduler and is out of scope for the auto-heal flow).
+ */
+export declare function getServiceUnitPath(): string | null;

package/dist/util/install-info.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { getRuntimeInfoPath } from './paths.js';
+/**
+ * Walk up from a given file (typically import.meta.url) to find the directory
+ * containing package.json — i.e. the beecork install root. Works for both:
+ *  - source dev runs (.../src/util/install-info.ts → .../ )
+ *  - built/installed runs (.../dist/util/install-info.js → .../ )
+ */
+export function findInstallRoot(fromFileUrl) {
+    const fromPath = fileURLToPath(fromFileUrl);
+    let dir = path.dirname(fromPath);
+    for (let i = 0; i < 6; i++) {
+        if (fs.existsSync(path.join(dir, 'package.json')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error(`Could not locate beecork install root walking up from ${fromPath}`);
+}
+export function getDaemonScript(installRoot) {
+    return path.join(installRoot, 'dist', 'daemon.js');
+}
+export function writeRuntimeInfo(info) {
+    const filePath = getRuntimeInfoPath();
+    // Atomic-ish write: temp + rename so a partial write never confuses a reader.
+    const tmp = filePath + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(info, null, 2));
+    fs.renameSync(tmp, filePath);
+}
+export function readRuntimeInfo() {
+    const filePath = getRuntimeInfoPath();
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (typeof data?.pid === 'number' && typeof data?.installRoot === 'string') {
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function removeRuntimeInfo() {
+    const filePath = getRuntimeInfoPath();
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch { /* not present, fine */ }
+}
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Cross-platform path to the service-manager unit file that launches the daemon.
+ * Returns null if beecork doesn't manage one on this OS (currently Windows uses
+ * Task Scheduler and is out of scope for the auto-heal flow).
+ */
+export function getServiceUnitPath() {
+    const home = os.homedir();
+    if (process.platform === 'darwin')
+        return path.join(home, 'Library', 'LaunchAgents', 'com.beecork.daemon.plist');
+    if (process.platform === 'linux')
+        return path.join(home, '.config', 'systemd', 'user', 'beecork.service');
+    return null;
+}

package/dist/util/paths.d.ts

@@ -5,6 +5,7 @@ export declare function getCrontabPath(): string;
 export declare function getMcpConfigPath(): string;
 export declare function getLogsDir(): string;
 export declare function getPidPath(): string;
+export declare function getRuntimeInfoPath(): string;
 export declare function getCronReloadSignalPath(): string;
 export declare function ensureBeecorkDirs(): void;
 export declare function expandHome(p: string): string;

package/dist/util/paths.js

@@ -23,6 +23,9 @@ export function getLogsDir() {
 export function getPidPath() {
     return path.join(getBeecorkHome(), 'beecork.pid');
 }
+export function getRuntimeInfoPath() {
+    return path.join(getBeecorkHome(), 'runtime.json');
+}
 export function getCronReloadSignalPath() {
     return path.join(getBeecorkHome(), '.cron-reload');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "beecork",
-  "version": "1.4.8",
+  "version": "1.4.10",
   "description": "Claude Code always-on infrastructure — a phone number, a memory, and an alarm clock",
   "type": "module",
   "bin": {
@@ -16,7 +16,8 @@
     "test": "vitest",
     "lint": "eslint src/",
     "build:css": "tailwindcss --content src/dashboard/html.ts --minify",
-    "prepublishOnly": "npm test && npm run build"
+    "prepublishOnly": "npm test && npm run build",
+    "postinstall": "node scripts/postinstall.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
@@ -42,7 +43,8 @@
     "vitest": "^4.1.4"
   },
   "files": [
-    "dist/"
+    "dist/",
+    "scripts/postinstall.mjs"
   ],
   "keywords": [
     "claude",

package/scripts/postinstall.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+// Beecork postinstall hook.
+//
+// Runs after `npm install -g beecork[@<version>]`. Goal: if a beecork daemon
+// is already managed by the OS (launchd plist on mac, systemd unit on linux)
+// from a DIFFERENT install path than this freshly-installed one, rewrite the
+// unit file to point at this install and signal the daemon to restart so the
+// running process picks up the new code without the user having to think about
+// install prefixes.
+//
+// No-ops cleanly in every other case (first install, local install,
+// dependency install, no daemon, dependency install in CI, etc.).
+
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import fs from 'node:fs';
+
+// Run only for global installs. npm sets npm_config_global="true" for `npm install -g`.
+// `npm ci` / `npm install` (no -g) inside the repo leaves it unset/empty — skip those.
+if (process.env.npm_config_global !== 'true') {
+  process.exit(0);
+}
+
+// Resolve the auto-heal module from dist/. If the user installed from a
+// tarball without dist/ (shouldn't happen — `files` whitelists dist/, and
+// `prepublishOnly` builds it — but be defensive), skip silently.
+const here = path.dirname(fileURLToPath(import.meta.url));
+const installRoot = path.dirname(here);
+const autoHealModule = path.join(installRoot, 'dist', 'util', 'auto-heal.js');
+
+if (!fs.existsSync(autoHealModule)) {
+  // Built artifacts missing — skip silently. This is the npm-publish-with-no-build
+  // edge case which is already caught by `prepublishOnly`. Don't fail the install.
+  process.exit(0);
+}
+
+try {
+  const { autoHealInstall } = await import(autoHealModule);
+  const result = autoHealInstall(import.meta.url);
+  if (result.action === 'rewrote-unit' || result.action === 'rewrote-and-signaled') {
+    process.stderr.write(`[beecork] launchd/systemd unit re-pointed at ${result.newDaemonScript}\n`);
+  }
+  if (result.action === 'signaled-daemon' || result.action === 'rewrote-and-signaled') {
+    process.stderr.write(`[beecork] running daemon signaled to restart on new code\n`);
+  }
+  // 'noop' / 'skip' → silent
+} catch (err) {
+  // Never fail an install on auto-heal trouble — just leave a breadcrumb.
+  process.stderr.write(`[beecork] postinstall auto-heal skipped: ${err?.message ?? err}\n`);
+}