@adhdev/daemon-core 0.9.82-rc.535 → 0.9.82-rc.537

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.535",
+  "version": "0.9.82-rc.537",
   "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.535",
-    "@adhdev/session-host-core": "0.9.82-rc.535",
+    "@adhdev/mesh-shared": "0.9.82-rc.537",
+    "@adhdev/session-host-core": "0.9.82-rc.537",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/cli-adapters/provider-cli-adapter.ts

@@ -356,6 +356,13 @@ export class ProviderCliAdapter implements CliAdapter {
         const currentScreenLooksIdle = /(?:^|\n|\r)\s*[❯›>]\s*(?:Try\s+["“][^\n\r"”]+["”])?\s*(?:\n|\r|$)/.test(screenText)
             && !activeScreenPattern.test(screenText);
         if (staleSnapshotLooksActive && currentScreenLooksIdle) return screenText;
+        // When the current frame already resolves to a settled/idle prompt via the
+        // provider's own detector, do NOT graft an older snapshot onto it: the
+        // older frame can carry a dead modal box (e.g. cursor-agent's leftover
+        // "Workspace Trust Required" rows) that re-fires `waiting_approval` at the
+        // appended tail and wedges the turn in `generating`. A truly idle current
+        // screen needs no historical supplement.
+        if (this.runDetectStatus(screenText) === 'idle') return screenText;
         if (currentSnapshot.length >= lastSnapshot.length) return screenText;
         // Terminal screen reads can miss a just-rendered completed Hermes box while
         // the normalized snapshot captured during output still has it. Feed both

package/src/providers/sdk/v1/builders/cli/detect-status.ts

@@ -227,6 +227,108 @@ function modalMatches(spec: ModalSpec, input: CliStatusInput): boolean {
   return false;
 }
 
+/**
+ * Index (line number) of the last line in `screenText` that carries a modal
+ * cue — question line, question variant, or a button-block label line — or -1
+ * if none. Used to detect a *stale* modal box: some CLIs (e.g. cursor-agent's
+ * "Workspace Trust Required" prompt) never clear their box rows after the user
+ * answers. The redraw that replaces the modal with the idle composer is shorter
+ * than the box, so the top modal rows linger in the terminal grid. Without a
+ * spatial check, the unscoped whole-screen `modalMatches` keeps firing
+ * `waiting_approval` forever and the session wedges in `starting` — the
+ * startup gate never releases because `detectStatus` never returns `idle`.
+ */
+function lastModalCueLine(spec: ModalSpec, screenText: string): number {
+  if (!screenText) return -1;
+  const lines = screenText.split('\n');
+  const question = compile(spec.questionPattern, spec.questionFlags ?? 'i');
+  const variants = (spec.questionVariants ?? []).map((v) => compile(v.regex, v.flags ?? 'i'));
+  const buttonFlags = spec.buttonFlags && spec.buttonFlags.includes('m')
+    ? spec.buttonFlags
+    : `${spec.buttonFlags ?? ''}m`;
+  const buttonRe = compile(spec.buttonPattern, buttonFlags);
+  let last = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    question.lastIndex = 0;
+    if (question.test(line)) { last = i; continue; }
+    if (variants.some((re) => { re.lastIndex = 0; return re.test(line); })) { last = i; continue; }
+    buttonRe.lastIndex = 0;
+    if (buttonRe.test(line)) { last = i; continue; }
+  }
+  return last;
+}
+
+/**
+ * True when the modal cue is *stale* — a leftover box the CLI failed to clear —
+ * because the live idle composer has repainted BELOW it.
+ *
+ * The discriminator is spatial, so a live modal (whose own selection cursor /
+ * button block can incidentally match a settled-prompt regex) is NOT mistaken
+ * for stale:
+ *
+ *   - A settled-prompt cue must match strictly BELOW the last modal cue line.
+ *   - AND at least one non-blank line between them is neither a modal cue nor
+ *     part of the settled-prompt match itself (the separator prose).
+ *
+ * A live modal renders its question + button block FLUSH against its own
+ * composer/selection cursor (no intervening prose). A stale box, by contrast,
+ * has the CLI's welcome banner / follow-up hint / mode footer repainted between
+ * the leftover box rows and the live composer. So the discriminator is: a
+ * settled-prompt cue matches strictly BELOW the last modal cue line AND at least
+ * one non-blank, non-modal line separates them. That separator is exactly the
+ * content a live modal never has between its buttons and its cursor, and it is
+ * robust to the terminal-snapshot append that can shuffle the tail window.
+ */
+function modalSupersededBySettledPrompt(
+  modalSpec: ModalSpec,
+  settledSpec: SettledPromptSpec | undefined,
+  settled: ReturnType<typeof compileSettledPromptMatchers> | null,
+  input: CliStatusInput,
+): boolean {
+  if (!settled || !settledSpec) return false;
+  if (settledSpec.scope === 'whole-screen') return false;
+  const screenText = input.screenText ?? '';
+  if (!screenText) return false;
+  const modalLine = lastModalCueLine(modalSpec, screenText);
+  if (modalLine < 0) return false;
+  const lines = screenText.split('\n');
+  const below = lines.slice(modalLine + 1);
+  if (below.length === 0) return false;
+  // A settled prompt (composer) must render somewhere below the modal box.
+  const belowText = below.join('\n');
+  if (!settled.prompt.test(belowText)) return false;
+  if (settled.footers.length > 0 && !settled.footers.every((f) => f.test(belowText))) return false;
+  // Require a real separator between the leftover box and the composer: a
+  // non-blank line that is neither a modal cue NOR part of the settled-prompt
+  // match itself. That separator is the CLI's welcome banner / follow-up hint /
+  // mode footer a stale box shows above the repainted composer. A live modal's
+  // selection cursor sits flush against its buttons with no such prose between
+  // them (and the cursor line, even if it matches the settled regex, is not a
+  // separator), so an active modal is never misread as stale.
+  const question = compile(modalSpec.questionPattern, modalSpec.questionFlags ?? 'i');
+  const variants = (modalSpec.questionVariants ?? []).map((v) => compile(v.regex, v.flags ?? 'i'));
+  const buttonFlags = modalSpec.buttonFlags && modalSpec.buttonFlags.includes('m')
+    ? modalSpec.buttonFlags
+    : `${modalSpec.buttonFlags ?? ''}m`;
+  const buttonRe = compile(modalSpec.buttonPattern, buttonFlags);
+  const isModalCueLine = (line: string): boolean => {
+    question.lastIndex = 0;
+    if (question.test(line)) return true;
+    if (variants.some((re) => { re.lastIndex = 0; return re.test(line); })) return true;
+    buttonRe.lastIndex = 0;
+    return buttonRe.test(line);
+  };
+  // A single-line settled regex would let a lone match count as its own line;
+  // test each below-line against the prompt regex on that line alone.
+  const settledPromptLineRe = compile(settledSpec.regex, (settledSpec.flags ?? 'm').includes('m') ? (settledSpec.flags ?? 'm') : `${settledSpec.flags ?? ''}m`);
+  const isSettledLine = (line: string): boolean => {
+    settledPromptLineRe.lastIndex = 0;
+    return settledPromptLineRe.test(line);
+  };
+  return below.some((line) => line.trim() !== '' && !isModalCueLine(line) && !isSettledLine(line));
+}
+
 // ─── Public builder ────────────────────────────────────────────────────
 
 const DEFAULT_ORDER: DispatchGroup[] = ['spinner', 'modal', 'settled-prompt'];
@@ -248,7 +350,12 @@ function evaluateGroup(
     }
     case 'modal': {
       if (!spec.modal) return null;
-      return modalMatches(spec.modal, input) ? 'waiting_approval' : null;
+      if (!modalMatches(spec.modal, input)) return null;
+      // A modal cue with the live composer repainted below it (in the settled
+      // prompt's own tail scope) is a stale box the CLI failed to clear — yield
+      // so settled-prompt/idle can win.
+      if (modalSupersededBySettledPrompt(spec.modal, spec.settledPrompt, compiled.settled, input)) return null;
+      return 'waiting_approval';
     }
     case 'settled-prompt': {
       if (!spec.settledPrompt || !compiled.settled) return null;

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;
 }