@adhdev/daemon-core 0.9.82-rc.539 → 0.9.82-rc.540

package/dist/providers/approval-utils.d.ts

@@ -1,5 +1,6 @@
 import type { ProviderModule } from './contracts.js';
 export declare function normalizeApprovalLabel(value: string): string;
+export declare function isNegativeApprovalLabel(value: string): boolean;
 /**
  * True when any of the given button labels reads as a decline/negative option
  * (No / Deny / Cancel / Skip / …). Used as the second half of an approval-modal

package/package.json

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

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

@@ -421,6 +421,49 @@ export class ProviderCliAdapter implements CliAdapter {
         return this.providerOwnsTranscript() && this.provider.transcriptContext === 'full';
     }
 
+    /**
+     * MULTI-TURN TRANSCRIPT FLICKER (kimi): whether this provider reconstructs
+     * its ENTIRE transcript from the rendered PTY buffer on every read and so
+     * must be fed the full accumulated buffer rather than the current-turn slice.
+     *
+     * The turn-scope slice (buildCliParseInput → sliceFromOffset(accumulatedBuffer,
+     * scope.bufferStart)) exists so a mid-turn parse only sees the fresh output of
+     * the CURRENT turn — correct for status/streaming detection and for providers
+     * that reassemble prior history elsewhere (native-history on disk, or a
+     * provider-owned full-context parser). But a pure-PTY provider with NO native
+     * history and NO provider transcript authority, whose tui parser walks the
+     * whole buffer for its per-turn bubble markers (kimi's `●`/`✨` bullets),
+     * loses every prior turn's bubbles the instant a new turn starts: bufferStart
+     * jumps to the new turn's offset, the slice drops turns 1..n-1, and until the
+     * new turn emits its first bullet parseSession returns zero messages — so
+     * read_chat momentarily goes EMPTY and the dashboard clears every bubble,
+     * then restores them once output arrives (the observed flicker).
+     *
+     * accumulatedBuffer is the terminal-EMULATED rendered scrollback (overwritten
+     * cells collapsed), not raw PTY append, so parsing it in full yields the clean
+     * cumulative transcript with no repaint duplication. Scope to exactly this
+     * class (tui transcriptPty scope 'buffer' + no native history + not
+     * provider-owned) so no other provider's turn-scoped parse changes.
+     */
+    private parsesFullPtyTranscriptFromBuffer(): boolean {
+        if (this.providerOwnsTranscript()) return false;
+        // nativeHistory is a top-level provider field not surfaced on
+        // CliProviderModule; read it via the same structural cast used for `tui`.
+        if ((this.provider as { nativeHistory?: unknown }).nativeHistory) return false;
+        const transcriptPty = (this.provider.tui as { transcriptPty?: { scope?: unknown } } | undefined)?.transcriptPty;
+        return transcriptPty?.scope === 'buffer';
+    }
+
+    /**
+     * The turn scope to feed the transcript parser. Normally the live turn scope
+     * (so a mid-turn parse is current-turn-only), but null (= full accumulated
+     * buffer) for pure-PTY full-transcript providers so prior turns never drop.
+     * See {@link parsesFullPtyTranscriptFromBuffer}.
+     */
+    private transcriptParseScope(): TurnParseScope | null {
+        return this.parsesFullPtyTranscriptFromBuffer() ? null : this.engine.currentTurnScope;
+    }
+
     private getIdleFinishConfirmMs(): number {
         return this.timeouts.idleFinishConfirm;
     }
@@ -918,7 +961,10 @@ export class ProviderCliAdapter implements CliAdapter {
             baseMessages: [],
             partialResponse: this.responseBuffer,
             isWaitingForResponse: this.engine.isWaitingForResponse,
-            scope: this.engine.currentTurnScope,
+            // Full accumulated buffer (scope null) for pure-PTY full-transcript
+            // providers so prior turns' bubbles never drop when a new turn starts;
+            // the current-turn slice otherwise. See parsesFullPtyTranscriptFromBuffer.
+            scope: this.transcriptParseScope(),
             runtimeSettings: this.runtimeSettings,
             spawnAt: this.spawnAt,
         });

package/src/commands/chat-commands-write.ts

@@ -8,7 +8,7 @@ import type { CommandResult, CommandHelpers } from './handler.js';
 import type { CliAdapter } from '../cli-adapter-types.js';
 import { normalizeInputEnvelope, type InputEnvelope, type ProviderModule, type ProviderScripts } from '../providers/contracts.js';
 import { assertProviderSupportsDeclaredInput, assertTextOnlyInput } from '../providers/provider-input-support.js';
