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

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

@@ -55,6 +55,8 @@ export declare class CliProviderInstance implements ProviderInstance {
     private historyWriter;
     private runtimeMessages;
     private lastPersistedHistoryMessages;
+    private lastAcknowledgedUserInputAt;
+    private externalBusyIdleFingerprint;
     private lastNativeSourceCanonicalCheckAt;
     private lastNativeSourceCanonicalCacheKey;
     private cachedSqliteDb;
@@ -130,6 +132,8 @@ export declare class CliProviderInstance implements ProviderInstance {
     private readExternalCompletionMessages;
     private completionFinalAssistantEvidence;
     private completionFinalSummary;
+    private externalNativeFinalFingerprint;
+    private getExternalNativeFinalReconciliation;
     private buildCompletedFinalizationDiagnostic;
     private hasAdapterPendingResponse;
     private shouldSuppressStaleParsedBusyStatus;

package/dist/providers/contracts.d.ts

@@ -315,7 +315,38 @@ 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/dist/providers/sdk/v1/types/common/index.d.ts

@@ -138,7 +138,41 @@ 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;
+};
 export interface CompatibilityEntryDef {
     /** SemVer range against the agent's own version. Optional. */
     ideVersion?: string;

package/dist/providers/spec/adapter.d.ts

@@ -49,6 +49,10 @@ export declare class TerminalAdapter {
     send_keys(s: string): void;
     resize(cols: number, rows: number): void;
     snapshot(): string;
+    getCursorPosition(): {
+        row: number;
+        col: number;
+    };
     kill(): void;
     private onChunk;
     private computeScreen;

package/dist/providers/spec/driver.d.ts

@@ -1,5 +1,6 @@
 import type { PtyTransportFactory } from '../../cli-adapters/pty-transport.js';
-import { type TraceEntry } from './evaluator.js';
+import { type SpecEvaluation, type TraceEntry } from './evaluator.js';
+import type { CliSpec } from './types.js';
 export type DashboardEvent = {
     kind: 'pty_data';
     chunk: string;
@@ -96,6 +97,8 @@ export interface SpecDriverOpts {
  * embedded `\n`.
  */
 export declare function resolveSubmitDelayMs(specBeforeSubmit: number | undefined, text: string): number;
+export declare function matchesCompletionIdleRule(spec: CliSpec, ev: SpecEvaluation, screen: string): string | null;
+export declare function matchesCompletionIdleTargetState(spec: CliSpec, ev: SpecEvaluation, screen: string): boolean;
 export declare class SpecDriver {
     private readonly opts;
     private spec;
@@ -122,6 +125,8 @@ export declare class SpecDriver {
      *  because the evaluator already moved past busy by the time the hold
      *  kicks in. */
     private lastBusyState;
+    private completionIdleFirstSeenAt;
+    private completionIdleKey;
     /** Timer that re-runs evaluate() once the hold window expires. Needed
      *  because the PTY stops emitting once the agent finishes; without an
      *  explicit wake-up there's nothing to trigger the busy → idle
@@ -134,6 +139,10 @@ export declare class SpecDriver {
     start(): void;
     dispatch(cmd: DashboardCommand): void;
     snapshot(): string;
+    getCursorPosition(): {
+        row: number;
+        col: number;
+    };
     shutdown(): void;
     private loadSpecOrThrow;
     private buildAdapterOpts;

package/dist/providers/spec/evaluator.d.ts

@@ -44,4 +44,12 @@ export interface SpecEvaluation {
     sections: ResolvedSection[];
     trace: TraceEntry[];
 }
-export declare function evaluate(spec: CliSpec, screenText: string): SpecEvaluation;
+export declare function evaluate(spec: CliSpec, screenText: string, 
+/** Optional cursor position (0-based row and col). When supplied, states
+ *  with cursor_row_min/max or cursor_col_min/max predicates are filtered.
+ *  When omitted, cursor predicates are ignored and evaluation is text-only
+ *  (backward-compatible with all existing specs and call sites). */
+cursor?: {
+    row: number;
+    col: number;
+}): SpecEvaluation;

package/dist/providers/spec/schema.gen.d.ts

@@ -124,6 +124,28 @@ export declare const SCHEMA: {
                     readonly type: "integer";
                     readonly minimum: 0;
                 };
+                readonly completion_idle_after: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["regex", "hold_ms"];
+                    readonly properties: {
+                        readonly section: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly regex: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly flags: {
+                            readonly type: "string";
+                        };
+                        readonly hold_ms: {
+                            readonly type: "integer";
+                            readonly minimum: 0;
+                        };
+                    };
+                };
             };
         };
     };
@@ -181,6 +203,22 @@ export declare const SCHEMA: {
                     readonly type: "string";
                     readonly default: "i";
                 };
+                readonly cursor_row_min: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly cursor_row_max: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly cursor_col_min: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly cursor_col_max: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
             };
         };
         readonly sectionPattern: {

package/dist/providers/spec/types.d.ts

@@ -11,6 +11,21 @@ export interface SectionRegex {
     section?: string;
     regex: string;
     flags?: string;
+    /**
+     * Optional cursor-position guards. When present, the state is only
+     * considered matched if the terminal cursor row/column satisfies the
+     * bounds (0-based, inclusive). Missing or undefined means "no constraint".
+     *
+     * Use case: distinguish modal zone from body zone for TUIs that use
+     * cursor position rather than distinct text to locate the active prompt
+     * (e.g. Antigravity cursor lands in modal_zone rows 8-31 when approval
+     * is visible, never in body rows 0-7). Without this guard, body text
+     * containing "Do you want to proceed?" could false-positive a modal match.
+     */
+    cursor_row_min?: number;
+    cursor_row_max?: number;
+    cursor_col_min?: number;
+    cursor_col_max?: number;
 }
 export interface SectionPattern {
     section?: string;
@@ -208,5 +223,15 @@ export interface CliSpec {
          *  once the window passes and an idle state has actually been
          *  observed. */
         startup_grace_ms?: number;
+        /** Treat a provider-specific completion marker as idle after it has
+         *  remained visible for hold_ms. This handles TUIs that leave their
+         *  last spinner glyph next to a completed timer, causing the normal
+         *  busy regex to keep matching after the turn is done. */
+        completion_idle_after?: {
+            section?: string;
+            regex: string;
+            flags?: string;
+            hold_ms: number;
+        };
     };
 }

package/dist/repo-mesh-types.d.ts

@@ -305,11 +305,17 @@ export interface RepoMeshSessionStatus {
     sessionId: string;
     providerType?: string;
     state?: string;
+    chatStatus?: string;
     lifecycle?: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'interrupted';
     surfaceKind?: 'live_runtime' | 'recovery_snapshot' | 'inactive_record';
     recoveryState?: string | null;
     workspace?: string | null;
     title?: string | null;
+    role?: string | null;
+    isSelfCoordinator?: boolean;
+    statusNote?: string | null;
+    createdAt?: string | null;
+    startedAt?: string | null;
     lastActivityAt?: string | null;
     isCached?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.187",
+  "version": "0.9.82-rc.189",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/boot/daemon-lifecycle.ts

@@ -63,6 +63,7 @@ export interface DaemonInitConfig {
 
     /** Router transport-specific callbacks */
     onStatusChange?: () => void;
+    onMeshStateChange?: (meshId: string) => void;
     onPostChatCommand?: () => void;
     sessionHostControl?: SessionHostControlPlane | null;
     getCdpLogFn?: (ideType: string) => (msg: string) => void;
@@ -310,6 +311,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         },
         onIdeConnected: () => poller?.start(),
         onStatusChange: config.onStatusChange,
+        onMeshStateChange: config.onMeshStateChange,
         onPostChatCommand: config.onPostChatCommand,
         sessionHostControl: config.sessionHostControl,
         statusInstanceId: config.statusInstanceId,

package/src/commands/chat-commands.ts

@@ -1378,6 +1378,15 @@ function hasVisibleAssistantMessage(messages: unknown[] | undefined): boolean {
     });
 }
 
