@adhdev/daemon-core 0.9.82-rc.49 → 0.9.82-rc.490

package/src/commands/cli-manager.ts

@@ -18,13 +18,15 @@ import { loadConfig } from '../config/config.js';
 import { loadState, saveState } from '../config/state-store.js';
 import { getWorkspaceState, resolveLaunchDirectory } from '../config/workspaces.js';
 import { appendRecentActivity } from '../config/recent-activity.js';
+import { shortHash } from '../system/hash.js';
+import { unregisterMeshCoordinator, getCoordinatorForSession, listCoordinatorsForWorkspace } from '../mesh/coordinator-registry.js';
 import { upsertSavedProviderSession } from '../config/saved-sessions.js';
 import { buildLegacyModelModeSummaryMetadata, normalizeProviderSummaryMetadata } from '../providers/summary-metadata.js';
 import { CliProviderInstance } from '../providers/cli-provider-instance.js';
 import { AcpProviderInstance } from '../providers/acp-provider-instance.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { ProviderLoader } from '../providers/provider-loader.js';
-import { normalizeInputEnvelope, type ProviderModule, type ProviderResumeCapability } from '../providers/contracts.js';
+import { normalizeInputEnvelope, type MeshCoordinatorDelegatedWorkerIsolation, type ProviderModule, type ProviderResumeCapability } from '../providers/contracts.js';
 import { assertProviderSupportsDeclaredInput, assertTextOnlyInput } from '../providers/provider-input-support.js';
 import type { CliAdapter } from '../cli-adapter-types.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
