@adhdev/daemon-core 0.7.45 → 0.8.0

package/src/daemon/dev-server.ts

@@ -29,7 +29,7 @@ import { generateTemplate as genScaffoldTemplate, generateFiles as genScaffoldFi
 import { VersionArchive, detectAllVersions } from '../providers/version-archive.js';
 import { LOG } from '../logging/logger.js';
 import { handleCdpEvaluate, handleCdpClick, handleCdpDomQuery, handleScreenshot, handleScriptsRun, handleTypeAndSend, handleTypeAndSendAt, handleScriptHints, handleCdpTargets, handleDomInspect, handleDomChildren, handleDomAnalyze, handleFindCommon, handleFindByText, handleDomContext } from './dev-cdp-handlers.js';
-import { handleCliStatus, handleCliLaunch, handleCliSend, handleCliStop, handleCliDebug, handleCliResolve, handleCliRaw, handleCliSSE } from './dev-cli-debug.js';
+import { handleCliStatus, handleCliLaunch, handleCliSend, handleCliStop, handleCliDebug, handleCliTrace, handleCliExercise, handleCliFixtureCapture, handleCliFixtureList, handleCliFixtureReplay, handleCliResolve, handleCliRaw, handleCliSSE } from './dev-cli-debug.js';
 import { handleAutoImplement, handleAutoImplCancel, handleAutoImplSSE } from './dev-auto-implement.js';
 
 export const DEV_SERVER_PORT = 19280;
@@ -102,11 +102,16 @@ export class DevServer implements DevServerContext {
     { method: 'GET',  pattern: '/api/cli/status',           handler: (q, s) => this.handleCliStatus(q, s) },
     { method: 'POST', pattern: '/api/cli/launch',           handler: (q, s) => this.handleCliLaunch(q, s) },
     { method: 'POST', pattern: '/api/cli/send',             handler: (q, s) => this.handleCliSend(q, s) },
+    { method: 'POST', pattern: '/api/cli/exercise',         handler: (q, s) => this.handleCliExercise(q, s) },
+    { method: 'POST', pattern: '/api/cli/fixture/capture',  handler: (q, s) => this.handleCliFixtureCapture(q, s) },
+    { method: 'POST', pattern: '/api/cli/fixture/replay',   handler: (q, s) => this.handleCliFixtureReplay(q, s) },
     { method: 'POST', pattern: '/api/cli/resolve',           handler: (q, s) => this.handleCliResolve(q, s) },
     { method: 'POST', pattern: '/api/cli/raw',               handler: (q, s) => this.handleCliRaw(q, s) },
     { method: 'POST', pattern: '/api/cli/stop',              handler: (q, s) => this.handleCliStop(q, s) },
     { method: 'GET',  pattern: '/api/cli/events',            handler: (q, s) => this.handleCliSSE(q, s) },
     { method: 'GET',  pattern: /^\/api\/cli\/debug\/([^/]+)$/, handler: (q, s, p) => this.handleCliDebug(p![0], q, s) },
+    { method: 'GET',  pattern: /^\/api\/cli\/trace\/([^/]+)$/, handler: (q, s, p) => this.handleCliTrace(p![0], q, s) },
+    { method: 'GET',  pattern: /^\/api\/cli\/fixtures\/([^/]+)$/, handler: (q, s, p) => this.handleCliFixtureList(p![0], q, s) },
     // Dynamic routes (provider :type param)
     { method: 'POST', pattern: /^\/api\/providers\/([^/]+)\/script$/,                handler: (q, s, p) => this.handleRunScript(p![0], q, s) },
     { method: 'GET',  pattern: /^\/api\/providers\/([^/]+)\/files$/,                 handler: (q, s, p) => this.handleListFiles(p![0], q, s) },
@@ -1427,22 +1432,32 @@ export class DevServer implements DevServerContext {
     lines.push('| `detectStatus` | `{ tail, screenText, rawBuffer }` | `idle`, `generating`, `waiting_approval`, or `error` |');
     lines.push('| `parseApproval` | `{ buffer, rawBuffer, tail }` | `{ message, buttons }` or `null` |');
     lines.push('');
+    lines.push('## Primary Source of Truth');
+    lines.push('The runtime now provides a reliable current-screen snapshot. Treat `screenText` as the primary source of truth for the LIVE visible UI.');
+    lines.push('That means:');
+    lines.push('- Use `screenText` first for prompt detection, approval UI, status, and visible assistant content.');
+    lines.push('- Use `rawBuffer` only as supporting evidence when ANSI/style/cursor cues matter.');
+    lines.push('- Use `buffer` only when the visible screen does not contain enough text to recover the latest assistant answer.');
+    lines.push('- Do NOT build the parser around stale transcript noise if the current screen already gives the answer.');
+    lines.push('');
 
     lines.push('## Rules');
     lines.push('0. **🚫 SCOPE CONSTRAINT**: You may ONLY edit files marked ✏️ EDIT above. ALL other files are READ-ONLY. Do NOT modify, rewrite, refactor, or "improve" any file not explicitly marked as editable — even if you notice bugs or improvements. No exceptions.');
     lines.push('1. These scripts run in Node.js CommonJS, not in the browser. Do NOT use DOM APIs.');
-    lines.push('2. Prefer `screenText` for current visible UI state. That is the PTY equivalent of parsing the current IDE DOM.');
+    lines.push('2. Prefer `screenText` for current visible UI state. It is now the PTY equivalent of a trustworthy live DOM snapshot.');
     lines.push('3. Use `messages` as prior transcript state so redraws do not duplicate old turns on every parse.');
     lines.push('4. Use `partialResponse` for the actively streaming assistant text when status is `generating`.');
-    lines.push('5. `detectStatus` must stay lightweight and tail-based. Do not scan the entire history there.');
-    lines.push('6. `parseApproval` should understand the live approval area and return clean button labels.');
-    lines.push('7. Use `rawBuffer` only when ANSI/control-sequence artifacts matter. Do not depend on raw escape noise unless necessary.');
+    lines.push('5. `detectStatus` must stay lightweight and current-screen-oriented. Prefer the active bottom-of-screen region over stale history.');
+    lines.push('6. `parseApproval` should understand the live approval area and return clean button labels from the CURRENT visible modal.');
+    lines.push('7. Use `rawBuffer` only when ANSI/control-sequence artifacts or style cues matter. Do not depend on raw escape noise unless necessary.');
     lines.push('8. Keep exports compatible with the existing `scripts.js` router (`module.exports = function ...`).');
     lines.push('9. Do NOT modify ANY file not explicitly marked ✏️ EDIT above. No exceptions — no "tiny supporting changes" to other files.');
     lines.push('10. When the verification API returns `instanceId`, keep using that exact instance for follow-up `send`, `resolve`, `raw`, and `stop` calls. Do not assume type-only routing is safe if multiple sessions exist.');
     lines.push('11. Do NOT repeatedly dump the same target files. Read the target scripts once, reproduce the bug, then move directly to patching.');
     lines.push('12. If the user instructions include concrete screen text, raw PTY snippets, or a specific repro, treat that as the primary acceptance criteria.');
     lines.push('13. After the first successful live repro, stop broad diagnosis. Edit the scripts, reload, and verify. Do not burn tokens on repeated re-inspection without code changes.');
+    lines.push('14. If the visible current screen is clean and sufficient, do NOT fall back to complex buffer heuristics. Simpler current-screen parsing is preferred.');
+    lines.push('15. Before changing parser logic, verify whether `provider.json` submit/approval behavior (`sendDelayMs`, `approvalKeys`, submit strategy) is the simpler and more correct fix.');
     lines.push('');
 
     lines.push('## Task');
@@ -1462,9 +1477,16 @@ export class DevServer implements DevServerContext {
     lines.push('### 2. Inspect parsed + raw adapter state');
     lines.push('```bash');
     lines.push(`curl -sS http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/debug/${type}`);
+    lines.push(`curl -sS http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/trace/${type}`);
     lines.push(`curl -sS http://127.0.0.1:${DEV_SERVER_PORT}/api/cli/status`);
     lines.push('```');
     lines.push('');
+    lines.push('The debug payload should be read in this priority order:');
+    lines.push('1. `screenText` / current visible state');
+    lines.push('2. parsed `status`, `messages`, `activeModal`');
+    lines.push('3. `rawBuffer` only for style/control-sequence cues');
+    lines.push('4. `buffer` only when the current screen is insufficient');
+    lines.push('');
     lines.push('Extract the current `instanceId` from the launch or status response and keep using it below.');
     lines.push('');
     lines.push('### 3. Send a realistic approval-triggering prompt');
@@ -1511,6 +1533,8 @@ export class DevServer implements DevServerContext {
     lines.push('5. Confirm the Python file was actually created and executed, not just described in chat text.');
     lines.push('6. Confirm the final assistant transcript includes the exact Python output, including the working directory line and the five square numbers.');
     lines.push('7. Re-run the debug endpoints after edits. Do NOT finish until the parsed result looks correct.');
+    lines.push('8. Confirm the parser still works after a redraw or scroll change without duplicating transcript history.');
+    lines.push('9. Confirm the implementation prefers current-screen signals over stale history when both are present.');
     lines.push('');
 
     if (userComment) {
@@ -1600,6 +1624,19 @@ export class DevServer implements DevServerContext {
     return handleCliSend(this, req, res);
   }
 
+  /** POST /api/cli/exercise — launch/send/approve/wait helper for provider-fix loops */
+  private async handleCliExercise(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    return handleCliExercise(this, req, res);
+  }
+
+  private async handleCliFixtureCapture(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    return handleCliFixtureCapture(this, req, res);
+  }
+
+  private async handleCliFixtureReplay(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    return handleCliFixtureReplay(this, req, res);
+  }
+
   /** POST /api/cli/stop — stop a running CLI { type } */
   private async handleCliStop(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     return handleCliStop(this, req, res);
@@ -1622,6 +1659,15 @@ export class DevServer implements DevServerContext {
     return handleCliDebug(this, type, _req, res);
   }
 
+  /** GET /api/cli/trace/:type — recent CLI trace timeline plus current debug snapshot */
+  private async handleCliTrace(type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    return handleCliTrace(this, type, _req, res);
+  }
+
+  private async handleCliFixtureList(type: string, _req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    return handleCliFixtureList(this, type, _req, res);
+  }
+
   /** POST /api/cli/resolve — resolve an approval modal { type, buttonIndex } */
   private async handleCliResolve(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     return handleCliResolve(this, req, res);

package/src/index.ts

@@ -66,6 +66,8 @@ export { loadConfig, saveConfig, resetConfig, isSetupComplete, markSetupComplete
 export { getWorkspaceState } from './config/workspaces.js';
 export { appendRecentActivity, getRecentActivity } from './config/recent-activity.js';
 export type { RecentActivityEntry } from './config/recent-activity.js';
+export { getSavedProviderSessions, upsertSavedProviderSession } from './config/saved-sessions.js';
+export type { SavedProviderSessionEntry } from './config/saved-sessions.js';
 
 // ── Detection ──
 export { detectIDEs } from './detection/ide-detector.js';

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

@@ -5,8 +5,11 @@
  * collectCliData() + status transition logic from daemon-status.ts moved here.
  */
 
+import * as os from 'os';
 import * as path from 'path';
 import * as crypto from 'crypto';
+import * as fs from 'fs';
+import { createRequire } from 'node:module';
 import type { ProviderModule } from './contracts.js';
 import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
@@ -15,6 +18,27 @@ import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import { StatusMonitor } from './status-monitor.js';
 import { ChatHistoryWriter } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
+import type { ChatMessage } from '../types.js';
+
+let CachedDatabaseSync: (new (path: string, options?: { readOnly?: boolean }) => {
+    prepare(sql: string): { get(...params: Array<string | number>): unknown };
+    close(): void;
+}) | null = null;
+
+function getDatabaseSync() {
+    if (CachedDatabaseSync) return CachedDatabaseSync;
+    const requireFn = typeof require === 'function'
+        ? require
+        : createRequire(path.join(process.cwd(), '__adhdev_sqlite_loader__.js'));
+    const sqliteModule = requireFn(`node:${'sqlite'}`) as {
+        DatabaseSync: typeof CachedDatabaseSync;
+    };
+    CachedDatabaseSync = sqliteModule.DatabaseSync;
+    if (!CachedDatabaseSync) {
+        throw new Error('node:sqlite DatabaseSync unavailable');
+    }
+    return CachedDatabaseSync;
+}
 
 export class CliProviderInstance implements ProviderInstance {
     readonly type: string;
@@ -31,9 +55,21 @@ export class CliProviderInstance implements ProviderInstance {
     private generatingDebouncePending: { chatTitle: string; timestamp: number } | null = null;
     private lastApprovalEventAt = 0;
     private historyWriter: ChatHistoryWriter;
+    private runtimeMessages: Array<{ key: string; message: ChatMessage }> = [];
     readonly instanceId: string;
 
     private presentationMode: 'terminal' | 'chat';
+    private providerSessionId?: string;
+    private launchMode: 'new' | 'resume' | 'manual';
+    private readonly startedAt = Date.now();
+    private onProviderSessionResolved?: (info: {
+        instanceId: string;
+        providerType: string;
+        providerName: string;
+        workspace: string;
+        providerSessionId: string;
+        previousProviderSessionId?: string;
+    }) => void;
 
     constructor(
         private provider: ProviderModule,
@@ -41,10 +77,25 @@ export class CliProviderInstance implements ProviderInstance {
         private cliArgs: string[] = [],
         instanceId?: string,
         transportFactory?: PtyTransportFactory,
+        options?: {
+            providerSessionId?: string;
+            launchMode?: 'new' | 'resume' | 'manual';
+            onProviderSessionResolved?: (info: {
+                instanceId: string;
+                providerType: string;
+                providerName: string;
+                workspace: string;
+                providerSessionId: string;
+                previousProviderSessionId?: string;
+            }) => void;
+        },
     ) {
         this.type = provider.type;
         this.instanceId = instanceId || crypto.randomUUID();
         this.presentationMode = 'chat';
+        this.providerSessionId = options?.providerSessionId;
+        this.launchMode = options?.launchMode || 'new';
+        this.onProviderSessionResolved = options?.onProviderSessionResolved;
         this.adapter = new ProviderCliAdapter(provider as any as CliProviderModule, workingDir, cliArgs, transportFactory);
         this.monitor = new StatusMonitor();
         this.historyWriter = new ChatHistoryWriter();
@@ -78,20 +129,72 @@ export class CliProviderInstance implements ProviderInstance {
 
  // PTY spawn
         await this.adapter.spawn();
+        if (this.providerSessionId && this.launchMode === 'resume') {
+            const resumedAt = Date.now();
+            this.historyWriter.appendSystemMarker(
+                this.type,
+                `Resumed saved session at ${this.formatMarkerTimestamp(resumedAt)}`,
+                {
+                    instanceId: this.instanceId,
+                    historySessionId: this.providerSessionId,
+                    dedupKey: `resume:${this.providerSessionId}:${resumedAt}`,
+                    receivedAt: resumedAt,
+                },
+            );
+        }
     }
 
     async onTick(): Promise<void> {
- // CLI is event-based so tick is unnecessary
- // Health check etc here if needed
+        if (this.providerSessionId) return;
+
+        let probedSessionId: string | null = null;
+        if (this.type === 'opencode-cli') {
+            probedSessionId = this.probeOpenCodeSessionId();
+        } else if (this.type === 'codex-cli') {
+            probedSessionId = this.probeCodexSessionId();
+        } else if (this.type === 'goose-cli') {
+            probedSessionId = this.probeGooseSessionId();
+        }
+
+        if (probedSessionId) {
+            this.promoteProviderSessionId(probedSessionId);
+        }
     }
 
     getState(): ProviderState {
         const adapterStatus = this.adapter.getStatus();
         const parsedStatus = this.adapter.getScriptParsedStatus?.() || null;
+        const parsedProviderSessionId = typeof parsedStatus?.providerSessionId === 'string'
+            ? parsedStatus.providerSessionId.trim()
+            : '';
+        if (parsedProviderSessionId) {
+            this.promoteProviderSessionId(parsedProviderSessionId);
+        }
         const runtime = this.adapter.getRuntimeMetadata();
+        const parsedMessages = Array.isArray(parsedStatus?.messages) ? parsedStatus.messages : [];
+        const mergedMessages = this.mergeConversationMessages(parsedMessages);
 
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
 
+        if (parsedMessages.length > 0) {
+            let messagesToSave = parsedMessages;
+            if ((parsedStatus?.status === 'generating' || parsedStatus?.status === 'long_generating')) {
+                const lastIdx = messagesToSave.length - 1;
+                if (lastIdx >= 0 && messagesToSave[lastIdx]?.role === 'assistant') {
+                    messagesToSave = messagesToSave.slice(0, lastIdx);
+                }
+            }
+            if (messagesToSave.length > 0) {
+                this.historyWriter.appendNewMessages(
+                    this.type,
+                    messagesToSave,
+                    parsedStatus?.title || dirName,
+                    this.instanceId,
+                    this.providerSessionId,
+                );
+            }
+        }
+
         return {
             type: this.type,
             name: this.provider.name,
@@ -100,14 +203,15 @@ export class CliProviderInstance implements ProviderInstance {
             mode: this.presentationMode,
             activeChat: {
                 id: `${this.type}_${this.workingDir}`,
-                title: parsedStatus?.title || `${this.provider.name} · ${dirName}`,
+                title: parsedStatus?.title || dirName,
                 status: parsedStatus?.status || adapterStatus.status,
-                messages: Array.isArray(parsedStatus?.messages) ? parsedStatus.messages : [],
+                messages: mergedMessages,
                 activeModal: parsedStatus?.activeModal ?? adapterStatus.activeModal,
                 inputContent: '',
             },
             workspace: this.workingDir,
             instanceId: this.instanceId,
+            providerSessionId: this.providerSessionId,
             lastUpdated: Date.now(),
             settings: this.settings,
             pendingEvents: this.flushEvents(),
@@ -207,6 +311,11 @@ export class CliProviderInstance implements ProviderInstance {
                 const approvalCooldown = 5000;
                 if (this.lastStatus !== 'waiting_approval' && (!this.lastApprovalEventAt || now - this.lastApprovalEventAt > approvalCooldown)) {
                     this.lastApprovalEventAt = now;
+                    this.appendRuntimeSystemMessage(
+                        this.formatApprovalRequestMessage(modal?.message, modal?.buttons),
+                        `approval_request:${now}`,
+                        now,
+                    );
                     this.pushEvent({
                         event: 'agent:waiting_approval', chatTitle, timestamp: now,
                         modalMessage: modal?.message,
@@ -274,4 +383,174 @@ export class CliProviderInstance implements ProviderInstance {
 
     get cliType(): string { return this.type; }
     get cliName(): string { return this.provider.name; }
+
+    recordApprovalSelection(buttonText: string): void {
+        const cleanButton = String(buttonText || '').trim();
+        if (!cleanButton) return;
+        const now = Date.now();
+        this.appendRuntimeSystemMessage(
+            `Approval selected: ${cleanButton}`,
+            `approval_selection:${now}:${cleanButton}`,
+            now,
+        );
+    }
+
+    private formatMarkerTimestamp(timestamp: number): string {
+        const date = new Date(timestamp);
+        const pad = (value: number) => String(value).padStart(2, '0');
+        return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+    }
+
+    private appendRuntimeSystemMessage(content: string, dedupKey: string, receivedAt = Date.now()): void {
+        const normalizedContent = String(content || '').trim();
+        if (!normalizedContent) return;
+        if (this.runtimeMessages.some((entry) => entry.key === dedupKey)) return;
+
+        this.runtimeMessages.push({
+            key: dedupKey,
+            message: {
+                role: 'system',
+                senderName: 'System',
+                content: normalizedContent,
+                receivedAt,
+                timestamp: receivedAt,
+            },
+        });
+        if (this.runtimeMessages.length > 50) {
+            this.runtimeMessages = this.runtimeMessages.slice(-50);
+        }
+
+        this.historyWriter.appendNewMessages(
+            this.type,
+            [{
+                role: 'system',
+                senderName: 'System',
+                content: normalizedContent,
+                receivedAt,
+                historyDedupKey: dedupKey,
+            }],
+            this.adapter.getScriptParsedStatus?.()?.title || this.workingDir.split('/').filter(Boolean).pop() || 'session',
+            this.instanceId,
+            this.providerSessionId,
+        );
+    }
+
+    private mergeConversationMessages(parsedMessages: any[]): ChatMessage[] {
+        if (this.runtimeMessages.length === 0) return parsedMessages;
+
+        return [...parsedMessages, ...this.runtimeMessages.map((entry) => entry.message)]
+            .map((message, index) => ({ message, index }))
+            .sort((a, b) => {
+                const aTime = a.message.receivedAt || a.message.timestamp || 0;
+                const bTime = b.message.receivedAt || b.message.timestamp || 0;
+                if (aTime !== bTime) return aTime - bTime;
+                return a.index - b.index;
+            })
+            .map((entry) => entry.message);
+    }
+
+    private formatApprovalRequestMessage(modalMessage?: string, buttons?: string[]): string {
+        const lines = ['Approval requested'];
+        const cleanMessage = String(modalMessage || '').trim();
+        if (cleanMessage) lines.push(cleanMessage);
+        const labels = (buttons || []).map((button) => String(button || '').trim()).filter(Boolean);
+        if (labels.length > 0) {
+            lines.push(labels.map((label) => `[${label}]`).join(' '));
+        }
+        return lines.join('\n');
+    }
+
+    private promoteProviderSessionId(sessionId: string): void {
+        const nextSessionId = String(sessionId || '').trim();
+        if (!nextSessionId || nextSessionId === this.providerSessionId) return;
+
+        const previousHistorySessionId = this.providerSessionId || this.instanceId;
+        const previousProviderSessionId = this.providerSessionId;
+        this.providerSessionId = nextSessionId;
+        this.historyWriter.promoteHistorySession(this.type, previousHistorySessionId, nextSessionId);
+        this.adapter.updateRuntimeMeta({ providerSessionId: nextSessionId });
+        this.onProviderSessionResolved?.({
+            instanceId: this.instanceId,
+            providerType: this.type,
+            providerName: this.provider.name,
+            workspace: this.workingDir,
+            providerSessionId: nextSessionId,
+            previousProviderSessionId,
+        });
+        LOG.info('CLI', `[${this.type}] discovered provider session id: ${nextSessionId}`);
+    }
+
+    private probeOpenCodeSessionId(): string | null {
+        const dbPath = path.join(os.homedir(), '.local', 'share', 'opencode', 'opencode.db');
+        if (!fs.existsSync(dbPath)) return null;
+        const minCreatedAt = Math.max(0, this.startedAt - 60_000);
+        const directories = this.getProbeDirectories();
+        const query = `select id from session where directory in (${this.buildSqlPlaceholderList(directories.length)}) and time_created >= ? and time_archived is null order by time_updated desc limit 1;`;
+        return this.querySqliteText(dbPath, query, [...directories, minCreatedAt]);
+    }
+
+    private probeCodexSessionId(): string | null {
+        const dbPath = path.join(os.homedir(), '.codex', 'state_5.sqlite');
+        if (!fs.existsSync(dbPath)) return null;
+        const minCreatedAt = Math.max(0, Math.floor((this.startedAt - 60_000) / 1000));
+        const directories = this.getProbeDirectories();
+        const query = `select id from threads where cwd in (${this.buildSqlPlaceholderList(directories.length)}) and created_at >= ? and archived = 0 order by created_at desc limit 1;`;
+        return this.querySqliteText(dbPath, query, [...directories, minCreatedAt]);
+    }
+
+    private probeGooseSessionId(): string | null {
+        const dbPath = path.join(os.homedir(), '.local', 'share', 'goose', 'sessions', 'sessions.db');
+        if (!fs.existsSync(dbPath)) return null;
+        const minCreatedAtIso = new Date(Math.max(0, this.startedAt - 60_000)).toISOString().slice(0, 19).replace('T', ' ');
+        const directories = this.getProbeDirectories();
+        const query = `select id from sessions where working_dir in (${this.buildSqlPlaceholderList(directories.length)}) and created_at >= ? order by updated_at desc limit 1;`;
+        try {
+            return this.querySqliteText(dbPath, query, [...directories, minCreatedAtIso]);
+        } catch {
+            return null;
+        }
+    }
+
+    private getProbeDirectories(): string[] {
+        const dirs = new Set<string>();
+        const addDir = (value: string | null | undefined) => {
+            const normalized = typeof value === 'string' ? value.trim() : '';
+            if (normalized) dirs.add(normalized);
+        };
+
+        addDir(this.workingDir);
+        try {
+            addDir(fs.realpathSync.native(this.workingDir));
+        } catch {
+            // noop
+        }
+
+        return Array.from(dirs);
+    }
+
+    private buildSqlPlaceholderList(count: number): string {
+        return Array.from({ length: count }, () => '?').join(', ');
+    }
+
+    private querySqliteText(dbPath: string, query: string, params: Array<string | number>): string | null {
+        let db: {
+            prepare(sql: string): { get(...values: Array<string | number>): unknown };
+            close(): void;
+        } | null = null;
+        try {
+            const DatabaseSync = getDatabaseSync();
+            db = new DatabaseSync(dbPath, { readOnly: true });
+            const row = db.prepare(query).get(...params) as { id?: unknown } | undefined;
+            const sessionId = typeof row?.id === 'string' ? row.id.trim() : '';
+            return sessionId || null;
+        } catch {
+            return null;
+        } finally {
+            try {
+                db?.close();
+            } catch {
+                // noop
+            }
+        }
+    }
 }

package/src/providers/contracts.ts

@@ -399,6 +399,9 @@ export interface ProviderResumeCapability {
   stopCommand?: string;
   shutdownGraceMs?: number;
   resumeArgs?: string[];
+  resumeSessionArgs?: string[];
+  newSessionArgs?: string[];
+  sessionIdFormat?: 'uuid' | 'string';
 }
 
 // ─── ACP Auth Types ─────────────────────────────────
@@ -493,6 +496,14 @@ export interface ResolvedProvider extends ProviderModule {
   _resolvedVersion?: string;
  /** Warning when detected version is not in compatibility matrix */
   _versionWarning?: string;
+ /** On-disk provider directory selected by ProviderLoader */
+  _resolvedProviderDir?: string;
+ /** Script directory selected by compatibility/default resolution */
+  _resolvedScriptDir?: string;
+ /** scripts.js path or fallback script directory used to build runtime scripts */
+  _resolvedScriptsPath?: string;
+ /** Why this script selection was chosen */
+  _resolvedScriptsSource?: string;
 }
 
 // ─── Provider Settings ─────────────────────────────────

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

@@ -61,6 +61,7 @@ interface ProviderStateBase {
     errorReason?: ProviderErrorReason;
     /** meta */
     instanceId: string;
+    providerSessionId?: string;
     lastUpdated: number;
     settings: Record<string, any>;
     /** Event queue (cleared after daemon collects) */

package/src/providers/provider-instance.ts

@@ -76,6 +76,7 @@ interface ProviderStateBase {
     errorReason?: ProviderErrorReason;
  /** meta */
     instanceId: string;
+    providerSessionId?: string;
     lastUpdated: number;
     settings: Record<string, any>;
  /** Event queue (cleared after daemon collects) */

package/src/providers/provider-loader.ts

@@ -425,6 +425,7 @@ export class ProviderLoader {
   resolve(type: string, context?: { os?: string; version?: string }): ResolvedProvider | undefined {
     const base = this.providers.get(type);
     if (!base) return undefined;
+    const providerDir = this.findProviderDirInternal(type) || undefined;
 
     const currentOs = context?.os || process.platform;
     const currentVersion = context?.version ??
@@ -441,6 +442,9 @@ export class ProviderLoader {
     if (base.scripts) {
       resolved.scripts = { ...base.scripts };
     }
+    if (providerDir) {
+      resolved._resolvedProviderDir = providerDir;
+    }
 
  // 1. Apply OS override
     if (base.os?.[currentOs]) {
@@ -468,6 +472,14 @@ export class ProviderLoader {
             if (loaded) {
               resolved.scripts = loaded;
               this.log(`  [compatibility] ${type} v${currentVersion} → ${entry.scriptDir}`);
+              resolved._resolvedScriptDir = entry.scriptDir;
+              resolved._resolvedScriptsSource = `compatibility:${entry.ideVersion}`;
+              if (providerDir) {
+                const fullDir = path.join(providerDir, entry.scriptDir);
+                resolved._resolvedScriptsPath = fs.existsSync(path.join(fullDir, 'scripts.js'))
+                  ? path.join(fullDir, 'scripts.js')
+                  : fullDir;
+              }
               matched = true;
             }
             break; // first match wins
@@ -480,6 +492,14 @@ export class ProviderLoader {
           if (loaded) {
             resolved.scripts = loaded;
             this.log(`  [compatibility] ${type} v${currentVersion} → default: ${(base as any).defaultScriptDir}`);
+            resolved._resolvedScriptDir = (base as any).defaultScriptDir;
+            resolved._resolvedScriptsSource = 'defaultScriptDir:version_miss';
+            if (providerDir) {
+              const fullDir = path.join(providerDir, (base as any).defaultScriptDir);
+              resolved._resolvedScriptsPath = fs.existsSync(path.join(fullDir, 'scripts.js'))
+                ? path.join(fullDir, 'scripts.js')
+                : fullDir;
+            }
           }
           resolved._versionWarning = `Version ${currentVersion} not in compatibility matrix. Using default scripts.`;
         }
@@ -495,6 +515,14 @@ export class ProviderLoader {
             if (loaded) {
               resolved.scripts = loaded;
               this.log(`  [version override] ${type} ${range} → ${dirOverride}`);
+              resolved._resolvedScriptDir = dirOverride;
+              resolved._resolvedScriptsSource = `versions:${range}`;
+              if (providerDir) {
+                const fullDir = path.join(providerDir, dirOverride);
+                resolved._resolvedScriptsPath = fs.existsSync(path.join(fullDir, 'scripts.js'))
+                  ? path.join(fullDir, 'scripts.js')
+                  : fullDir;
+              }
             }
           } else if (override.scripts) {
             resolved.scripts = { ...resolved.scripts, ...override.scripts };
@@ -507,6 +535,14 @@ export class ProviderLoader {
       if (loaded) {
         resolved.scripts = loaded;
         this.log(`  [compatibility] ${type} no version detected → default: ${(base as any).defaultScriptDir}`);
+        resolved._resolvedScriptDir = (base as any).defaultScriptDir;
+        resolved._resolvedScriptsSource = 'defaultScriptDir:no_version';
+        if (providerDir) {
+          const fullDir = path.join(providerDir, (base as any).defaultScriptDir);
+          resolved._resolvedScriptsPath = fs.existsSync(path.join(fullDir, 'scripts.js'))
+            ? path.join(fullDir, 'scripts.js')
+            : fullDir;
+        }
       }
     }
 
@@ -583,6 +619,9 @@ export class ProviderLoader {
         });
 
         const handleChange = (filePath: string) => {
+          if (/[\/\\]fixtures[\/\\]/.test(filePath)) {
+            return;
+          }
           if (filePath.endsWith('.js') || filePath.endsWith('.json')) {
             this.log(`File changed: ${path.basename(filePath)}, reloading...`);
             this.reload();

package/src/session-host/runtime-support.ts

@@ -64,6 +64,7 @@ export async function listHostedCliRuntimes(endpoint: SessionHostEndpoint): Prom
                 cliType: record.providerType,
                 workspace: record.workspace,
                 cliArgs: Array.isArray(record.meta?.cliArgs) ? (record.meta.cliArgs as string[]) : [],
+                providerSessionId: typeof record.meta?.providerSessionId === 'string' ? String(record.meta.providerSessionId) : undefined,
             }));
     } finally {
         await client.close().catch(() => {});

package/src/shared-types.d.ts

@@ -41,6 +41,7 @@ export interface SessionEntry {
     parentId: string | null;
     providerType: string;
     providerName: string;
+    providerSessionId?: string;
     kind: SessionKind;
     transport: SessionTransport;
     status: 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
@@ -152,6 +153,7 @@ export interface RecentLaunchEntry {
     providerType: string;
     providerName: string;
     kind: 'ide' | 'cli' | 'acp';
+    providerSessionId?: string;
     title?: string;
     workspace?: string | null;
     currentModel?: string;