@adhdev/daemon-core 0.8.29 → 0.8.31

package/src/commands/cli-manager.ts

@@ -10,6 +10,7 @@ import * as path from 'path';
 import * as crypto from 'crypto';
 import chalk from 'chalk';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
+import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
 import { detectCLI } from '../detection/cli-detector.js';
 import { loadConfig } from '../config/config.js';
 import { loadState, saveState } from '../config/state-store.js';
@@ -24,6 +25,7 @@ import type { ProviderModule, ProviderResumeCapability } from '../providers/cont
 import type { CliAdapter } from '../cli-adapter-types.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import type { SessionRegistry } from '../sessions/registry.js';
+import type { ProviderInstance } from '../providers/provider-instance.js';
 import { LOG } from '../logging/logger.js';
 
 // ─── external dependency interface ──────────────────────────
@@ -67,9 +69,17 @@ export interface HostedCliRuntimeDescriptor {
     providerSessionId?: string;
 }
 
-const chalkApi: any = (chalk as any)?.yellow
-    ? (chalk as any)
-    : (chalk as any)?.default || null;
+type CliPresentationInstance = ProviderInstance & {
+    getPresentationMode?(): 'terminal' | 'chat';
+};
+
+type ChalkColorFn = (text: string) => string;
+type ChalkLike = Partial<Record<'red' | 'green' | 'yellow' | 'cyan', ChalkColorFn>>;
+
+const chalkModule = chalk as unknown as ChalkLike & { default?: ChalkLike };
+const chalkApi: ChalkLike | null = typeof chalkModule.yellow === 'function'
+    ? chalkModule
+    : chalkModule.default || null;
 
 function colorize(color: 'red' | 'green' | 'yellow' | 'cyan', text: string): string {
     const fn = chalkApi?.[color];
@@ -84,6 +94,10 @@ type CliSessionBinding = {
     launchMode: CliLaunchMode;
 };
 
+type CliAdapterWithExtraArgs = CliAdapter & {
+    extraArgs?: string[];
+};
+
 function isUuid(value: string): boolean {
     return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 }
@@ -239,7 +253,7 @@ export class DaemonCliManager {
 
     getSessionPresentationMode(sessionId: string): 'terminal' | 'chat' | null {
         if (!sessionId) return null;
-        const instance = this.deps.getInstanceManager()?.getInstance(sessionId) as any;
+        const instance = this.deps.getInstanceManager()?.getInstance(sessionId) as CliPresentationInstance | undefined;
         const mode = instance?.category === 'cli'
             ? instance.getPresentationMode?.()
             : null;
@@ -321,7 +335,7 @@ export class DaemonCliManager {
                 providerSessionId,
                 attachExisting,
             );
-            return new ProviderCliAdapter(resolvedProvider as any, workingDir, cliArgs, transportFactory);
+            return new ProviderCliAdapter(resolvedProvider as CliProviderModule, workingDir, cliArgs, transportFactory);
         }
 
         throw new Error(`No CLI provider found for '${cliType}'. Create a provider.js in providers/cli/${cliType}/`);
@@ -408,7 +422,7 @@ export class DaemonCliManager {
             throw new Error(`Failed to start ${provider.displayName || provider.name || cliType}: ${spawnErr?.message}`);
         }
 
-        this.adapters.set(key, cliInstance.getAdapter() as any);
+        this.adapters.set(key, cliInstance.getAdapter());
         this.startCliExitMonitor(key, cliType);
     }
 
@@ -475,6 +489,7 @@ export class DaemonCliManager {
  // Register ACP entry in adapter map (getStatus queries from acpInstance in real-time)
             this.adapters.set(key, {
                 cliType: normalizedType,
+                cliName: provider.name,
                 workingDir: resolvedDir,
                 _acpInstance: acpInstance,
                 spawn: async () => {},
@@ -488,9 +503,13 @@ export class DaemonCliManager {
                         activeModal: state.activeChat?.activeModal || null,
                     };
                 },
+                getPartialResponse: () => '',
+                cancel: () => { instanceManager.removeInstance(key); },
+                isProcessing: () => false,
+                isReady: () => true,
                 setOnStatusChange: () => {},
                 setOnPtyData: () => {},
-            } as any);
+            });
 
             console.log(colorize('green', `  ✓ ACP agent started: ${provider.name} in ${resolvedDir}`));
 
