@adhdev/daemon-core 0.9.82-rc.530 → 0.9.82-rc.532

package/dist/providers/sdk/v1/builders/cli/parse-session.d.ts

@@ -39,6 +39,20 @@ export interface TranscriptPtySpec {
     chromePatterns?: ChromePatternSpec[];
     stripLeadingChrome?: boolean;
     scope?: 'screen' | 'buffer' | 'tail';
+    /**
+     * Optional SGR background-color codes that mark a USER turn. Some TUIs
+     * (cursor-agent) render the user's submitted message and the composer echo
+     * inside a colored box but render the assistant answer as a plain line with
+     * no background. After ANSI stripping both look like bare 2-space lines, so
+     * a bg-less assistant answer and a boxed user echo are indistinguishable by
+     * text prefix alone — the user echo then leaks into an assistant bubble.
+     * When set, a raw line whose ANSI carries any of these background SGRs (e.g.
+     * "48;5;233") is classified as a user turn regardless of its stripped text,
+     * so the plain assistant answer is the only assistant bubble left. Matched
+     * against the raw pre-strip line; the visible text is still ANSI-stripped
+     * for the bubble content.
+     */
+    userBackgroundSgr?: string[];
 }
 export interface SessionIdExtractionSpec {
     $schema?: 'adhdev:tui/session-id-extraction@1';

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

@@ -114,6 +114,19 @@ export interface NativeHistoryMessageMap {
     content_unwrap?: string[];
     timestamp_ms?: string;
     kind?: string;
+    /**
+     * Optional jsonpath-lite path to a per-message workspace/cwd value. sqlite
+     * sources have no `session_meta` record to carry the workspace (that's a
+     * jsonl-only convention), so a native-source provider whose store keeps the
+     * session directory as a column (e.g. opencode's `session.directory`) can
+     * SELECT it into each message row and map it here. The read pipeline's
+     * `hasSafeNativeHistoryMapping` guard requires each message to declare a
+     * workspace when the read is workspace-scoped (no provider session id was
+     * captured from the TUI); without it a workspace-only lookup fails closed
+     * and every assistant bubble is dropped. Absent → messages carry no
+     * workspace (jsonl still fills it from session_meta).
+     */
+    workspace?: string;
     /**
      * Declarative tool-bubble extraction. Without it the executor only emits
      * the text-bearing parts of each record, so a turn that is purely a tool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.530",
+  "version": "0.9.82-rc.532",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.530",
-    "@adhdev/session-host-core": "0.9.82-rc.530",
+    "@adhdev/mesh-shared": "0.9.82-rc.532",
+    "@adhdev/session-host-core": "0.9.82-rc.532",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/providers/sdk/v1/builders/cli/parse-session.ts

@@ -46,6 +46,20 @@ export interface TranscriptPtySpec {
     chromePatterns?: ChromePatternSpec[]
     stripLeadingChrome?: boolean
     scope?: 'screen' | 'buffer' | 'tail'
+    /**
+     * Optional SGR background-color codes that mark a USER turn. Some TUIs
+     * (cursor-agent) render the user's submitted message and the composer echo
+     * inside a colored box but render the assistant answer as a plain line with
+     * no background. After ANSI stripping both look like bare 2-space lines, so
+     * a bg-less assistant answer and a boxed user echo are indistinguishable by
+     * text prefix alone — the user echo then leaks into an assistant bubble.
+     * When set, a raw line whose ANSI carries any of these background SGRs (e.g.
+     * "48;5;233") is classified as a user turn regardless of its stripped text,
+     * so the plain assistant answer is the only assistant bubble left. Matched
+     * against the raw pre-strip line; the visible text is still ANSI-stripped
+     * for the bubble content.
+     */
+    userBackgroundSgr?: string[]
 }
 
 export interface SessionIdExtractionSpec {
@@ -107,6 +121,22 @@ function splitLines(text: string): string[] {
         .map(l => l.replace(/\s+$/, ''))
 }
 
+/**
+ * Split into raw (pre-strip) lines paired with their stripped visible text so
+ * per-line ANSI (e.g. a user-turn background SGR) can be inspected before the
+ * color is discarded. The stripped column matches splitLines() line for line:
+ * same newline split, same trailing-space trim — only the ANSI is retained on
+ * the `raw` side. Splitting on newline keeps any leading SGR of a line attached
+ * to that line (cursor-agent writes `<bg-sgr> <text>` on one raw line), so a
+ * per-line background test is exact.
+ */
+function splitRawLines(text: string): Array<{ raw: string; text: string }> {
+    return String(text || '')
+        .split(/\r?\n/)
+        // eslint-disable-next-line no-control-regex
+        .map(rawLine => ({ raw: rawLine, text: stripAnsi(rawLine).replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '').replace(/\s+$/, '') }))
+}
+
 function pickInputText(input: any, scope: TranscriptPtySpec['scope']): string {
     if (!input) return ''
     if (scope === 'screen') return String(input.screenText || input.screen?.text || '')
@@ -187,6 +217,19 @@ export function buildParseSessionFromTui(spec: ParseSessionTuiSpec): (input: any
     const requireIndentForContinuation = spec.transcriptPty.continuationLine?.indented ?? false
     const stripLeadingChrome = spec.transcriptPty.stripLeadingChrome ?? true
     const scope = spec.transcriptPty.scope ?? 'buffer'
+    // Background-SGR user-turn markers. A raw line whose ANSI carries one of
+    // these `48;5;NNN`-style background codes is a user turn even when its
+    // stripped text is a bare line the assistantPrefix would otherwise grab.
+    const userBgList = Array.isArray(spec.transcriptPty.userBackgroundSgr)
+        ? spec.transcriptPty.userBackgroundSgr.map(s => String(s).trim()).filter(Boolean)
+        : []
+    const userBgRes = userBgList.map(code => {
+        // Match the code inside an SGR run: `\x1b[<...>48;5;233<...>m`. The code
+        // (e.g. "48;5;233") appears somewhere in the `;`-separated parameter list
+        // terminated by `m`. Escape regex-special chars in the code first.
+        const esc = code.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        return new RegExp(`\\x1b\\[[0-9;]*${esc}[0-9;]*m`)
+    })
 
     // Compose detect + approval helpers if their inputs are present.
     const detectStatus = (spec.spinner || spec.settledPrompt || spec.modal || spec.dispatchOrder)
@@ -215,13 +258,16 @@ export function buildParseSessionFromTui(spec: ParseSessionTuiSpec): (input: any
         const modal = parseApproval(input as any)
 
         const text = pickInputText(input, scope)
-        const lines = splitLines(text)
+        // When a bg-SGR user marker is configured we need the raw (pre-strip)
+        // line to test the background color; otherwise the cheaper stripped
+        // split is enough. Both yield the same stripped `text` per line.
+        const rawLines = userBgRes.length > 0 ? splitRawLines(text) : splitLines(text).map(t => ({ raw: '', text: t }))
 
         const messages: SynthesizedMessage[] = []
         let seenFirstRoleLine = !stripLeadingChrome
 
-        for (const raw of lines) {
-            const line = raw
+        for (const entry of rawLines) {
+            const line = entry.text
             if (line.trim() === '') {
                 // Blank line: ends streaming continuation but doesn't add a message.
                 continue
@@ -234,6 +280,19 @@ export function buildParseSessionFromTui(spec: ParseSessionTuiSpec): (input: any
             }
             if (isChrome) continue
 
+            // Background-SGR user classification. Checked before prefix matching
+            // so a user turn rendered as a bg-boxed plain line (no distinctive
+            // glyph — cursor-agent) is attributed to the user instead of being
+            // grabbed by a permissive assistantPrefix. The visible text is the
+            // ANSI-stripped `line`.
+            if (userBgRes.length > 0 && entry.raw && userBgRes.some(re => re.test(entry.raw))) {
+                seenFirstRoleLine = true
+                // Strip a leading composer glyph (e.g. "→ ") the boxed echo may carry.
+                const content = line.replace(/^\s*[→>›❯]\s*/, '').trim()
+                if (content) messages.push({ role: 'user', kind: 'standard', content })
+                continue
+            }
+
             // Role detection
             const userMatch = userRe ? line.match(userRe) : null
             const toolMatch = toolRe ? line.match(toolRe) : null

package/src/providers/sdk/v1/schemas/primitives/tui-transcript-pty-v1.json

@@ -78,6 +78,11 @@
       "enum": ["screen", "buffer", "tail"],
       "default": "buffer",
       "description": "Which input field to parse: rendered screen text, full buffer (default), or tail string. Most providers use buffer because the screen alone loses scrollback."
+    },
+    "userBackgroundSgr": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Optional SGR background-color codes (e.g. \"48;5;233\") that mark a USER turn. Some TUIs (cursor-agent) render the user's submitted message and composer echo inside a colored box while rendering the assistant answer as a plain no-background line. After ANSI stripping both are bare lines, so a permissive assistantPrefix grabs the user echo as an assistant bubble. When set, a raw line whose ANSI carries any of these background codes is classified as a user turn regardless of its stripped text, leaving the plain assistant answer as the only assistant bubble. Checked against the raw pre-strip line before prefix matching."
     }
   }
 }

package/src/providers/spec/native-history-executor.ts

@@ -357,11 +357,28 @@ function executeSqlite(src: NativeHistorySqliteSource, input: NativeHistoryInput
                 const sessionFloorSeconds = typeof input.sessionStartedAtMs === 'number'
                     ? Math.floor(input.sessionStartedAtMs / 1000)
                     : 0;
+                // Workspace the daemon spawned this CLI in. A store that keeps
+                // the session directory as a column (opencode's
+                // `session.directory`) can scope the newest-session pick to this
+                // workspace so two concurrent sessions in different workspaces
+                // don't cross-bind — the time floor alone can't disambiguate
+                // when the OTHER workspace's session was touched more recently.
+                const workspaceHint = typeof input.workspace === 'string' ? input.workspace : '';
                 const stmt = db.prepare(src.session_query);
+                // Binding tiers, tried in order (better-sqlite3 throws when the
+                // statement declares params the bind object/args don't satisfy,
+                // so each tier is guarded):
+                //   1. named { floor, workspace } — spec references @floor/@workspace
+                //   2. positional (floor) — legacy single-`?` floor specs
+                //   3. no-arg — specs with no bound params
                 try {
-                    sessionRow = stmt.get(sessionFloorSeconds);
+                    sessionRow = stmt.get({ floor: sessionFloorSeconds, workspace: workspaceHint });
                 } catch {
-                    sessionRow = stmt.get();
+                    try {
+                        sessionRow = stmt.get(sessionFloorSeconds);
+                    } catch {
+                        sessionRow = stmt.get();
+                    }
                 }
             } catch { return ''; }
             if (!sessionRow) return '';
@@ -406,12 +423,18 @@ function executeSqlite(src: NativeHistorySqliteSource, input: NativeHistoryInput
         }
         if (messages.length === 0) return null;
 
+        // Surface the workspace at the result level too (mirrors the jsonl
+        // session_meta path) so callers that read result.workspace — not just
+        // per-message workspace — see the session directory.
+        const resultWorkspace = messages.find(m => m.workspace)?.workspace;
+
         return {
             messages,
             providerSessionId: sessionId,
             sourcePath: resolved,
             sourceMtimeMs: mtime,
             nativeHistoryCoverage: 'full',
+            ...(resultWorkspace ? { workspace: resultWorkspace } : {}),
         };
     } finally {
         try { db.close(); } catch { /* ignore */ }
@@ -1015,9 +1038,17 @@ function projectMessages(record: any, map: NativeHistoryMessageMap, index: numbe
         }
     }
 
+    // Per-message workspace: sqlite sources have no `session_meta` record to
+    // carry the cwd (jsonl-only), so a spec can SELECT the session directory
+    // into each row and map it here. The downstream hasSafeNativeHistoryMapping
+    // guard needs it to accept a workspace-scoped read (no provider session id
+    // captured from the TUI); without it every assistant bubble is dropped.
+    const workspaceRaw = map.workspace ? jsonPathGet(record, map.workspace) : undefined;
+    const workspace = typeof workspaceRaw === 'string' && workspaceRaw.trim() ? workspaceRaw.trim() : undefined;
+
     const contentRaw = jsonPathGet(record, map.content);
     const content = cleanContent(stringifyContent(contentRaw), map);
-    if (content) out.push({ role, content, receivedAt, kind });
+    if (content) out.push(workspace ? { role, content, receivedAt, kind, workspace } : { role, content, receivedAt, kind });
 
     // Block-nested tool bubbles are ordered just after the text bubble of the
     // same record by nudging receivedAt forward a millisecond per bubble, so a

package/src/providers/spec/types.ts

@@ -135,6 +135,19 @@ export interface NativeHistoryMessageMap {
     content_unwrap?: string[];
     timestamp_ms?: string;
     kind?: string;
+    /**
+     * Optional jsonpath-lite path to a per-message workspace/cwd value. sqlite
+     * sources have no `session_meta` record to carry the workspace (that's a
+     * jsonl-only convention), so a native-source provider whose store keeps the
+     * session directory as a column (e.g. opencode's `session.directory`) can
+     * SELECT it into each message row and map it here. The read pipeline's
+     * `hasSafeNativeHistoryMapping` guard requires each message to declare a
+     * workspace when the read is workspace-scoped (no provider session id was
+     * captured from the TUI); without it a workspace-only lookup fails closed
+     * and every assistant bubble is dropped. Absent → messages carry no
+     * workspace (jsonl still fills it from session_meta).
+     */
+    workspace?: string;
     /**
      * Declarative tool-bubble extraction. Without it the executor only emits
      * the text-bearing parts of each record, so a turn that is purely a tool