@adhdev/daemon-core 0.8.34 → 0.8.36

package/src/commands/router.ts

@@ -31,6 +31,7 @@ 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 { buildMachineInfo, buildStatusSnapshot } from '../status/snapshot.js';
 import { getSessionCompletionMarker } from '../status/snapshot.js';
 import { spawnDetachedDaemonUpgradeHelper } from './upgrade-helper.js';
 import * as fs from 'fs';
@@ -71,6 +72,9 @@ export interface CommandRouterDeps {
     getCdpLogFn?: (ideType: string) => (msg: string) => void;
     /** Package name for upgrade detection ('adhdev' or '@adhdev/daemon-standalone') */
     packageName?: string;
+    /** Canonical daemon status identity used by snapshot commands */
+    statusInstanceId?: string;
+    statusVersion?: string;
     /** Session host control plane */
     sessionHostControl?: SessionHostControlPlane | null;
 }
@@ -491,6 +495,27 @@ export class DaemonCommandRouter {
                 return { success: true, userName: name };
             }
 
+            case 'get_status_metadata': {
+                const snapshot = buildStatusSnapshot({
+                    allStates: this.deps.instanceManager.collectAllStates(),
+                    cdpManagers: this.deps.cdpManagers,
+                    providerLoader: this.deps.providerLoader,
+                    detectedIdes: this.deps.detectedIdes.value,
+                    instanceId: this.deps.statusInstanceId || loadConfig().machineId || 'daemon',
+                    version: this.deps.statusVersion || 'unknown',
+                    profile: 'metadata',
+                });
+                return { success: true, status: snapshot };
+            }
+
+            case 'get_machine_runtime_stats': {
+                return {
+                    success: true,
+                    machine: buildMachineInfo('full'),
+                    timestamp: Date.now(),
+                };
+            }
+
             case 'mark_session_seen': {
                 const sessionId = args?.sessionId;
                 if (!sessionId || typeof sessionId !== 'string') {

package/src/commands/stream-commands.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Stream Commands — Agent Stream, PTY I/O, Provider Settings,
+ *                   IDE Extension Settings, Extension Script Execution
+ */
+import type { CommandResult, CommandHelpers } from './handler.js';
+export declare function handleFocusSession(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handlePtyInput(h: CommandHelpers, args: any): CommandResult;
+export declare function handlePtyResize(h: CommandHelpers, args: any): CommandResult;
+export declare function handleGetProviderSettings(h: CommandHelpers, args: any): CommandResult;
+export declare function handleSetProviderSetting(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleExtensionScript(h: CommandHelpers, args: any, scriptName: string): Promise<CommandResult>;
+export declare function handleProviderScript(h: CommandHelpers, args: any): Promise<CommandResult>;
+export declare function handleGetIdeExtensions(h: CommandHelpers, args: any): CommandResult;
+export declare function handleSetIdeExtension(h: CommandHelpers, args: any): CommandResult;

package/src/commands/stream-commands.ts

@@ -164,13 +164,17 @@ function applyProviderPatch(h: CommandHelpers, args: any, payload: any): void {
 }
 
 async function executeProviderScript(h: CommandHelpers, args: any, scriptName: string): Promise<CommandResult> {
-    const { agentType, ideType } = args || {};
-    if (!agentType) return { success: false, error: 'agentType is required' };
+    const resolvedProviderType =
+        h.currentSession?.providerType
+        || h.currentProviderType
+        || args?.agentType
+        || args?.providerType;
+    if (!resolvedProviderType) return { success: false, error: 'targetSessionId or providerType is required' };
 
     const loader = h.ctx.providerLoader;
     if (!loader) return { success: false, error: 'ProviderLoader not initialized' };
-    const provider = loader.resolve(agentType);
-    if (!provider) return { success: false, error: `Provider not found: ${agentType}` };
+    const provider = loader.resolve(resolvedProviderType);
+    if (!provider) return { success: false, error: `Provider not found: ${resolvedProviderType}` };
 
     const webviewScriptName = `webview${scriptName.charAt(0).toUpperCase() + scriptName.slice(1)}`;
     const hasWebviewScript = provider.category === 'ide' &&
@@ -179,13 +183,13 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
     const actualScriptName = hasWebviewScript ? webviewScriptName : scriptName;
 
     if (!provider.scripts?.[actualScriptName as keyof typeof provider.scripts]) {
-        return { success: false, error: `Script '${actualScriptName}' not available for ${agentType}` };
+        return { success: false, error: `Script '${actualScriptName}' not available for ${resolvedProviderType}` };
     }
 
     const normalizedArgs = normalizeProviderScriptArgs(args);
 
     if (provider.category === 'cli') {
-        const adapter = h.getCliAdapter(args?.targetSessionId || agentType);
+        const adapter = h.getCliAdapter(args?.targetSessionId || resolvedProviderType);
         if (!adapter?.invokeScript) {
             return { success: false, error: `CLI adapter does not support script '${actualScriptName}'` };
         }
@@ -213,8 +217,8 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
     if (!scriptCode) return { success: false, error: `Script '${actualScriptName}' returned null` };
 
     const cdpKey = provider.category === 'ide'
-        ? (h.currentSession?.cdpManagerKey || h.currentManagerKey || agentType)
-        : (h.currentSession?.cdpManagerKey || h.currentManagerKey || ideType);
+        ? (h.currentSession?.cdpManagerKey || h.currentManagerKey || resolvedProviderType)
+        : (h.currentSession?.cdpManagerKey || h.currentManagerKey);
     LOG.info('Command', `[ExtScript] provider=${provider.type} category=${provider.category} cdpKey=${cdpKey}`);
     const cdp = h.getCdp(cdpKey);
     if (!cdp?.isConnected) return { success: false, error: `No CDP connection for ${cdpKey || 'any'}` };
@@ -224,7 +228,7 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
 
         if (provider.category === 'extension') {
             const runtimeSessionId = h.currentSession?.sessionId || args?.targetSessionId;
-            if (!runtimeSessionId) return { success: false, error: `No target session found for ${agentType}` };
+            if (!runtimeSessionId) return { success: false, error: `No target session found for ${resolvedProviderType}` };
             const parentSessionId = h.currentSession?.parentSessionId;
             if (parentSessionId) {
                 await h.agentStream?.setActiveSession(cdp, parentSessionId, runtimeSessionId);
@@ -257,7 +261,7 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
                 }
             } else {
                 if (!targetSessionId) {
-                    return { success: false, error: `No active session found for ${agentType}` };
+                    return { success: false, error: `No active session found for ${resolvedProviderType}` };
                 }
                 result = await cdp.evaluateInSessionFrame(targetSessionId, scriptCode);
             }

package/src/commands/upgrade-helper.d.ts

@@ -0,0 +1,10 @@
+export interface DaemonUpgradeHelperPayload {
+    packageName: string;
+    targetVersion: string;
+    parentPid: number;
+    restartArgv: string[];
+    cwd?: string;
+    sessionHostAppName?: string;
+}
+export declare function spawnDetachedDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): void;
+export declare function maybeRunDaemonUpgradeHelperFromEnv(): Promise<boolean>;

package/src/commands/workspace-commands.d.ts

@@ -0,0 +1,11 @@
+/**
+ * workspace_* commands — list/add/remove/default (config.json)
+ */
+export type WorkspaceCommandResult = {
+    success: boolean;
+    [key: string]: unknown;
+};
+export declare function handleWorkspaceList(): WorkspaceCommandResult;
+export declare function handleWorkspaceAdd(args: any): WorkspaceCommandResult;
+export declare function handleWorkspaceRemove(args: any): WorkspaceCommandResult;
+export declare function handleWorkspaceSetDefault(args: any): WorkspaceCommandResult;

package/src/config/chat-history.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Chat History Persistence — Persist completed chat messages to local disk
+ *
+ * Design:
+ * - ~/.adhdev/history/{agentType}/YYYY-MM-DD.jsonl
+ * - JSONL format (one line = one message, append-friendly)
+ * - Track only new messages (hash comparison with previous)
+ * - Auto-rotation (delete files older than 30 days)
+ * - Async/non-blocking (no impact on chat collection)
+ */
+interface HistoryMessage {
+    ts: string;
+    receivedAt: number;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    kind?: string;
+    senderName?: string;
+    agent: string;
+    instanceId?: string;
+    historySessionId?: string;
+    sessionTitle?: string;
+}
+export interface SavedHistorySessionSummary {
+    historySessionId: string;
+    sessionTitle?: string;
+    messageCount: number;
+    firstMessageAt: number;
+    lastMessageAt: number;
+    preview?: string;
+}
+export declare class ChatHistoryWriter {
+    /** Last seen message count per agent (deduplication) */
+    private lastSeenCounts;
+    /** Last seen message hash per agent (deduplication) */
+    private lastSeenHashes;
+    /** Last appended normalized message signature per agent/session */
+    private lastSeenSignatures;
+    /** Last appended normalized non-system turn signature per agent/session */
+    private lastSeenTurnSignatures;
+    private rotated;
+    /**
+    * Append new messages to history
+    *
+    * @param agentType agent type (e.g. 'antigravity', 'cursor')
+    * @param messages Message array received from readChat
+    * @param sessionTitle Current session title
+    * @param instanceId IDE instance UUID (distinguishes windows of the same agent)
+    */
+    appendNewMessages(agentType: string, messages: Array<{
+        role: string;
+        content: string;
+        receivedAt?: number;
+        kind?: string;
+        senderName?: string;
+        historyDedupKey?: string;
+    }>, sessionTitle?: string, instanceId?: string, historySessionId?: string): void;
+    seedSessionHistory(agentType: string, messages?: Array<{
+        role: string;
+        content: string;
+        receivedAt?: number;
+        kind?: string;
+        historyDedupKey?: string;
+    }>, historySessionId?: string, instanceId?: string): void;
+    appendSystemMarker(agentType: string, content: string, options?: {
+        sessionTitle?: string;
+        instanceId?: string;
+        historySessionId?: string;
+        dedupKey?: string;
+        receivedAt?: number;
+        senderName?: string;
+    }): void;
+    promoteHistorySession(agentType: string, previousHistorySessionId: string, nextHistorySessionId: string): void;
+    compactHistorySession(agentType: string, historySessionId: string): void;
+    /** Called when agent session is explicitly changed */
+    onSessionChange(agentType: string): void;
+    /** Delete history files older than 30 days */
+    private rotateOldFiles;
+    /** Allow only filename-safe characters */
+    private sanitize;
+}
+/**
+ * Read history (static — called from P2P commands)
+ *
+ * Read JSONL files in reverse order, returning most recent messages first.
+ * When instanceId is specified, reads only that instance file.
+ * Offset/limit-based paging.
+ */
+export declare function readChatHistory(agentType: string, offset?: number, limit?: number, historySessionId?: string): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+};
+export declare function listSavedHistorySessions(agentType: string, options?: {
+    offset?: number;
+    limit?: number;
+}): {
+    sessions: SavedHistorySessionSummary[];
+    hasMore: boolean;
+};
+export {};

package/src/config/config.d.ts

@@ -29,6 +29,15 @@ export interface ADHDevConfig {
      */
     machineId?: string;
     machineSecret?: string | null;
+    /**
+     * Server-side D1 `machines.id` — the row ID assigned when daemon registers via
+     * `POST /cli/complete`. This remains useful for account-side machine actions
+     * that target the registered machine row directly (for example cloud rename).
+     *
+     * Machine auth itself uses `machineSecret` (adm_) and no longer falls back
+     * to `registeredMachineId`.
+     */
+    registeredMachineId?: string;
     providerSettings: Record<string, Record<string, any>>;
     ideSettings: Record<string, {
         extensions?: Record<string, {
@@ -37,6 +46,11 @@ export interface ADHDevConfig {
     }>;
     disableUpstream?: boolean;
     providerDir?: string;
+    /**
+     * Browser terminal sizing behavior for dashboard CLI panes.
+     * Default `measured` keeps terminal size daemon-authoritative.
+     * `fit` opt-in restores xterm fit-based sizing for advanced users.
+     */
     terminalSizingMode?: 'measured' | 'fit';
 }
 export declare function generateMachineId(): string;

package/src/config/config.ts

@@ -18,6 +18,12 @@ export interface ADHDevConfig {
  // Server connection
     serverUrl: string;
 
+    /**
+     * Allow server-relayed REST/API commands to reach the daemon.
+     * Disabled by default so cloud dashboard traffic stays P2P-only.
+     */
+    allowServerApiProxy?: boolean;
+
  // Selected IDE (primary)
     selectedIde: string | null;
 
@@ -90,6 +96,7 @@ export interface ADHDevConfig {
 
 const DEFAULT_CONFIG: ADHDevConfig = {
     serverUrl: 'https://api.adhf.dev',
+    allowServerApiProxy: false,
     selectedIde: null,
     configuredIdes: [],
     installedExtensions: [],
@@ -140,6 +147,7 @@ function normalizeConfig(raw: unknown): ADHDevConfig & { activeWorkspaceId?: str
         serverUrl: typeof parsed.serverUrl === 'string' && parsed.serverUrl.trim()
             ? parsed.serverUrl
             : DEFAULT_CONFIG.serverUrl,
+        allowServerApiProxy: asBoolean(parsed.allowServerApiProxy, DEFAULT_CONFIG.allowServerApiProxy ?? false),
         selectedIde: asNullableString(parsed.selectedIde),
         configuredIdes: asStringArray(parsed.configuredIdes),
         installedExtensions: asStringArray(parsed.installedExtensions),

package/src/config/recent-activity.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Unified recent activity — launcher-facing "pick up where you launched".
+ *
+ * Unlike live session state, this is launch oriented:
+ * - one normalized row shape for IDE / CLI / ACP
+ * - deduped by provider session when available, else by kind + providerType + workspace
+ * - used only for quick-launch shortcuts
+ */
+import type { DaemonState } from './state-store.js';
+export interface RecentActivityEntry {
+    id: string;
+    kind: 'ide' | 'cli' | 'acp';
+    providerType: string;
+    providerName: string;
+    providerSessionId?: string;
+    workspace?: string | null;
+    currentModel?: string;
+    title?: string;
+    lastUsedAt: number;
+}
+export declare function buildRecentActivityKey(entry: Pick<RecentActivityEntry, 'kind' | 'providerType' | 'workspace'>): string;
+export declare function buildRecentActivityKeyForEntry(entry: Pick<RecentActivityEntry, 'kind' | 'providerType' | 'workspace' | 'providerSessionId'>): string;
+export declare function appendRecentActivity(state: DaemonState, entry: Omit<RecentActivityEntry, 'id' | 'lastUsedAt'> & {
+    lastUsedAt?: number;
+}): DaemonState;
+export declare function getRecentActivity(state: DaemonState, limit?: number): RecentActivityEntry[];
+export declare function getSessionSeenAt(state: DaemonState, sessionId: string): number;
+export declare function getSessionSeenMarker(state: DaemonState, sessionId: string): string;
+export declare function markSessionSeen(state: DaemonState, sessionId: string, seenAt?: number, completionMarker?: string | null): DaemonState;

package/src/config/saved-sessions.d.ts

@@ -0,0 +1,22 @@
+import type { DaemonState } from './state-store.js';
+export interface SavedProviderSessionEntry {
+    id: string;
+    kind: 'cli' | 'acp';
+    providerType: string;
+    providerName: string;
+    providerSessionId: string;
+    workspace?: string | null;
+    currentModel?: string;
+    title?: string;
+    createdAt: number;
+    lastUsedAt: number;
+}
+export declare function buildSavedProviderSessionKey(providerSessionId: string): string;
+export declare function upsertSavedProviderSession(state: DaemonState, entry: Omit<SavedProviderSessionEntry, 'id' | 'createdAt' | 'lastUsedAt'> & {
+    createdAt?: number;
+    lastUsedAt?: number;
+}): DaemonState;
+export declare function getSavedProviderSessions(state: DaemonState, filters?: {
+    providerType?: string;
+    kind?: SavedProviderSessionEntry['kind'];
+}): SavedProviderSessionEntry[];

package/src/config/state-store.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ADHDev State Store — Runtime state persistence
+ *
+ * Separates volatile runtime state (sessions, activity, read markers)
+ * from static configuration (config.json).
+ *
+ * State is stored in ~/.adhdev/state.json
+ */
+import type { RecentActivityEntry } from './recent-activity.js';
+import type { SavedProviderSessionEntry } from './saved-sessions.js';
+export interface DaemonState {
+    /** Unified recent activity across IDE / CLI / ACP launch flows */
+    recentActivity: RecentActivityEntry[];
+    /** Persistent resume-capable provider sessions keyed by providerSessionId */
+    savedProviderSessions: SavedProviderSessionEntry[];
+    /** Last seen timestamps for live sessions, keyed by sessionId */
+    sessionReads: Record<string, number>;
+    /** Last seen completion marker for live sessions, keyed by sessionId */
+    sessionReadMarkers: Record<string, string>;
+}
+/**
+ * Load runtime state from disk
+ */
+export declare function loadState(): DaemonState;
+/**
+ * Save runtime state to disk
+ */
+export declare function saveState(state: DaemonState): void;
+/**
+ * Reset runtime state
+ */
+export declare function resetState(): void;

package/src/config/workspaces.d.ts

@@ -17,7 +17,6 @@ export declare function validateWorkspacePath(absPath: string): {
 };
 /** Default workspace label from path */
 export declare function defaultWorkspaceLabel(absPath: string): string;
-
 export declare function getDefaultWorkspacePath(config: ADHDevConfig): string | null;
 export declare function getWorkspaceState(config: ADHDevConfig): {
     workspaces: WorkspaceEntry[];

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

@@ -0,0 +1,43 @@
+/**
+ * DevServer — Auto-Implement Handlers
+ *
+ * Extracted from dev-server.ts for maintainability.
+ * Contains prompt builders (IDE + CLI), agent spawn logic,
+ * SSE streaming, and provider directory resolution for auto-implement.
+ */
+import type * as http from 'http';
+import type { DevServerContext, ProviderCategory } from './dev-server-types.js';
+type CliExerciseVerification = {
+    request?: Record<string, any>;
+    mustContainAny?: string[];
+    mustNotContainAny?: string[];
+    mustMatchAny?: string[];
+    mustNotMatchAny?: string[];
+    lastAssistantMustContainAny?: string[];
+    lastAssistantMustNotContainAny?: string[];
+    lastAssistantMustMatchAny?: string[];
+    lastAssistantMustNotMatchAny?: string[];
+    inspectFields?: string[];
+    description?: string;
+    focusAreas?: string[];
+    fixtureName?: string;
+    fixtureNames?: string[];
+};
+export declare function getDefaultAutoImplReference(ctx: DevServerContext, category: string, type: string): string;
+export declare function resolveAutoImplReference(ctx: DevServerContext, category: string, requestedReference: string | undefined, targetType: string): string | null;
+export declare function getLatestScriptVersionDir(scriptsDir: string): string | null;
+export declare function resolveAutoImplWritableProviderDir(ctx: DevServerContext, category: ProviderCategory, type: string, requestedDir?: string): {
+    dir: string | null;
+    reason?: string;
+};
+export declare function loadAutoImplReferenceScripts(ctx: DevServerContext, referenceType: string | null): Record<string, string>;
+export declare function handleAutoImplement(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function buildAutoImplPrompt(ctx: DevServerContext, type: string, provider: any, providerDir: string, functions: string[], domContext: any, referenceScripts: Record<string, string>, userComment?: string, referenceType?: string | null, verification?: CliExerciseVerification): string;
+export declare function buildCliAutoImplPrompt(ctx: DevServerContext, type: string, provider: any, providerDir: string, functions: string[], referenceScripts: Record<string, string>, userComment?: string, referenceType?: string | null, verification?: CliExerciseVerification): string;
+export declare function handleAutoImplSSE(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): void;
+export declare function handleAutoImplCancel(ctx: DevServerContext, _type: string, _req: http.IncomingMessage, res: http.ServerResponse): void;
+export declare function sendAutoImplSSE(ctx: DevServerContext, msg: {
+    event: string;
+    data: any;
+}): void;
+export {};

package/src/daemon/dev-cdp-handlers.d.ts

@@ -0,0 +1,22 @@
+/**
+ * DevServer — CDP & DOM Handlers
+ *
+ * Extracted from dev-server.ts for maintainability.
+ */
+import type * as http from 'http';
+import type { DevServerContext } from './dev-server-types.js';
+export declare function handleCdpEvaluate(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleCdpClick(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleCdpDomQuery(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleScreenshot(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleScriptsRun(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleTypeAndSend(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleTypeAndSendAt(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleScriptHints(ctx: DevServerContext, type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleCdpTargets(ctx: DevServerContext, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleDomInspect(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleDomChildren(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleDomAnalyze(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleFindCommon(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleFindByText(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handleDomContext(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;

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

@@ -0,0 +1,106 @@
+/**
+ * DevServer — CLI Debug Handlers
+ *
+ * Extracted from dev-server.ts for maintainability.
+ * All functions take a DevServerContext as their first argument.
+ */
+import type * as http from 'http';
+import type { DevServerContext } from './dev-server-types.js';
+type CliExerciseRequest = {
+    type?: string;
+    text?: string;
+    instanceId?: string;
+    workingDir?: string;
+    args?: string[];
+    autoLaunch?: boolean;
+    freshSession?: boolean;
+    autoResolveApprovals?: boolean;
+    approvalButtonIndex?: number;
+    timeoutMs?: number;
+    readyTimeoutMs?: number;
+    idleSettledMs?: number;
+    traceLimit?: number;
+    stopWhenDone?: boolean;
+};
+export type CliFixtureAssertions = {
+    mustContainAny?: string[];
+    mustNotContainAny?: string[];
+    mustMatchAny?: string[];
+    mustNotMatchAny?: string[];
+    lastAssistantMustContainAny?: string[];
+    lastAssistantMustNotContainAny?: string[];
+    lastAssistantMustMatchAny?: string[];
+    lastAssistantMustNotMatchAny?: string[];
+    statusesSeen?: string[];
+    requireNotTimedOut?: boolean;
+};
+type CliExerciseFixture = {
+    version: 1;
+    kind: 'cli-exercise-fixture';
+    name: string;
+    type: string;
+    createdAt: string;
+    providerDir: string | null;
+    providerResolution: Record<string, any> | null;
+    request: CliExerciseRequest;
+    result: Record<string, any>;
+    assertions: CliFixtureAssertions;
+    notes?: string;
+};
+export declare function validateCliFixtureResult(result: any, assertions: CliFixtureAssertions): string[];
+export declare function runCliExerciseInternal(ctx: DevServerContext, body: CliExerciseRequest): Promise<Record<string, any>>;
+export declare function runCliAutoImplVerification(ctx: DevServerContext, type: string, verification?: {
+    request?: Record<string, any>;
+    mustContainAny?: string[];
+    mustNotContainAny?: string[];
+    mustMatchAny?: string[];
+    mustNotMatchAny?: string[];
+    lastAssistantMustContainAny?: string[];
+    lastAssistantMustNotContainAny?: string[];
+    lastAssistantMustMatchAny?: string[];
+    lastAssistantMustNotMatchAny?: string[];
+    fixtureName?: string;
+    fixtureNames?: string[];
+}): Promise<{
+    mode: 'fixture_replay' | 'fixture_replay_suite' | 'exercise';
+    pass: boolean;
+    failures: string[];
+    result: Record<string, any>;
+    assertions: CliFixtureAssertions;
+    fixture?: CliExerciseFixture;
+    results?: Array<{
+        fixtureName: string;
+        pass: boolean;
+        failures: string[];
+        result: Record<string, any>;
+        assertions: CliFixtureAssertions;
+        fixture: CliExerciseFixture;
+    }>;
+}>;
+/** GET /api/cli/status — list all running CLI/ACP instances with state */
+export declare function handleCliStatus(ctx: DevServerContext, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/launch — launch a CLI agent { type, workingDir?, args? } */
+export declare function handleCliLaunch(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/send — send message to a running CLI { type, text } */
+export declare function handleCliSend(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/stop — stop a running CLI { type } */
+export declare function handleCliStop(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** GET /api/cli/events — SSE stream of CLI status events */
+export declare function handleCliSSE(ctx: DevServerContext, cliSSEClients: http.ServerResponse[], _req: http.IncomingMessage, res: http.ServerResponse): void;
+/** GET /api/cli/debug/:type — full internal debug state of a CLI adapter */
+export declare function handleCliDebug(ctx: DevServerContext, type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** GET /api/cli/trace/:type — recent CLI trace timeline plus current debug snapshot */
+export declare function handleCliTrace(ctx: DevServerContext, type: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/exercise — autonomously run a CLI repro and wait for final settled trace */
+export declare function handleCliExercise(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/fixture/capture — run exact exercise once and persist it as a reusable fixture */
+export declare function handleCliFixtureCapture(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** GET /api/cli/fixtures/:type — list saved exercise fixtures for a provider */
+export declare function handleCliFixtureList(ctx: DevServerContext, type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/fixture/replay — rerun a saved exact exercise and validate against saved assertions */
+export declare function handleCliFixtureReplay(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/resolve — resolve an approval modal { type, buttonIndex } */
+export declare function handleCliResolve(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+/** POST /api/cli/raw — send raw keystrokes to PTY { type, keys } */
+export declare function handleCliRaw(ctx: DevServerContext, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export {};

package/src/daemon/dev-server-types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared types & context interface for DevServer handler modules.
+ *
+ * Each handler module (cdp, cli-debug, auto-implement) imports DevServerContext
+ * to access shared state and utilities without circular references.
+ */
+import type * as http from 'http';
+import type { ProviderLoader } from '../providers/provider-loader.js';
+import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
+import type { DaemonCliManager } from '../commands/cli-manager.js';
+import type { ProviderCategory } from '../providers/contracts.js';
+/**
+ * Context passed from the main DevServer to handler modules.
+ * Provides access to shared dependencies and utility methods.
+ */
+export interface DevServerContext {
+    readonly providerLoader: ProviderLoader;
+    readonly cdpManagers: Map<string, DaemonCdpManager>;
+    readonly instanceManager: ProviderInstanceManager | null;
+    readonly cliManager: DaemonCliManager | null;
+    getCdp(ideType?: string): DaemonCdpManager | null;
+    json(res: http.ServerResponse, status: number, data: any): void;
+    readBody(req: http.IncomingMessage): Promise<any>;
+    log(msg: string): void;
+    autoImplSSEClients: http.ServerResponse[];
+    sendAutoImplSSE(msg: {
+        event: string;
+        data: any;
+    }): void;
+    autoImplStatus: {
+        running: boolean;
+        type: string | null;
+        progress: any[];
+    };
+    autoImplProcess: import('child_process').ChildProcess | null;
+    sendCliSSE(data: any): void;
+    handleRunScript(type: string, req: http.IncomingMessage, res: http.ServerResponse, parsedBody?: any): Promise<void>;
+    findProviderDir(type: string): string | null;
+    getLatestScriptVersionDir(scriptsDir: string): string | null;
+}
+/** Re-export for convenience */
+export type { ProviderCategory };