@@ -893,7 +912,7 @@ export class DaemonCliManager {
                 const dir = rdir.path;
                 if (!cliType) throw new Error('cliType required');
                 const found = this.findAdapter(cliType, { instanceKey: args?.targetSessionId, dir });
-                const prevCliArgs = found ? (found.adapter as any).extraArgs : undefined;
+                const prevCliArgs = found ? (found.adapter as CliAdapterWithExtraArgs).extraArgs : undefined;
                 if (found) await this.stopSession(found.key);
                 await this.startSession(cliType, dir, args?.cliArgs || prevCliArgs, args?.initialModel);
                 return { success: true, restarted: true };
@@ -916,7 +935,7 @@ export class DaemonCliManager {
                     await adapter.sendMessage(message);
                     return { success: true, status: 'generating' };
                 } else if (action === 'clear_history') {
-                    if (typeof (adapter as any).clearHistory === 'function') (adapter as any).clearHistory();
+                    if (typeof adapter.clearHistory === 'function') adapter.clearHistory();
                     return { success: true, cleared: true };
                 } else if (action === 'stop') {
                     await this.stopSession(key);

package/src/commands/handler.ts

@@ -16,8 +16,9 @@ import { CdpDomHandlers } from '../cdp/devtools.js';
 import { findCdpManager } from '../status/builders.js';
 import { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
-import type { ProviderModule } from '../providers/contracts.js';
+import type { ProviderModule, ProviderScripts } from '../providers/contracts.js';
 import type { DaemonAgentStreamManager } from '../agent-stream/index.js';
+import type { CliAdapter } from '../cli-adapter-types.js';
 import { loadConfig } from '../config/config.js';
 import { ChatHistoryWriter } from '../config/chat-history.js';
 import type { SessionRegistry, SessionRuntimeTarget } from '../sessions/registry.js';
@@ -39,7 +40,7 @@ export interface CommandResult {
 export interface CommandContext {
     cdpManagers: Map<string, DaemonCdpManager>;
     ideType: string;
-    adapters: Map<string, any>;
+    adapters: Map<string, CliAdapter>;
     providerLoader?: ProviderLoader;
     /** ProviderInstanceManager — for runtime settings propagation */
     instanceManager?: ProviderInstanceManager;
@@ -56,7 +57,7 @@ export interface CommandHelpers {
     getProvider(overrideType?: string): ProviderModule | undefined;
     getProviderScript(scriptName: string, params?: Record<string, string>, ideType?: string): string | null;
     evaluateProviderScript(scriptName: string, params?: Record<string, string>, timeout?: number): Promise<{ result: any; category: string } | null>;
-    getCliAdapter(type?: string): any | null;
+    getCliAdapter(type?: string): CliAdapter | null;
     readonly currentManagerKey: string | undefined;
     readonly currentIdeType: string | undefined;
     readonly currentProviderType: string | undefined;
@@ -66,6 +67,8 @@ export interface CommandHelpers {
     readonly historyWriter: ChatHistoryWriter;
 }
 
+type LegacyStringScript = (params?: Record<string, unknown> | string) => string;
+
 const COMMAND_DEBUG_LEVELS = new Set([
     'pty_input',
     'pty_resize',
@@ -214,15 +217,16 @@ export class DaemonCommandHandler implements CommandHelpers {
     getProviderScript(scriptName: string, params?: Record<string, string>, ideType?: string): string | null {
         const provider = this.getProvider(ideType);
         if (provider?.scripts) {
-            const fn = (provider.scripts as any)[scriptName];
+            const fn = provider.scripts[scriptName];
             if (typeof fn === 'function') {
+                const callScript = fn as LegacyStringScript;
                 if (params && Object.keys(params).length > 0) {
                     const firstVal = Object.values(params)[0];
                     if (scriptName === 'sendMessage' && typeof firstVal === 'string') {
-                        const legacyScript = fn(firstVal);
+                        const legacyScript = callScript(firstVal);
                         if (legacyScript) return legacyScript;
                     }
-                    const script = fn(params);
+                    const script = callScript(params);
                     if (script) {
                         const likelyLegacyObjectLeak =
                             typeof script === 'string'
@@ -232,13 +236,13 @@ export class DaemonCommandHandler implements CommandHelpers {
                     }
 
                     if (firstVal !== undefined) {
-                        const legacyScript = fn(firstVal);
+                        const legacyScript = callScript(firstVal);
                         if (legacyScript) return legacyScript;
                     }
 
                     if (script) return script;
                 } else {
-                    const script = fn();
+                    const script = callScript();
                     if (script) return script;
                 }
             }
@@ -290,7 +294,7 @@ export class DaemonCommandHandler implements CommandHelpers {
     }
 
     /** CLI adapter search */
-    getCliAdapter(type?: string): any | null {
+    getCliAdapter(type?: string): CliAdapter | null {
         const target = type || this._currentRoute.session?.sessionId || this._currentRoute.providerType || this._currentRoute.managerKey;
         if (!target || !this._ctx.adapters) return null;
         const session = this._ctx.sessionRegistry?.get(target);
@@ -313,7 +317,7 @@ export class DaemonCommandHandler implements CommandHelpers {
         const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
         let session = targetSessionId ? this._ctx.sessionRegistry?.get(targetSessionId) : undefined;
         if (targetSessionId && !session) {
-            reconcileIdeRuntimeSessions(this._ctx.instanceManager as any, this._ctx.sessionRegistry);
+            reconcileIdeRuntimeSessions(this._ctx.instanceManager, this._ctx.sessionRegistry);
             session = this._ctx.sessionRegistry?.get(targetSessionId);
         }
         const sessionLookupFailed = !!targetSessionId && !session;

package/src/commands/router.ts

@@ -28,6 +28,7 @@ import { detectIDEs } from '../detection/ide-detector.js';
 import { SessionRegistry } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
 import { logCommand } from '../logging/command-log.js';
+import type { CommandLogEntry } from '../logging/command-log.js';
 import { getRecentLogs, LOG_PATH } from '../logging/logger.js';
 import { buildSessionEntries } from '../status/builders.js';
 import { getSessionCompletionMarker } from '../status/snapshot.js';
@@ -86,6 +87,19 @@ const CHAT_COMMANDS = [
 ];
 const READ_DEBUG_ENABLED = process.argv.includes('--dev') || process.env.ADHDEV_READ_DEBUG === '1';
 
+function normalizeCommandSource(source: string): CommandLogEntry['source'] {
+    switch (source) {
+        case 'ws':
+        case 'p2p':
+        case 'ext':
+        case 'api':
+        case 'standalone':
+            return source;
+        default:
+            return 'unknown';
+    }
+}
+
 function toHostedCliRuntimeDescriptor(record: any): HostedCliRuntimeDescriptor | null {
     if (!record || typeof record !== 'object') return null;
     const runtimeId = typeof record.sessionId === 'string' ? record.sessionId : '';
@@ -130,18 +144,19 @@ export class DaemonCommandRouter {
      */
     async execute(cmd: string, args: any, source: string = 'unknown'): Promise<CommandRouterResult> {
         const cmdStart = Date.now();
+        const logSource = normalizeCommandSource(source);
 
         try {
             // 1. Try daemon-level command
             const daemonResult = await this.executeDaemonCommand(cmd, args);
             if (daemonResult) {
-                logCommand({ ts: new Date().toISOString(), cmd, source: source as any, args, success: daemonResult.success, durationMs: Date.now() - cmdStart });
+                logCommand({ ts: new Date().toISOString(), cmd, source: logSource, args, success: daemonResult.success, durationMs: Date.now() - cmdStart });
                 return daemonResult;
             }
 
             // 2. Delegate to DaemonCommandHandler
             const handlerResult = await this.deps.commandHandler.handle(cmd, args);
-            logCommand({ ts: new Date().toISOString(), cmd, source: source as any, args, success: handlerResult.success, durationMs: Date.now() - cmdStart });
+            logCommand({ ts: new Date().toISOString(), cmd, source: logSource, args, success: handlerResult.success, durationMs: Date.now() - cmdStart });
 
             // 3. Post-chat command callback
             if (CHAT_COMMANDS.includes(cmd) && this.deps.onPostChatCommand) {
@@ -150,7 +165,7 @@ export class DaemonCommandRouter {
 
             return handlerResult;
         } catch (e: any) {
-            logCommand({ ts: new Date().toISOString(), cmd, source: source as any, args, success: false, error: e.message, durationMs: Date.now() - cmdStart });
+            logCommand({ ts: new Date().toISOString(), cmd, source: logSource, args, success: false, error: e.message, durationMs: Date.now() - cmdStart });
             throw e;
         }
     }
@@ -417,7 +432,7 @@ export class DaemonCommandRouter {
                         ? this.deps.getCdpLogFn(result.ideId)
                         : LOG.forComponent(`CDP:${result.ideId}`).asLogFn();
                     const provider = this.deps.providerLoader.getMeta(result.ideId);
-                    const manager = new DaemonCdpManager(result.port, logFn, undefined, (provider as any)?.targetFilter);
+                    const manager = new DaemonCdpManager(result.port, logFn, undefined, provider?.targetFilter);
                     const connected = await manager.connect();
                     if (connected) {
                         // Register active extension providers for this IDE in CDP manager
@@ -457,7 +472,7 @@ export class DaemonCommandRouter {
                         }));
                     } catch { /* ignore activity persist errors */ }
                 }
-                return { success: result.success, ...result as any };
+                return { ...result };
             }
 
             // ─── Detect IDEs ───
@@ -485,7 +500,7 @@ export class DaemonCommandRouter {
                 const prevSeenAt = currentState.sessionReads?.[sessionId] || 0;
                 const sessionEntries = buildSessionEntries(
                     this.deps.instanceManager.collectAllStates(),
-                    this.deps.cdpManagers as Map<string, any>,
+                    this.deps.cdpManagers,
                 );
                 const targetSession = sessionEntries.find((entry) => entry.id === sessionId);
                 const completionMarker = targetSession ? getSessionCompletionMarker(targetSession) : '';
@@ -606,8 +621,7 @@ export class DaemonCommandRouter {
             }
         }
         for (const instanceKey of keysToRemove) {
-            const ideInstance = this.deps.instanceManager.getInstance(instanceKey) as any;
-            if (ideInstance) {
+            if (this.deps.instanceManager.getInstance(instanceKey)) {
                 this.deps.instanceManager.removeInstance(instanceKey);
                 LOG.info('StopIDE', `Instance removed: ${instanceKey}`);
             }
@@ -615,8 +629,7 @@ export class DaemonCommandRouter {
         // Fallback: single instance key
         if (keysToRemove.length === 0) {
             const instanceKey = `ide:${ideType}`;
-            const ideInstance = this.deps.instanceManager.getInstance(instanceKey) as any;
-            if (ideInstance) {
+            if (this.deps.instanceManager.getInstance(instanceKey)) {
                 this.deps.instanceManager.removeInstance(instanceKey);
                 LOG.info('StopIDE', `Instance removed: ${instanceKey}`);
             }

package/src/commands/stream-commands.ts

@@ -5,11 +5,16 @@
 
 import type { CommandResult, CommandHelpers } from './handler.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
+import type { ProviderInstance } from '../providers/provider-instance.js';
 import { LOG } from '../logging/logger.js';
 
+interface CliPresentationInstance extends ProviderInstance {
+    getPresentationMode?(): 'terminal' | 'chat';
+}
+
 function getCliPresentationMode(h: CommandHelpers, targetSessionId?: string): 'terminal' | 'chat' | null {
     if (!targetSessionId) return null;
-    const instance = h.ctx.instanceManager?.getInstance(targetSessionId) as any;
+    const instance = h.ctx.instanceManager?.getInstance(targetSessionId) as CliPresentationInstance | undefined;
     if (instance?.category !== 'cli') return null;
     const mode = instance.getPresentationMode?.();
     return mode === 'chat' || mode === 'terminal' ? mode : null;
@@ -49,11 +54,12 @@ export function handlePtyResize(h: CommandHelpers, args: any): CommandResult {
     if (!adapter || typeof adapter.resize !== 'function') {
         return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || 'unknown'}` };
     }
+    const resize = adapter.resize;
     if (force) {
-        adapter.resize(cols - 1, rows);
-        setTimeout(() => adapter.resize(cols, rows), 50);
+        resize(cols - 1, rows);
+        setTimeout(() => resize(cols, rows), 50);
     } else {
-        adapter.resize(cols, rows);
+        resize(cols, rows);
     }
     return { success: true };
 }
@@ -119,7 +125,7 @@ function parseScriptResult(result: unknown): { success: boolean; payload: any }
             return { success: true, payload: { result } };
         }
     }
-    if (result && typeof result === 'object' && (result as any).success === false) {
+    if (result && typeof result === 'object' && 'success' in result && result.success === false) {
         return { success: false, payload: result };
     }
     return { success: true, payload: result };

package/src/config/config.ts

@@ -57,10 +57,11 @@ export interface ADHDevConfig {
 
     /**
      * Server-side D1 `machines.id` — the row ID assigned when daemon registers via
-     * `POST /cli/complete`. Used as fallback for machine lookup on re-auth.
+     * `POST /cli/complete`. This remains useful for account-side machine actions
+     * that target the registered machine row directly (for example cloud rename).
      *
-     * @deprecated Legacy bridge field — will be removed after 2026-05-01.
-     * Modern auth flow uses `machineSecret` (adm_) to identify machines.
+     * Machine auth itself uses `machineSecret` (adm_) and no longer falls back
+     * to `registeredMachineId`.
      */
     registeredMachineId?: string;
 
@@ -174,17 +175,10 @@ function ensureMachineId(config: ADHDevConfig): { config: ADHDevConfig; changed:
         return { config, changed: false };
     }
 
-    // TODO(2026-05-01): Remove this legacy bridge after cloud clients have had
-    // time to persist registeredMachineId from the upgraded setup/login flow.
-    const legacyRegisteredMachineId = (!config.registeredMachineId && config.machineSecret && config.machineId)
-        ? config.machineId
-        : config.registeredMachineId;
-
     return {
         config: {
             ...config,
             machineId: generateMachineId(),
-            registeredMachineId: legacyRegisteredMachineId,
         },
         changed: true,
     };

package/src/daemon/dev-auto-implement.ts

@@ -10,6 +10,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import type * as http from 'http';
+import type { ChildProcess } from 'child_process';
 import type { DevServerContext, ProviderCategory } from './dev-server-types.js';
 import { DEV_SERVER_PORT } from './dev-server.js';
 import { LOG } from '../logging/logger.js';
@@ -33,8 +34,8 @@ type CliExerciseVerification = {
 };
 
 function getAutoImplPid(ctx: DevServerContext): number | null {
-  const proc: any = ctx.autoImplProcess;
-  return proc && typeof proc.pid === 'number' && proc.pid > 0 ? proc.pid : null;
+  const pid = ctx.autoImplProcess?.pid;
+  return typeof pid === 'number' && pid > 0 ? pid : null;
 }
 
 function isPidAlive(pid: number): boolean {
@@ -57,6 +58,15 @@ function clearStaleAutoImplState(ctx: DevServerContext, reason: string): void {
   ctx.autoImplStatus.running = false;
 }
 
+function tryKillAutoImplProcess(processRef: ChildProcess | null, signal: NodeJS.Signals): void {
+  if (!processRef) return;
+  try {
+    processRef.kill(signal);
+  } catch {
+    // ignore
+  }
+}
+
 export function getDefaultAutoImplReference(ctx: DevServerContext, category: string, type: string): string {
   if (category === 'cli') {
     return type === 'codex-cli' ? 'claude-cli' : 'codex-cli';
@@ -283,14 +293,14 @@ export async function handleAutoImplement(ctx: DevServerContext, type: string, r
 
     // 5. Determine agent command from provider spawn config
     const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
-    const spawn = (agentProvider as any)?.spawn;
+    const spawn = agentProvider?.spawn;
     if (!spawn?.command) {
       try { fs.unlinkSync(promptFile); } catch { /* ignore */ }
       ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
       return;
     }
 
-    const agentCategory = (agentProvider as any)?.category;
+    const agentCategory = agentProvider?.category;
 
     // ─── ACP Agent: use ACP SDK (JSON-RPC protocol) ───
     if (agentCategory === 'acp') {
@@ -521,10 +531,12 @@ export async function handleAutoImplement(ctx: DevServerContext, type: string, r
     let autoStopIssued = false;
     
     try {
-      const { normalizeCliProviderForRuntime } = await import('../cli-adapters/provider-cli-adapter.js');
-      const normalized = normalizeCliProviderForRuntime(agentProvider);
-      approvalPatterns = normalized.patterns.approval;
-      approvalKeys = (agentProvider as any)?.approvalKeys || { 0: 'y\r', 1: 'a\r' };
+      if (agentProvider?.category === 'cli') {
+        const { normalizeCliProviderForRuntime } = await import('../cli-adapters/provider-cli-adapter.js');
+        const normalized = normalizeCliProviderForRuntime(agentProvider);
+        approvalPatterns = normalized.patterns.approval;
+        approvalKeys = agentProvider.approvalKeys || { 0: 'y\r', 1: 'a\r' };
+      }
     } catch (err: any) {
       ctx.log(`Failed to load approval patterns: ${err.message}`);
     }
@@ -547,11 +559,7 @@ export async function handleAutoImplement(ctx: DevServerContext, type: string, r
         sendAutoImplSSE(ctx, { event: 'output', data: { chunk: `\n[🤖 ADHDev Pipeline] Completion token detected. Proceeding...\n`, stream: 'stdout' } });
         approvalBuffer = '';
         
-        try {
-          (ctx.autoImplProcess as any).kill('SIGINT');
-        } catch {
-          // ignore
-        }
+        tryKillAutoImplProcess(ctx.autoImplProcess, 'SIGINT');
         return;
       }
       
@@ -592,11 +600,7 @@ export async function handleAutoImplement(ctx: DevServerContext, type: string, r
             stream: 'stdout',
           },
         });
-        try {
-          (ctx.autoImplProcess as any).kill('SIGINT');
-        } catch {
-          // ignore
-        }
+        tryKillAutoImplProcess(ctx.autoImplProcess, 'SIGINT');
       }, 30000);
     };
 

package/src/daemon/dev-cli-debug.ts

@@ -9,6 +9,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 import type * as http from 'http';
 import type { DevServerContext } from './dev-server-types.js';
+import type { CliAdapter } from '../cli-adapter-types.js';
+import type { AcpProviderState, CliProviderState, ProviderInstance, ProviderState } from '../providers/provider-instance.js';
 
 // ─── Helpers ──────────────────────────────────────
 
@@ -56,6 +58,36 @@ type CliExerciseFixture = {
   notes?: string;
 };
 
+type CliTargetState = CliProviderState | AcpProviderState;
+type CliDebugState = {
+  status?: string;
+  activeModal?: { message?: string; buttons?: string[] } | null;
+  startupParseGate?: boolean;
+  ready?: boolean;
+  currentTurnScope?: unknown;
+  providerResolution?: Record<string, any> | null;
+  messages?: Array<{ role?: string; content?: string }>;
+  partialResponse?: string;
+  [key: string]: unknown;
+};
+type CliTraceState = {
+  entryCount?: number;
+  activeModal?: { message?: string; buttons?: string[] } | null;
+  entries?: Array<{ type?: string; [key: string]: unknown }>;
+  messages?: Array<{ role?: string; content?: string }>;
+  responseBuffer?: string;
+  [key: string]: unknown;
+};
+type CliDebugAdapter = CliAdapter & {
+  getDebugState?: () => CliDebugState | null;
+  getTraceState?: (limit?: number) => CliTraceState | null;
+  getProviderResolutionMeta?: () => Record<string, any> | null;
+};
+type CliAdapterBackedInstance = ProviderInstance & {
+  getAdapter?: () => CliDebugAdapter;
+  adapter?: CliDebugAdapter;
+};
+
 function slugifyFixtureName(value: string): string {
   const normalized = String(value || '')
     .trim()
@@ -223,7 +255,18 @@ export function validateCliFixtureResult(result: any, assertions: CliFixtureAsse
   return failures;
 }
 
-function getCliProviderResolutionMeta(ctx: DevServerContext, type: string, adapter?: any): Record<string, any> | null {
+function isCliTargetState(state: ProviderState): state is CliTargetState {
+  return state.category === 'cli' || state.category === 'acp';
+}
+
+function getCliAdapterFromInstance(instance: ProviderInstance | undefined): CliDebugAdapter | null {
+  if (!instance) return null;
+  const candidate = instance as CliAdapterBackedInstance;
+  if (typeof candidate.getAdapter === 'function') return candidate.getAdapter();
+  return candidate.adapter || null;
+}
+
+function getCliProviderResolutionMeta(ctx: DevServerContext, type: string, adapter?: CliDebugAdapter | null): Record<string, any> | null {
   const adapterMeta = typeof adapter?.getProviderResolutionMeta === 'function'
     ? adapter.getProviderResolutionMeta()
     : (adapter?.getDebugState?.()?.providerResolution || null);
@@ -241,11 +284,11 @@ function getCliProviderResolutionMeta(ctx: DevServerContext, type: string, adapt
   };
 }
 
-function findCliTarget(ctx: DevServerContext, type?: string, instanceId?: string): any | null {
+function findCliTarget(ctx: DevServerContext, type?: string, instanceId?: string): CliTargetState | null {
   if (!ctx.instanceManager) return null;
   const cliStates = ctx.instanceManager
     .collectAllStates()
-    .filter(s => s.category === 'cli' || s.category === 'acp');
+    .filter(isCliTargetState);
   if (instanceId) return cliStates.find(s => s.instanceId === instanceId) || null;
   if (!type) return cliStates[cliStates.length - 1] || null;
   const matches = cliStates.filter(s => s.type === type);
@@ -253,16 +296,16 @@ function findCliTarget(ctx: DevServerContext, type?: string, instanceId?: string
 }
 
 function getCliTargetBundle(ctx: DevServerContext, type?: string, instanceId?: string): {
-  target: any;
-  instance: any;
-  adapter: any;
+  target: CliTargetState;
+  instance: ProviderInstance;
+  adapter: CliDebugAdapter;
 } | null {
   if (!ctx.instanceManager) return null;
   const target = findCliTarget(ctx, type, instanceId);
   if (!target) return null;
-  const instance = ctx.instanceManager.getInstance(target.instanceId) as any;
+  const instance = ctx.instanceManager.getInstance(target.instanceId);
   if (!instance) return null;
-  const adapter = instance.getAdapter?.() || instance.adapter;
+  const adapter = getCliAdapterFromInstance(instance);
   if (!adapter) return null;
   return { target, instance, adapter };
 }
@@ -838,14 +881,14 @@ export async function handleCliDebug(ctx: DevServerContext, type: string, _req:
   }
 
   // Get the ProviderInstance and access adapter debug state
-  const instance = ctx.instanceManager.getInstance(target.instanceId) as any;
+  const instance = ctx.instanceManager.getInstance(target.instanceId);
   if (!instance) {
     ctx.json(res, 404, { error: `Instance not found: ${target.instanceId}` });
     return;
   }
 
   try {
-    const adapter = instance.getAdapter?.() || instance.adapter;
+    const adapter = getCliAdapterFromInstance(instance);
     if (adapter && typeof adapter.getDebugState === 'function') {
       const debugState = adapter.getDebugState();
       ctx.json(res, 200, {
@@ -891,14 +934,14 @@ export async function handleCliTrace(ctx: DevServerContext, type: string, req: h
     return;
   }
 
-  const instance = ctx.instanceManager.getInstance(target.instanceId) as any;
+  const instance = ctx.instanceManager.getInstance(target.instanceId);
   if (!instance) {
     ctx.json(res, 404, { error: `Instance not found: ${target.instanceId}` });
     return;
   }
 
   try {
-    const adapter = instance.getAdapter?.() || instance.adapter;
+    const adapter = getCliAdapterFromInstance(instance);
     const url = new URL(req.url || '/', 'http://127.0.0.1');
     const limit = parseInt(url.searchParams.get('limit') || '120', 10);
     if (adapter && typeof adapter.getTraceState === 'function') {
@@ -1101,8 +1144,8 @@ export async function handleCliResolve(ctx: DevServerContext, req: http.Incoming
     return;
   }
 
-  const instance = ctx.instanceManager.getInstance(target.instanceId) as any;
-  const adapter = instance?.getAdapter?.() || instance?.adapter;
+  const instance = ctx.instanceManager.getInstance(target.instanceId);
+  const adapter = getCliAdapterFromInstance(instance);
   if (!adapter) {
     ctx.json(res, 404, { error: `Adapter not found for instance: ${target.instanceId}` });
     return;
@@ -1144,8 +1187,8 @@ export async function handleCliRaw(ctx: DevServerContext, req: http.IncomingMess
     return;
   }
 
-  const instance = ctx.instanceManager.getInstance(target.instanceId) as any;
-  const adapter = instance?.getAdapter?.() || instance?.adapter;
+  const instance = ctx.instanceManager.getInstance(target.instanceId);
+  const adapter = getCliAdapterFromInstance(instance);
   if (!adapter) {
     ctx.json(res, 404, { error: `Adapter not found for instance: ${target.instanceId}` });
     return;