@adhdev/daemon-core 0.9.82-rc.160 → 0.9.82-rc.162

package/src/commands/mesh-coordinator.ts

@@ -1,7 +1,13 @@
 import { createHash } from 'node:crypto'
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import * as os from 'node:os'
 import { isAbsolute, join, resolve } from 'node:path'
-import type { ProviderModule, MeshCoordinatorMcpConfigFormat } from '../providers/contracts.js'
+import { LOG } from '../logging/logger.js'
+import type {
+  MeshCoordinatorMcpConfigFormat,
+  MeshCoordinatorSystemPromptInjection,
+  ProviderModule,
+} from '../providers/contracts.js'
 
 export interface MeshCoordinatorMcpServerLaunch {
   command: string
@@ -249,3 +255,231 @@ function resolveMcpPort(explicitPort?: number): number | undefined {
   const parsed = Number(raw)
   return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined
 }
+
+/**
+ * Apply a provider's declared system-prompt injection rule, mutating `cliArgs`
+ * and `launchEnv` in place and writing any required workspace context file.
+ *
+ * Replaces the previous hard-coded `if (cliType === 'claude-cli') ... else if
+ * (cliType === 'hermes-cli') ...` branches in router.ts. Adding a new CLI is
+ * now provider.v1.json data, not a router edit.
+ *
+ * Failures are non-fatal: log and continue with whatever was applied so the
+ * coordinator session still launches, just without the prompt for that
+ * provider. A missing/unknown rule means "skip injection" — safe by default
+ * (the previous fallback unconditionally pushed --append-system-prompt onto
+ * every non-Claude CLI, which crashed agy on launch).
+ */
+export interface CoordinatorInjectionEffect {
+  /** Absolute path the daemon wrote a wrapper-blocked file to. Only set for
+   *  context_file injection. R48 schedules a strip after launch so workers
+   *  don't see the wrapper on disk; R47's unregister cleanup uses it as a
+   *  fallback if the timer never fires (process crash, etc). */
+  contextFilePath?: string
+}
+
+export function applyMeshCoordinatorSystemPromptInjection(
+  systemPrompt: string,
+  injection: MeshCoordinatorSystemPromptInjection | undefined,
+  ctx: { cliArgs: string[]; launchEnv: Record<string, string>; workspace: string; cliType: string },
+): CoordinatorInjectionEffect {
+  if (!systemPrompt || !injection) return {}
+  return applyInjectionRule(systemPrompt, injection, ctx)
+}
+
+function applyInjectionRule(
+  systemPrompt: string,
+  injection: MeshCoordinatorSystemPromptInjection,
+  ctx: { cliArgs: string[]; launchEnv: Record<string, string>; workspace: string; cliType: string },
+): CoordinatorInjectionEffect {
+  switch (injection.mode) {
+    case 'cli_arg': {
+      if (!injection.flag) return {}
+      ctx.cliArgs.push(injection.flag, systemPrompt)
+      return {}
+    }
+    case 'config_override': {
+      if (!injection.flag || !injection.template) return {}
+      const rendered = injection.template
+        .replace(/\{prompt_json\}/g, JSON.stringify(systemPrompt))
+        .replace(/\{prompt\}/g, systemPrompt)
+      ctx.cliArgs.push(injection.flag, rendered)
+      return {}
+    }
+    case 'env_var': {
+      if (!injection.name) return {}
+      ctx.launchEnv[injection.name] = systemPrompt
+      return {}
+    }
+    case 'context_file': {
+      if (!injection.path) return {}
+      const target = isAbsolute(injection.path)
+        ? injection.path
+        : join(ctx.workspace, injection.path)
+      const wrapper = injection.wrapper && injection.wrapper.includes('{prompt}')
+        ? injection.wrapper
+        : '{prompt}'
+      // Prepend a short managed-by hint inside the wrapper block so a user
+      // opening AGENTS.md / GEMINI.md immediately understands the block is
+      // auto-regenerated by the daemon on every coordinator launch. The hint
+      // sits between the opening sentinel and the prompt body, so the stable
+      // sentinels declared in provider.v1.json are untouched and the
+      // idempotent replace regex above still matches on relaunches.
+      const managedNote =
+        '> _Managed by adhdev mesh coordinator — do not hand-edit this block. ' +
+        'Changes inside the sentinels are overwritten on next coordinator launch._'
+      const promptWithNote = `${managedNote}\n\n${systemPrompt}`
+      const rendered = wrapper.replace(/\{prompt\}/g, promptWithNote)
+      // If the wrapper has a stable opening sentinel, treat everything up to
+      // the matching closing sentinel as our previously-written block and
+      // replace it. Otherwise just append. The marker is the first non-
+      // placeholder line of the wrapper; this keeps relaunches idempotent
+      // without forcing spec authors to declare an explicit marker.
+      const sentinel = wrapper.split('{prompt}')[0].trim()
+      try {
+        if (existsSync(target)) {
+          const existing = readFileSync(target, 'utf-8')
+          if (sentinel && existing.includes(sentinel)) {
+            const closing = wrapper.split('{prompt}')[1]?.trim()
+            const safeOpen = sentinel.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            const safeClose = closing
+              ? closing.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+              : ''
+            const re = closing
+              ? new RegExp(`${safeOpen}[\\s\\S]*?${safeClose}`, 'g')
+              : new RegExp(`${safeOpen}[\\s\\S]*$`, 'g')
+            writeFileSync(target, existing.replace(re, rendered), 'utf-8')
+          } else {
+            writeFileSync(target, `${existing}\n\n${rendered}`, 'utf-8')
+          }
+        } else {
+          writeFileSync(target, rendered, 'utf-8')
+        }
+        LOG.info('MeshCoordinator', `Wrote coordinator prompt to ${target} (${ctx.cliType})`)
+        return { contextFilePath: target }
+      } catch (error: any) {
+        LOG.warn('MeshCoordinator', `Could not write ${target}: ${error?.message || error}`)
+        return {}
+      }
+    }
+    default:
+      // Unknown future mode — skip silently. Adding the new mode is a spec-
+      // language extension, not a runtime crash.
+      return {}
+  }
+}
+
+/**
+ * Strip the daemon's wrapper block from a context_file we previously wrote.
+ *
+ * Used in two places:
+ *   1. R48 inject-then-remove: ~5s after spawn, after agy/gemini have read
+ *      the file into their in-memory system-prompt cache. Removing it from
+ *      disk at that point doesn't affect the running coordinator but keeps
+ *      worker sessions (or fresh non-coordinator launches) in the same
+ *      workspace from picking up our wrapper.
+ *   2. R47 unregister fallback: if the timer never fires (process crash,
+ *      kill -9), coordinator-registry.unregisterMeshCoordinator runs the
+ *      same logic when its entry is dropped.
+ *
+ * Idempotent: missing file is fine, missing sentinels are fine, returns
+ * silently. Leaves user-authored content outside the sentinels intact.
+ * Deletes the file outright if our wrapper was the only content.
+ */
+export function stripCoordinatorWrapperFile(filePath: string): void {
+  const OPEN = '<!-- adhdev-mesh-coordinator-prompt -->'
+  const CLOSE = '<!-- /adhdev-mesh-coordinator-prompt -->'
+  try {
+    if (!existsSync(filePath)) return
+    const existing = readFileSync(filePath, 'utf-8')
+    const openIdx = existing.indexOf(OPEN)
+    if (openIdx < 0) return
+    const closeIdx = existing.indexOf(CLOSE, openIdx)
+    if (closeIdx < 0) return
+    const remaining = (existing.slice(0, openIdx) + existing.slice(closeIdx + CLOSE.length))
+      .replace(/^\s*\n+/, '')
+      .replace(/\n+\s*$/, '')
+    if (!remaining.trim()) {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const fs = require('node:fs')
+        fs.unlinkSync(filePath)
+      } catch { /* best-effort */ }
+    } else {
+      writeFileSync(filePath, remaining + '\n', 'utf-8')
+    }
+  } catch { /* best-effort */ }
+}
+
+export interface PtyExecResult {
+  exitCode: number | null
+  signal: number | null
+  output: string
+  timedOut: boolean
+}
+
+/**
+ * Run a one-shot CLI command under a real PTY and collect its output.
+ *
+ * Some provider mcp-registration commands (`agy mcp add`, future bubbletea
+ * TUIs) refuse to run without `/dev/tty`. Daemon-side `execFileSync` runs
+ * pipe-only, so those commands fail with errors like
+ *   `bubbletea: error opening TTY: open /dev/tty: device not configured`
+ * and silently skip the registration, leaving the launched session
+ * without the adhdev-mesh MCP tools — which is exactly what we saw with
+ * agy coordinators.
+ *
+ * Wrapping the registration through node-pty gives the child a real PTY,
+ * so the bubbletea check passes. We close stdin immediately and just
+ * collect stdout until the process exits or the timeout fires.
+ */
+export async function execUnderPty(
+  command: string,
+  args: string[],
+  options: { cwd?: string; env?: Record<string, string>; timeoutMs?: number } = {},
+): Promise<PtyExecResult> {
+  let ptyLib: any
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    ptyLib = require('node-pty')
+  } catch (error: any) {
+    throw new Error(`node-pty is not available: ${error?.message || error}`)
+  }
+  const env = { ...(options.env ?? (process.env as Record<string, string>)), TERM: 'xterm-256color' }
+  const timeoutMs = typeof options.timeoutMs === 'number' && options.timeoutMs > 0 ? options.timeoutMs : 20_000
+  return new Promise<PtyExecResult>((resolveResult) => {
+    let child: any
+    try {
+      child = ptyLib.spawn(command, args, {
+        name: 'xterm-256color',
+        cols: 120,
+        rows: 30,
+        cwd: options.cwd ?? process.cwd(),
+        env,
+      })
+    } catch (error: any) {
+      resolveResult({ exitCode: null, signal: null, output: String(error?.message || error), timedOut: false })
+      return
+    }
+    let buffer = ''
+    let settled = false
+    const timer = setTimeout(() => {
+      if (settled) return
+      settled = true
+      try { child.kill() } catch { /* ignore */ }
+      resolveResult({ exitCode: null, signal: null, output: buffer, timedOut: true })
+    }, timeoutMs)
+    child.onData((chunk: string) => {
+      buffer += chunk
+      if (buffer.length > 256 * 1024) {
+        buffer = buffer.slice(-128 * 1024)
+      }
+    })
+    child.onExit(({ exitCode, signal }: { exitCode: number; signal?: number }) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolveResult({ exitCode, signal: signal ?? null, output: buffer, timedOut: false })
+    })
+  })
+}

