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

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/driver.ts

@@ -132,6 +132,37 @@ export function resolveSubmitDelayMs(specBeforeSubmit: number | undefined, text:
     return Math.max(spec, SUBMIT_DELAY_FLOOR_MS + linesBonus);
 }
 
+export function matchesCompletionIdleRule(spec: CliSpec, ev: SpecEvaluation, screen: string): string | null {
+    const rule = spec.debounce?.completion_idle_after;
+    if (!rule?.regex) return null;
+    const haystack = rule.section
+        ? ev.sections.find(section => section.id === rule.section)?.text ?? ''
+        : screen;
+    if (!haystack) return null;
+    try {
+        const regex = new RegExp(rule.regex, rule.flags || '');
+        const match = haystack.match(regex);
+        return match?.[0] || null;
+    } catch {
+        return null;
+    }
+}
+
+export function matchesCompletionIdleTargetState(spec: CliSpec, ev: SpecEvaluation, screen: string): boolean {
+    const target = spec.states.find(state => state.id === spec.default_state)
+        ?? spec.states.find(state => state.id === 'idle');
+    if (!target?.when?.regex) return false;
+    const haystack = target.when.section
+        ? ev.sections.find(section => section.id === target.when.section)?.text ?? ''
+        : screen;
+    if (!haystack) return false;
+    try {
+        return new RegExp(target.when.regex, target.when.flags || 'i').test(haystack);
+    } catch {
+        return false;
+    }
+}
+
 export class SpecDriver {
     private spec!: CliSpec;
     private adapter!: TerminalAdapter;
@@ -157,6 +188,8 @@ export class SpecDriver {
      *  because the evaluator already moved past busy by the time the hold
      *  kicks in. */
     private lastBusyState: SpecEvaluation['state'] | null = null;
+    private completionIdleFirstSeenAt = 0;
+    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
@@ -305,6 +338,40 @@ export class SpecDriver {
                 evState = this.lastBusyState ?? evState;
             }
         }
+        const completionIdleRule = this.spec.debounce?.completion_idle_after;
+        let busyWakeMs = busyHoldMs;
+        if (evState.id === 'busy' && completionIdleRule) {
+            const completionKey = matchesCompletionIdleRule(this.spec, ev, screen);
+            if (completionKey) {
+                const now = Date.now();
+                if (completionKey !== this.completionIdleKey) {
+                    this.completionIdleKey = completionKey;
+                    this.completionIdleFirstSeenAt = now;
+                }
+                const holdMs = Math.max(0, completionIdleRule.hold_ms || 0);
+                const ageMs = now - this.completionIdleFirstSeenAt;
+                if (ageMs >= holdMs) {
+                    if (matchesCompletionIdleTargetState(this.spec, ev, screen)) {
+                        const idle = this.spec.states.find(state => state.id === this.spec.default_state)
+                            ?? this.spec.states.find(state => state.id === 'idle');
+                        evState = idle
+                            ? { id: idle.id, label: idle.label, title: null }
+                            : { id: 'idle', label: 'Ready', title: null };
+                    } else {
+                        busyWakeMs = Math.min(busyWakeMs, 1000);
+                    }
+                } else {
+                    busyWakeMs = Math.min(busyWakeMs, Math.max(holdMs - ageMs, 0));
+                }
+            } else {
+                this.completionIdleKey = '';
+                this.completionIdleFirstSeenAt = 0;
+            }
+        } else if (evState.id !== 'busy') {
+            this.completionIdleKey = '';
+            this.completionIdleFirstSeenAt = 0;
+        }
+
         if (evState.id === 'busy') {
             this.lastBusyAt = Date.now();
             this.lastBusyState = evState;
@@ -313,7 +380,7 @@ export class SpecDriver {
             // footer settles), so without an explicit timer the driver
             // never wakes up to downshift to idle and the dashboard sees
             // status stuck at generating long after the turn ended.
-            this.scheduleBusyExpiry(busyHoldMs);
+            this.scheduleBusyExpiry(busyWakeMs);
         }
 
         const changed = forceEmit

package/src/providers/spec/schema.gen.ts

@@ -130,7 +130,18 @@ export const SCHEMA = {
             "additionalProperties": false,
             "properties": {
                 "busy_hold_ms": { "type": "integer", "minimum": 0 },
-                "startup_grace_ms": { "type": "integer", "minimum": 0 }
+                "startup_grace_ms": { "type": "integer", "minimum": 0 },
+                "completion_idle_after": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["regex", "hold_ms"],
+                    "properties": {
+                        "section": { "type": "string", "minLength": 1 },
+                        "regex": { "type": "string", "minLength": 1 },
+                        "flags": { "type": "string" },
+                        "hold_ms": { "type": "integer", "minimum": 0 }
+                    }
+                }
             }
         }
     },

package/src/providers/spec/schema.json

@@ -59,7 +59,27 @@
             "default": [],
             "items": { "$ref": "#/definitions/delegateTrigger" }
         },
-        "native_history": { "$ref": "#/definitions/nativeHistory" }
+        "native_history": { "$ref": "#/definitions/nativeHistory" },
+        "cli_version_range": { "type": "string", "minLength": 1 },
+        "debounce": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "busy_hold_ms": { "type": "integer", "minimum": 0 },
+                "startup_grace_ms": { "type": "integer", "minimum": 0 },
+                "completion_idle_after": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["regex", "hold_ms"],
+                    "properties": {
+                        "section": { "type": "string", "minLength": 1 },
+                        "regex": { "type": "string", "minLength": 1 },
+                        "flags": { "type": "string" },
+                        "hold_ms": { "type": "integer", "minimum": 0 }
+                    }
+                }
+            }
+        }
     },
     "definitions": {
         "size": {

package/src/providers/spec/types.ts

@@ -227,5 +227,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/src/repo-mesh-types.ts

@@ -359,11 +359,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;
 }