@adhdev/daemon-core 0.9.82-rc.187 → 0.9.82-rc.189

package/src/git/git-status.ts

@@ -48,6 +48,11 @@ export async function getGitRepoStatus(
     if (includeSubmodules) {
       submodules = await getSubmoduleStatuses(repo, options);
     }
+    const submoduleDirty = (submodules || []).some(submodule => submodule.dirty || submodule.outOfSync || !!submodule.error);
+    const dirty = parsed.staged + parsed.modified + parsed.untracked + parsed.deleted + parsed.renamed > 0
+      || parsed.conflictFiles.length > 0
+      || stashCount > 0
+      || submoduleDirty;
 
     return {
       workspace: repo.workspace,
@@ -67,6 +72,7 @@ export async function getGitRepoStatus(
       untracked: parsed.untracked,
       deleted: parsed.deleted,
       renamed: parsed.renamed,
+      dirty,
       hasConflicts: parsed.conflictFiles.length > 0,
       conflictFiles: parsed.conflictFiles,
       stashCount,
@@ -285,6 +291,7 @@ function emptyStatus(workspace: string, lastCheckedAt: number, error: GitCommand
     untracked: 0,
     deleted: 0,
     renamed: 0,
+    dirty: false,
     hasConflicts: false,
     conflictFiles: [],
     stashCount: 0,
@@ -304,12 +311,34 @@ async function getSubmoduleStatuses(
 
   try {
     const result = await runGit(repo, ['submodule', 'status', '--recursive'], options);
-    return parseSubmoduleStatusOutput(result.stdout, repo.repoRoot, options.submoduleIgnorePaths);
+    const submodules = parseSubmoduleStatusOutput(result.stdout, repo.repoRoot, options.submoduleIgnorePaths);
+    await Promise.all(submodules.map(submodule => enrichSubmoduleWorktreeStatus(repo, submodule, options)));
+    return submodules;
   } catch {
     return [];
   }
 }
 
+async function enrichSubmoduleWorktreeStatus(
+  repo: ResolvedGitRepo,
+  submodule: GitSubmoduleStatus,
+  options: GitStatusOptions,
+): Promise<void> {
+  try {
+    const result = await runGit(repo, ['status', '--porcelain=v2', '--branch'], {
+      ...options,
+      cwd: submodule.repoPath,
+    });
+    const parsed = parsePorcelainV2Status(result.stdout);
+    const dirty = parsed.staged + parsed.modified + parsed.untracked + parsed.deleted + parsed.renamed > 0
+      || parsed.conflictFiles.length > 0;
+    submodule.dirty = submodule.dirty || dirty;
+  } catch (error) {
+    submodule.dirty = true;
+    submodule.error = formatGitError(error);
+  }
+}
+
 function parseSubmoduleStatusOutput(
   output: string,
   repoRoot: string,
@@ -321,9 +350,9 @@ function parseSubmoduleStatusOutput(
   for (const line of output.split('\n')) {
     if (!line.trim()) continue;
 
-    // Format: [+- ]<commit> <path> (<branch>)
-    // - = out of sync, + = dirty, ' ' = clean
-    const match = line.match(/^([\-+\s])([0-9a-f]{40})\s+(\S+)(?:\s+\(([^)]+)\))?/);
+    // Format: [+-U ]<commit> <path> (<branch>)
+    // - = not initialized, + = gitlink out of sync, U = conflict, ' ' = aligned.
+    const match = line.match(/^([\-+U\s])([0-9a-f]{40})\s+(\S+)(?:\s+\(([^)]+)\))?/);
     if (!match) continue;
 
     const prefix = match[1];
@@ -336,8 +365,8 @@ function parseSubmoduleStatusOutput(
       path,
       commit,
       repoPath: repoRoot + '/' + path,
-      dirty: prefix === '+',
-      outOfSync: prefix === '-',
+      dirty: prefix === 'U',
+      outOfSync: prefix === '-' || prefix === '+',
       lastCheckedAt: Date.now(),
     });
   }

package/src/git/git-types.ts

@@ -60,6 +60,8 @@ export interface GitRepoStatus extends GitRepoIdentity {
   untracked: number;
   deleted: number;
   renamed: number;
+  /** Aggregate dirty flag including root worktree changes, conflicts, stash, and submodule drift. */
+  dirty: boolean;
   hasConflicts: boolean;
   conflictFiles: string[];
   stashCount: number;

package/src/index.ts

@@ -275,7 +275,7 @@ export type { CdpInitializerConfig } from './cdp/initializer.js';
 // ── Commands ──
 export { DaemonCommandHandler } from './commands/handler.js';
 export type { CommandResult, CommandContext } from './commands/handler.js';
-export { DaemonCommandRouter } from './commands/router.js';
+export { DaemonCommandRouter, readCachedInlineMeshActiveSessionDetails } from './commands/router.js';
 export type { CommandRouterDeps, CommandRouterResult } from './commands/router.js';
 export {
   maybeRunDaemonUpgradeHelperFromEnv,

package/src/mesh/mesh-events.ts

@@ -1962,6 +1962,11 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
     const nodeId = readNonEmptyString(payload.nodeId);
     const workspace = readNonEmptyString(payload.workspace);
     const nodeLabel = nodeId ? `Node '${nodeId}'` : workspace ? `Agent at ${workspace}` : 'Remote agent';
+    const relayModalMessage = readNonEmptyString(payload.modalMessage);
+    const relayModalButtons = Array.isArray(payload.modalButtons)
+        ? (payload.modalButtons as unknown[]).filter((b): b is string => typeof b === 'string' && b.trim().length > 0)
+        : null;
+
     return injectMeshSystemMessage(components, {
         meshId,
         nodeId,
@@ -1979,6 +1984,8 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
             startedAt: readNonEmptyString(payload.startedAt),
             completedAt: readNonEmptyString(payload.completedAt),
             retryOfJobId: readNonEmptyString(payload.retryOfJobId),
+            ...(relayModalMessage ? { modalMessage: relayModalMessage } : {}),
+            ...(relayModalButtons && relayModalButtons.length > 0 ? { modalButtons: relayModalButtons } : {}),
             ...(payload.result && typeof payload.result === 'object' && !Array.isArray(payload.result) ? { result: payload.result } : {}),
             ...(payload.completionDiagnostic && typeof payload.completionDiagnostic === 'object' && !Array.isArray(payload.completionDiagnostic) ? { completionDiagnostic: payload.completionDiagnostic } : {}),
             ...(payload.workerResult && typeof payload.workerResult === 'object' && !Array.isArray(payload.workerResult) ? { workerResult: payload.workerResult } : {}),

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

@@ -73,6 +73,12 @@ type CompletionFinalAssistantEvidence = {
     source: 'parsed' | 'external-native' | 'unavailable';
 };
 
+type ExternalNativeFinalReconciliation = {
+    fingerprint: string;
+    finalSummary: string;
+    evidence: CompletionFinalAssistantEvidence;
+};
+
 type ExternalTranscriptProbe = {
     readAt: number;
     msgCount: number;
@@ -369,6 +375,8 @@ export class CliProviderInstance implements ProviderInstance {
     private historyWriter: ChatHistoryWriter;
     private runtimeMessages: Array<{ key: string; message: ChatMessage }> = [];
     private lastPersistedHistoryMessages: PersistableCliHistoryMessage[] = [];
+    private lastAcknowledgedUserInputAt = 0;
+    private externalBusyIdleFingerprint = '';
     private lastNativeSourceCanonicalCheckAt = 0;
     private lastNativeSourceCanonicalCacheKey: string | undefined = undefined;
     private cachedSqliteDb: {
@@ -587,9 +595,13 @@ export class CliProviderInstance implements ProviderInstance {
             typeof adapterStatus?.providerSessionId === 'string' ? adapterStatus.providerSessionId : '',
         );
         const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, Date.now());
-        const visibleStatus = parseErrorMessage || parsedStatus?.status === 'error'
+        let visibleStatus = parseErrorMessage || parsedStatus?.status === 'error'
             ? 'error'
             : (autoApproveActive ? 'generating' : adapterStatus.status);
+        const externalNativeFinal = this.getExternalNativeFinalReconciliation(parsedStatus?.messages, adapterStatus);
+        if (externalNativeFinal && isCliGeneratingLikeStatus(visibleStatus)) {
+            visibleStatus = 'idle';
+        }
         const runtime = this.adapter.getRuntimeMetadata();
         this.maybeAppendRuntimeRecoveryMessage(runtime);
         let parsedMessages = Array.isArray(parsedStatus?.messages)
@@ -788,7 +800,22 @@ export class CliProviderInstance implements ProviderInstance {
     }
 
     updateSettings(newSettings: Record<string, any>): void {
-        this.settings = { ...newSettings };
+        const runtimeMeshSettings: Record<string, any> = {};
+        for (const key of [
+            'meshNodeFor',
+            'meshNodeId',
+            'meshActiveTaskId',
+            'meshCoordinatorFor',
+            'meshCoordinatorDaemonId',
+            'meshCoordinatorNodeId',
+            'spawnedSessionVisibility',
+            'launchedByCoordinator',
+        ]) {
+            if (this.settings[key] !== undefined && newSettings[key] === undefined) {
+                runtimeMeshSettings[key] = this.settings[key];
+            }
+        }
+        this.settings = { ...newSettings, ...runtimeMeshSettings };
         this.adapter.updateRuntimeSettings?.(this.settings);
         this.monitor.updateConfig({
             approvalAlert: this.settings.approvalAlert !== false,
@@ -884,6 +911,8 @@ export class CliProviderInstance implements ProviderInstance {
         if (!content) return;
 
         const receivedAt = Date.now();
+        this.lastAcknowledgedUserInputAt = receivedAt;
+        this.externalBusyIdleFingerprint = '';
         const dedupKey = `user_input_ack:${crypto
             .createHash('sha256')
             .update(`${this.instanceId}:${content}:${receivedAt}`)
@@ -1049,6 +1078,59 @@ export class CliProviderInstance implements ProviderInstance {
         return extractFinalSummaryFromMessages(evidence.messages as any);
     }
 
+    private externalNativeFinalFingerprint(evidence: CompletionFinalAssistantEvidence): string {
+        const messages = Array.isArray(evidence.messages) ? evidence.messages : [];
+        const visibleMessages = messages.filter((message: any) => isUserFacingChatMessage(message as ChatMessage));
+        const lastVisible = visibleMessages[visibleMessages.length - 1] as ChatMessage | undefined;
+        const content = lastVisible ? flattenContent(lastVisible.content).trim() : '';
+        const receivedAt = lastVisible ? getMessageTime(lastVisible) : 0;
+        const probe = this.lastExternalCompletionProbe;
+        return crypto
+            .createHash('sha256')
+            .update([
+                this.type,
+                this.providerSessionId || '',
+                probe?.sourcePath || '',
+                String(probe?.sourceMtimeMs || 0),
+                String(receivedAt || 0),
+                content.slice(-500),
+            ].join('\0'))
+            .digest('hex')
+            .slice(0, 24);
+    }
+
+    private getExternalNativeFinalReconciliation(parsedMessages: unknown, adapterStatus: any): ExternalNativeFinalReconciliation | null {
+        const rawStatus = typeof adapterStatus?.status === 'string' ? adapterStatus.status.trim() : '';
+        if (!isCliGeneratingLikeStatus(rawStatus)) return null;
+        if (hasNonEmptyCliModalButtons(adapterStatus?.activeModal ?? adapterStatus?.modal)) return null;
+
+        const evidence = this.completionFinalAssistantEvidence(parsedMessages);
+        if (evidence.source !== 'external-native' || !evidence.present) return null;
+
+        const messages = Array.isArray(evidence.messages) ? evidence.messages : [];
+        const visibleMessages = messages.filter((message: any) => isUserFacingChatMessage(message as ChatMessage));
+        const lastVisible = visibleMessages[visibleMessages.length - 1] as ChatMessage | undefined;
+        const lastMessageAt = lastVisible ? getMessageTime(lastVisible) : 0;
+        const sourceMtimeMs = Number(this.lastExternalCompletionProbe?.sourceMtimeMs || 0);
+        const minEvidenceAt = Math.max(
+            this.startedAt > 0 ? this.startedAt - 5_000 : 0,
+            this.generatingStartedAt > 0 ? this.generatingStartedAt - 5_000 : 0,
+            this.lastAcknowledgedUserInputAt > 0 ? this.lastAcknowledgedUserInputAt - 1_000 : 0,
+        );
+        if (minEvidenceAt > 0 && lastMessageAt > 0 && lastMessageAt < minEvidenceAt && sourceMtimeMs < minEvidenceAt) {
+            return null;
+        }
+
+        const finalSummary = extractFinalSummaryFromMessages(evidence.messages as any);
+        if (!finalSummary) return null;
+        const fingerprint = this.externalNativeFinalFingerprint(evidence);
+        if (fingerprint === this.externalBusyIdleFingerprint) {
+            return { fingerprint, finalSummary, evidence };
+        }
+        this.externalBusyIdleFingerprint = fingerprint;
+        return { fingerprint, finalSummary, evidence };
+    }
+
     private buildCompletedFinalizationDiagnostic(args: {
         blockReason: string;
         latestStatus?: any;
@@ -1138,12 +1220,13 @@ export class CliProviderInstance implements ProviderInstance {
         return true;
     }
 
-    private getCompletedFinalizationBlock(latestVisibleStatus: string, pending: CompletedDebouncePending): CompletedFinalizationBlock | null {
+    private getCompletedFinalizationBlock(latestVisibleStatus: string, pending: CompletedDebouncePending, opts?: { externalNativeFinal?: ExternalNativeFinalReconciliation | null }): CompletedFinalizationBlock | null {
         if (latestVisibleStatus !== 'idle') return { reason: `status:${latestVisibleStatus}`, terminal: true };
 
         const adapterAny = this.adapter as any;
         const approvalResolvedIdle = pending.previousStatus === 'waiting_approval';
-        if (!approvalResolvedIdle) {
+        const externalNativeFinal = opts?.externalNativeFinal || null;
+        if (!approvalResolvedIdle && !externalNativeFinal) {
             if (adapterAny?.isWaitingForResponse === true) return { reason: 'adapter_waiting_for_response', terminal: true };
             if (adapterAny?.currentTurnScope) return { reason: 'adapter_turn_scope_active', terminal: true };
             if (this.hasAdapterPendingResponse()) return { reason: 'adapter_pending_response', terminal: true };
@@ -1152,7 +1235,7 @@ export class CliProviderInstance implements ProviderInstance {
         const partial = typeof this.adapter.getPartialResponse === 'function'
             ? this.adapter.getPartialResponse()
             : '';
-        if (typeof partial === 'string' && partial.trim()) return { reason: 'partial_response_pending', terminal: true };
+        if (!externalNativeFinal && typeof partial === 'string' && partial.trim()) return { reason: 'partial_response_pending', terminal: true };
 
         let parsed: any;
         try {
@@ -1164,6 +1247,7 @@ export class CliProviderInstance implements ProviderInstance {
         const parsedStatus = typeof parsed?.status === 'string' ? parsed.status : 'unknown';
         if (parsedStatus !== 'idle') {
             const adapterStatus = this.adapter.getStatus({ allowParse: false });
+            if (externalNativeFinal && isCliGeneratingLikeStatus(parsedStatus)) return null;
             if (this.shouldSuppressStaleParsedBusyStatus(parsed, adapterStatus)) return null;
             return { reason: `parsed_status:${parsedStatus}`, terminal: isCliGeneratingLikeStatus(parsedStatus) };
         }
@@ -1230,7 +1314,10 @@ export class CliProviderInstance implements ProviderInstance {
 
         const latestStatus = this.adapter.getStatus({ allowParse: false });
         const latestAutoApproveActive = latestStatus.status === 'waiting_approval' && this.shouldAutoApprove();
-        const latestVisibleStatus = latestAutoApproveActive ? 'generating' : latestStatus.status;
+        const externalNativeFinal = this.getExternalNativeFinalReconciliation(undefined, latestStatus);
+        const latestVisibleStatus = externalNativeFinal && isCliGeneratingLikeStatus(latestStatus.status)
+            ? 'idle'
+            : (latestAutoApproveActive ? 'generating' : latestStatus.status);
         if (latestVisibleStatus !== 'idle') {
             LOG.info('CLI', `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
             this.completedDebouncePending = null;
@@ -1238,7 +1325,7 @@ export class CliProviderInstance implements ProviderInstance {
             return;
         }
 
-        const block = this.getCompletedFinalizationBlock(latestVisibleStatus, pending);
+        const block = this.getCompletedFinalizationBlock(latestVisibleStatus, pending, { externalNativeFinal });
         if (block) {
             const blockReason = block.reason;
             const waitedMs = Date.now() - pending.firstObservedAt;
@@ -1282,7 +1369,18 @@ export class CliProviderInstance implements ProviderInstance {
             chatTitle: pending.chatTitle,
             duration: pending.duration,
             timestamp: pending.timestamp,
-            finalSummary: this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages),
+            finalSummary: externalNativeFinal?.finalSummary || this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages),
+            ...(externalNativeFinal ? {
+                completionDiagnostic: {
+                    providerType: this.type,
+                    sessionId: this.instanceId,
+                    providerSessionId: this.providerSessionId || null,
+                    reconciliationReason: 'external_native_final_assistant_while_adapter_busy',
+                    finalAssistantPresent: true,
+                    finalAssistantEvidenceSource: externalNativeFinal.evidence.source,
+                    externalFinalFingerprint: externalNativeFinal.fingerprint,
+                },
+            } : {}),
         });
         this.completedDebouncePending = null;
         this.completedDebounceTimer = null;
@@ -1359,7 +1457,10 @@ export class CliProviderInstance implements ProviderInstance {
         const parsedStatus = null;
         const rawStatus = adapterStatus.status;
         const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, now);
-        const newStatus = autoApproveActive ? 'generating' : rawStatus;
+        const externalNativeFinal = this.getExternalNativeFinalReconciliation(undefined, adapterStatus);
+        const newStatus = externalNativeFinal && isCliGeneratingLikeStatus(rawStatus)
+            ? 'idle'
+            : (autoApproveActive ? 'generating' : rawStatus);
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
         const chatTitle = `${this.provider.name} · ${dirName}`;
         const partial = this.adapter.getPartialResponse();

package/src/providers/contracts.d.ts

@@ -401,7 +401,62 @@ export interface ProviderModule {
     spawnArgBuilder?: (config: Record<string, string>) => string[];
     /** ACP agent auth methods (multiple supported — in priority order) */
     auth?: AcpAuthMethod[];
+    /**
+     * Repo Mesh coordinator capability and MCP ingestion behavior.
+     * Providers must declare this rather than relying on daemon hardcoded CLI quirks.
+     */
+    meshCoordinator?: ProviderMeshCoordinatorConfig;
+}
+export type MeshCoordinatorMcpConfigMode = 'auto_import' | 'manual' | 'none';
+export type MeshCoordinatorMcpConfigFormat = 'claude_mcp_json' | 'hermes_config_yaml';
+export interface ProviderMeshCoordinatorConfig {
+    supported: boolean;
+    reason?: string;
+    mcpConfig?: {
+        mode: MeshCoordinatorMcpConfigMode;
+        format?: MeshCoordinatorMcpConfigFormat;
+        path?: string;
+        serverName?: string;
+        configPathCommand?: string;
+        requiresRestart?: boolean;
+        instructions?: string;
+        template?: string;
+    };
+    systemPromptInjection?: MeshCoordinatorSystemPromptInjection;
+    delegatedWorkerIsolation?: MeshCoordinatorDelegatedWorkerIsolation;
 }
+export type MeshCoordinatorSystemPromptInjection = {
+    mode: 'cli_arg';
+    flag: string;
+} | {
+    mode: 'config_override';
+    flag: string;
+    template: string;
+} | {
+    mode: 'context_file';
+    path: string;
+    wrapper?: string;
+} | {
+    mode: 'env_var';
+    name: string;
+};
+export interface MeshCoordinatorDelegatedWorkerIsolation {
+    env?: {
+        unset?: string[];
+    };
+    args?: MeshCoordinatorDelegatedWorkerArgRule[];
+}
+export type MeshCoordinatorDelegatedWorkerArgRule = {
+    mode: 'empty_mcp_config';
+    flag: string;
+    strictFlag?: string;
+} | {
+    mode: 'config_override';
+    flag: string;
+    key: string;
+    value: string;
+    dedupeKey?: string;
+};
 export interface ProviderResumeCapability {
     supported: boolean;
     stopStrategy?: 'command' | 'ctrl_c';

package/src/providers/contracts.ts

@@ -403,8 +403,43 @@ export interface ProviderMeshCoordinatorConfig {
    * the CLI doesn't recognize).
    */
   systemPromptInjection?: MeshCoordinatorSystemPromptInjection;
+  /**
+   * How coordinator-launched worker sessions are isolated from coordinator-only
+   * MCP/tools/config. Provider-specific CLI quirks belong here, not in daemon
+   * launch code.
+   */
+  delegatedWorkerIsolation?: MeshCoordinatorDelegatedWorkerIsolation;
 }
 
+export interface MeshCoordinatorDelegatedWorkerIsolation {
+  /** Environment variables to unset for delegated worker sessions. */
+  env?: {
+    unset?: string[];
+  };
+  /** Spawn-argument rules applied before launching a delegated worker. */
+  args?: MeshCoordinatorDelegatedWorkerArgRule[];
+}
+
+export type MeshCoordinatorDelegatedWorkerArgRule =
+  | {
+      mode: 'empty_mcp_config';
+      /** CLI flag that points at an MCP config file, e.g. '--mcp-config'. */
+      flag: string;
+      /** Optional CLI flag that forces only the provided MCP config to be used. */
+      strictFlag?: string;
+    }
+  | {
+      mode: 'config_override';
+      /** CLI config flag, e.g. '-c' or '--config'. */
+      flag: string;
+      /** Config key to set for worker isolation. */
+      key: string;
+      /** Config value to set. */
+      value: string;
+      /** Optional broader key prefix used for duplicate detection. */
+      dedupeKey?: string;
+    };
+
 /**
  * Declarative description of how a CLI accepts a session-scoped system prompt.
  *

package/src/providers/provider-schema.ts

@@ -300,7 +300,11 @@ function validateMeshCoordinator(raw: unknown, errors: string[]): void {
     errors.push('meshCoordinator.reason must be a non-empty string when provided')
   }
 
-  const mcpConfig = meshCoordinator.mcpConfig
+  validateMeshCoordinatorMcpConfig(meshCoordinator.mcpConfig, errors)
+  validateMeshCoordinatorDelegatedWorkerIsolation(meshCoordinator.delegatedWorkerIsolation, errors)
+}
+
+function validateMeshCoordinatorMcpConfig(mcpConfig: unknown, errors: string[]): void {
   if (mcpConfig === undefined) return
   if (!mcpConfig || typeof mcpConfig !== 'object' || Array.isArray(mcpConfig)) {
     errors.push('meshCoordinator.mcpConfig must be an object')
@@ -348,6 +352,57 @@ function validateMeshCoordinator(raw: unknown, errors: string[]): void {
   }
 }
 
+function validateMeshCoordinatorDelegatedWorkerIsolation(raw: unknown, errors: string[]): void {
+  if (raw === undefined) return
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    errors.push('meshCoordinator.delegatedWorkerIsolation must be an object')
+    return
+  }
+  const isolation = raw as Record<string, unknown>
+  const env = isolation.env
+  if (env !== undefined) {
+    if (!env || typeof env !== 'object' || Array.isArray(env)) {
+      errors.push('meshCoordinator.delegatedWorkerIsolation.env must be an object')
+    } else {
+      const unset = (env as Record<string, unknown>).unset
+      if (unset !== undefined && (!Array.isArray(unset) || unset.some((key) => typeof key !== 'string' || !key.trim()))) {
+        errors.push('meshCoordinator.delegatedWorkerIsolation.env.unset must be an array of non-empty strings')
+      }
+    }
+  }
+  const args = isolation.args
+  if (args === undefined) return
+  if (!Array.isArray(args)) {
+    errors.push('meshCoordinator.delegatedWorkerIsolation.args must be an array')
+    return
+  }
+  for (const [index, rule] of args.entries()) {
+    const prefix = `meshCoordinator.delegatedWorkerIsolation.args[${index}]`
+    if (!rule || typeof rule !== 'object' || Array.isArray(rule)) {
+      errors.push(`${prefix} must be an object`)
+      continue
+    }
+    const item = rule as Record<string, unknown>
+    const mode = item.mode
+    if (mode !== 'empty_mcp_config' && mode !== 'config_override') {
+      errors.push(`${prefix}.mode must be one of: empty_mcp_config, config_override`)
+      continue
+    }
+    for (const key of mode === 'empty_mcp_config' ? ['flag'] : ['flag', 'key', 'value']) {
+      const value = item[key]
+      if (typeof value !== 'string' || !value.trim()) {
+        errors.push(`${prefix}.${key} must be a non-empty string`)
+      }
+    }
+    for (const key of ['strictFlag', 'dedupeKey']) {
+      const value = item[key]
+      if (value !== undefined && (typeof value !== 'string' || !value.trim())) {
+        errors.push(`${prefix}.${key} must be a non-empty string when provided`)
+      }
+    }
+  }
+}
+
 function validateControl(control: ProviderControlDef, errors: string[]): void {
   if (!control || typeof control !== 'object') {
     errors.push('controls: each control must be an object')

package/src/providers/sdk/v1/schemas/cli/provider.schema.json

@@ -320,6 +320,52 @@
             { "type": "object", "additionalProperties": false, "required": ["mode", "name"],
               "properties": { "mode": { "const": "env_var" }, "name": { "type": "string" } } }
           ]
+        },
+        "delegatedWorkerIsolation": {
+          "description": "Provider-declared launch isolation for coordinator-spawned worker sessions. Keeps worker-only sessions from inheriting coordinator MCP/tools/config.",
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "env": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "unset": {
+                  "type": "array",
+                  "items": { "type": "string", "minLength": 1 }
+                }
+              }
+            },
+            "args": {
+              "type": "array",
+              "items": {
+                "oneOf": [
+                  {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["mode", "flag"],
+                    "properties": {
+                      "mode": { "const": "empty_mcp_config" },
+                      "flag": { "type": "string", "minLength": 1 },
+                      "strictFlag": { "type": "string", "minLength": 1 }
+                    }
+                  },
+                  {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["mode", "flag", "key", "value"],
+                    "properties": {
+                      "mode": { "const": "config_override" },
+                      "flag": { "type": "string", "minLength": 1 },
+                      "key": { "type": "string", "minLength": 1 },
+                      "value": { "type": "string", "minLength": 1 },
+                      "dedupeKey": { "type": "string", "minLength": 1 }
+                    }
+                  }
+                ]
+              }
+            }
+          }
         }
       }
     },

package/src/providers/sdk/v1/types/common/index.ts

@@ -169,8 +169,27 @@ export interface McpConfigDef {
 export interface MeshCoordinatorDef {
   supported: boolean;
   mcpConfig?: McpConfigDef;
+  systemPromptInjection?: MeshCoordinatorSystemPromptInjectionDef;
+  delegatedWorkerIsolation?: MeshCoordinatorDelegatedWorkerIsolationDef;
 }
 
+export type MeshCoordinatorSystemPromptInjectionDef =
+  | { mode: 'cli_arg'; flag: string }
+  | { mode: 'config_override'; flag: string; template: string }
+  | { mode: 'context_file'; path: string; wrapper?: string }
+  | { mode: 'env_var'; name: string };
+
+export interface MeshCoordinatorDelegatedWorkerIsolationDef {
+  env?: {
+    unset?: ReadonlyArray<string>;
+  };
+  args?: ReadonlyArray<MeshCoordinatorDelegatedWorkerArgRuleDef>;
+}
+
+export type MeshCoordinatorDelegatedWorkerArgRuleDef =
+  | { mode: 'empty_mcp_config'; flag: string; strictFlag?: string }
+  | { mode: 'config_override'; flag: string; key: string; value: string; dedupeKey?: string };
+
 // ─── Compatibility ──────────────────────────────────────────────────────
 
 export interface CompatibilityEntryDef {

package/src/providers/spec/adapter.ts

@@ -128,6 +128,14 @@ export class TerminalAdapter {
         return this.lastScreen || this.computeScreen();
     }
 
+    getCursorPosition(): { row: number; col: number } {
+        const buf = this.term.buffer.active;
+        return {
+            row: Math.max(0, (buf as any).cursorY ?? 0),
+            col: Math.max(0, (buf as any).cursorX ?? 0),
+        };
+    }
+
     kill(): void {
         this.stopTimers();
         try { this.pty?.kill(); } catch { /* ignore */ }