@adhdev/daemon-core 0.9.82-rc.534 → 0.9.82-rc.536

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

@@ -51,6 +51,19 @@ export interface TranscriptPtySpec {
      * 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.
+     *
+     * Value-agnostic mode: the sentinel "*" (or "48;*" / "bg") matches ANY
+     * background-color SGR — 256-color `48;5;<n>` OR truecolor `48;2;<r>;<g>;<b>`
+     * — instead of an allowlist of exact color numbers. This is the robust form:
+     * the earlier allowlist bug recurred every time a TUI changed its exact box
+     * color (cursor `48;5;233` guess, opencode rc.531), because a hard-coded
+     * color that no longer matched let the boxed user echo fall through to the
+     * permissive assistantPrefix. The sentinel keys off the *presence* of a
+     * background-color param group — the structural signal of a boxed turn —
+     * so a genuine assistant line (no background SGR) is still classified
+     * assistant. Chrome patterns are filtered BEFORE this check, so bg-colored
+     * chrome (e.g. the "→ Add a follow-up" composer footer) is already excluded
+     * and does not become a spurious user bubble.
      */
     userBackgroundSgr?: string[];
 }

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

@@ -76,6 +76,23 @@ export interface NativeHistoryJsonlSource {
     message_filter?: {
         where: string;
     };
+    /**
+     * Fallback workspace attribution when the transcript carries no
+     * `session_meta` cwd record. Some stores (cursor-agent) do NOT write a
+     * session_meta line and keep the workspace only in the on-disk project-slug
+     * directory (`~/.cursor/projects/<slug>/…`), which is a lossy, sometimes
+     * truncated+hashed transform of the real path and cannot be reversed. When
+     * this flag is set and no session_meta workspace was found, the executor
+     * stamps `input.workspace` onto each message — but ONLY after confirming the
+     * resolved file actually lives under that workspace's project slug (a path
+     * segment matches the input workspace's cursor/claude slug, allowing for
+     * cursor's length-truncation). This closes the first-turn read gap (before a
+     * provider session id is pinned, the downstream hasSafeNativeHistoryMapping
+     * guard needs a per-message workspace) without risking cross-workspace
+     * aliasing: a slug mismatch leaves the workspace unset and the read fails
+     * closed as before.
+     */
+    workspace_from_input?: boolean;
     message_map: NativeHistoryMessageMap;
 }
 export interface NativeHistorySqliteSource {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.534",
+  "version": "0.9.82-rc.536",
   "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.534",
-    "@adhdev/session-host-core": "0.9.82-rc.534",
+    "@adhdev/mesh-shared": "0.9.82-rc.536",
+    "@adhdev/session-host-core": "0.9.82-rc.536",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/cli-adapters/cli-state-engine.ts

@@ -1206,7 +1206,19 @@ export class CliStateEngine {
         const detectFn = typeof this.transport.runDetectStatus === 'function'
             ? () => this.transport.runDetectStatus!(snap.recentOutputBuffer)
             : () => this.runDetectStatus(snap);
-        const latestStatus = detectFn() || this.currentStatus;
+        // Only a POSITIVE `generating` verdict from the live detector defers the
+        // finish. A null verdict is "no cue matched", NOT "still generating" — for
+        // a provider whose only idle cue is a composer placeholder (opencode's
+        // `Ask anything`) that can momentarily fall out of the captured frame while
+        // the TUI redraws its status chip, detectStatus returns null under the
+        // manifest's `onNoMatch: preserve-last` policy. Collapsing that null to
+        // `this.currentStatus` (which is `generating` while the hold is armed) made
+        // the finish defer on EVERY tick, so the completion never fired and the
+        // session wedged in `generating` forever even though its assistant reply had
+        // already landed in native-history. Treat null as "no evidence to defer" and
+        // let the idle-finish proceed; a real in-flight turn still re-reports a
+        // positive `generating` here and defers as before.
+        const latestStatus = detectFn();
         if (latestStatus === 'generating') {
             this.evaluateSettled(snap);
             return true;

package/src/providers/provider-loader.ts

@@ -1339,13 +1339,24 @@ export class ProviderLoader {
         candidates.push(path.join(providerDir, 'specs', 'default.json'));
         candidates.push(path.join(providerDir, 'spec.json'));
         const specPath = candidates.find((p: string) => fs.existsSync(p));
+        // native_history block, resolved from either the separate spec file
+        // (snake_case `native_history`) or — for v1-manifest-only providers that
+        // ship no specs/*.json — the inline camelCase `nativeHistory` on the
+        // manifest itself. The separate spec file wins when both exist. Without
+        // the v1-manifest fallback, a provider whose ONLY declaration is an
+        // inline `nativeHistory.source` (e.g. opencode's sqlite source) never got
+        // its `scripts.readNativeHistory` wired: the whole block was gated on
+        // `specPath`, so read_chat returned native-unavailable, the assistant
+        // reply (only in the on-disk store, never in the PTY snapshot) was
+        // dropped, providerSessionId stayed null, and the session wedged in
+        // `generating` because no native completion evidence ever arrived.
+        let nh: any | undefined;
         if (specPath) {
           // Hand the resolved spec path off to route.ts via a hidden field
           // so the routing layer doesn't have to repeat the candidate walk.
           (resolved as any)._resolvedSpecPath = specPath;
           // Extract control_bar + native_history directly from the JSON header.
           let specControls: any[] | undefined;
-          let nh: any | undefined;
           try {
             const rawSpec = JSON.parse(fs.readFileSync(specPath, 'utf8'));
             specControls = rawSpec.control_bar;
@@ -1382,44 +1393,56 @@ export class ProviderLoader {
               }
             }
           }
-          if (nh) {
-            let reader: ((input: any) => any) | null = null;
-            let format = 'spec';
-
-            if (nh.source) {
-              format = `spec-${nh.source.kind}`;
-              reader = (input: any) => executeNativeHistory(nh, input);
-            } else if (nh.override_path) {
-              const overrideFile = path.resolve(providerDir, nh.override_path);
-              if (fs.existsSync(overrideFile)) {
-                try {
-                  registerProviderScriptRootSafely(path.dirname(path.dirname(providerDir)));
-                  delete require.cache[require.resolve(overrideFile)];
-                  // eslint-disable-next-line @typescript-eslint/no-var-requires
-                  const mod = require(overrideFile);
-                  const fn = typeof mod === 'function' ? mod : (mod && typeof mod.default === 'function' ? mod.default : null);
-                  if (fn) {
-                    format = 'spec-override';
-                    reader = (input: any) => fn(input);
-                  }
-                } catch { /* fall through — leave native unavailable */ }
-              }
-            } else if (nh.reader) {
-              const dispatch = createNativeHistoryDispatcher(nh.reader as ReaderId);
-              format = nh.reader;
-              reader = (input: any) => dispatch(input);
+        }
+        // Fall back to the v1 manifest's inline `nativeHistory` (camelCase) when
+        // no separate spec file provided a `native_history` block. Only treat it
+        // as a declarative reader source when it actually carries source/
+        // override_path/reader — a bare `nativeHistory` marker that only names
+        // `scripts.readSession` (claude/codex/antigravity, whose real reader is
+        // wired from their specs/*.json) must not be mistaken for one.
+        if (!nh) {
+          const inlineNh = (base as any)?.nativeHistory || (resolved as any)?.nativeHistory;
+          if (inlineNh && (inlineNh.source || inlineNh.override_path || inlineNh.reader)) {
+            nh = inlineNh;
+          }
+        }
+        if (nh) {
+          let reader: ((input: any) => any) | null = null;
+          let format = 'spec';
+
+          if (nh.source) {
+            format = `spec-${nh.source.kind}`;
+            reader = (input: any) => executeNativeHistory(nh, input);
+          } else if (nh.override_path) {
+            const overrideFile = path.resolve(providerDir, nh.override_path);
+            if (fs.existsSync(overrideFile)) {
+              try {
+                registerProviderScriptRootSafely(path.dirname(path.dirname(providerDir)));
+                delete require.cache[require.resolve(overrideFile)];
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const mod = require(overrideFile);
+                const fn = typeof mod === 'function' ? mod : (mod && typeof mod.default === 'function' ? mod.default : null);
+                if (fn) {
+                  format = 'spec-override';
+                  reader = (input: any) => fn(input);
+                }
+              } catch { /* fall through — leave native unavailable */ }
             }
+          } else if (nh.reader) {
+            const dispatch = createNativeHistoryDispatcher(nh.reader as ReaderId);
+            format = nh.reader;
+            reader = (input: any) => dispatch(input);
+          }
 
-            if (reader) {
-              resolved.scripts = { ...(resolved.scripts || {}) };
-              (resolved.scripts as any).readNativeHistory = reader;
-              (resolved as any).nativeHistory = {
-                format,
-                watchPath: undefined,
-                scripts: { readSession: 'readNativeHistory' },
-                mode: 'native-source',
-              };
-            }
+          if (reader) {
+            resolved.scripts = { ...(resolved.scripts || {}) };
+            (resolved.scripts as any).readNativeHistory = reader;
+            (resolved as any).nativeHistory = {
+              format,
+              watchPath: undefined,
+              scripts: { readSession: 'readNativeHistory' },
+              mode: 'native-source',
+            };
           }
         }
       } catch {

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

@@ -58,6 +58,19 @@ export interface TranscriptPtySpec {
      * 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.
+     *
+     * Value-agnostic mode: the sentinel "*" (or "48;*" / "bg") matches ANY
+     * background-color SGR — 256-color `48;5;<n>` OR truecolor `48;2;<r>;<g>;<b>`
+     * — instead of an allowlist of exact color numbers. This is the robust form:
+     * the earlier allowlist bug recurred every time a TUI changed its exact box
+     * color (cursor `48;5;233` guess, opencode rc.531), because a hard-coded
+     * color that no longer matched let the boxed user echo fall through to the
+     * permissive assistantPrefix. The sentinel keys off the *presence* of a
+     * background-color param group — the structural signal of a boxed turn —
+     * so a genuine assistant line (no background SGR) is still classified
+     * assistant. Chrome patterns are filtered BEFORE this check, so bg-colored
+     * chrome (e.g. the "→ Add a follow-up" composer footer) is already excluded
+     * and does not become a spurious user bubble.
      */
     userBackgroundSgr?: string[]
 }
@@ -223,7 +236,16 @@ export function buildParseSessionFromTui(spec: ParseSessionTuiSpec): (input: any
     const userBgList = Array.isArray(spec.transcriptPty.userBackgroundSgr)
         ? spec.transcriptPty.userBackgroundSgr.map(s => String(s).trim()).filter(Boolean)
         : []
+    // Value-agnostic sentinel: "*" / "48;*" / "bg" matches ANY background-color
+    // SGR (256-color `48;5;<n>` OR truecolor `48;2;<r>;<g>;<b>`) as the boxed-user
+    // signal, instead of an allowlist of exact colors that breaks whenever a TUI
+    // changes its box color. The param group must sit inside an SGR run terminated
+    // by `m`; 3-digit color indices / channels are matched structurally.
+    const ANY_BG_SENTINELS = new Set(['*', '48;*', 'bg', '48'])
     const userBgRes = userBgList.map(code => {
+        if (ANY_BG_SENTINELS.has(code.toLowerCase())) {
+            return new RegExp('\\x1b\\[[0-9;]*\\b48;(?:5;\\d{1,3}|2;\\d{1,3};\\d{1,3};\\d{1,3})[0-9;]*m')
+        }
         // 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.

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

@@ -82,7 +82,7 @@
     "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."
+      "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 (chrome patterns are filtered first, so bg-colored chrome is not misclassified as a user turn).\n\nValue-agnostic sentinel: the entry \"*\" (also \"48;*\" / \"bg\") matches ANY background-color SGR — 256-color `48;5;<n>` OR truecolor `48;2;<r>;<g>;<b>` — instead of an exact-color allowlist. Prefer \"*\": a hard-coded color re-breaks every time the TUI changes its box color (cursor \"48;5;233\", opencode), whereas \"*\" keys off the structural presence of a bg box. A genuine assistant line carries no background SGR, so it still classifies as assistant."
     }
   }
 }

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

@@ -106,7 +106,12 @@ function executeJsonl(src: NativeHistoryJsonlSource, input: NativeHistoryInput):
     const mtime = safeMtimeMs(sourcePath);
     const lines = readJsonlLines(sourcePath);
     if (lines.length === 0) return null;
-    const transcriptWorkspace = readSessionMetaWorkspace(lines);
+    // Prefer an in-transcript session_meta cwd; fall back to the input workspace
+    // only when the spec opts in AND the resolved file lives under that
+    // workspace's project slug (cursor-agent writes no session_meta and hides the
+    // workspace in the lossy on-disk slug — see workspace_from_input).
+    const transcriptWorkspace = readSessionMetaWorkspace(lines)
+        ?? (src.workspace_from_input ? workspaceFromInputIfSlugMatches(sourcePath, input) : undefined);
 
     // session id: filename uuid or extracted from first record
     let providerSessionId: string | undefined;
@@ -248,6 +253,50 @@ function readSessionMetaWorkspace(lines: any[]): string | undefined {
     return undefined;
 }
 
+/**
+ * Return `input.workspace` when the resolved transcript file provably lives
+ * under that workspace's project-slug directory, else undefined.
+ *
+ * cursor-agent stores transcripts at `~/.cursor/projects/<slug>/…` where
+ * `<slug>` is the workspace realpath with every non-`[A-Za-z0-9_-]` char turned
+ * into `-` (the same transform claude uses, minus the leading dash from the root
+ * `/`). Long slugs are truncated and suffixed with a short hash
+ * (`<prefix>-<7hex>`). The transform is lossy, so we cannot reconstruct the real
+ * path from the slug — but we CAN verify a candidate workspace matches it. We
+ * compute the workspace's slug (both the claude form and the leading-`/`-stripped
+ * cursor form) and accept when a path segment of the file equals it OR is a
+ * truncated `<prefix>-<hash>` of it. On match the caller stamps the KNOWN real
+ * `input.workspace`, so downstream workspace comparison (path.resolve-based)
+ * still works; on mismatch we return undefined and the read fails closed rather
+ * than aliasing another workspace's transcript.
+ */
+function workspaceFromInputIfSlugMatches(sourcePath: string, input: NativeHistoryInput): string | undefined {
+    const wsRaw = typeof input.workspace === 'string' ? input.workspace.trim() : '';
+    if (!wsRaw) return undefined;
+    let wsReal = wsRaw;
+    try { wsReal = fs.realpathSync(wsRaw); } catch { /* keep raw */ }
+    const slugs = new Set<string>();
+    for (const w of [wsReal, wsRaw]) {
+        if (!w) continue;
+        slugs.add(claudeProjectDirName(w));            // "-Users-…" (leading dash)
+        slugs.add(claudeProjectDirName(w.replace(/^\/+/, ''))); // cursor form, no leading dash
+    }
+    const segments = sourcePath.split(path.sep);
+    for (const seg of segments) {
+        if (!seg) continue;
+        for (const slug of slugs) {
+            if (!slug) continue;
+            if (seg === slug) return wsRaw;
+            // Truncated+hashed cursor slug: `<prefix>-<7+hex>` where prefix is a
+            // leading portion of the full slug. Require a non-trivial prefix so a
+            // short common head can't false-match an unrelated workspace.
+            const m = seg.match(/^(.*)-[0-9a-f]{6,}$/);
+            if (m && m[1] && m[1].length >= 8 && slug.startsWith(m[1])) return wsRaw;
+        }
+    }
+    return undefined;
+}
+
 function readJsonlLines(p: string): any[] {
     let text: string;
     try { text = fs.readFileSync(p, 'utf8'); } catch { return []; }

package/src/providers/spec/types.ts

@@ -95,6 +95,23 @@ export interface NativeHistoryJsonlSource {
     session_id_from?: 'filename_uuid' | 'first_record';
     session_id_path?: string;
     message_filter?: { where: string };
+    /**
+     * Fallback workspace attribution when the transcript carries no
+     * `session_meta` cwd record. Some stores (cursor-agent) do NOT write a
+     * session_meta line and keep the workspace only in the on-disk project-slug
+     * directory (`~/.cursor/projects/<slug>/…`), which is a lossy, sometimes
+     * truncated+hashed transform of the real path and cannot be reversed. When
+     * this flag is set and no session_meta workspace was found, the executor
+     * stamps `input.workspace` onto each message — but ONLY after confirming the
+     * resolved file actually lives under that workspace's project slug (a path
+     * segment matches the input workspace's cursor/claude slug, allowing for
+     * cursor's length-truncation). This closes the first-turn read gap (before a
+     * provider session id is pinned, the downstream hasSafeNativeHistoryMapping
+     * guard needs a per-message workspace) without risking cross-workspace
+     * aliasing: a slug mismatch leaves the workspace unset and the read fails
+     * closed as before.
+     */
+    workspace_from_input?: boolean;
     message_map: NativeHistoryMessageMap;
 }