@adhdev/daemon-core 0.9.76-rc.66 → 0.9.76-rc.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.76-rc.66",
+  "version": "0.9.76-rc.68",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -35,6 +35,7 @@ import {
     normalizeScreenSnapshot,
     promptLikelyVisible,
     sanitizeTerminalText,
+    TerminalTranscriptAccumulator,
     type CliChatMessage,
     type CliProviderModule,
     type CliScriptInput,
@@ -195,8 +196,10 @@ export class ProviderCliAdapter implements CliAdapter {
     // ─── CLI Scripts (script-based parsing) ───
     private cliScripts: CliScripts;
     private runtimeSettings: Record<string, any> = {};
-    /** Full accumulated ANSI-stripped PTY output */
+    /** Full accumulated rendered PTY transcript for parser/readback use */
     private accumulatedBuffer: string = '';
+    /** Stateful rendered transcript accumulator; raw debug remains in accumulatedRawBuffer. */
+    private transcriptAccumulator = new TerminalTranscriptAccumulator();
     /** Full accumulated raw PTY output (with ANSI) */
     private accumulatedRawBuffer: string = '';
     /** Current visible terminal screen snapshot */
@@ -287,6 +290,7 @@ export class ProviderCliAdapter implements CliAdapter {
 
     private resetTerminalScreen(rows?: number, cols?: number): void {
         this.terminalScreen.reset(rows, cols);
+        this.transcriptAccumulator.reset();
         this.lastScreenText = '';
         this.lastScreenSnapshot = '';
         this.lastScreenChangeAt = 0;
@@ -634,6 +638,7 @@ export class ProviderCliAdapter implements CliAdapter {
     private handleOutput(rawData: string): void {
         this.terminalScreen.write(rawData);
         const cleanData = sanitizeTerminalText(rawData);
+        const renderedTranscript = this.transcriptAccumulator.append(rawData);
         const now = Date.now();
         const shouldReadScreen = this.shouldReadTerminalScreenSnapshot(now);
         const screenText = shouldReadScreen ? this.readTerminalScreenText(now) : this.lastScreenText;
@@ -680,15 +685,21 @@ export class ProviderCliAdapter implements CliAdapter {
             }
         }
 
-        // Rolling buffers
+        // Rolling parser/readback buffers. `accumulatedBuffer` and
+        // `recentOutputBuffer` intentionally use the rendered transcript state,
+        // not raw PTY append text, so overwritten CLI status/tool lines do not
+        // leak stale cells into read_chat / mesh_read_chat compact summaries.
         const prevRecentLen = this.recentOutputBuffer.length;
-        const prevAccumulatedLen = this.accumulatedBuffer.length;
         const prevAccumulatedRawLen = this.accumulatedRawBuffer.length;
-        this.recentOutputBuffer = appendBoundedText(this.recentOutputBuffer, cleanData, ProviderCliAdapter.MAX_RECENT_OUTPUT_BUFFER);
-        this.accumulatedBuffer = appendBoundedText(this.accumulatedBuffer, cleanData, ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        const nextAccumulatedBuffer = renderedTranscript.length <= ProviderCliAdapter.MAX_ACCUMULATED_BUFFER
+            ? renderedTranscript
+            : renderedTranscript.slice(-ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        const nextRecentOutputBuffer = nextAccumulatedBuffer.slice(-ProviderCliAdapter.MAX_RECENT_OUTPUT_BUFFER);
+        this.recentOutputBuffer = nextRecentOutputBuffer;
+        this.accumulatedBuffer = nextAccumulatedBuffer;
         this.accumulatedRawBuffer = appendBoundedText(this.accumulatedRawBuffer, rawData, ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
-        const droppedRecent = this.recordBoundedAppendDrop(prevRecentLen, cleanData.length, this.recentOutputBuffer.length);
-        const droppedClean = this.recordBoundedAppendDrop(prevAccumulatedLen, cleanData.length, this.accumulatedBuffer.length);
+        const droppedRecent = Math.max(0, prevRecentLen - this.recentOutputBuffer.length);
+        const droppedClean = Math.max(0, renderedTranscript.length - this.accumulatedBuffer.length);
         const droppedRaw = this.recordBoundedAppendDrop(prevAccumulatedRawLen, rawData.length, this.accumulatedRawBuffer.length);
         this.recentOutputDroppedChars += droppedRecent;
         this.accumulatedBufferDroppedChars += droppedClean;

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

@@ -173,32 +173,216 @@ export interface CliProviderModule {
 function stripAnsi(str: string): string {
     // eslint-disable-next-line no-control-regex
     return str
-        .replace(/\x1B\][^\x07]*\x07/g, '')
-        .replace(/\x1B\][\s\S]*?\x1B\\/g, '')
+        .replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, '')
         .replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, '')
-        .replace(/\x1B\[\d*[A-HJKSTfG]/g, ' ')
-        .replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '')
-        .replace(/  +/g, ' ');
+        .replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+}
+
+type SavedCursor = { row: number; col: number };
+
+function parseCount(params: string, fallback = 1): number {
+    const first = Number(String(params || '').split(';')[0] || fallback);
+    return Math.max(1, Number.isFinite(first) ? first : fallback);
+}
+
+function isCombiningMark(ch: string): boolean {
+    return /[\u0300-\u036F\u1AB0-\u1AFF\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/.test(ch);
+}
+
+function isWideCodePoint(ch: string): boolean {
+    const cp = ch.codePointAt(0) || 0;
+    return cp >= 0x1100 && (
+        cp <= 0x115F || cp === 0x2329 || cp === 0x232A ||
+        (cp >= 0x2E80 && cp <= 0xA4CF && cp !== 0x303F) ||
+        (cp >= 0xAC00 && cp <= 0xD7A3) ||
+        (cp >= 0xF900 && cp <= 0xFAFF) ||
+        (cp >= 0xFE10 && cp <= 0xFE19) ||
+        (cp >= 0xFE30 && cp <= 0xFE6F) ||
+        (cp >= 0xFF00 && cp <= 0xFF60) ||
+        (cp >= 0xFFE0 && cp <= 0xFFE6) ||
+        (cp >= 0x1F300 && cp <= 0x1FAFF)
+    );
+}
+
+/**
+ * Stateful, transcript-oriented terminal cell accumulator.
+ *
+ * CLI transcript parsing must not consume raw PTY append text for user-visible
+ * readback: CLIs rewrite prompts/status/tool lines with CR, BS, CSI cursor
+ * motion and erase-line. This accumulator preserves parser state across chunks
+ * and mutates rendered cells before exposing plain transcript text. It is a
+ * deliberately small terminal model for readback buffers; live UI rendering still
+ * uses TerminalScreen's ghostty/xterm backend.
+ */
+export class TerminalTranscriptAccumulator {
+    private lines: string[][] = [[]];
+    private row = 0;
+    private col = 0;
+    private savedCursor: SavedCursor | null = null;
+    private pendingEscape = '';
+
+    append(data: string): string {
+        const input = this.pendingEscape + String(data || '');
+        this.pendingEscape = '';
+        for (let i = 0; i < input.length; i += 1) {
+            let ch = input[i];
+            if (ch === '\x1B') {
+                const consumed = this.consumeEscape(input.slice(i));
+                if (consumed === 0) {
+                    this.pendingEscape = input.slice(i);
+                    break;
+                }
+                i += consumed - 1;
+                continue;
+            }
+            const cp = input.codePointAt(i);
+            if (cp && cp > 0xFFFF) {
+                ch = String.fromCodePoint(cp);
+                i += 1;
+            }
+            this.writeControlOrChar(ch);
+        }
+        return this.getText();
+    }
+
+    reset(): void {
+        this.lines = [[]];
+        this.row = 0;
+        this.col = 0;
+        this.savedCursor = null;
+        this.pendingEscape = '';
+    }
+
+    getText(): string {
+        return this.lines.map(line => line.join('').replace(/[ \t]+$/g, '')).join('\n');
+    }
+
+    private ensureRow(row = this.row): void {
+        while (this.lines.length <= row) this.lines.push([]);
+    }
+
+    private writeControlOrChar(ch: string): void {
+        if (ch === '\r') {
+            this.col = 0;
+            return;
+        }
+        if (ch === '\n') {
+            this.row += 1;
+            this.col = 0;
+            this.ensureRow();
+            return;
+        }
+        if (ch === '\b') {
+            this.col = Math.max(0, this.col - 1);
+            return;
+        }
+        if (ch < ' ' || ch === '\x7F') return;
+
+        this.ensureRow();
+        const line = this.lines[this.row];
+        if (isCombiningMark(ch) && this.col > 0) {
+            line[this.col - 1] = `${line[this.col - 1] || ''}${ch}`;
+            return;
+        }
+        while (line.length < this.col) line.push(' ');
+        line[this.col] = ch;
+        this.col += isWideCodePoint(ch) ? 2 : 1;
+    }
+
+    private consumeEscape(seq: string): number {
+        if (seq.length < 2) return 0;
+        const next = seq[1];
+        if (next === '7') {
+            this.savedCursor = { row: this.row, col: this.col };
+            return 2;
+        }
+        if (next === '8') {
+            if (this.savedCursor) {
+                this.row = this.savedCursor.row;
+                this.col = this.savedCursor.col;
+                this.ensureRow();
+            }
+            return 2;
+        }
+        if (next === ']') {
+            const bel = seq.indexOf('\x07', 2);
+            const st = seq.indexOf('\x1B\\', 2);
+            const end = bel >= 0 && (st < 0 || bel < st) ? bel + 1 : st >= 0 ? st + 2 : 0;
+            return end;
+        }
+        if (next === '[') {
+            const match = seq.match(/^\x1B\[([0-?]*)([ -/]*)([@-~])/);
+            if (!match) return seq.length < 32 ? 0 : 1;
+            this.applyCsi(match[1] || '', match[3]);
+            return match[0].length;
+        }
+        if (/[P^_X]/.test(next)) {
+            const bel = seq.indexOf('\x07', 2);
+            const st = seq.indexOf('\x1B\\', 2);
+            const end = bel >= 0 && (st < 0 || bel < st) ? bel + 1 : st >= 0 ? st + 2 : 0;
+            return end;
+        }
+        return 2;
+    }
+
+    private applyCsi(params: string, final: string): void {
+        const count = parseCount(params);
+        this.ensureRow();
+        if (final === 'A') this.row = Math.max(0, this.row - count);
+        else if (final === 'B') this.row += count;
+        else if (final === 'C') this.col += count;
+        else if (final === 'D') this.col = Math.max(0, this.col - count);
+        else if (final === 'G') this.col = Math.max(0, count - 1);
+        else if (final === 'H' || final === 'f') {
+            const parts = String(params || '').split(';');
+            this.row = Math.max(0, (Number(parts[0] || 1) || 1) - 1);
+            this.col = Math.max(0, (Number(parts[1] || 1) || 1) - 1);
+        } else if (final === 'J') {
+            const mode = Number(params || 0) || 0;
+            if (mode === 2 || mode === 3) {
+                this.lines = [[]];
+                this.row = 0;
+                this.col = 0;
+            } else if (mode === 0) {
+                this.lines[this.row] = this.lines[this.row].slice(0, this.col);
+                this.lines.splice(this.row + 1);
+            } else if (mode === 1) {
+                for (let r = 0; r < this.row; r += 1) this.lines[r] = [];
+                const line = this.lines[this.row];
+                for (let c = 0; c <= Math.min(this.col, line.length - 1); c += 1) line[c] = ' ';
+            }
+        } else if (final === 'K') {
+            const mode = Number(params || 0) || 0;
+            const line = this.lines[this.row];
+            if (mode === 2) this.lines[this.row] = [];
+            else if (mode === 1) {
+                for (let c = 0; c <= Math.min(this.col, line.length - 1); c += 1) line[c] = ' ';
+            } else {
+                this.lines[this.row] = line.slice(0, this.col);
+            }
+        } else if (final === 's') {
+            this.savedCursor = { row: this.row, col: this.col };
+        } else if (final === 'u') {
+            if (this.savedCursor) {
+                this.row = this.savedCursor.row;
+                this.col = this.savedCursor.col;
+            }
+        }
+        this.ensureRow();
+    }
 }
 
 function stripTerminalNoise(str: string): string {
     return String(str || '')
         .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, '')
-        .replace(/(^|[\s([])(?:\??\d{1,4}(?:;\d{1,4})*[A-Za-z])(?=$|[\s)\]])/g, '$1')
-        .replace(/(^|[\s([])(?:\[\??\d{1,4}(?:;\d{1,4})*[A-Za-z])(?=$|[\s)\]])/g, '$1')
-        .replace(/(^|[\s([])(?:\d{1,4};\?)(?=$|[\s)\]])/g, '$1')
-        .replace(/(^|[\s([])(?:\d+\$r[0-9;\" ]*[A-Za-z]?)(?=$|[\s)\]])/g, '$1')
-        .replace(/(^|[\s([])(?:>\|[A-Za-z0-9_.:-]+(?:\([^)]*\))?)(?=$|[\s)\]])/g, '$1')
-        .replace(/(^|[\s([])(?:[A-Z]\d(?:\s+[A-Z]\d)+)(?=$|[\s)\]])/g, '$1')
-        .replace(/(^|[\s([])(?:\d+;[^\s)\]]+)(?=$|[\s)\]])/g, '$1')
         .replace(/\r+/g, '\n')
         .replace(/[ \t]+\n/g, '\n')
-        .replace(/\n{3,}/g, '\n\n')
-        .replace(/ {2,}/g, ' ');
+        .replace(/\n{4,}/g, '\n\n\n');
 }
 
 export function sanitizeTerminalText(str: string): string {
-    return stripTerminalNoise(stripAnsi(str));
+    const accumulator = new TerminalTranscriptAccumulator();
+    return stripTerminalNoise(stripAnsi(accumulator.append(str)));
 }
 
 export function listCliScriptNames(scripts: CliScripts | undefined): string[] {

package/src/mesh/mesh-events.ts

@@ -6,6 +6,17 @@ function readNonEmptyString(value: unknown): string {
     return typeof value === 'string' && value.trim() ? value.trim() : '';
 }
 
+const MESH_COORDINATOR_EVENTS = new Set([
+    'agent:generating_completed',
+    'agent:waiting_approval',
+    'agent:stopped',
+    'monitor:long_generating',
+]);
+
+function isMeshCoordinatorEvent(eventName: unknown): eventName is string {
+    return typeof eventName === 'string' && MESH_COORDINATOR_EVENTS.has(eventName);
+}
+
 function formatCompletionMetadata(event: Record<string, unknown>): string {
     const parts = [
         readNonEmptyString(event.targetSessionId) ? `session_id=${readNonEmptyString(event.targetSessionId)}` : '',
@@ -27,6 +38,12 @@ function buildMeshSystemMessage(args: {
     if (args.event === 'agent:waiting_approval') {
         return `[System] ${args.nodeLabel} is waiting for approval to proceed${metadata}. You may use mesh_read_chat and mesh_approve to handle it.`;
     }
+    if (args.event === 'agent:stopped') {
+        return `[System] ${args.nodeLabel} has stopped${metadata}. Use mesh_read_chat once if you need to inspect its last output.`;
+    }
+    if (args.event === 'monitor:long_generating') {
+        return `[System] ${args.nodeLabel} has been generating for a long time${metadata}. Use mesh_read_chat once for a status check, but do not poll repeatedly.`;
+    }
     return '';
 }
 
@@ -63,7 +80,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
 
 export function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>) {
     const eventName = readNonEmptyString(payload.event);
-    if (eventName !== 'agent:generating_completed' && eventName !== 'agent:waiting_approval') {
+    if (!isMeshCoordinatorEvent(eventName)) {
         return { success: false, error: 'unsupported mesh event' };
     }
     const meshId = readNonEmptyString(payload.meshId);
@@ -86,8 +103,8 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
 
 export function setupMeshEventForwarding(components: DaemonComponents) {
     components.instanceManager.onEvent((event) => {
-        // We only care about agent sub-session completion or waiting approval
-        if (event.event !== 'agent:generating_completed' && event.event !== 'agent:waiting_approval') return;
+        // We only care about lightweight Repo Mesh coordinator control/status hints.
+        if (!isMeshCoordinatorEvent(event.event)) return;
 
         const instanceId = readNonEmptyString(event.instanceId);
         if (!instanceId) return;