-import { pickApprovalButton } from '../providers/approval-utils.js';
+import { pickApprovalButton, isNegativeApprovalLabel } from '../providers/approval-utils.js';
 import { LOG } from '../logging/logger.js';
 import {
     READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS,
@@ -773,7 +773,12 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
             buttonIndex = buttons.findIndex(b => b.toLowerCase().includes(btnLower));
         }
         if (buttonIndex < 0 && (action === 'reject' || action === 'deny')) {
-            buttonIndex = buttons.findIndex(b => /deny|reject|no/i.test(b));
+            // Use the canonical negative detector (no|deny|reject|cancel|skip|exit|stop)
+            // rather than a narrow /deny|reject|no/ — cursor's decline button is
+            // "Skip", which the old regex missed, so reject reported "did not match
+            // any visible button" and left the modal wedged. This mirrors the
+            // negative guard pickApprovalButton already applies on the approve side.
+            buttonIndex = buttons.findIndex(b => isNegativeApprovalLabel(b));
         }
         if (buttonIndex < 0 && (action === 'always' || /always/i.test(button))) {
             buttonIndex = buttons.findIndex(b => /always/i.test(b));

package/src/providers/approval-utils.ts

@@ -24,7 +24,7 @@ export function normalizeApprovalLabel(value: string): string {
         .trim();
 }
 
-function isNegativeApprovalLabel(value: string): boolean {
+export function isNegativeApprovalLabel(value: string): boolean {
     const label = normalizeApprovalLabel(value);
     return /^(no|deny|reject|cancel|skip|exit|stop)\b/.test(label)
         || /\bwithout\b/.test(label)
@@ -104,18 +104,45 @@ export function pickApprovalButton(
     const normalizedButtons = labels.map((label) => normalizeApprovalLabel(label));
     const hints = getApprovalPositiveHints(provider);
 
-    for (const hint of hints) {
-        const exactIndex = normalizedButtons.findIndex((label, index) => label === hint && !isNegativeApprovalLabel(labels[index]));
-        if (exactIndex >= 0) return { index: exactIndex, label: labels[exactIndex] };
+    // Match QUALITY dominates hint ORDER: try the strongest tier (exact) across
+    // ALL hints before falling to prefix, and prefix before the weakest tier
+    // (substring). The old code exhausted all three tiers per-hint, so a weak
+    // substring hit on an early hint beat a strong prefix hit on a later hint.
+    //
+    // Live cursor defect: the 'Not in allowlist: git status' modal offers
+    //   ["Run (once)", "Add Shell(git status) to allowlist?", "Run Everything", "Skip"]
+    // with hints ["trust","allow",…,"run","yes"]. `allow` (earlier) substring-hit
+    // "add shell … to allow-LIST" → index 1 (a scope-broadening grant that does
+    // NOT execute the command) before `run` (later) prefix-hit "run once" → the
+    // correct least-permissive affirmative at index 0. Approve then wedged.
+    //
+    // Substring is further constrained to WHOLE-WORD hits so `allow` matches
+    // "allow all edits" but never "allowlist" — a hint buried inside a larger
+    // word (allowlist, disallow, runtime) is almost never the intended button.
+    const includesWord = (label: string, hint: string): boolean => {
+        if (!label.includes(hint)) return false;
+        const re = new RegExp(`(?:^|\\s)${hint.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\s|$)`);
+        return re.test(label);
+    };
 
-        const prefixIndex = normalizedButtons.findIndex((label, index) => label.startsWith(hint) && !isNegativeApprovalLabel(labels[index]));
-        if (prefixIndex >= 0) return { index: prefixIndex, label: labels[prefixIndex] };
-
-        const includeIndex = normalizedButtons.findIndex((label, index) => label.includes(hint) && !isNegativeApprovalLabel(labels[index]));
-        if (includeIndex >= 0) return { index: includeIndex, label: labels[includeIndex] };
-    }
+    const findMatch = (
+        predicate: (label: string, hint: string) => boolean,
+    ): { index: number; label: string } | null => {
+        for (const hint of hints) {
+            const idx = normalizedButtons.findIndex(
+                (label, index) => predicate(label, hint) && !isNegativeApprovalLabel(labels[index]),
+            );
+            if (idx >= 0) return { index: idx, label: labels[idx] };
+        }
+        return null;
+    };
 
-    return { index: -1, label: '' };
+    return (
+        findMatch((label, hint) => label === hint)
+        ?? findMatch((label, hint) => label.startsWith(hint))
+        ?? findMatch((label, hint) => includesWord(label, hint))
+        ?? { index: -1, label: '' }
+    );
 }
 
 export function pickAutoApprovalButton(