package/src/commands/router.ts

@@ -38,7 +38,7 @@ import { createInteractionId, getRecentDebugTrace, recordDebugTrace } from '../l
 import { getSessionHostSurfaceKind, partitionSessionHostRecords } from '../session-host/runtime-surface.js';
 import { createHermesManualMeshCoordinatorSetup, resolveMeshCoordinatorSetup } from './mesh-coordinator.js';
 import { buildSessionEntries } from '../status/builders.js';
-import { registerMeshCoordinator } from '../mesh/coordinator-registry.js';
+import { registerMeshCoordinator, getCoordinatorForSession } from '../mesh/coordinator-registry.js';
 import { handleMeshForwardEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent } from '../mesh/mesh-events.js';
 import { buildMeshHostRequiredFailure, normalizeMeshDaemonRole, resolveMeshHostStatus } from '../mesh/mesh-host-ownership.js';
 import { fastForwardMeshNode } from '../mesh/mesh-fast-forward.js';
@@ -4077,6 +4077,116 @@ export class DaemonCommandRouter {
                 };
             }
 
+            // Session-info popup data. Aggregates whatever the daemon knows
+            // about a single live session into one envelope so the dashboard
+            // doesn't need to stitch together status + coordinator registry +
+            // session registry on the client. Includes the actual system
+            // prompt that was injected at launch when the session is a mesh
+            // coordinator — that's the "what prompt did the agent see?"
+            // question the info-icon dialog is meant to answer.
+            case 'get_session_info': {
+                const sessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim()
+                    : typeof args?.sessionId === 'string' ? args.sessionId.trim() : '';
+                if (!sessionId) return { success: false, error: 'targetSessionId required' };
+                const target = this.deps.sessionRegistry.get(sessionId);
+                if (!target) return { success: false, error: 'Session not found', sessionId };
+                const adapter = this.deps.cliManager.findAdapter(target.providerType, { instanceKey: sessionId })?.adapter;
+                const runtimeMeta = (adapter && typeof (adapter as any).getRuntimeMetadata === 'function')
+                    ? (adapter as any).getRuntimeMetadata()
+                    : undefined;
+                const coord = getCoordinatorForSession(sessionId);
+                const providerMetaForSession = this.deps.providerLoader.resolve?.(target.providerType) || this.deps.providerLoader.getMeta(target.providerType);
+                return {
+                    success: true,
+                    session: {
+                        sessionId,
+                        providerType: target.providerType,
+                        providerName: providerMetaForSession?.name,
+                        transport: target.transport,
+                        workspace: (target as any).workspace,
+                        spawnedAtMs: (target as any).spawnedAtMs,
+                        providerSessionId: (target as any).providerSessionId,
+                        runtimeMetadata: runtimeMeta,
+                    },
+                    coordinator: coord ? {
+                        meshId: coord.meshId,
+                        startedAt: coord.startedAt,
+                        cliType: coord.cliType,
+                        systemPrompt: coord.systemPrompt,
+                        extraSystemPrompt: coord.extraSystemPrompt,
+                        injection: coord.injection,
+                        mcpConfigPath: coord.mcpConfigPath,
+                    } : null,
+                };
+            }
+
+            // ── User-level coordinator-prompt files (~/.adhdev/coordinator-prompts/).
+            //    These live on this daemon's filesystem and never sync to the
+            //    cloud / other daemons — they're per-machine config. The
+            //    Settings page in the dashboard reads/writes via these two
+            //    commands instead of going through fs from the browser.
+            case 'list_coordinator_prompts': {
+                const fs = await import('node:fs');
+                const path = await import('node:path');
+                const os = await import('node:os');
+                const dir = path.join(os.homedir(), '.adhdev', 'coordinator-prompts');
+                const entries: Record<string, { override: string; append: string }> = {};
+                try {
+                    if (fs.existsSync(dir)) {
+                        for (const name of fs.readdirSync(dir)) {
+                            // Bucket files into <key>.{md|append.md}; ignore others
+                            // so a stray README or .DS_Store doesn't show up.
+                            const matchOverride = name.match(/^([a-zA-Z0-9_.-]+)\.md$/);
+                            const matchAppend = name.match(/^([a-zA-Z0-9_.-]+)\.append\.md$/);
+                            // append-pattern wins when both match (file is `.append.md`).
+                            const m = matchAppend || matchOverride;
+                            if (!m) continue;
+                            const isAppend = !!matchAppend;
+                            const key = m[1];
+                            const full = path.join(dir, name);
+                            let content = '';
+                            try { content = fs.readFileSync(full, 'utf8'); } catch { /* skip */ }
+                            if (!entries[key]) entries[key] = { override: '', append: '' };
+                            if (isAppend) entries[key].append = content;
+                            else entries[key].override = content;
+                        }
+                    }
+                } catch (error: any) {
+                    return { success: false, error: error?.message || String(error) };
+                }
+                return { success: true, dir, entries };
+            }
+
+            case 'write_coordinator_prompt': {
+                const fs = await import('node:fs');
+                const path = await import('node:path');
+                const os = await import('node:os');
+                const key = typeof args?.key === 'string' ? args.key.trim() : '';
+                const kind = args?.kind === 'append' ? 'append' : 'override';
+                const content = typeof args?.content === 'string' ? args.content : '';
+                // Whitelist key chars so a malicious caller can't write
+                // ../../etc/passwd. Same charset readUserPromptFile accepts.
+                if (!key || !/^[a-zA-Z0-9_.-]+$/.test(key)) {
+                    return { success: false, error: 'key must match [a-zA-Z0-9_.-]+' };
+                }
+                const dir = path.join(os.homedir(), '.adhdev', 'coordinator-prompts');
+                const filename = kind === 'append' ? `${key}.append.md` : `${key}.md`;
+                const full = path.join(dir, filename);
+                try {
+                    fs.mkdirSync(dir, { recursive: true });
+                    if (content.trim()) {
+                        fs.writeFileSync(full, content, { encoding: 'utf8', mode: 0o600 });
+                    } else if (fs.existsSync(full)) {
+                        // Empty content = "reset to default" — delete the file
+                        // so the daemon's readUserPromptFile path falls through.
+                        fs.unlinkSync(full);
+                    }
+                    return { success: true, path: full, kind, key };
+                } catch (error: any) {
+                    return { success: false, error: error?.message || String(error) };
+                }
+            }
+
             case 'mark_session_seen': {
                 const sessionId = args?.sessionId;
                 if (!sessionId || typeof sessionId !== 'string') {
@@ -4743,7 +4853,14 @@ export class DaemonCommandRouter {
                             delete (policy as any).providerPriority;
                         }
                     }
-                    const node = updateNode(meshId, nodeId, { policy: policy as any });
+                    const patch: Record<string, unknown> = { policy: policy as any };
+                    if (typeof args?.systemPrompt === 'string') {
+                        const trimmed = (args.systemPrompt as string).trim();
+                        patch.systemPrompt = trimmed || undefined;
+                    } else if (args?.systemPrompt === null) {
+                        patch.systemPrompt = undefined;
+                    }
+                    const node = updateNode(meshId, nodeId, patch as any);
                     if (!node) return { success: false, error: 'Mesh node not found' };
                     return { success: true, node };
                 } catch (e: any) {
@@ -5147,6 +5264,19 @@ export class DaemonCommandRouter {
             case 'launch_mesh_coordinator': {
                 const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
                 let cliType = typeof args?.cliType === 'string' ? args.cliType.trim() : '';
+                // Optional per-launch system-prompt addition. Dashboard or API
+                // callers (e.g. when spawning a mesh-node-specific coordinator)
+                // can pass extra context that gets appended to the rendered
+                // default prompt under the "## Additional Context" section.
+                // Going through buildCoordinatorSystemPrompt's userInstruction
+                // means user-level override files (~/.adhdev/coordinator-prompts)
+                // and this per-launch addition compose cleanly: an override
+                // wins outright, but if there's no override, the default
+                // prompt + the optional append.md file + this extra context
+                // all stack in declared order.
+                const extraSystemPrompt = typeof args?.extraSystemPrompt === 'string'
+                    ? args.extraSystemPrompt.trim()
+                    : '';
                 if (!meshId) return { success: false, error: 'meshId required' };
 
                 try {
@@ -5257,7 +5387,7 @@ export class DaemonCommandRouter {
                         // Build coordinator prompt first — fail closed on errors.
                         let cliCmdSystemPrompt = '';
                         try {
-                            cliCmdSystemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType });
+                            cliCmdSystemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined });
                         } catch (error: any) {
                             const message = error?.message || String(error);
                             LOG.error('MeshCoordinator', `Failed to build coordinator prompt: ${message}`);
@@ -5269,53 +5399,45 @@ export class DaemonCommandRouter {
                             };
                         }
 
-                        // Run the provider's MCP registration command.
+                        // Run the provider's MCP registration command under a
+                        // PTY. Some providers (agy, future bubbletea CLIs)
+                        // refuse to run without /dev/tty, so pipe-only
+                        // execFileSync silently no-ops the registration and
+                        // the coordinator ends up without any mcp tools. With
+                        // a real PTY the registration goes through and the
+                        // exit code tells us whether it actually persisted.
+                        let mcpRegistrationOk = false;
                         try {
-                            const { execFileSync: execCmdSync } = await import('node:child_process');
+                            const { execUnderPty } = await import('./mesh-coordinator.js');
                             const cmdParts = coordinatorSetup.command.trim().split(/\s+/);
                             const [regCmd, ...regArgs] = cmdParts;
-                            LOG.info('MeshCoordinator', `Running MCP registration: ${coordinatorSetup.command}`);
-                            execCmdSync(regCmd, regArgs, { stdio: 'pipe', timeout: 15_000 });
+                            LOG.info('MeshCoordinator', `Running MCP registration (pty): ${coordinatorSetup.command}`);
+                            const ptyResult = await execUnderPty(regCmd, regArgs, { cwd: workspace, timeoutMs: 20_000 });
+                            if (ptyResult.timedOut) {
+                                LOG.warn('MeshCoordinator', `MCP registration timed out — last output:\n${ptyResult.output.slice(-2000)}`);
+                            } else if (ptyResult.exitCode === 0) {
+                                mcpRegistrationOk = true;
+                                LOG.info('MeshCoordinator', `MCP registration succeeded (exit=0)`);
+                            } else {
+                                // Non-fatal — many providers return non-zero on duplicate registration.
+                                LOG.warn('MeshCoordinator', `MCP registration exit=${ptyResult.exitCode} signal=${ptyResult.signal} — output:\n${ptyResult.output.slice(-2000)}`);
+                            }
                         } catch (error: any) {
-                            // Non-fatal — server may already be registered (providers return exit 1 on duplicate).
-                            LOG.warn('MeshCoordinator', `MCP registration command failed (may be pre-registered): ${error?.message || error}`);
+                            LOG.warn('MeshCoordinator', `MCP registration command failed: ${error?.message || error}`);
                         }
 
-                        // Inject system prompt using provider-native methods.
-                        // Codex: -c 'instructions="..."' CLI config override
-                        // Gemini: write GEMINI.md to workspace (auto-loaded as context)
+                        // Inject system prompt declaratively from provider.v1.json.
                         const cliCmdArgs: string[] = [];
                         const cliCmdEnv: Record<string, string> = {};
+                        let cliCmdContextFilePath: string | undefined;
                         if (cliCmdSystemPrompt) {
-                            if (cliType === 'codex-cli') {
-                                // Codex reads `developer_instructions` from config.toml as system instructions.
-                                // The -c flag overrides a config key for this session only.
-                                cliCmdArgs.push('-c', `developer_instructions=${JSON.stringify(cliCmdSystemPrompt)}`);
-                            } else if (cliType === 'gemini-cli') {
-                                // Gemini CLI auto-loads GEMINI.md from CWD as project context.
-                                // Write a temporary GEMINI.md to the workspace before launch.
-                                try {
-                                    const { writeFileSync: wfs, existsSync: efs, readFileSync: rfs } = await import('node:fs');
-                                    const geminiMdPath = `${workspace}/GEMINI.md`;
-                                    const marker = '<!-- adhdev-mesh-coordinator-prompt -->';
-                                    const markerEnd = '<!-- /adhdev-mesh-coordinator-prompt -->';
-                                    const block = `${marker}\n${cliCmdSystemPrompt}\n${markerEnd}`;
-                                    if (efs(geminiMdPath)) {
-                                        const existing = rfs(geminiMdPath, 'utf-8');
-                                        // Replace existing block or append
-                                        const replaced = existing.replace(
-                                            new RegExp(`${marker}[\\s\\S]*?${markerEnd}`, 'g'),
-                                            block,
-                                        );
-                                        wfs(geminiMdPath, replaced.includes(marker) ? replaced : `${existing}\n\n${block}`);
-                                    } else {
-                                        wfs(geminiMdPath, block);
-                                    }
-                                    LOG.info('MeshCoordinator', `Wrote coordinator prompt to ${workspace}/GEMINI.md`);
-                                } catch (e: any) {
-                                    LOG.warn('MeshCoordinator', `Could not write GEMINI.md: ${e?.message || e}`);
-                                }
-                            }
+                            const { applyMeshCoordinatorSystemPromptInjection } = await import('./mesh-coordinator.js');
+                            const effect = applyMeshCoordinatorSystemPromptInjection(
+                                cliCmdSystemPrompt,
+                                providerMeta?.meshCoordinator?.systemPromptInjection,
+                                { cliArgs: cliCmdArgs, launchEnv: cliCmdEnv, workspace, cliType },
+                            );
+                            cliCmdContextFilePath = effect.contextFilePath;
                         }
 
                         const cliCmdLaunch: any = await this.deps.cliManager.handleCliCommand('launch_cli', {
@@ -5326,6 +5448,22 @@ export class DaemonCommandRouter {
                             settings: { meshCoordinatorFor: meshId },
                         });
 
+                        // R48 inject-then-remove. Spawn was just kicked off above; agy and
+                        // gemini-cli read AGENTS.md / GEMINI.md exactly once at startup and
+                        // cache it for the rest of the session, so we can safely strip
+                        // the wrapper from disk shortly after launch. That keeps any
+                        // worker session launched into the same workspace later from
+                        // picking up our wrapper block.
+                        if (cliCmdLaunch?.success && cliCmdContextFilePath) {
+                            const stripPath = cliCmdContextFilePath;
+                            setTimeout(() => {
+                                void import('./mesh-coordinator.js').then(({ stripCoordinatorWrapperFile }) => {
+                                    stripCoordinatorWrapperFile(stripPath);
+                                    LOG.info('MeshCoordinator', `Stripped wrapper from ${stripPath} after launch settle (cli_command)`);
+                                }).catch(() => { /* best-effort */ });
+                            }, 5000);
+                        }
+
                         if (!cliCmdLaunch?.success) {
                             return { success: false, error: cliCmdLaunch?.error || 'Failed to launch CLI session' };
                         }
@@ -5333,7 +5471,23 @@ export class DaemonCommandRouter {
                         LOG.info('MeshCoordinator', `Launched ${cliType} coordinator (cli_command) for mesh ${meshId}`);
                         const cliCmdSessionId = cliCmdLaunch.sessionId || cliCmdLaunch.id;
                         if (cliCmdSessionId) {
-                            registerMeshCoordinator({ meshId, sessionId: cliCmdSessionId, workspace, startedAt: Date.now() });
+                            const cliCmdInjectionDecl = providerMeta?.meshCoordinator?.systemPromptInjection;
+                            registerMeshCoordinator({
+                                meshId,
+                                sessionId: cliCmdSessionId,
+                                workspace,
+                                startedAt: Date.now(),
+                                cliType,
+                                systemPrompt: cliCmdSystemPrompt || undefined,
+                                extraSystemPrompt: extraSystemPrompt || undefined,
+                                injection: cliCmdInjectionDecl ? {
+                                    mode: cliCmdInjectionDecl.mode,
+                                    target: 'flag' in cliCmdInjectionDecl ? cliCmdInjectionDecl.flag
+                                        : 'name' in cliCmdInjectionDecl ? cliCmdInjectionDecl.name
+                                        : 'path' in cliCmdInjectionDecl ? cliCmdInjectionDecl.path
+                                        : undefined,
+                                } : undefined,
+                            });
                         }
                         try {
                             const { appendLedgerEntry } = await import('../mesh/mesh-ledger.js');
@@ -5351,7 +5505,7 @@ export class DaemonCommandRouter {
                             cliType,
                             workspace,
                             sessionId: cliCmdSessionId,
-                            mcpRegistered: true,
+                            mcpRegistered: mcpRegistrationOk,
                         };
                     }
 
@@ -5372,7 +5526,7 @@ export class DaemonCommandRouter {
                     // broken mesh state is visible instead of silently launching with weaker rules.
                     let systemPrompt = '';
                     try {
-                        systemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType });
+                        systemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType, userInstruction: extraSystemPrompt || undefined });
                     } catch (error: any) {
                         const message = error?.message || String(error);
                         LOG.error('MeshCoordinator', `Failed to build coordinator prompt: ${message}`);
@@ -5487,12 +5641,15 @@ export class DaemonCommandRouter {
                         launchEnv.HERMES_HOME = dirname(mcpConfigPath);
                         launchEnv.HERMES_IGNORE_USER_CONFIG = '';
                     }
+                    let autoImportContextFilePath: string | undefined;
                     if (systemPrompt) {
-                        if (configFormat === 'hermes_config_yaml') {
-                            launchEnv.HERMES_EPHEMERAL_SYSTEM_PROMPT = systemPrompt;
-                        } else {
-                            cliArgs.push('--append-system-prompt', systemPrompt);
-                        }
+                        const { applyMeshCoordinatorSystemPromptInjection } = await import('./mesh-coordinator.js');
+                        const effect = applyMeshCoordinatorSystemPromptInjection(
+                            systemPrompt,
+                            providerMeta?.meshCoordinator?.systemPromptInjection,
+                            { cliArgs, launchEnv, workspace, cliType },
+                        );
+                        autoImportContextFilePath = effect.contextFilePath;
                     }
                     if (cliType === 'claude-cli') {
                         cliArgs.push('--mcp-config', coordinatorSetup.configPath);
@@ -5511,6 +5668,20 @@ export class DaemonCommandRouter {
                         }
                     });
 
