@adhdev/daemon-core 1.0.23 → 1.0.24-rc.1

package/dist/providers/cli-provider-instance.d.ts

@@ -768,6 +768,30 @@ export declare class CliProviderInstance implements ProviderInstance {
      * the emitted event, exactly as each inline builder produced before.
      */
     private emitGeneratingCompleted;
+    /**
+     * COMPLETION-WEAK-REARM (fix1): the double-emit guard shared by the three transcript
+     * re-emit paths (flushMeshCompletionBeforeCleanup, tryReconcilePurePtyCompletionForStall,
+     * tryReconcileNativeSourceCompletionForStall). Returns true when a re-emit for `taskId`
+     * must be SUPPRESSED because this turn's completion already fired with strong evidence.
+     *
+     * The defect this replaces: the old guard short-circuited on ANY prior emit for the
+     * taskId, regardless of its evidence. After a WEAK completion (CANON-C decoupled-immediate
+     * missing_final_assistant, or a startup-grace fast-collapse synth), the same session
+     * reaching a GENUINE idle later (final assistant present) was silently swallowed — the
+     * worker never emitted the genuine completion and the coordinator held on the acked-death
+     * deadline (8 min).
+     *
+     * New behavior:
+     *   • no latch / taskId mismatch → NOT suppressed (the caller's own evidence gate runs).
+     *   • prior emit was GENUINE (not weak) → SUPPRESSED (single-shot; a clean completion is
+     *     never re-emitted).
+     *   • prior emit was WEAK → re-arm ONE-SHOT, but only across a real generating→idle
+     *     transition: require busyEpoch to have advanced past the weak emit's epoch, so a
+     *     static idle screen cannot re-fire the same weak frame. The genuine re-emit passes
+     *     evidenceLevel:'transcript' (non-weak), overwriting the latch → any subsequent idle
+     *     tick hits the now-genuine latch and is suppressed. Never a third emit.
+     */
+    private shouldSuppressCompletionReEmit;
     /**
      * AUTOAPPROVE-FLAP-INBOX-MISSING sticky-approval overlay. Returns the adapterStatus a
      * flap-prone claude-cli approval SHOULD present this frame — either the raw status

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "1.0.23",
+  "version": "1.0.24-rc.1",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "*",
-    "@adhdev/session-host-core": "*",
+    "@adhdev/mesh-shared": "1.0.24-rc.1",
+    "@adhdev/session-host-core": "1.0.24-rc.1",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/cli-adapters/provider-cli-shared.ts

@@ -789,6 +789,112 @@ export function computeTerminalQueryTail(buffer: string): string {
     return '';
 }
 
+/**
+ * Windows executable extensions to probe, derived from `%PATHEXT%` so we honor
+ * whatever the shell would actually resolve (`.exe;.bat;.cmd;.ps1;…`). We add
+ * `.ps1` explicitly (npm now ships PowerShell shims and it is not always in the
+ * default PATHEXT) and always include `''` so an already-extensioned name
+ * (`codex.cmd`) still matches. Falls back to a sane default list when PATHEXT
+ * is unset. Non-win32 callers never reach this.
+ */
+function windowsExecutableExtensions(): string[] {
+    const raw = process.env.PATHEXT;
+    const fromEnv = raw
+        ? raw.split(';').map((e) => e.trim().toLowerCase()).filter(Boolean)
+        : ['.exe', '.cmd', '.bat'];
+    const merged = [...fromEnv];
+    if (!merged.includes('.ps1')) merged.push('.ps1');
+    // Bare name last so extensioned matches win first.
+    if (!merged.includes('')) merged.push('');
+    // De-dupe while preserving order.
+    return Array.from(new Set(merged));
+}
+
+/**
+ * Best-effort resolution of the active npm global prefix via
+ * `npm config get prefix`. This is the authoritative non-default prefix that a
+ * daemon's inherited PATH cannot infer — nvm / nvm-windows, `npm config set
+ * prefix`, `~/.npm-global`, custom `--prefix`. Consulted with a SHORT timeout so
+ * a slow/absent npm never hangs detection, and memoized per-process so repeated
+ * detections don't re-spawn the (relatively slow) npm process.
+ * Returns the raw prefix dir, or undefined when npm is unavailable.
+ */
+let cachedNpmPrefix: string | undefined | null = undefined; // null = resolved-to-nothing
+function npmGlobalPrefix(): string | undefined {
+    if (cachedNpmPrefix !== undefined) return cachedNpmPrefix ?? undefined;
+    try {
+        const prefix = execSync('npm config get prefix', {
+            encoding: 'utf-8',
+            timeout: 2000,
+            windowsHide: true,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        cachedNpmPrefix = prefix && prefix !== 'undefined' ? prefix : null;
+    } catch {
+        cachedNpmPrefix = null; // npm not on PATH or slow — remember and skip
+    }
+    return cachedNpmPrefix ?? undefined;
+}
+
+/** Test-only: reset the memoized npm-prefix so a test can re-stub `execSync`. */
+export function __resetNpmPrefixCacheForTests(): void {
+    cachedNpmPrefix = undefined;
+}
+
+/**
+ * Common Windows npm-global / package-manager bin dirs that a daemon's inherited
+ * PATH frequently misses. Additive and existence-guarded — we only return dirs
+ * that exist, so the common path stats nothing extra beyond a handful of paths.
+ * `npm config get prefix` is consulted best-effort (short timeout) because it is
+ * the authoritative non-default prefix (nvm-windows, custom `--prefix`).
+ */
+function windowsExtraBinDirs(): string[] {
+    const dirs: string[] = [];
+    const fs = require('fs');
+    const push = (dir: string | undefined | null) => {
+        if (!dir) return;
+        try { if (fs.existsSync(dir)) dirs.push(dir); } catch { /* best-effort */ }
+    };
+    if (process.env.APPDATA) push(path.join(process.env.APPDATA, 'npm'));
+    if (process.env.LOCALAPPDATA) push(path.join(process.env.LOCALAPPDATA, 'npm'));
+    if (process.env.USERPROFILE) push(path.join(process.env.USERPROFILE, 'scoop', 'shims'));
+    // nvm-windows / custom prefix: `npm config get prefix` points at the active
+    // global bin dir, which on Windows is the prefix dir itself (shims live there).
+    push(npmGlobalPrefix());
+    try { push(path.dirname(process.execPath)); } catch { /* best-effort */ }
+    return dirs;
+}
+
+/**
+ * Common Unix (Linux/macOS) global-bin dirs that a daemon's minimal non-login
+ * PATH frequently misses. The systemd unit ships no PATH pin, so a daemon started
+ * outside the user's interactive shell never sees these. Additive and
+ * existence-guarded. Notably includes `~/.local/bin`, the Claude Code native
+ * installer default (`curl … install.sh | bash`), plus the npm global prefix bin
+ * (nvm / `npm config set prefix` / `~/.npm-global`).
+ */
+function unixExtraBinDirs(): string[] {
+    const dirs: string[] = [];
+    const fs = require('fs');
+    const home = os.homedir();
+    const push = (dir: string | undefined | null) => {
+        if (!dir) return;
+        try { if (fs.existsSync(dir)) dirs.push(dir); } catch { /* best-effort */ }
+    };
+    // Claude Code native-installer default + alternate native location.
+    push(path.join(home, '.local', 'bin'));
+    push(path.join(home, '.claude', 'local', 'bin'));
+    // Historical / explicit npm-global default.
+    push(path.join(home, '.npm-global', 'bin'));
+    push('/usr/local/bin');
+    push('/opt/homebrew/bin');
+    // Active npm prefix bin — covers nvm / custom `npm config set prefix`.
+    const prefix = npmGlobalPrefix();
+    if (prefix) push(path.join(prefix, 'bin'));
+    try { push(path.dirname(process.execPath)); } catch { /* best-effort */ }
+    return dirs;
+}
+
 export function findBinary(name: string): string {
     const trimmed = String(name || '').trim();
     if (!trimmed) return trimmed;
@@ -809,15 +915,12 @@ export function findBinary(name: string): string {
     // handling then launches it correctly regardless of PATH.
     const extraDirs: string[] = [];
     if (isWin) {
-        if (process.env.APPDATA) extraDirs.push(path.join(process.env.APPDATA, 'npm'));
-        try { extraDirs.push(path.dirname(process.execPath)); } catch { /* best-effort */ }
+        extraDirs.push(...windowsExtraBinDirs());
     } else {
-        extraDirs.push(path.join(os.homedir(), '.npm-global', 'bin'));
-        extraDirs.push('/usr/local/bin', '/opt/homebrew/bin');
-        try { extraDirs.push(path.dirname(process.execPath)); } catch { /* best-effort */ }
+        extraDirs.push(...unixExtraBinDirs());
     }
     const searchDirs = [...paths, ...extraDirs];
-    const exes = isWin ? ['.exe', '.cmd', '.bat', ''] : [''];
+    const exes = isWin ? windowsExecutableExtensions() : [''];
 
     for (const p of searchDirs) {
         if (!p) continue;

package/src/commands/upgrade-helper.d.ts

@@ -19,11 +19,14 @@ export interface PinnedGlobalInstallCommand {
     surface: CurrentGlobalInstallSurface;
     execOptions: { shell: boolean };
 }
+export declare function resolveInstanceDir(configDir?: string): string;
 export declare function resolveCurrentGlobalInstallSurface(options: {
     packageName: string;
     currentCliPath?: string;
     nodeExecutable?: string;
     platform?: NodeJS.Platform;
+    homeDir?: string;
+    instanceDir?: string;
 }): CurrentGlobalInstallSurface;
 export declare function buildPinnedGlobalInstallCommand(options: {
     packageName: string;

package/src/commands/upgrade-helper.ts

@@ -16,9 +16,22 @@ import {
   stopOwnedProcessesForPrefixes,
   waitForPidExit,
 } from './process-lifecycle.js';
+import { getConfigDir } from '../config/config.js';
 
 const UPGRADE_HELPER_ENV = 'ADHDEV_DAEMON_UPGRADE_HELPER';
 
+// Canonical per-instance base dir name (e.g. `.adhdev` for stable,
+// `.adhdev-preview` for the coexisting preview install). Derived from the
+// running daemon's config dir basename so it stays consistent with Phase 0/1:
+// the installer pins ADHDEV_CONFIG_DIR=~/.adhdev-preview for the preview
+// instance, getConfigDir() honors it, and its basename is the instance dir. A
+// stable / no-override daemon yields `.adhdev`, so every Windows-layout path is
+// byte-for-byte identical to before the instance axis existed.
+export function resolveInstanceDir(configDir: string = getConfigDir()): string {
+  const base = path.basename(configDir).trim();
+  return base || '.adhdev';
+}
+
 export interface DaemonUpgradeHelperPayload {
   packageName: string;
   targetVersion: string;
@@ -152,9 +165,9 @@ function resolveInstallPrefixFromPackageRoot(packageRoot: string, packageName: s
 // dispatcher shims in ~/.adhdev/npm-global. Because self-upgrade reuses the
 // running prefix, that install then re-installs into the same node22 dir forever
 // and never converts to the dispatcher. Detecting it lets us force convergence.
-function isPortableNode22Prefix(prefix: string | null, homeDir: string): boolean {
+function isPortableNode22Prefix(prefix: string | null, homeDir: string, instanceDir: string = '.adhdev'): boolean {
   if (!prefix) return false;
-  const portableRoot = path.join(homeDir, '.adhdev', 'tools', 'node22');
+  const portableRoot = path.join(homeDir, instanceDir, 'tools', 'node22');
   const normalizedPrefix = path.resolve(prefix).replace(/[\\/]+$/, '').toLowerCase();
   const normalizedRoot = path.resolve(portableRoot).replace(/[\\/]+$/, '').toLowerCase();
   return normalizedPrefix === normalizedRoot || normalizedPrefix.startsWith(`${normalizedRoot}${path.sep.toLowerCase()}`);
@@ -168,9 +181,9 @@ function isPortableNode22Prefix(prefix: string | null, homeDir: string): boolean
 // resolveWindowsInstallerLayout only requires a `npm-installs/version-*` path —
 // performWindowsAtomicUpgrade stages a fresh version- prefix of its own and uses
 // this only as the "old prefix" to stop/clean, so a non-existent path is a no-op.
-function canonicalDispatcherInstallPrefix(homeDir: string): string {
-  const installRoot = path.join(homeDir, '.adhdev', 'npm-installs');
-  const pointerPath = path.join(homeDir, '.adhdev', 'npm-global', '.adhdev-current');
+function canonicalDispatcherInstallPrefix(homeDir: string, instanceDir: string = '.adhdev'): string {
+  const installRoot = path.join(homeDir, instanceDir, 'npm-installs');
+  const pointerPath = path.join(homeDir, instanceDir, 'npm-global', '.adhdev-current');
   try {
     const activeVersion = fs.readFileSync(pointerPath, 'utf8').trim();
     if (activeVersion.startsWith('version-')) return path.join(installRoot, activeVersion);
@@ -186,11 +199,19 @@ export function resolveCurrentGlobalInstallSurface(options: {
   nodeExecutable?: string;
   platform?: NodeJS.Platform;
   homeDir?: string;
+  /**
+   * Per-instance base dir name under homeDir (`.adhdev` stable /
+   * `.adhdev-preview` preview). Defaults to the running daemon's config-dir
+   * basename via resolveInstanceDir(), so the legacy-prefix convergence checks
+   * scope to the correct instance's tools/node22 + npm-installs tree.
+   */
+  instanceDir?: string;
 }): CurrentGlobalInstallSurface {
   const packageRoot = findCurrentPackageRoot(options.currentCliPath || process.argv[1], options.packageName);
   const npmInvocation = resolveSiblingNpmInvocation(options.nodeExecutable || process.execPath, options.platform);
   const platform = options.platform || process.platform;
   const homeDir = options.homeDir || os.homedir();
+  const instanceDir = options.instanceDir || resolveInstanceDir();
   let installPrefix = packageRoot ? resolveInstallPrefixFromPackageRoot(packageRoot, options.packageName) : null;
   // FIX C: on Windows, never let a self-upgrade perpetuate the legacy
   // node22-prefix install. If the running adhdev lives under ~/.adhdev/tools/
@@ -198,8 +219,8 @@ export function resolveCurrentGlobalInstallSurface(options: {
   // converges to the ~/.adhdev/npm-global pointer + shims. Scoped to win32 AND a
   // tools/node22 prefix so npm-linked dev / standalone / real dispatcher installs
   // are untouched.
-  if (platform === 'win32' && isPortableNode22Prefix(installPrefix, homeDir)) {
-    installPrefix = canonicalDispatcherInstallPrefix(homeDir);
+  if (platform === 'win32' && isPortableNode22Prefix(installPrefix, homeDir, instanceDir)) {
+    installPrefix = canonicalDispatcherInstallPrefix(homeDir, instanceDir);
   }
   return {
     npmExecutable: npmInvocation.executable,
@@ -576,12 +597,18 @@ async function runDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): Prom
 
   await stopSessionHostProcesses(sessionHostAppName);
   removeDaemonPidFile();
+  // Scope the Windows atomic-upgrade layout to THIS daemon's instance so
+  // `adhdev-preview update` rotates only the preview prefix/pointer/tools tree
+  // and never touches the stable install (and vice-versa). Stable / no-override
+  // daemons resolve `.adhdev`, keeping the historical layout byte-identical.
+  const instanceDir = resolveInstanceDir();
   const windowsInstallerLayout = resolveWindowsInstallerLayout({
     homeDir: os.homedir(),
     installPrefix: installCommand.surface.installPrefix,
+    instanceDir,
   });
   if (windowsInstallerLayout) {
-    const portableNode = findPortableNode22(os.homedir());
+    const portableNode = findPortableNode22(os.homedir(), process.execPath, instanceDir);
     if (!portableNode) {
       throw new Error('installer-managed Windows update requires the portable Node.js 22 runtime');
     }

package/src/commands/windows-atomic-upgrade.ts

@@ -103,14 +103,32 @@ function normalizeForCompare(value: string): string {
   return path.resolve(value).replace(/[\\/]+$/, '').toLowerCase();
 }
 
+// The per-instance base directory name under homeDir. Stable installs live under
+// `.adhdev` (the historical literal); the coexisting preview install lives under
+// `.adhdev-preview`. When unset it falls back to `.adhdev`, so every stable
+// call site resolves to byte-identical paths to before this option existed.
+export const DEFAULT_INSTANCE_DIR = '.adhdev';
+
+function normalizeInstanceDir(instanceDir?: string | null): string {
+  const trimmed = instanceDir?.trim();
+  return trimmed ? trimmed : DEFAULT_INSTANCE_DIR;
+}
+
 export function resolveWindowsInstallerLayout(options: {
   homeDir: string;
   installPrefix: string | null;
   platform?: NodeJS.Platform;
+  /**
+   * Per-instance base dir name under homeDir (e.g. `.adhdev` for stable,
+   * `.adhdev-preview` for the coexisting preview install). Defaults to
+   * `.adhdev`, keeping the stable layout byte-for-byte identical to before.
+   */
+  instanceDir?: string;
 }): WindowsInstallerLayout | null {
   if ((options.platform || process.platform) !== 'win32' || !options.installPrefix) return null;
-  const installRoot = path.join(options.homeDir, '.adhdev', 'npm-installs');
-  const stablePrefix = path.join(options.homeDir, '.adhdev', 'npm-global');
+  const instanceDir = normalizeInstanceDir(options.instanceDir);
+  const installRoot = path.join(options.homeDir, instanceDir, 'npm-installs');
+  const stablePrefix = path.join(options.homeDir, instanceDir, 'npm-global');
   const pointerPath = path.join(stablePrefix, POINTER_NAME);
   const activeVersionName = path.basename(options.installPrefix);
   if (!activeVersionName.startsWith('version-')) return null;
@@ -140,9 +158,13 @@ function nodeMajor(nodeExecutable: string): number | null {
   }
 }
 
-export function findPortableNode22(homeDir: string, currentNode: string = process.execPath): string | null {
+export function findPortableNode22(
+  homeDir: string,
+  currentNode: string = process.execPath,
+  instanceDir: string = DEFAULT_INSTANCE_DIR,
+): string | null {
   const candidates: string[] = [currentNode];
-  const portableRoot = path.join(homeDir, '.adhdev', 'tools', 'node22');
+  const portableRoot = path.join(homeDir, normalizeInstanceDir(instanceDir), 'tools', 'node22');
   try {
     const dirs = fs.readdirSync(portableRoot, { withFileTypes: true })
       .filter((entry) => entry.isDirectory())

package/src/index.ts

@@ -205,7 +205,7 @@ export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete
 export type { IDaemonCore, DaemonCoreOptions } from './daemon-core.js';
 
 // ── Config ──
-export { loadConfig, saveConfig, resetConfig, isSetupComplete, markSetupComplete, updateConfig, getDaemonDataDir } from './config/config.js';
+export { loadConfig, saveConfig, resetConfig, isSetupComplete, markSetupComplete, updateConfig, getConfigDir, getDaemonDataDir } from './config/config.js';
 export { getWorkspaceState } from './config/workspaces.js';
 export { appendRecentActivity, getRecentActivity } from './config/recent-activity.js';
 export type { RecentActivityEntry } from './config/recent-activity.js';
@@ -392,6 +392,7 @@ export {
   maybeRunDaemonUpgradeHelperFromEnv,
   spawnDetachedDaemonUpgradeHelper,
   resolveCurrentGlobalInstallSurface,
+  resolveInstanceDir,
   buildPinnedGlobalInstallCommand,
   execNpmCommandSync,
   getNpmExecOptions,

package/src/providers/cli-provider-instance.ts

@@ -27,6 +27,7 @@ import { LOG } from '../logging/logger.js';
 import { recordDebugTrace } from '../logging/debug-trace.js';
 import { shouldCollectTraceCategory } from '../logging/debug-config.js';
 import { traceMeshEventStage, traceMeshEventDrop } from '../mesh/mesh-event-trace.js';
+import { isWeakCompletionEvidence } from '../mesh/mesh-events-utils.js';
 import type { ChatMessage } from '../types.js';
 import { buildPersistedProviderEffectMessage, normalizeProviderEffects } from './control-effects.js';
 import { formatAutoApprovalMessage, pickApprovalButton, hasNegativeApprovalOption, hasReliableApprovalAffirmative, looksLikeActiveApprovalPromptText, normalizeApprovalLabel } from './approval-utils.js';
@@ -1439,7 +1440,20 @@ export class CliProviderInstance implements ProviderInstance {
     // this to refuse a SECOND completion for a turn whose completion already fired —
     // so a worker that finished cleanly and is simply being auto-cleaned never emits a
     // duplicate. taskId '' covers an ad-hoc (no-task) turn. null = none emitted yet.
-    private lastEmittedCompletion: { taskId: string; at: number } | null = null;
+    //
+    // COMPLETION-WEAK-REARM (fix1): the latch now carries the EVIDENCE STRENGTH of the
+    // recorded emit. `weak` mirrors isWeakCompletionEvidence() over the exact event that
+    // was pushed (evidenceLevel ∈ {weak,insufficient}, reviewRecommended, or a
+    // missing_final_assistant diagnostic — the CANON-C decoupled-immediate emit and the
+    // startup-grace fast-collapse synth are the two weak producers). `emittedAtEpoch`
+    // snapshots busyEpoch at emit time so the transcript re-emit paths can require a real
+    // generating→idle transition (busyEpoch advanced past this) before re-arming — a
+    // static idle screen can never re-fire the same weak frame. A weak latch is a
+    // ONE-SHOT re-arm: the genuine re-emit overwrites this with weak=false, so a
+    // subsequent idle tick hits the non-weak latch and stops (never a third emit).
+    private lastEmittedCompletion:
+        | { taskId: string; at: number; evidenceLevel?: string; weak: boolean; emittedAtEpoch: number }
+        | null = null;
 
     private async enforceFreshSessionLaunchIfNeeded(): Promise<void> {
         const scriptName = getForcedNewSessionScriptName(this.provider, this.launchMode);
@@ -2658,8 +2672,10 @@ export class CliProviderInstance implements ProviderInstance {
         if (!this.isMeshWorkerSession()) return false;
         const taskId = this.completingTurnTaskId();
 
-        // DOUBLE-EMIT guard: this turn's completion already fired — never re-emit.
-        if (this.lastEmittedCompletion && this.lastEmittedCompletion.taskId === (taskId ?? '')) {
+        // DOUBLE-EMIT guard (COMPLETION-WEAK-REARM fix1): suppress a re-emit only when this
+        // turn's completion already fired with GENUINE evidence. A prior WEAK emit is
+        // re-armable once a real generating→idle transition intervened (one-shot).
+        if (this.shouldSuppressCompletionReEmit(taskId)) {
             return false;
         }
 
@@ -2737,8 +2753,10 @@ export class CliProviderInstance implements ProviderInstance {
         if (this.hasAdapterPendingResponse()) return false;
 
         const taskId = this.completingTurnTaskId();
-        // DOUBLE-EMIT guard: this turn's completion already fired — never re-emit.
-        if (this.lastEmittedCompletion && this.lastEmittedCompletion.taskId === (taskId ?? '')) {
+        // DOUBLE-EMIT guard (COMPLETION-WEAK-REARM fix1): suppress a re-emit only when this
+        // turn's completion already fired with GENUINE evidence. A prior WEAK emit is
+        // re-armable once a real generating→idle transition intervened (one-shot).
+        if (this.shouldSuppressCompletionReEmit(taskId)) {
             return false;
         }
         // The injected task's own turn must have genuinely started (guards against a
@@ -2814,8 +2832,10 @@ export class CliProviderInstance implements ProviderInstance {
         if (this.hasAdapterPendingResponse()) return false;
 
         const taskId = this.completingTurnTaskId();
-        // DOUBLE-EMIT guard: this turn's completion already fired — never re-emit.
-        if (this.lastEmittedCompletion && this.lastEmittedCompletion.taskId === (taskId ?? '')) {
+        // DOUBLE-EMIT guard (COMPLETION-WEAK-REARM fix1): suppress a re-emit only when this
+        // turn's completion already fired with GENUINE evidence. A prior WEAK emit is
+        // re-armable once a real generating→idle transition intervened (one-shot).
+        if (this.shouldSuppressCompletionReEmit(taskId)) {
             return false;
         }
         // The injected task's own turn must have genuinely started (guards against a
@@ -3401,12 +3421,8 @@ export class CliProviderInstance implements ProviderInstance {
         if (summary) {
             this.lastCompletionSummary = { content: summary, receivedAt: opts.timestamp };
         }
-        // KIMI-MESH-COMPLETION-EMIT (axis 2, double-emit guard): record that THIS turn's
-        // completion has now been emitted, keyed by its taskId, so the pre-cleanup
-        // completion flush never fires a duplicate for the same turn.
-        this.lastEmittedCompletion = { taskId: typeof opts.taskId === 'string' ? opts.taskId : '', at: Date.now() };
-        this.pushEvent({
-            event: 'agent:generating_completed',
+        const completionEvent = {
+            event: 'agent:generating_completed' as const,
             chatTitle: opts.chatTitle,
             duration: opts.duration,
             timestamp: opts.timestamp,
@@ -3417,7 +3433,27 @@ export class CliProviderInstance implements ProviderInstance {
             finalSummary: opts.finalSummary,
             ...(opts.evidenceLevel !== undefined ? { evidenceLevel: opts.evidenceLevel } : {}),
             ...(opts.completionDiagnostic !== undefined ? { completionDiagnostic: opts.completionDiagnostic } : {}),
-        });
+        };
+        // KIMI-MESH-COMPLETION-EMIT (axis 2, double-emit guard): record that THIS turn's
+        // completion has now been emitted, keyed by its taskId, so the pre-cleanup
+        // completion flush never fires a duplicate for the same turn.
+        //
+        // COMPLETION-WEAK-REARM (fix1): stamp the emit's evidence STRENGTH so the three
+        // transcript re-emit guards can distinguish a weak first emit (which must be
+        // re-armable once a genuine idle lands) from a genuine one (single-shot). The
+        // weakness is read from the exact event being pushed — evidenceLevel plus the
+        // completionDiagnostic (missing_final_assistant blockReason) — via the same
+        // isWeakCompletionEvidence() the coordinator/ledger paths share, so the worker's
+        // notion of "weak" cannot drift from theirs. emittedAtEpoch snapshots busyEpoch so
+        // a re-arm requires a real generating→idle transition after this emit.
+        this.lastEmittedCompletion = {
+            taskId: typeof opts.taskId === 'string' ? opts.taskId : '',
+            at: Date.now(),
+            evidenceLevel: opts.evidenceLevel,
+            weak: isWeakCompletionEvidence(completionEvent as Record<string, unknown>),
+            emittedAtEpoch: this.busyEpoch,
+        };
+        this.pushEvent(completionEvent);
         // COORDINATOR-SILENT-IDLE one-shot consume: this completion's snapshot rides the
         // armed mute (resolveMuted honors settings.silentNextIdlePush for the idle status
         // above), so the routine idle push is suppressed for THIS completion only. Clear
@@ -3429,6 +3465,42 @@ export class CliProviderInstance implements ProviderInstance {
         }
     }
 
+    /**
+     * COMPLETION-WEAK-REARM (fix1): the double-emit guard shared by the three transcript
+     * re-emit paths (flushMeshCompletionBeforeCleanup, tryReconcilePurePtyCompletionForStall,
+     * tryReconcileNativeSourceCompletionForStall). Returns true when a re-emit for `taskId`
+     * must be SUPPRESSED because this turn's completion already fired with strong evidence.
+     *
+     * The defect this replaces: the old guard short-circuited on ANY prior emit for the
+     * taskId, regardless of its evidence. After a WEAK completion (CANON-C decoupled-immediate
+     * missing_final_assistant, or a startup-grace fast-collapse synth), the same session
+     * reaching a GENUINE idle later (final assistant present) was silently swallowed — the
+     * worker never emitted the genuine completion and the coordinator held on the acked-death
+     * deadline (8 min).
+     *
+     * New behavior:
+     *   • no latch / taskId mismatch → NOT suppressed (the caller's own evidence gate runs).
+     *   • prior emit was GENUINE (not weak) → SUPPRESSED (single-shot; a clean completion is
+     *     never re-emitted).
+     *   • prior emit was WEAK → re-arm ONE-SHOT, but only across a real generating→idle
+     *     transition: require busyEpoch to have advanced past the weak emit's epoch, so a
+     *     static idle screen cannot re-fire the same weak frame. The genuine re-emit passes
+     *     evidenceLevel:'transcript' (non-weak), overwriting the latch → any subsequent idle
+     *     tick hits the now-genuine latch and is suppressed. Never a third emit.
+     */
+    private shouldSuppressCompletionReEmit(taskId: string | undefined): boolean {
+        const latch = this.lastEmittedCompletion;
+        if (!latch || latch.taskId !== (taskId ?? '')) return false;
+        // Prior emit was genuine → single-shot, never re-emit.
+        if (!latch.weak) return true;
+        // Prior emit was weak → allow the genuine re-emit ONLY once a real generating phase
+        // opened after the weak emit (busyEpoch advanced). Otherwise a static idle frame would
+        // re-fire the same weak completion. Bounded to a single re-arm by the latch overwrite
+        // the genuine re-emit performs (weak=false), so the next tick is suppressed above.
+        if (this.busyEpoch <= latch.emittedAtEpoch) return true;
+        return false;
+    }
+
     /**
      * AUTOAPPROVE-FLAP-INBOX-MISSING sticky-approval overlay. Returns the adapterStatus a
      * flap-prone claude-cli approval SHOULD present this frame — either the raw status

package/src/session-host/managed-host.ts

@@ -9,6 +9,8 @@ import {
     type SessionHostRequestType,
 } from '@adhdev/session-host-core';
 import { getProcessCommandLine, parseNodeScriptPath } from '../commands/process-lifecycle.js';
+import { findPortableNode22 } from '../commands/windows-atomic-upgrade.js';
+import { resolveInstanceDir } from '../commands/upgrade-helper.js';
 import { LOG } from '../logging/logger.js';
 import { ensureSessionHostReady as ensureSharedSessionHostReady } from './runtime-support.js';
 import { DEFAULT_SESSION_HOST_READY_TIMEOUT_MS } from '../runtime-defaults.js';
@@ -139,8 +141,52 @@ export function createManagedSessionHost(options: ManagedSessionHostOptions): Ma
         }
     }
 
+    /**
+     * Resolve the node binary used to launch the session-host-daemon child.
+     *
+     * The session-host process `require()`s node-pty, whose Windows conpty.node
+     * prebuild only ships for the bundled portable Node 22 (matching node-pty's
+     * shipped win32-x64 prebuild). If the parent daemon happens to run under a
+     * different node (e.g. the box's SYSTEM node 24 on a fresh install), spawning
+     * the session-host with raw `process.execPath` would load node-pty under that
+     * node — and if the prebuild is missing there, every session start crashes
+     * with `Cannot find module ./prebuilds/win32-x64/conpty.node`.
+     *
+     * On win32 we therefore resolve the portable Node 22 the atomic-upgrade path
+     * already uses (`findPortableNode22`) and spawn the child with it. If no
+     * portable Node 22 is staged we fall back to `process.execPath` (never crash
+     * a working setup) but warn loudly so the misconfiguration is diagnosable.
+     *
+     * On every other platform this returns `process.execPath` unchanged — the
+     * session-host runtime selection is win32-only.
+     */
+    function resolveSessionHostNode(): string {
+        if (process.platform !== 'win32') {
+            return process.execPath;
+        }
+        let portableNode: string | null = null;
+        try {
+            portableNode = findPortableNode22(os.homedir(), process.execPath, resolveInstanceDir());
+        } catch (error) {
+            LOG.warn(
+                'SessionHost',
+                `Failed to resolve portable Node 22 for the session-host spawn: ${error instanceof Error ? error.message : String(error)}`,
+            );
+        }
+        if (portableNode) {
+            return portableNode;
+        }
+        LOG.warn(
+            'SessionHost',
+            `Portable Node 22 not found; spawning the session-host with ${process.execPath}. ` +
+                'node-pty may fail to load its conpty.node prebuild under a non-22 Node on win32.',
+        );
+        return process.execPath;
+    }
+
     function spawnHost(): void {
         const entry = resolveEntry();
+        const nodeExecutable = resolveSessionHostNode();
         let stdio: StdioOptions = 'ignore';
         let logFd: number | null = null;
         if (options.spawnStdio === 'logfile') {
@@ -149,7 +195,7 @@ export function createManagedSessionHost(options: ManagedSessionHostOptions): Ma
             logFd = fs.openSync(path.join(logDir, 'session-host.log'), 'a');
             stdio = ['ignore', logFd, logFd];
         }
-        const child = spawn(process.execPath, [entry], {
+        const child = spawn(nodeExecutable, [entry], {
             detached: true,
             stdio,
             windowsHide: true,