+function hasFinalVisibleAssistantMessage(messages: unknown[] | undefined): boolean {
+    if (!Array.isArray(messages)) return false;
+    const visible = filterUserFacingChatMessages(messages as ChatMessage[]);
+    const last = visible[visible.length - 1] as ChatMessage | undefined;
+    const role = typeof last?.role === 'string' ? last.role.trim().toLowerCase() : '';
+    const content = last ? flattenContent(last.content).trim() : '';
+    return (role === 'assistant' || role === 'model') && content.length > 0;
+}
+
 function shouldTrustCliAdapterTerminalStatus(parsedStatus: unknown, activeModal: unknown, adapter: CliAdapter, adapterStatus: any): boolean {
     if (!isGeneratingLikeStatus(parsedStatus)) return false;
     if (hasNonEmptyModalButtons(activeModal)) return false;
@@ -2479,6 +2488,23 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                     });
                 }
             }
+            if (
+                isGeneratingLikeStatus(selectedStatus)
+                && selectedTranscriptAuthority === 'provider'
+                && !hasNonEmptyModalButtons(activeModal)
+                && hasFinalVisibleAssistantMessage(selectedMessages)
+            ) {
+                selectedStatus = 'idle';
+                selectedMessages = finalizeStreamingMessagesWhenIdle(selectedMessages, selectedStatus);
+                messageSource = {
+                    ...messageSource,
+                    statusReconciled: {
+                        from: returnedStatus,
+                        to: 'idle',
+                        reason: 'provider_native_final_assistant',
+                    },
+                };
+            }
             LOG.debug('Command', `[read_chat] cli-like parsed provider=${adapter.cliType} target=${String(args?.targetSessionId || '')} adapterStatus=${String(adapterStatus.status || '')} parsedStatus=${String(parsedRecord.status || '')} parsedMsgCount=${parsedRecord.messages.length} returnedMsgCount=${returnedMessages.length}`);
             return buildReadChatCommandResult({
                 messages: selectedMessages,

package/src/commands/cli-manager.ts

@@ -25,7 +25,7 @@ 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';
@@ -247,18 +247,19 @@ type CliStartOptions = {
     extraEnv?: Record<string, 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 {
@@ -270,6 +271,21 @@ function hasCliArg(args: string[], flag: string): boolean {
     return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
 }
 
+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 });
@@ -282,12 +298,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 };
@@ -1090,6 +1125,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({
@@ -1097,6 +1134,7 @@ 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
@@ -1104,15 +1142,15 @@ export class DaemonCliManager {
                 // 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 provLookup = this.providerLoader.getMeta(this.providerLoader.resolveAlias(cliType)) as any;
-                const provTrust = provLookup?._sourceTrust;
+                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: provLookup?._sourceName ?? null,
+                            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.',

package/src/commands/router.ts

@@ -849,7 +849,7 @@ function readCachedInlineMeshActiveSessions(node: any): string[] {
     return sessionId ? [sessionId] : [];
 }
 
-function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<string, unknown>> {
+export function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<string, unknown>> {
     const cachedStatus = readObjectRecord(node?.cachedStatus);
     const activeSession = readObjectRecord(cachedStatus.activeSession);
     const fallbackSession = Object.keys(activeSession).length
@@ -877,9 +877,14 @@ function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<strin
             node?.provider_type,
         ),
         state: readStringValue(fallbackSession.status, fallbackSession.state, fallbackSession.lifecycle),
+        chatStatus: readStringValue(fallbackSession.chatStatus, fallbackSession.chat_status),
         lifecycle: readStringValue(fallbackSession.lifecycle),
         title: readStringValue(fallbackSession.title, fallbackSession.displayName, fallbackSession.display_name) ?? null,
         workspace: readStringValue(fallbackSession.workspace, node?.workspace) ?? null,
+        role: readStringValue(fallbackSession.role) ?? null,
+        isSelfCoordinator: fallbackSession.isSelfCoordinator === true || fallbackSession.is_self_coordinator === true,
+        createdAt: readStringValue(fallbackSession.createdAt, fallbackSession.created_at) ?? null,
+        startedAt: readStringValue(fallbackSession.startedAt, fallbackSession.started_at) ?? null,
         lastActivityAt: readStringValue(fallbackSession.lastActivityAt, fallbackSession.last_activity_at) ?? null,
         recoveryState: readStringValue(fallbackSession.recoveryState, fallbackSession.recovery_state) ?? null,
         isCached: true,
@@ -1067,15 +1072,28 @@ async function hydrateInlineMeshDirectTruth(args: {
 }
 
 function summarizeMeshSessionRecord(record: any): Record<string, unknown> {
+    const meta = readObjectRecord(record?.meta);
+    const isSelfCoordinator = Boolean(readStringValue(meta.meshCoordinatorFor));
+    const chatStatus = readStringValue(record?.chatStatus, record?.activeChat?.status, meta.chatStatus, meta.sessionStatus);
+    const state = readLiveMeshSessionState(record);
+    const statusNote = isSelfCoordinator && (!chatStatus || chatStatus === 'idle' || state === 'idle')
+        ? 'Coordinator self status is sampled from the session host and may read idle while the coordinator is generating this response.'
+        : null;
     return {
         sessionId: readStringValue(record?.sessionId) || 'unknown',
         providerType: readStringValue(record?.providerType),
-        state: readLiveMeshSessionState(record),
+        state,
+        chatStatus,
         lifecycle: readStringValue(record?.lifecycle),
         surfaceKind: getSessionHostSurfaceKind(record as any),
-        recoveryState: readStringValue(record?.meta?.runtimeRecoveryState) ?? null,
+        recoveryState: readStringValue(meta.runtimeRecoveryState) ?? null,
         workspace: readStringValue(record?.workspace) ?? null,
         title: readStringValue(record?.displayName, record?.workspaceLabel) ?? null,
+        role: isSelfCoordinator ? 'coordinator' : readStringValue(meta.meshRole, meta.role) ?? null,
+        isSelfCoordinator,
+        statusNote,
+        createdAt: toIsoTimestamp(record?.createdAt ?? record?.created_at),
+        startedAt: toIsoTimestamp(record?.startedAt ?? record?.started_at ?? record?.spawnedAtMs ?? record?.spawned_at_ms),
         lastActivityAt: toIsoTimestamp(record?.updatedAt ?? record?.lastActivityAt ?? record?.last_activity_at),
         isCached: false,
     };
@@ -2130,12 +2148,14 @@ export interface CommandRouterDeps {
     /** Reference to detected IDEs array (mutable — router updates it) */
     detectedIdes: { value: any[] };
     sessionRegistry: SessionRegistry;
-    /** Callback for CDP manager creation after launch_ide */
+    /** Callback after CDP manager created (transport-specific extras) */
     onCdpManagerCreated?: (ideType: string, manager: DaemonCdpManager) => void;
     /** Callback after IDE connected (e.g., startAgentStreamPolling) */
     onIdeConnected?: () => void;
     /** Callback after status change (stop_ide, restart) */
     onStatusChange?: () => void;
+    /** Callback when a mesh state is invalidated */
+    onMeshStateChange?: (meshId: string) => void;
     /** Callback after chat-related commands */
     onPostChatCommand?: () => void;
     /** Get a connected CDP manager (for agent stream reset check) */
@@ -2456,6 +2476,16 @@ export class DaemonCommandRouter {
         return next;
     }
 
+    public getCachedInlineMeshNodes(): any[] {
+        const nodes: any[] = [];
+        for (const mesh of this.inlineMeshCache.values()) {
+            if (Array.isArray(mesh?.nodes)) {
+                nodes.push(...mesh.nodes);
+            }
+        }
+        return nodes;
+    }
+
     public getCachedInlineMesh(meshId: string, inlineMesh?: unknown): any | undefined {
         if (inlineMesh && typeof inlineMesh === 'object') {
             return this.warmInlineMeshCache(meshId, inlineMesh);
@@ -2510,6 +2540,7 @@ export class DaemonCommandRouter {
 
     private invalidateAggregateMeshStatus(meshId: string): void {
         this.aggregateMeshStatusCache.delete(meshId);
+        this.deps.onMeshStateChange?.(meshId);
     }
 
 

package/src/git/git-commands.ts

@@ -66,7 +66,7 @@ export interface GitPushResult extends GitRepoIdentity {
 }
 
 export interface GitCommandServices {
-  getStatus?: (params: { workspace: string; refreshUpstream?: boolean }) => Promise<GitRepoStatus> | GitRepoStatus;
+  getStatus?: (params: { workspace: string; refreshUpstream?: boolean; includeSubmodules?: boolean; submoduleIgnorePaths?: string[] }) => Promise<GitRepoStatus> | GitRepoStatus;
   getDiffSummary?: (params: { workspace: string; staged?: boolean }) => Promise<GitDiffSummary> | GitDiffSummary;
   getDiffFile?: (params: { workspace: string; path: string; staged?: boolean }) => Promise<GitFileDiff> | GitFileDiff;
   createSnapshot?: (params: {
@@ -294,7 +294,16 @@ export async function handleGitCommand(
   switch (command) {
     case 'git_status': {
       if (!services.getStatus) return serviceNotImplemented(command);
-      const status = await runService(() => services.getStatus!({ workspace, refreshUpstream: optionalBoolean(args?.refreshUpstream) }));
+      const submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths)
+        ? args.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string' && value.trim().length > 0)
+        : undefined;
+      const statusParams: { workspace: string; refreshUpstream?: boolean; includeSubmodules?: boolean; submoduleIgnorePaths?: string[] } = { workspace };
+      const refreshUpstream = optionalBoolean(args?.refreshUpstream);
+      const includeSubmodules = optionalBoolean(args?.includeSubmodules);
+      if (refreshUpstream !== undefined) statusParams.refreshUpstream = refreshUpstream;
+      if (includeSubmodules !== undefined) statusParams.includeSubmodules = includeSubmodules;
+      if (submoduleIgnorePaths && submoduleIgnorePaths.length > 0) statusParams.submoduleIgnorePaths = submoduleIgnorePaths;
+      const status = await runService(() => services.getStatus!(statusParams));
       return 'success' in status ? status : { success: true, status };
     }
 
@@ -446,6 +455,15 @@ async function gitCheckpoint(
   if (statusResult.hasConflicts) {
     throw new GitCommandError('conflict', 'Repository has conflicts — resolve before checkpointing');
   }
+  const dirtySubmodules = (statusResult.submodules || []).filter(submodule => submodule.dirty);
+  if (dirtySubmodules.length > 0) {
+    const paths = dirtySubmodules.map(submodule => submodule.path).join(', ');
+    throw new GitCommandError(
+      'dirty_index_required',
+      `Repository has dirty submodules that must be checkpointed first: ${paths}. ` +
+      'Checkpoint or commit each dirty submodule, then checkpoint this repository to record gitlink changes.',
+    );
+  }
 
   const addArgs = includeUntracked ? ['-A'] : ['-u'];
   await runGit(repo, ['add', ...addArgs], { cwd: repoRoot });