+                    // R48 inject-then-remove. See the cli_command branch for context;
+                    // same idea: strip the wrapper from disk ~5s after launch so the
+                    // user's AGENTS.md / GEMINI.md is untouched the moment any
+                    // worker session opens up in the same workspace.
+                    if (launchResult?.success && autoImportContextFilePath) {
+                        const stripPath = autoImportContextFilePath;
+                        setTimeout(() => {
+                            void import('./mesh-coordinator.js').then(({ stripCoordinatorWrapperFile }) => {
+                                stripCoordinatorWrapperFile(stripPath);
+                                LOG.info('MeshCoordinator', `Stripped wrapper from ${stripPath} after launch settle (auto_import)`);
+                            }).catch(() => { /* best-effort */ });
+                        }, 5000);
+                    }
+
                     if (!launchResult?.success) {
                         return { success: false, error: launchResult?.error || 'Failed to launch CLI session' };
                     }
@@ -5518,7 +5689,24 @@ export class DaemonCommandRouter {
                     LOG.info('MeshCoordinator', `Launched ${cliType} coordinator for mesh ${meshId} in ${workspace}`);
                     const launchSessionId = launchResult.sessionId || launchResult.id;
                     if (launchSessionId) {
-                        registerMeshCoordinator({ meshId, sessionId: launchSessionId, workspace, startedAt: Date.now() });
+                        const autoImportInjectionDecl = providerMeta?.meshCoordinator?.systemPromptInjection;
+                        registerMeshCoordinator({
+                            meshId,
+                            sessionId: launchSessionId,
+                            workspace,
+                            startedAt: Date.now(),
+                            cliType,
+                            systemPrompt: systemPrompt || undefined,
+                            extraSystemPrompt: extraSystemPrompt || undefined,
+                            mcpConfigPath,
+                            injection: autoImportInjectionDecl ? {
+                                mode: autoImportInjectionDecl.mode,
+                                target: 'flag' in autoImportInjectionDecl ? autoImportInjectionDecl.flag
+                                    : 'name' in autoImportInjectionDecl ? autoImportInjectionDecl.name
+                                    : 'path' in autoImportInjectionDecl ? autoImportInjectionDecl.path
+                                    : undefined,
+                            } : undefined,
+                        });
                     }
 
                     // Record coordinator launch in task ledger