@@ -80,6 +82,126 @@ export interface CliManagerDeps {
 
 type CommandResult = { success: boolean;[key: string]: unknown };
 
+const BUSY_AGENT_STATUSES = new Set(['generating', 'running', 'streaming', 'starting', 'busy', 'waiting', 'waiting_approval', 'no_progress', 'long_generating']);
+const ZERO_MESSAGE_STARTING_SEND_WAIT_MS = 2_000;
+
+function normalizeAgentStatus(value: unknown): string {
+    return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+
+function hasNonEmptyModalButtons(activeModal: unknown): boolean {
+    const buttons = (activeModal as any)?.buttons;
+    return Array.isArray(buttons) && buttons.some((button) => String(button || '').trim().length > 0);
+}
+
+function hasAdapterPendingResponse(adapter: any): boolean {
+    if (adapter?.isWaitingForResponse === true) return true;
+    if (adapter?.currentTurnScope) return true;
+    try {
+        if (typeof adapter?.isProcessing === 'function' && adapter.isProcessing()) return true;
+    } catch { /* defensive: send guard should not fail on diagnostics */ }
+    try {
+        const partial = typeof adapter?.getPartialResponse === 'function' ? adapter.getPartialResponse() : '';
+        if (typeof partial === 'string' && partial.trim()) return true;
+    } catch { /* defensive: missing partial means no pending evidence */ }
+    return false;
+}
+
+function countMessages(value: unknown): number {
+    return Array.isArray(value) ? value.length : 0;
+}
+
+function hasFinalAssistantMessage(value: unknown): boolean {
+    const messages = Array.isArray(value) ? value : [];
+    const last = messages[messages.length - 1] as any;
+    if (!last || last.role !== 'assistant') return false;
+    if (last.bubbleState === 'streaming') return false;
+    if (last.meta?.streaming === true) return false;
+    return typeof last.content === 'string' && last.content.trim().length > 0;
+}
+
+function hasZeroMessageStartingLaunch(adapter: any): boolean {
+    const adapterStatus = adapter?.getStatus?.({ allowParse: false }) ?? adapter?.getStatus?.() ?? {};
+    const parsedStatus = typeof adapter?.getScriptParsedStatus === 'function'
+        ? adapter.getScriptParsedStatus()
+        : {};
+    const adapterRawStatus = normalizeAgentStatus(adapterStatus?.status);
+    const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+    if (adapterRawStatus !== 'starting') return false;
+    if (parsedRawStatus && parsedRawStatus !== 'starting' && parsedRawStatus !== 'generating') return false;
+    if (hasNonEmptyModalButtons(adapterStatus?.activeModal ?? adapterStatus?.modal ?? parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+    if (countMessages(adapterStatus?.messages) > 0 || countMessages(parsedStatus?.messages) > 0) return false;
+    return !hasAdapterPendingResponse(adapter);
+}
+
+function hasCompletedStartingLaunch(adapter: any): boolean {
+    const adapterStatus = adapter?.getStatus?.({ allowParse: false }) ?? adapter?.getStatus?.() ?? {};
+    const adapterRawStatus = normalizeAgentStatus(adapterStatus?.status);
+    if (adapterRawStatus !== 'starting') return false;
+    if (hasAdapterPendingResponse(adapter)) return false;
+
+    const parsedStatus = typeof adapter?.getScriptParsedStatus === 'function'
+        ? adapter.getScriptParsedStatus()
+        : {};
+    const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+    if (parsedRawStatus !== 'idle') return false;
+    if (hasNonEmptyModalButtons(adapterStatus?.activeModal ?? adapterStatus?.modal ?? parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+    return hasFinalAssistantMessage(parsedStatus?.messages);
+}
+
+/**
+ * WTCLAIM (B): compare two workspace paths for node scoping. Normalizes separator
+ * style, trailing slashes, and case (Windows paths are case-insensitive; the
+ * coordinator-supplied node.workspace and the adapter's launch workingDir can
+ * differ only in those) so a base node and a worktree clone are still told apart
+ * by their distinct workspace roots.
+ */
+function normalizeDirForCompare(dir?: string): string {
+    if (typeof dir !== 'string') return '';
+    return dir.trim().replace(/[\\/]+/g, '/').replace(/\/+$/, '').toLowerCase();
+}
+
+function shouldSuppressStaleParsedBusyStatus(adapterStatus: string, parsedStatus: any, adapter: any): boolean {
+    const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+    if (!BUSY_AGENT_STATUSES.has(parsedRawStatus)) return false;
+    if (adapterStatus !== 'idle') return false;
+    if (hasNonEmptyModalButtons(parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
+    return !hasAdapterPendingResponse(adapter);
+}
+
+function getEffectiveAgentSendStatus(adapter: any): string {
+    const adapterStatus = normalizeAgentStatus(adapter?.getStatus?.({ allowParse: false })?.status ?? adapter?.getStatus?.()?.status);
+    if (adapterStatus === 'starting' && hasCompletedStartingLaunch(adapter)) return 'idle';
+    if (adapterStatus && adapterStatus !== 'idle') return adapterStatus;
+    if (adapterStatus !== 'idle') return adapterStatus;
+
+    if (typeof adapter?.getScriptParsedStatus !== 'function') return adapterStatus;
+    try {
+        const parsedStatus = adapter.getScriptParsedStatus();
+        const parsedRawStatus = normalizeAgentStatus(parsedStatus?.status);
+        if (BUSY_AGENT_STATUSES.has(parsedRawStatus) && !shouldSuppressStaleParsedBusyStatus(adapterStatus, parsedStatus, adapter)) {
+            return parsedRawStatus;
+        }
+    } catch {
+        return adapterStatus;
+    }
+    return adapterStatus;
+}
+
+async function waitForZeroMessageStartingLaunch(adapter: any): Promise<boolean> {
+    try {
+        if (!hasZeroMessageStartingLaunch(adapter)) return false;
+    } catch {
+        return false;
+    }
+    await new Promise(resolve => setTimeout(resolve, ZERO_MESSAGE_STARTING_SEND_WAIT_MS));
+    try {
+        return hasZeroMessageStartingLaunch(adapter);
+    } catch {
+        return false;
+    }
+}
+
 export interface CliTransportFactoryParams {
     runtimeId: string;
     providerType: string;
@@ -87,6 +209,16 @@ export interface CliTransportFactoryParams {
     cliArgs?: string[];
     providerSessionId?: string;
     attachExisting?: boolean;
+    /**
+     * Launch-time record meta (meshNodeId / meshNodeFor / launchedByCoordinator /
+     * autoLaunchedForQueueTaskId). Defense-in-depth for SESSION-ACCUMULATION-LEAK:
+     * a session-host factory impl SHOULD seed the create_session record with this
+     * so the node binding is present the instant the record exists, rather than
+     * relying solely on the post-spawn updateRuntimeMeta round-trip. Optional and
+     * additive — factory impls that ignore it keep the prior behavior; the
+     * post-spawn WTDISPATCH stamp in register() still runs as the primary path.
+     */
+    initialMeta?: Record<string, unknown>;
 }
 
 export interface HostedCliRuntimeDescriptor {
@@ -101,6 +233,14 @@ export interface HostedCliRuntimeDescriptor {
     cliArgs?: string[];
     providerSessionId?: string;
     managedBy?: string;
+    /**
+     * Real spawn time (ms epoch) of the underlying session-host runtime — a PAST
+     * timestamp recorded when the runtime first started. Threaded through so an
+     * attach can restore the native-history session-floor to the runtime's actual
+     * birth instead of collapsing spawnedAtMs to 0. Undefined when unrecoverable
+     * (genuine post-restart-unknown), in which case the caller keeps the 0 fallback.
+     */
+    startedAtMs?: number;
 }
 
 type CliPresentationInstance = ProviderInstance & {
@@ -136,20 +276,25 @@ type CliStartOptions = {
     resumeSessionId?: string;
     settingsOverride?: Record<string, any>;
     extraEnv?: Record<string, string>;
+    /** BRAIN-ROUTING thinking axis: standard level ('low'|'medium'|'high') applied
+     *  at launch via the provider's thinkingLaunchArgs (CLI) or setConfigOption
+     *  ('thought_level', ACP). Best-effort — ignored by providers with no support. */
+    initialThinkingLevel?: string;
 };
 
-const COORDINATOR_DELEGATED_ENV_UNSETS: Record<string, string> = {
-    ADHDEV_INLINE_MESH: '',
-    ADHDEV_MCP_TRANSPORT: '',
-    ADHDEV_MESH_ID: '',
-    HERMES_EPHEMERAL_SYSTEM_PROMPT: '',
-};
+const DEFAULT_COORDINATOR_DELEGATED_ENV_UNSETS = [
+    'ADHDEV_INLINE_MESH',
+    'ADHDEV_MCP_TRANSPORT',
+    'ADHDEV_MESH_ID',
+    'HERMES_EPHEMERAL_SYSTEM_PROMPT',
+] as const;
 
 export interface CoordinatorDelegatedCliLaunchOptionsInput {
     cliType: string;
     workspace: string;
     cliArgs?: string[];
     env?: Record<string, string>;
+    isolation?: MeshCoordinatorDelegatedWorkerIsolation;
 }
 
 export interface CoordinatorDelegatedCliLaunchOptions {
@@ -161,10 +306,52 @@ function hasCliArg(args: string[], flag: string): boolean {
     return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
 }
 
+/**
+ * Decide the session-registry spawnedAtMs (the native-history session-floor) for a
+ * newly registered CLI instance.
+ *
+ * - Fresh launch (attachExisting=false): now (nowMs). A real live spawn floor
+ *   isolates a fresh session's own store and holds prior-session leak protection.
+ * - Attach WITH a recoverable record startedAt (a PAST timestamp): that startedAt.
+ *   Restoring a hosted runtime (coordinator / MAGI replica / hermes / claude /
+ *   codex) after a daemon restart, the real spawn time is in the past. Using it
+ *   restores each session's per-session birth-floor so co-located antigravity
+ *   runtimes resolve their OWN conversation (ownerConfirmed) instead of the
+ *   floor-less newest-by-mtime path that let a replica claim the coordinator's conv.
+ * - Attach with NO recoverable startedAt: 0 — disables the floor for this session
+ *   (recent_window_ms still bounds the look-back). NEVER use nowMs here: nowMs is in
+ *   the FUTURE relative to existing transcripts and would push the floor past every
+ *   transcript file, losing them (the ANTIGRAVITY-FINAL-MESSAGE-TAIL-GAP regression).
+ */
+export function resolveHostedSpawnedAtMs(
+    attachExisting: boolean,
+    attachStartedAtMs: number | undefined,
+    nowMs: number,
+): number {
+    if (!attachExisting) return nowMs;
+    if (typeof attachStartedAtMs === 'number' && attachStartedAtMs > 0) return attachStartedAtMs;
+    return 0;
+}
+
+function hasConfigOverride(args: string[], key: string): boolean {
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        const next = args[index + 1];
+        if ((arg === '-c' || arg === '--config') && typeof next === 'string') {
+            if (next === key || next.startsWith(`${key}=`) || next.startsWith(`${key}.`)) return true;
+        }
+        if (arg.startsWith('--config=')) {
+            const value = arg.slice('--config='.length);
+            if (value === key || value.startsWith(`${key}=`) || value.startsWith(`${key}.`)) return true;
+        }
+    }
+    return false;
+}
+
 function ensureEmptyDelegatedMcpConfig(workspace: string): string {
     const baseDir = path.join(os.tmpdir(), 'adhdev-delegated-agent-empty-mcp');
     mkdirSync(baseDir, { recursive: true });
-    const workspaceHash = crypto.createHash('sha256').update(path.resolve(workspace || os.tmpdir())).digest('hex').slice(0, 16);
+    const workspaceHash = shortHash(path.resolve(workspace || os.tmpdir()));
     const filePath = path.join(baseDir, `${workspaceHash}.json`);
     writeFileSync(filePath, JSON.stringify({ mcpServers: {} }, null, 2), 'utf-8');
     return filePath;
@@ -173,12 +360,31 @@ function ensureEmptyDelegatedMcpConfig(workspace: string): string {
 export function buildCoordinatorDelegatedCliLaunchOptions(
     input: CoordinatorDelegatedCliLaunchOptionsInput,
 ): CoordinatorDelegatedCliLaunchOptions {
-    const cliType = String(input.cliType || '').trim();
     const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
-    const env: Record<string, string> = { ...(input.env || {}), ...COORDINATOR_DELEGATED_ENV_UNSETS };
+    const env: Record<string, string> = { ...(input.env || {}) };
+    const envUnsets = new Set<string>(DEFAULT_COORDINATOR_DELEGATED_ENV_UNSETS);
+    for (const key of input.isolation?.env?.unset || []) {
+        if (typeof key === 'string' && key.trim()) envUnsets.add(key.trim());
+    }
+    for (const key of envUnsets) env[key] = '';
 
-    if (cliType === 'claude-cli' && !hasCliArg(cliArgs, '--mcp-config')) {
-        cliArgs.unshift('--mcp-config', ensureEmptyDelegatedMcpConfig(input.workspace));
+    for (const rule of input.isolation?.args || []) {
+        if (!rule || typeof rule !== 'object') continue;
+        if (rule.mode === 'empty_mcp_config') {
+            if (rule.flag && !hasCliArg(cliArgs, rule.flag)) {
+                cliArgs.unshift(rule.flag, ensureEmptyDelegatedMcpConfig(input.workspace));
+            }
+            if (rule.strictFlag && !hasCliArg(cliArgs, rule.strictFlag)) {
+                cliArgs.unshift(rule.strictFlag);
+            }
+            continue;
+        }
+        if (rule.mode === 'config_override') {
+            const key = String(rule.dedupeKey || rule.key || '').trim();
+            const flag = String(rule.flag || '').trim();
+            if (!key || !flag || hasConfigOverride(cliArgs, key)) continue;
+            cliArgs.unshift(flag, `${rule.key}=${rule.value}`);
+        }
     }
 
     return { cliArgs, env };
@@ -212,6 +418,40 @@ function expandResumeArgs(template: string[] | undefined, sessionId: string): st
     return template.map((part) => part === '{{id}}' ? sessionId : part);
 }
 
+/**
+ * Expand a provider's `modelLaunchArgs` template with the requested model, mirroring
+ * expandResumeArgs. `{{model}}` → the trimmed model string. Returns undefined when
+ * there is no template or no model (a model request without a template is a no-op —
+ * see startSession, where the caller logs the skip). MAGI kind-panel model axis.
+ */
+export function expandModelLaunchArgs(template: string[] | undefined, model: string | undefined): string[] | undefined {
+    const m = typeof model === 'string' ? model.trim() : '';
+    if (!m || !Array.isArray(template) || template.length === 0) return undefined;
+    // Substitute {{model}} anywhere in a token, not only when it is the whole token,
+    // so templates like ['-c', 'model={{model}}'] (codex) expand as well as the
+    // standalone ['--model', '{{model}}'] (claude) form.
+    return template.map((part) => part.includes('{{model}}') ? part.split('{{model}}').join(m) : part);
+}
+
+/**
+ * Expand a provider's `thinkingLaunchArgs` template with the requested thinking
+ * level, parallel to expandModelLaunchArgs. The standard level ('low'|'medium'|
+ * 'high') is first mapped through the provider's `thinkingLevelMap` (a level absent
+ * from the map passes through unchanged), then substituted into every `{{level}}`
+ * token. Returns undefined when there is no template or no level (best-effort; a
+ * thinking request without a template is a no-op). BRAIN-ROUTING thinking axis.
+ */
+export function expandThinkingLaunchArgs(
+    template: string[] | undefined,
+    level: string | undefined,
+    levelMap: Partial<Record<string, string>> | undefined,
+): string[] | undefined {
+    const raw = typeof level === 'string' ? level.trim() : '';
+    if (!raw || !Array.isArray(template) || template.length === 0) return undefined;
+    const mapped = (levelMap && typeof levelMap[raw] === 'string' && levelMap[raw]!.trim()) ? levelMap[raw]!.trim() : raw;
+    return template.map((part) => part.includes('{{level}}') ? part.replace('{{level}}', mapped) : part);
+}
+
 function readSubcommandSessionId(args: string[], subcommands: string[]): string | undefined {
     const resumeIndex = args.findIndex((arg) => subcommands.includes(arg));
     if (resumeIndex < 0) return undefined;
@@ -255,10 +495,14 @@ function detectExplicitProviderSessionId(
 
     const subcommands = resume?.sessionIdFromSubcommand;
     if (Array.isArray(subcommands) && subcommands.length > 0) {
+        const hasResumeSubcommand = args.some((arg) => subcommands.includes(arg));
         const subcommandSessionId = readSubcommandSessionId(args, subcommands);
         if (subcommandSessionId) {
             return { providerSessionId: subcommandSessionId, launchMode: 'resume' };
         }
+        if (hasResumeSubcommand) {
+            return { launchMode: 'resume' };
+        }
     }
 
     return { launchMode: 'manual' };
@@ -292,6 +536,12 @@ export function resolveCliSessionBinding(
             launchMode: explicit.launchMode,
         };
     }
+    if (explicit.launchMode === 'resume') {
+        return {
+            cliArgs: baseArgs,
+            launchMode: 'resume',
+        };
+    }
     if (explicit.launchMode === 'manual' && hasArg(baseArgs || [], ['--session-id'])) {
         return {
             cliArgs: baseArgs,
@@ -399,6 +649,7 @@ export class DaemonCliManager {
         cliArgs?: string[],
         providerSessionId?: string,
         attachExisting = false,
+        initialMeta?: Record<string, unknown>,
     ): PtyTransportFactory | undefined {
         return this.deps.createPtyTransportFactory?.({
             runtimeId,
@@ -407,6 +658,7 @@ export class DaemonCliManager {
             cliArgs,
             providerSessionId,
             attachExisting,
+            ...(initialMeta && Object.keys(initialMeta).length ? { initialMeta } : {}),
         }) || undefined;
     }
 
@@ -435,7 +687,9 @@ export class DaemonCliManager {
                 providerSessionId,
                 attachExisting,
             );
-            return new ProviderCliAdapter(resolvedProvider as CliProviderModule, workingDir, cliArgs, extraEnv || {}, transportFactory);
+            const adapter = new ProviderCliAdapter(resolvedProvider as CliProviderModule, workingDir, cliArgs, extraEnv || {}, transportFactory);
+            if (providerSessionId) adapter.updateRuntimeMeta({ providerSessionId });
+            return adapter;
         }
 
         throw new Error(`No CLI provider found for '${cliType}'. Create a provider.js in providers/cli/${cliType}/`);
@@ -457,6 +711,7 @@ export class DaemonCliManager {
                             this.deps.removeAgentTracking(key);
                             sessionRegistry?.unregisterByInstanceKey(key);
                             instanceManager?.removeInstance(key);
+                            unregisterMeshCoordinator(key);
                             LOG.info('CLI', `🧹 Auto-cleaned ${status.status} CLI: ${cliType}`);
                             this.deps.onStatusChange();
                         }
@@ -479,6 +734,16 @@ export class DaemonCliManager {
             providerSessionId?: string;
             launchMode?: CliLaunchMode;
             extraEnv?: Record<string, string>;
+            /** BRAIN-ROUTING: post-launch thinking level for runtime-control providers
+             *  (e.g. hermes reasoning). Passed through to the instance. */
+            initialThinkingLevel?: string;
+            /**
+             * On an attach (attachExisting=true), the real spawn time (ms epoch) of the
+             * session-host runtime being restored — a PAST timestamp. Used to restore the
+             * native-history session-floor to the runtime's actual birth instead of 0.
+             * See the spawnedAtMs computation below. Ignored for fresh launches.
+             */
+            attachStartedAtMs?: number;
             onProviderSessionResolved?: (info: {
                 instanceId: string;
                 providerType: string;
@@ -492,6 +757,24 @@ export class DaemonCliManager {
         const instanceManager = this.deps.getInstanceManager();
         const sessionRegistry = this.deps.getSessionRegistry?.() || null;
         if (!instanceManager) throw new Error('InstanceManager not available');
+
+        // Launch-time record meta (mesh node binding) — computed BEFORE the
+        // transport factory so the session-host record can be seeded with the
+        // binding at create_session time (Fix ②, defense-in-depth for
+        // SESSION-ACCUMULATION-LEAK), not only via the post-spawn WTDISPATCH
+        // updateRuntimeMeta round-trip below. See CliTransportFactoryParams.initialMeta.
+        const launchMeshNodeId = typeof settings?.meshNodeId === 'string' ? settings.meshNodeId.trim() : '';
+        const launchMeshNodeFor = typeof settings?.meshNodeFor === 'string' ? settings.meshNodeFor.trim() : '';
+        const launchAutoLaunchedForQueueTaskId = typeof settings?.autoLaunchedForQueueTaskId === 'string'
+            ? settings.autoLaunchedForQueueTaskId.trim()
+            : '';
+        const launchRecordMeta: Record<string, unknown> = {
+            ...(launchMeshNodeId ? { meshNodeId: launchMeshNodeId } : {}),
+            ...(launchMeshNodeFor ? { meshNodeFor: launchMeshNodeFor } : {}),
+            ...(settings?.launchedByCoordinator === true ? { launchedByCoordinator: true } : {}),
+            ...(launchAutoLaunchedForQueueTaskId ? { autoLaunchedForQueueTaskId: launchAutoLaunchedForQueueTaskId } : {}),
+        };
+
         const transportFactory = this.getTransportFactory(
             key,
             normalizedType,
@@ -499,6 +782,9 @@ export class DaemonCliManager {
             cliArgs,
             options?.providerSessionId,
             attachExisting,
+            // Only seed at create time for fresh launches — an attach restores an
+            // existing record whose meta is already stamped; re-seeding could clobber.
+            attachExisting ? undefined : launchRecordMeta,
         );
         const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key, transportFactory, options);
         try {
@@ -516,6 +802,33 @@ export class DaemonCliManager {
                 transport: 'pty',
                 adapterKey: key,
                 instanceKey: key,
+                workspace: resolvedDir,
+                // attachExisting === true means we're restoring an already-spawned
+                // hosted runtime after a daemon restart, not starting a fresh PTY.
+                //
+                // NEVER use Date.now() for the attach case: the real spawn time is in
+                // the PAST, and pinning the floor to now would push the native-history
+                // session-floor cutoff past every existing transcript file, so the
+                // agy/hermes/claude reader would return null even though the transcript
+                // on disk is fresh (the ANTIGRAVITY-FINAL-MESSAGE-TAIL-GAP regression).
+                //
+                // But collapsing to 0 for EVERY attach is also wrong: with the mesh
+                // coordinator + MAGI replicas all running as hosted runtimes sharing one
+                // workspace and attached with attachExisting=true, spawnedAtMs=0 disables
+                // the per-session native-history birth-floor for all of them. Without a
+                // floor, resolveAntigravityPath takes the floor-less newest-by-mtime
+                // branch (ownerConfirmed:false) and a replica's read can claim the
+                // coordinator's OWN conversation, which then reads as claimedByOther —
+                // regressing the coordinator chat to the pty-parser (user-only) path.
+                //
+                // So when the session-host record's REAL startedAt (a PAST timestamp) is
+                // recoverable, use it: the floor lands at the runtime's actual birth, the
+                // transcript is still found, AND each session's floor isolates its own
+                // conversation. Fall back to 0 ONLY when startedAt is unrecoverable (the
+                // genuine post-restart-unknown case) — that preserves the tail-gap
+                // protection. Fresh launches still get Date.now() so prior-session leak
+                // protection holds.
+                spawnedAtMs: resolveHostedSpawnedAtMs(attachExisting, options?.attachStartedAtMs, Date.now()),
             });
         } catch (spawnErr: any) {
             LOG.error('CLI', `[${cliType}] Spawn failed: ${spawnErr?.message}`);
@@ -524,6 +837,28 @@ export class DaemonCliManager {
         }
 
         this.adapters.set(key, cliInstance.getAdapter());
+
+        // WTDISPATCH (no_node_binding): a coordinator-launched worker carries its mesh node
+        // binding on the CLI-instance settings, but the session-host RECORD meta was never
+        // stamped with it — `updateRuntimeSettings` only mutates in-memory runtime settings and
+        // `updateRuntimeMeta` was only ever called with providerSessionId. So mesh_cleanup_sessions
+        // matched these worker sessions to a node by workspace ALONE
+        // (`live_session_matched_by_workspace_only_no_node_binding`), which on a daemon hosting
+        // sibling worktree nodes cannot tell two co-located clones apart. Push the launch-time node
+        // binding to the record meta so the record is 1:1 bound to its node (the spawned pty exists
+        // by now, so updateMeta reaches the session-host store). Best-effort; guarded.
+        //
+        // With the spec-CLI updateRuntimeMeta fix (SpecCliAdapter now forwards the FULL
+        // meta down to the transport, not just providerSessionId), this stamp finally
+        // reaches the session-host record for spec-backed providers too — previously it
+        // was silently dropped, which is what let orphans accumulate. launchRecordMeta
+        // is hoisted above and also seeds the create_session record via initialMeta.
+        if (Object.keys(launchRecordMeta).length) {
+            try {
+                cliInstance.getAdapter().updateRuntimeMeta?.({ ...launchRecordMeta });
+            } catch { /* best-effort — record-meta stamp is cleanup hygiene, not on the dispatch path */ }
+        }
+
         this.startCliExitMonitor(key, cliType);
     }
 
@@ -556,6 +891,24 @@ export class DaemonCliManager {
 
  // Create UUID-based key (allows separate instances even for same type+dir)
         const key = crypto.randomUUID();
+
+        // (3) Session-anchored mesh routing: when launching a mesh COORDINATOR session
+        // (settings.meshCoordinatorFor set), expose this session's OWN runtime id to its MCP
+        // server via env. The MCP server is spawned by the CLI as a child and inherits this
+        // env, so the MCP layer can stamp ADHDEV_COORDINATOR_SESSION_ID as the originating
+        // coordinator on every dispatch (→ MeshContext.coordinatorSessionId → worker
+        // meshCoordinatorSessionId → completion targetCoordinatorSessionId → strict route).
+        // `key` IS the instance id findLiveCoordinators matches on, so the stamp and the live
+        // session agree. Re-applied on every (re)launch, so it always reflects the current id;
+        // a stale value only survives if the CLI process outlives a daemon restart, in which
+        // case routing falls back to the daemon level (no wedge — see mesh-reconcile-loop).
+        {
+            const coordinatorMeshId = (options?.settingsOverride as Record<string, unknown> | undefined)?.meshCoordinatorFor;
+            if (typeof coordinatorMeshId === 'string' && coordinatorMeshId.trim()) {
+                options = { ...options, extraEnv: { ...(options?.extraEnv || {}), ADHDEV_COORDINATOR_SESSION_ID: key } };
+            }
+        }
+
         const sessionRegistry = this.deps.getSessionRegistry?.() || null;
 
  // ─── ACP category handle ───
@@ -589,6 +942,7 @@ export class DaemonCliManager {
                 transport: 'acp',
                 adapterKey: key,
                 instanceKey: key,
+                workspace: resolvedDir,
             });
 
  // Register ACP entry in adapter map (getStatus queries from acpInstance in real-time)
@@ -631,6 +985,19 @@ export class DaemonCliManager {
                 }
             }
 
+ // Brain routing thinking axis for ACP: route the standard level through the
+ // agent's thought_level config option. Best-effort — throws if the agent declares
+ // no thought_level category (see setConfigOption), so we swallow and warn.
+            if (options?.initialThinkingLevel) {
+                const lvl = options.initialThinkingLevel;
+                try {
+                    await acpInstance.setConfigOption('thought_level', lvl);
+                    console.log(colorize('green', `  🧠 Initial thinking level set: ${lvl}`));
+                } catch (e: any) {
+                    LOG.warn('CLI', `[ACP] Initial thinking level set failed (provider may not support thought_level): ${e?.message}`);
+                }
+            }
+
             this.persistRecentActivity({
                 kind: 'acp',
                 providerType: normalizedType,
@@ -663,8 +1030,37 @@ export class DaemonCliManager {
             console.log(colorize('cyan', `  📦 Using provider: ${provider.name} (${provider.type})`));
         }
 
+ // ─── Model axis (MAGI kind-panel): expand initialModel → launch args ───
+ // For a plain CLI provider the model is selected at spawn time via the manifest's
+ // modelLaunchArgs template ('{{model}}' → the requested model). ACP providers took
+ // the setConfigOption path above and never reach here. A provider with no template,
+ // or no requested model, is a no-op — model selection is best-effort and must never
+ // fail a launch. The model args are prepended so a caller's explicit cliArgs (e.g. a
+ // resume flag) still win positionally where order matters.
+        const modelLaunchArgs = expandModelLaunchArgs(provider?.modelLaunchArgs, initialModel);
+        const cliArgsWithModel = modelLaunchArgs
+            ? [...modelLaunchArgs, ...(cliArgs || [])]
+            : cliArgs;
+        if (initialModel && !modelLaunchArgs) {
+            LOG.warn('CLI', `[${normalizedType}] initialModel='${initialModel}' requested but provider declares no modelLaunchArgs template — launching without model selection.`);
+        }
+
+ // ─── Thinking axis (brain routing): expand initialThinkingLevel → launch args ───
+ // Parallel to the model axis: a plain CLI provider selects reasoning effort at spawn
+ // via the manifest's thinkingLaunchArgs template ('{{level}}' → the mapped level).
+ // Best-effort; a provider with no template (or no requested level) is a no-op. ACP
+ // providers route thinking through setConfigOption('thought_level') above.
+        const initialThinkingLevel = options?.initialThinkingLevel;
+        const thinkingLaunchArgs = expandThinkingLaunchArgs(provider?.thinkingLaunchArgs, initialThinkingLevel, provider?.thinkingLevelMap);
+        const cliArgsWithBrain = thinkingLaunchArgs
+            ? [...thinkingLaunchArgs, ...(cliArgsWithModel || [])]
+            : cliArgsWithModel;
+        if (initialThinkingLevel && !thinkingLaunchArgs) {
+            LOG.warn('CLI', `[${normalizedType}] initialThinkingLevel='${initialThinkingLevel}' requested but provider declares no thinkingLaunchArgs template — launching without thinking-level selection.`);
+        }
+
  // ─── Resolve launch options → provider session binding ───
-        const sessionBinding = resolveCliSessionBinding(provider, normalizedType, cliArgs, options?.resumeSessionId);
+        const sessionBinding = resolveCliSessionBinding(provider, normalizedType, cliArgsWithBrain, options?.resumeSessionId);
         const resolvedCliArgs = sessionBinding.cliArgs;
 
  // If InstanceManager exists, manage as CliProviderInstance unified
@@ -684,6 +1080,10 @@ export class DaemonCliManager {
                     providerSessionId: sessionBinding.providerSessionId,
                     launchMode: sessionBinding.launchMode,
                     extraEnv: options?.extraEnv,
+                    // BRAIN-ROUTING: for a provider with no thinkingLaunchArgs but a
+                    // runtime reasoning control (hermes), apply the level post-launch.
+                    // The launch-arg providers (claude/codex) already consumed it at spawn.
+                    ...(options?.initialThinkingLevel && !provider?.thinkingLaunchArgs ? { initialThinkingLevel: options.initialThinkingLevel } : {}),
                     onProviderSessionResolved: ({ providerSessionId, providerName, providerType, workspace }) => {
                         this.persistRecentActivity({
                             kind: 'cli',
@@ -783,6 +1183,7 @@ export class DaemonCliManager {
             this.deps.removeAgentTracking(key);
             this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
             this.deps.getInstanceManager()?.removeInstance(key);
+            unregisterMeshCoordinator(key);
             LOG.info('CLI', `🛑 Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`);
             this.deps.onStatusChange();
         } else {
@@ -792,6 +1193,7 @@ export class DaemonCliManager {
                 this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
                 im.removeInstance(key);
                 this.deps.removeAgentTracking(key);
+                unregisterMeshCoordinator(key);
                 LOG.warn('CLI', `🧹 Force-removed orphan entry: ${key}`);
                 this.deps.onStatusChange();
             }
@@ -819,6 +1221,29 @@ export class DaemonCliManager {
         const restoredBindings = new Set<string>();
         const managerTag = this.deps.hostedRuntimeManagerTag;
 
+        // CORDBADGE worker-overbind guard pre-pass: the workspace-scoped coordinator
+        // rebind fallback (below) recovers a coordinator's mark when its runtimeId
+        // changed across restart. But a delegated WORKER session that shares the
+        // coordinator's workspace+cliType ALSO misses the exact by-id lookup, so the
+        // fallback would wrongly stamp it with the lone registered coordinator's mesh
+        // mark (the reported bug: a worker shown with role:coordinator after restart).
+        // Two batch-level signals let the fallback refuse to mark a worker:
+        //   - restoredRuntimeIds: every runtimeId in this restore batch. If a
+        //     registered coordinator's own sessionId appears here, that coordinator is
+        //     being restored under its known id (the exact match binds it), so ANY
+        //     other same-workspace session is a worker — not the renamed coordinator.
+        //   - workspaceTypeCounts: how many sessions in the batch share a
+        //     workspace+cliType. >1 means we cannot tell the coordinator from a worker
+        //     even if the coordinator's id changed, so we stay unbound (ambiguous).
+        const restoredRuntimeIds = new Set<string>();
+        const workspaceTypeCounts = new Map<string, number>();
+        for (const r of sessions) {
+            if (!r?.runtimeId || !r?.cliType || !r?.workspace) continue;
+            restoredRuntimeIds.add(r.runtimeId);
+            const key = `${r.workspace}::${r.cliType}`;
+            workspaceTypeCounts.set(key, (workspaceTypeCounts.get(key) || 0) + 1);
+        }
+
         for (const record of sessions) {
             if (!record?.runtimeId || !record?.cliType || !record?.workspace) continue;
             if (!shouldRestoreHostedRuntime(record, managerTag)) {
@@ -852,6 +1277,74 @@ export class DaemonCliManager {
                 );
                 continue;
             }
+            // Re-establish the launch-time settings a fresh launch applies. startSession
+            // seeds every new instance with { ...providerLoader.getSettings(type), ...override };
+            // passing a bare {} here on restart silently dropped TWO launch settings, so a
+            // restored session diverged from a freshly-launched one:
+            //   - autoApprove (a provider/machine setting from getSettings) → a restored
+            //     coordinator self-session lost auto-approve and re-prompted on every tool call.
+            //   - meshCoordinatorFor (the coordinator launch's settingsOverride) → the restored
+            //     session was no longer recognized as this daemon's live CLI coordinator by
+            //     findLiveCoordinators (so pending mesh events stopped draining into its PTY) nor
+            //     surfaced with the coordinator badge via settings. The persisted coordinator
+            //     registry (loaded on boot) is the source of truth to rebuild that mark.
+            // Both restores are provider-agnostic — getSettings is keyed by provider type and the
+            // registry mark is type-independent.
+            const restoredSettings: Record<string, any> = { ...this.providerLoader.getSettings(normalizedType) };
+            // Primary rebind: exact persisted-registry match by runtimeId (stable across
+            // restart, see session-host runtimeId = runtimeRecord.sessionId).
+            let coordinatorEntry = getCoordinatorForSession(record.runtimeId);
+            // CORDBADGE fallback: the by-id match misses when a coordinator's runtime
+            // re-attaches under a different runtimeId than the one it was registered with
+            // (the registry survived, but its key no longer lines up). Without a rebind the
+            // restored session silently loses meshCoordinatorFor → the coordinator badge and
+            // selfIdentification block vanish and pending mesh events stop draining into its
+            // PTY, and the only recovery is a manual coordinator restart. Recover the mark
+            // from the persisted registry scoped to this exact workspace, but ONLY when it is
+            // UNAMBIGUOUS: exactly one registered coordinator for this workspace AND its
+            // cliType matches the restored session's type.
+            //
+            // WORKER-OVERBIND guard: "exactly one registered coordinator" is NOT enough —
+            // a delegated worker session sharing the coordinator's workspace+cliType also
+            // misses the by-id lookup, and the registry holding only the (single) real
+            // coordinator does NOT stop the fallback from projecting that coordinator's
+            // mark onto the worker record. So before adopting the mark we positively rule
+            // the worker out:
+            //   (a) coordinatorPresentById — the registered coordinator's own sessionId is
+            //       in this restore batch, i.e. it is being restored under its known id and
+            //       the exact match already binds it. Then THIS record (which missed) is a
+            //       worker, not the renamed coordinator → do not rebind.
+            //   (b) siblingCount > 1 — more than one session shares this workspace+cliType,
+            //       so even if the coordinator's id changed we cannot tell it from a worker
+            //       → stay unbound (ambiguous).
+            // Anything ambiguous stays unbound (we would rather miss a badge than
+            // mis-attribute one).
+            if (!coordinatorEntry?.meshId && record.workspace) {
+                const workspaceCoordinators = listCoordinatorsForWorkspace(record.workspace)
+                    .filter(e => e.meshId && (!e.cliType || e.cliType === record.cliType));
+                if (workspaceCoordinators.length === 1) {
+                    const candidate = workspaceCoordinators[0];
+                    const coordinatorPresentById = !!candidate.sessionId && restoredRuntimeIds.has(candidate.sessionId);
+                    const siblingCount = workspaceTypeCounts.get(`${record.workspace}::${record.cliType}`) || 1;
+                    if (!coordinatorPresentById && siblingCount === 1) {
+                        coordinatorEntry = candidate;
+                        LOG.info(
+                            'CLI',
+                            `↻ Rebound coordinator mark by workspace for ${record.runtimeKey || record.runtimeId} (mesh ${candidate.meshId} @ ${record.workspace}); registry key did not match runtimeId`
+                        );
+                    } else {
+                        LOG.info(
+                            'CLI',
+                            `↷ Skipping workspace coordinator rebind for ${record.runtimeKey || record.runtimeId} (${record.cliType} @ ${record.workspace}): ${coordinatorPresentById
+                                ? 'registered coordinator is restoring under its own id — this is a delegated worker'
+                                : `ambiguous (${siblingCount} sessions share this workspace+cliType)`}`
+                        );
+                    }
+                }
+            }
+            if (coordinatorEntry?.meshId) {
+                restoredSettings.meshCoordinatorFor = coordinatorEntry.meshId;
+            }
             try {
                 await this.registerCliInstance(
                     record.runtimeId,
@@ -860,11 +1353,17 @@ export class DaemonCliManager {
                     record.workspace,
                     record.cliArgs,
                     resolvedProvider,
-                    {},
+                    restoredSettings,
                     true,
                     {
                         providerSessionId: sessionBinding.providerSessionId,
                         launchMode: 'manual',
+                        // Thread the runtime's REAL past spawn time so the attach restores
+                        // the per-session native-history birth-floor instead of collapsing
+                        // to spawnedAtMs:0 (which disabled the antigravity per-session floor
+                        // and let MAGI replicas claim the coordinator's own conversation).
+                        // Undefined → registerCliInstance keeps the 0 fallback.
+                        attachStartedAtMs: record.startedAtMs,
                     },
                 );
                 restoredBindings.add(bindingKey);
@@ -899,18 +1398,36 @@ export class DaemonCliManager {
             const adapter = this.adapters.get(ik);
             if (adapter) return { adapter, key: ik };
         }
- // 1. agentType + dir match
-        if (opts?.dir) {
+ // 1. agentType + dir match.
+ //    FAIL-CLOSED when an explicit instanceKey/targetSessionId was named (step 0) but
+ //    did not resolve: the caller pinned a SPECIFIC session, so healing by workspace must
+ //    not silently redirect the command into a co-located SIBLING worktree session. The
+ //    remote mesh relay (ipcDispatchToRemoteAgent) carries `dir: node.workspace` alongside
+ //    targetSessionId for the sessionless-scope case; when a session WAS named, that dir
+ //    fallback is the WTDISPATCH-FANOUT (a) leak — a stale/relaunched session_id would
+ //    dir-match whatever session lives in that workspace instead of failing. The sessionless
+ //    node-scoped path uses findMeshNodeAdapter, not this fallback, so gating dir on
+ //    !instanceKey loses no legitimate routing. Mirror step 2's fail-closed rule.
+        if (opts?.dir && !opts?.instanceKey) {
             for (const [k, a] of this.adapters) {
                 if (a.cliType === agentType && a.workingDir === opts.dir) {
                     return { adapter: a, key: k };
                 }
             }
         }
- // 2. Fuzzy match (returns first of multiple sessions — may be inaccurate)
-        for (const [k, a] of this.adapters) {
-            if (a.cliType === agentType) {
-                return { adapter: a, key: k };
+ // 2. Fuzzy match (returns first of multiple sessions — may be inaccurate).
+ //    FAIL-CLOSED: only when NO explicit instanceKey/targetSessionId was requested.
+ //    When a specific session WAS named (step 0) but is not hosted on this daemon,
+ //    falling back to the first same-cliType adapter silently redirects the command
+ //    into an UNRELATED session — e.g. a relayed/misrouted mesh send_chat lands in the
+ //    coordinator's own CLI session, echoing the dispatched task body back to the
+ //    coordinator (TASKECHO self-inject). Returning null instead makes the caller
+ //    surface an explicit "not running" error rather than mis-delivering the message.
+        if (!opts?.instanceKey) {
+            for (const [k, a] of this.adapters) {
+                if (a.cliType === agentType) {
+                    return { adapter: a, key: k };
+                }
             }
         }
         return null;
@@ -925,6 +1442,40 @@ export class DaemonCliManager {
         return adapter ? { adapter, key: ik } : null;
     }
 
+    /**
+     * WTCLAIM (B): resolve the adapter for a mesh dispatch that named a node
+     * (meshContext.nodeId) but carried no explicit session. Matches by the
+     * instance's bound mesh node id (settings.meshNodeId, falling back to the
+     * sticky meshLastNodeId) first, then by the node workspace (workingDir).
+     *
+     * Unlike findAdapter's step-2 fuzzy fallback, this NEVER degrades to a
+     * provider-only first-match: on a daemon hosting BOTH a base node and a
+     * cloned worktree node (same daemonId), that fuzzy match could land a
+     * worktree-targeted task on the base session. Returns null when no session
+     * is bound to this node so the caller fails closed.
+     */
+    private findMeshNodeAdapter(agentType: string, nodeId: string, dir?: string): { adapter: CliAdapter; key: string } | null {
+        const instanceManager = this.deps.getInstanceManager();
+        const targetDir = normalizeDirForCompare(dir);
+        let workspaceMatch: { adapter: CliAdapter; key: string } | null = null;
+        for (const [k, a] of this.adapters) {
+            if (a.cliType !== agentType) continue;
+            const settings = (instanceManager?.getInstance(k) as any)?.getState?.()?.settings as Record<string, unknown> | undefined;
+            const boundNodeId = (typeof settings?.meshNodeId === 'string' && settings.meshNodeId.trim())
+                ? settings.meshNodeId.trim()
+                : (typeof settings?.meshLastNodeId === 'string' ? settings.meshLastNodeId.trim() : '');
+            // Exact node binding wins immediately (most precise).
+            if (boundNodeId && boundNodeId === nodeId) return { adapter: a, key: k };
+            // Workspace identity is the secondary signal for a session not (yet)
+            // stamped with a node id — a base node and a worktree clone always have
+            // distinct workspaces, so this still separates them.
+            if (!workspaceMatch && targetDir && normalizeDirForCompare(a.workingDir) === targetDir) {
+                workspaceMatch = { adapter: a, key: k };
+            }
+        }
+        return workspaceMatch;
+    }
+
  // ─── CLI command handling ────────────────────────────
 
     async handleCliCommand(cmd: string, args: any): Promise<CommandResult | null> {
@@ -955,6 +1506,8 @@ export class DaemonCliManager {
                 const launchSource = resolved.source;
                 if (!cliType) throw new Error('cliType required');
 
+                const providerType = this.providerLoader.resolveAlias(cliType);
+                const provLookup = this.providerLoader.getMeta(providerType) as ProviderModule | undefined;
                 const settingsOverride = args?.settings && typeof args.settings === 'object' ? args.settings : undefined;
                 const delegatedLaunch = settingsOverride?.launchedByCoordinator === true
                     ? buildCoordinatorDelegatedCliLaunchOptions({
@@ -962,8 +1515,28 @@ export class DaemonCliManager {
                         workspace: dir,
                         cliArgs: args?.cliArgs,
                         env: args?.env,
+                        isolation: provLookup?.meshCoordinator?.delegatedWorkerIsolation,
                     })
                     : null;
+                // Untrusted-provider gate: an external source that ships JS
+                // hooks needs explicit user confirmation before its first
+                // launch. Dashboards add `confirmExternalUntrusted: true` to
+                // the launch args after showing the trust modal. Without
+                // that ack we refuse to spawn and tell the caller why.
+                const provMeta = provLookup as any;
+                const provTrust = provMeta?._sourceTrust;
+                if (provTrust === 'external-untrusted' && args?.confirmExternalUntrusted !== true) {
+                    return {
+                        success: false,
+                        error: 'untrusted_external_provider',
+                        provider: {
+                            type: provLookup?.type ?? cliType,
+                            sourceName: provMeta?._sourceName ?? null,
+                            trust: provTrust,
+                        },
+                        hint: 'Resend launch_cli with confirmExternalUntrusted=true after the user explicitly approves running JavaScript from this 3rd-party source.',
+                    };
+                }
                 const started = await this.startSession(
                     cliType,
                     dir,
@@ -973,6 +1546,7 @@ export class DaemonCliManager {
                         resumeSessionId: args?.resumeSessionId,
                         settingsOverride,
                         extraEnv: delegatedLaunch ? delegatedLaunch.env : args?.env,
+                        ...(typeof args?.initialThinkingLevel === 'string' && args.initialThinkingLevel.trim() ? { initialThinkingLevel: args.initialThinkingLevel.trim() } : {}),
                     },
                 );
 
@@ -1030,6 +1604,45 @@ export class DaemonCliManager {
                 this.deps.onStatusChange();
                 return { success: true, id: found.key, mode };
             }
+            case 'record_provider_pty': {
+                const cliType = args?.type || args?.cliType;
+                if (!cliType) {
+                    return { success: false, error: '`type` (provider type) is required', code: 'MISSING_TYPE' };
+                }
+                const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId : '';
+                const dir = args?.dir || '';
+                const found = (targetSessionId ? this.findAdapterBySessionId(targetSessionId) : null)
+                    || this.findAdapter(cliType, { instanceKey: targetSessionId, dir });
+                if (!found) {
+                    return {
+                        success: false,
+                        error: `No running ${cliType} session. Launch one first (adhdev launch ${cliType}) or pass --target-session-id.`,
+                        code: 'NO_RUNNING_SESSION',
+                    };
+                }
+                const instance = this.deps.getInstanceManager()?.getInstance(found.key);
+                if (!(instance instanceof CliProviderInstance)) {
+                    return { success: false, error: 'CLI instance not available', code: 'CLI_INSTANCE_NOT_FOUND' };
+                }
+                const adapter = instance.getAdapter();
+                if (!adapter || typeof (adapter as any).getAccumulatedRawBuffer !== 'function') {
+                    return { success: false, error: 'Adapter does not expose PTY buffer', code: 'ADAPTER_NOT_RECORDABLE' };
+                }
+                const buffer = (adapter as any).getAccumulatedRawBuffer() as { text: string; droppedChars: number };
+                const maxBytes = Number(args?.maxBytes) > 0 ? Number(args.maxBytes) : 262144;
+                const truncated = buffer.text.length > maxBytes;
+                const ptyBytes = truncated ? buffer.text.slice(-maxBytes) : buffer.text;
+                return {
+                    success: true,
+                    cliType,
+                    sessionId: found.key,
+                    ptyBytes,
+                    bytes: ptyBytes.length,
+                    truncated,
+                    droppedChars: buffer.droppedChars,
+                    capturedAt: Date.now(),
+                };
+            }
             case 'restart_session': {
                 const cliType = args?.cliType || args?.agentType || args?.ideType;
                 const cfg = loadConfig();
@@ -1065,14 +1678,68 @@ export class DaemonCliManager {
                 const action = args?.action;
                 if (!agentType || !action) throw new Error('agentType and action required');
 
-                const found = this.findAdapter(agentType, {
-                    dir: args?.dir,
-                    instanceKey: args?.targetSessionId,
-                });
+                // WTCLAIM (B): a mesh dispatch that named a node (meshContext.nodeId)
+                // but resolved no explicit session must be scoped to THAT node's
+                // session — never routed by findAdapter's provider-only fuzzy fallback,
+                // which on a daemon hosting both a base node and a cloned worktree node
+                // (same daemonId) could land a worktree task on the base session. Fail
+                // closed when no session is bound to the node so the coordinator
+                // launches/retries instead of mis-landing the work.
+                const meshScopeNodeId = (() => {
+                    const mc = (args as any)?.meshContext;
+                    return mc && typeof mc === 'object' && typeof mc.nodeId === 'string' ? mc.nodeId.trim() : '';
+                })();
+                let found: { adapter: CliAdapter; key: string } | null;
+                if (meshScopeNodeId && !args?.targetSessionId) {
+                    found = this.findMeshNodeAdapter(agentType, meshScopeNodeId, args?.dir);
+                    if (!found) {
+                        throw new Error(`No mesh worker session bound to node '${meshScopeNodeId}' for agent '${agentType}' on this daemon; refusing provider-only fuzzy match to avoid cross-node dispatch`);
+                    }
+                } else {
+                    found = this.findAdapter(agentType, {
+                        dir: args?.dir,
+                        instanceKey: args?.targetSessionId,
+                    });
+                }
                 if (!found) throw new Error(`CLI agent not running: ${agentType}`);
                 const { adapter, key } = found;
 
                 if (action === 'send_chat') {
+                    let currentStatus = getEffectiveAgentSendStatus(adapter);
+                    if (currentStatus === 'starting' && await waitForZeroMessageStartingLaunch(adapter)) {
+                        currentStatus = 'idle';
+                    } else if (currentStatus === 'starting') {
+                        currentStatus = getEffectiveAgentSendStatus(adapter);
+                    }
+                    // Stamp mesh direct-dispatch assignment on the target
+                    // instance BEFORE sending the prompt so the completion
+                    // event has a routing marker by the time it fires.
+                    // mesh_send_task --direct ships meshContext for plain CLI
+                    // sessions that were never launched as mesh delegates.
+                    const meshContext = (args as any)?.meshContext;
+                    if (meshContext && typeof meshContext === 'object' && typeof meshContext.meshId === 'string' && meshContext.meshId) {
+                        const targetInstanceId = key;
+                        let stampResult: { stamped: boolean; reason?: string } | undefined;
+                        try {
+                            stampResult = this.deps.getInstanceManager()?.attachMeshAssignmentToInstance(targetInstanceId, {
+                                meshId: meshContext.meshId,
+                                ...(typeof meshContext.nodeId === 'string' && meshContext.nodeId ? { nodeId: meshContext.nodeId } : {}),
+                                ...(typeof meshContext.taskId === 'string' && meshContext.taskId ? { taskId: meshContext.taskId } : {}),
+                                // REDRIVE-DUP: carry the dispatch nonce onto the worker session so
+                                // its generating_started event echoes it back for the coordinator's
+                                // stale-nonce guard.
+                                ...(typeof meshContext.dispatchNonce === 'number' ? { dispatchNonce: meshContext.dispatchNonce } : {}),
+                                ...(typeof meshContext.coordinatorDaemonId === 'string' && meshContext.coordinatorDaemonId ? { coordinatorDaemonId: meshContext.coordinatorDaemonId } : {}),
+                            });
+                        } catch { /* best-effort — stamping is a routing aid, not a hard requirement */ }
+                        // DOUBLE-DISPATCH stamp guard: the instance manager refused this stamp because
+                        // the SAME task is already running on another live session on this daemon.
+                        // Sending the prompt anyway would double-execute the task — fail closed so the
+                        // coordinator does not duplicate the work onto a second session.
+                        if (stampResult && stampResult.stamped === false && stampResult.reason === 'task_already_stamped_on_live_instance') {
+                            throw new Error(`Refusing duplicate mesh dispatch: task ${meshContext.taskId} is already being worked by a live session on this daemon`);
+                        }
+                    }
                     const input = normalizeInputEnvelope(args?.input ? { input: args.input } : args);
                     const provider = this.providerLoader.resolve(agentType) || this.providerLoader.getMeta(agentType);
                     if (provider?.category === 'acp') {
@@ -1082,8 +1749,38 @@ export class DaemonCliManager {
                     }
                     const message = input.textFallback;
                     if (!message) throw new Error('message required for send_chat');
-                    await adapter.sendMessage(message);
-                    return { success: true, status: 'generating' };
+                    // ARCH-REFACTOR R1: thread the dispatched task's id into the turn so the
+                    // worker's completion event is bound to THIS task (per-turn identity),
+                    // not the last-write-wins session scalar. Carried for both local and
+                    // remote (P2P-echoed meshContext) dispatch; absent for plain ad-hoc chat.
+                    const meshTaskId = (meshContext && typeof meshContext === 'object'
+                        && typeof (meshContext as any).taskId === 'string' && (meshContext as any).taskId.trim())
+                        ? (meshContext as any).taskId as string
+                        : undefined;
+                    const forceSend = args?.force === true || args?.forceSend === true;
+                    // Preserve the exact prior call shape when there is no taskId (plain
+                    // ad-hoc chat / non-mesh dispatch); only thread the per-turn taskId when
+                    // present, so existing non-mesh callers and their contracts are unchanged.
+                    if (forceSend && typeof (adapter as any).forceSendMessage === 'function') {
+                        if (meshTaskId) await (adapter as any).forceSendMessage(message, meshTaskId);
+                        else await (adapter as any).forceSendMessage(message);
+                    } else if (forceSend) {
+                        await adapter.sendMessage(message, meshTaskId ? { force: true, meshTaskId } : { force: true });
+                    } else if (meshTaskId) {
+                        await adapter.sendMessage(message, { meshTaskId });
+                    } else {
+                        await adapter.sendMessage(message);
+                    }
+                    const targetInstance = this.deps.getInstanceManager()?.getInstance(key) as
+                        | { recordAcknowledgedUserInput?: (input: unknown) => void }
+                        | undefined;
+                    targetInstance?.recordAcknowledgedUserInput?.(input);
+                    return {
+                        success: true,
+                        status: BUSY_AGENT_STATUSES.has(currentStatus) ? currentStatus : 'generating',
+                        ...(BUSY_AGENT_STATUSES.has(currentStatus) ? { queued: true, queuedReason: 'agent_runtime_busy' } : {}),
+                        ...(forceSend ? { forceSent: true, queued: false } : {}),
+                    };
                 } else if (action === 'clear_history') {
                     if (typeof adapter.clearHistory === 'function') adapter.clearHistory();
                     return { success: true, cleared: true };