hammoc 1.7.2 → 1.8.0

package/packages/server/dist/services/cliChatEngine.js

@@ -59,17 +59,18 @@ import fs from 'fs/promises';
 import { watch, mkdirSync, writeFileSync, createWriteStream } from 'fs';
 import { sessionService } from './sessionService.js';
 import { cliSessionPool } from './cliSessionPool.js';
+import { preferencesService } from './preferencesService.js';
 import { createCliScreenModel, CLI_SCREEN_COLS, CLI_SCREEN_ROWS } from './cliScreenModel.js';
 import { setCliScreen } from './cliScreenCache.js';
 import { createTrailingThrottle } from '../utils/trailingThrottle.js';
 import { readSpinnerProgress } from './cliSpinnerProgress.js';
 import { detectPermissionDialog, detectUsageLimit, detectRateLimit, extractToolName, extractPromptSentence, detectQuestionModal, parseQuestionModal, parsePrecedingText, parsePrecedingPermissionText, countQuestionTabs, parseQuestionTabHeaders, parseQuestionTabBody, parseConfirmChoiceMenu, readPermissionMode, permissionModeCycleIndex, isIdleInputGrid, isGeneratingGrid, classifyPreInjectScreen, CLI_PERMISSION_MODE_CYCLE, } from './cliModalDetect.js';
 import { liveFooterText, scrollbackBodyRows } from './cliGridRegion.js';
-import { parseGridCards, collectToolHeaderKeys, restoreFlickeredToolBullets } from './cliGridCards.js';
+import { parseGridCards, collectToolLineKeys, restoreFlickeredToolBullets } from './cliGridCards.js';
 import { rateLimitProbeService } from './rateLimitProbeService.js';
 import { parseJSONLFile, parseTaskNotification } from './historyParser.js';
 import { rewindSessionFiles } from './fileRewind.js';
-import { DEFAULT_WORKSPACE_TEMPLATE, resolveTemplateVariables } from './workspaceContext.js';
+import { buildSystemPrompt, resolveTemplateVariables } from './workspaceContext.js';
 import { createLogger } from '../utils/logger.js';
 import { SDKError, SDKErrorCode } from '../utils/errors.js';
 import { CliDebugLog } from '../utils/cliDebugLog.js';
@@ -154,6 +155,13 @@ const CLI_MAX_BOOT_WAIT_MS = 4000; // boot readiness re-poll interval (inject as
 // "still painting"; injection is grid-gated so we keep polling. A genuine boot freeze is covered by the
 // soft screen-stall affordance (boot is now mirrored), pty.onExit (crash), and the user's Stop.
 const CLI_SUBMIT_GAP_MS = 1000; // Enter sent this long after the prompt text
+// Prompt injection is PACED in small chunks, not one bulk write. A single large pty.write of a long
+// prompt overruns the Windows ConPTY input path: only a fraction (~the last few hundred bytes) reaches
+// claude's input box and the head/middle is silently dropped (실측 2026-06-22: a 2439-byte prompt arrived
+// as 391 bytes; bracketed-paste framing did NOT help; paced chunks delivered 100%). Pacing lets the TUI
+// drain between writes so the buffer never overruns. Tuned from the same measurement (50 cps / 8ms = 100%).
+const CLI_INJECT_CHUNK_CHARS = 50; // code points per write (code-point sliced — never splits a char)
+const CLI_INJECT_CHUNK_GAP_MS = 8; // pause between chunk writes so the TUI drains its input buffer
 /**
  * Tool-approval interception (Story 32.6 — *constrained*; keys verified against
  * claude v2.1.162 by a real-PTY observation, Task 1). The interactive permission
@@ -672,6 +680,16 @@ export class CliChatEngine {
         const projectSlug = sessionService.encodeProjectPath(cwd);
         const sessionsDir = sessionService.getSessionsDir(cwd);
         const resumeId = typeof options.resume === 'string' && options.resume.length > 0 ? options.resume : undefined;
+        // Story BS-6: resolve the CLI debug instrumentation flags once per spawn. Preference-first
+        // (set via the HAMMOC_DEBUG settings panel), falling back to the original env vars so
+        // existing HAMMOC_CLI_* usage keeps working when no preference is set. Tool trace rides
+        // along with PTY dump (the original env coupling preserved). These are referenced below at
+        // the four gated sites (debug-file, PTY dump, tool trace, and the pre-inject snapshot deep
+        // inside attemptInjectFromGrid).
+        const debugPrefs = await preferencesService.readPreferences();
+        const cliDebug = debugPrefs.debugCliTrace ?? !!process.env.HAMMOC_CLI_DEBUG;
+        const ptyDump = debugPrefs.debugPtyDump ?? !!process.env.HAMMOC_CLI_PTY_DUMP;
+        const toolTrace = debugPrefs.debugToolTrace ?? (!!process.env.HAMMOC_CLI_TOOL_TRACE || ptyDump);
         // Build interactive claude args. NEVER --print / --output-format stream-json:
         // headless output bills like the SDK, which is the whole reason CLI mode exists.
         const args = [];
@@ -717,8 +735,8 @@ export class CliChatEngine {
         // workspaceContext). Verified: node-pty delivers the multi-line arg intact to the PTY child, and
         // billing is unaffected (the pool is set by interactive-vs-print, not prompt content — this only
         // adds input tokens to the same subscription pool).
-        const appendTemplate = options.customSystemPrompt || DEFAULT_WORKSPACE_TEMPLATE;
-        args.push('--append-system-prompt', resolveTemplateVariables(appendTemplate, cwd, options.displayName));
+        const assembled = buildSystemPrompt('cli', options.isBmadProject ?? false, options.customSystemPrompt);
+        args.push('--append-system-prompt', resolveTemplateVariables(assembled, cwd, options.displayName));
         // Session-scoped `--settings` JSON (the global ~/.claude/settings.json is never
         // modified). Thinking summaries (default ON): Opus 4.7+ omit summaries unless asked.
         const settingsObj = {};
@@ -750,7 +768,7 @@ export class CliChatEngine {
         // captured per spawn, to diagnose why claude self-compacts on some long-idle resumes.
         // No-op unless the env flag is set; *.log is gitignored. Best-effort — instrumentation
         // must never break a turn.
-        if (process.env.HAMMOC_CLI_DEBUG) {
+        if (cliDebug) {
             try {
                 const dbgDir = path.join(process.cwd(), 'logs', 'claude-debug');
                 mkdirSync(dbgDir, { recursive: true });
@@ -820,7 +838,7 @@ export class CliChatEngine {
         // raw bytes (ANSI intact) are appended to a gitignored logs/cli-pty-dump/*.log.
         // Best-effort — instrumentation must never break a turn.
         let ptyDumpStream = null;
-        if (process.env.HAMMOC_CLI_PTY_DUMP) {
+        if (ptyDump) {
             try {
                 const dumpDir = path.join(process.cwd(), 'logs', 'cli-pty-dump');
                 mkdirSync(dumpDir, { recursive: true });
@@ -840,7 +858,7 @@ export class CliChatEngine {
         // Activate when EITHER its own flag OR the PTY-dump flag is set — so when only HAMMOC_CLI_PTY_DUMP can
         // be toggled (already on), the tool-completion trace rides along with no extra env. (Temporary debug
         // convenience; both are gitignored *.log and OFF in normal runs.)
-        if (process.env.HAMMOC_CLI_TOOL_TRACE || process.env.HAMMOC_CLI_PTY_DUMP) {
+        if (toolTrace) {
             try {
                 const traceDir = path.join(process.cwd(), 'logs', 'cli-tool-trace');
                 mkdirSync(traceDir, { recursive: true });
@@ -861,7 +879,7 @@ export class CliChatEngine {
             }
         };
         // Unified CLI decision log — per-turn session file, opt-in via HAMMOC_CLI_DEBUG (no-op when unset).
-        const dlog = new CliDebugLog(resumeId ?? options.sessionId ?? 'new');
+        const dlog = new CliDebugLog(resumeId ?? options.sessionId ?? 'new', cliDebug);
         this.currentDebugLog?.close();
         this.currentDebugLog = dlog;
         // Story 36.2: report the pre-generation phase so the UI shows progress through the
@@ -909,6 +927,7 @@ export class CliChatEngine {
             let bootRecoverTimer = null; // Story 37.6: post-Esc re-classify timer
             let choiceMenuHandled = false; // Story 37.6 follow-up: one-shot handoff of a drivable confirm menu (resume prompt)
             let submitTimer = null;
+            let injectChunkTimer = null; // paces the chunked prompt write
             // Permission-dialog state (Story 32.6 — post-injection only). Story 37.4: detection reads
             // the settled screen grid (no rolling buffer); `permissionPending` is the per-modal re-fire
             // guard that the old buffer-clear consume used to provide.
@@ -1074,6 +1093,10 @@ export class CliChatEngine {
                     clearTimeout(submitTimer);
                     submitTimer = null;
                 }
+                if (injectChunkTimer) {
+                    clearTimeout(injectChunkTimer);
+                    injectChunkTimer = null;
+                }
                 if (questionSettleTimer) {
                     clearTimeout(questionSettleTimer);
                     questionSettleTimer = null;
@@ -1224,19 +1247,43 @@ export class CliChatEngine {
                     bootRecoverTimer = null;
                 }
                 try {
-                    pty.write(promptToInject);
-                    submitTimer = setTimeout(() => {
-                        submitTimer = null;
+                    // Inject the prompt in small paced chunks (see CLI_INJECT_CHUNK_* notes) instead of one bulk
+                    // write, which the Windows ConPTY input path truncates to its tail. The submit CR is sent as a
+                    // SEPARATE write only AFTER the final chunk + the usual gap, preserving bracketed-paste safety
+                    // (a CR close to typed text coalesces into a newline; the gap keeps it a real submit).
+                    const codePoints = Array.from(promptToInject);
+                    let chunkStart = 0;
+                    const writeNextChunk = () => {
+                        injectChunkTimer = null;
                         if (settled)
                             return;
+                        if (chunkStart >= codePoints.length) {
+                            // All chunks delivered — now schedule the submit Enter after the bracketed-paste-safe gap.
+                            submitTimer = setTimeout(() => {
+                                submitTimer = null;
+                                if (settled)
+                                    return;
+                                try {
+                                    pty.write('\r');
+                                    onPhase?.('waiting'); // prompt submitted — awaiting the first response block
+                                }
+                                catch (err) {
+                                    fail(err instanceof Error ? err : new Error(String(err)));
+                                }
+                            }, CLI_SUBMIT_GAP_MS);
+                            return;
+                        }
                         try {
-                            pty.write('\r');
-                            onPhase?.('waiting'); // prompt submitted — awaiting the first response block
+                            pty.write(codePoints.slice(chunkStart, chunkStart + CLI_INJECT_CHUNK_CHARS).join(''));
                         }
                         catch (err) {
                             fail(err instanceof Error ? err : new Error(String(err)));
+                            return;
                         }
-                    }, CLI_SUBMIT_GAP_MS);
+                        chunkStart += CLI_INJECT_CHUNK_CHARS;
+                        injectChunkTimer = setTimeout(writeNextChunk, CLI_INJECT_CHUNK_GAP_MS);
+                    };
+                    writeNextChunk();
                 }
                 catch (err) {
                     fail(err instanceof Error ? err : new Error(String(err)));
@@ -1331,7 +1378,7 @@ export class CliChatEngine {
                         return;
                     const grid = screen.readGrid();
                     const classification = classifyPreInjectScreen(grid);
-                    if (process.env.HAMMOC_CLI_DEBUG)
+                    if (cliDebug)
                         snapshotPreInject(grid, classification);
                     if (classification === 'input-box') {
                         void alignModeThenInject(); // AC1 — verified input box (align mode → inject)
@@ -1562,7 +1609,7 @@ export class CliChatEngine {
                     // mid-repaint) BEFORE parsing, so it opens as its own tool card instead of fusing into the prose
                     // above. Content-gated on the cross-frame memory, so prose is never promoted. Row count is
                     // unchanged (glyph prepended), so `bodyColors` stays index-aligned.
-                    cards = parseGridCards(restoreFlickeredToolBullets(bodyRows, recentToolHeaderKeys), bodyColors);
+                    cards = parseGridCards(restoreFlickeredToolBullets(bodyRows, recentToolHeaderKeys, bodyColors), bodyColors);
                     // Stop once a known block is in view: it is the bounded boundary — everything above it is known.
                     if (knownSigs.size === 0 || cards.some((c) => knownSigs.has(cardSig(c))))
                         break;
@@ -1579,17 +1626,18 @@ export class CliChatEngine {
                         cards: cards.map((c) => ({ kind: c.kind, tool: c.toolName, color: c.bulletColor, textLen: c.text.length, preview: c.text.slice(0, 50) })),
                     });
                 }
-                // Story 37.12: refresh the cross-frame tool-header memory from the FINAL (deepest) frame read.
+                // Story 37.12: refresh the cross-frame tool-line memory from the FINAL (deepest) frame read.
                 // First drop keys whose line scrolled off — retention is scoped to on-screen text INCLUDING
                 // bullet-less rows, so a tool whose glyph is currently flickering stays remembered while a tool that
                 // truly scrolled away is forgotten (can't re-promote unrelated prose later). Then add this frame's
-                // glyph-carrying tool headers — the confident observations worth remembering.
-                const onScreenToolKeys = collectToolHeaderKeys(bodyRows, true);
+                // TOOL-COLORED bullet lines (green/red/gray) — the confident observations worth remembering; a white
+                // text-body bullet is excluded by the color gate, so prose is never remembered as a flicker tool.
+                const onScreenToolKeys = collectToolLineKeys(bodyRows, { includeBulletless: true });
                 for (const key of [...recentToolHeaderKeys]) {
                     if (!onScreenToolKeys.has(key))
                         recentToolHeaderKeys.delete(key);
                 }
-                for (const key of collectToolHeaderKeys(bodyRows, false))
+                for (const key of collectToolLineKeys(bodyRows, { bulletColors: bodyColors }))
                     recentToolHeaderKeys.add(key);
                 // CONTENT-SET dedup (replaces the position/suffix align that re-emitted the whole sequence the
                 // moment a card was inserted mid-list or mutated). Walk the visible cards; for each STABLE card:
@@ -1609,30 +1657,34 @@ export class CliChatEngine {
                 // output; if it scrolled off we still mark complete (the turn-end reload fills the canonical output).
                 // Fixes "tool spins forever though the mirror shows a green/done bullet" — the completion row scrolls
                 // out of the viewport but the color is enough.
-                const flipDoneIfGreen = (slot, bulletColor, cardIdx) => {
-                    if (bulletColor !== 'green' || slot < 0 || gridResultFlippedSlots.has(slot))
+                const flipToolSettled = (slot, bulletColor, cardIdx) => {
+                    // A tool's bullet SETTLES to green (success) or red (failure) when it finishes — both are terminal
+                    // and flip the provisional card running→complete in place. Gray/other = still running → leave pending
+                    // (the turn-end reload supplies the canonical result). node-pty실측: red = 255,107,128, steady.
+                    if ((bulletColor !== 'green' && bulletColor !== 'red') || slot < 0 || gridResultFlippedSlots.has(slot))
                         return;
                     const sid = provToolSlotIds[slot];
                     if (!sid)
                         return;
                     const next = cards[cardIdx + 1];
                     const output = next && next.kind === 'result' && next.text.trim() ? next.text : '';
+                    const success = bulletColor === 'green';
                     gridResultFlippedSlots.add(slot);
-                    trace(`flip-green slot=${slot} sid=${sid} (screen green → done)`);
-                    dlog.server('grid-tool-green-flip', { slot, sid, hasOutput: !!output });
-                    callbacks.onToolResult?.(sid, { success: true, output }, true);
+                    trace(`flip-settled slot=${slot} sid=${sid} color=${bulletColor} (screen ${bulletColor} → ${success ? 'done' : 'failed'})`);
+                    dlog.server('grid-tool-settle-flip', { slot, sid, color: bulletColor, success, hasOutput: !!output });
+                    callbacks.onToolResult?.(sid, { success, output }, true);
                 };
                 for (let cardIdx = 0; cardIdx < cards.length; cardIdx++) {
                     const card = cards[cardIdx];
                     if (card.kind === 'result') {
-                        // Flip the preceding tool running→complete ONLY when its `●` bullet is GREEN (done). claude
-                        // paints `⎿ Waiting…`/`⎿ Running…` under a still-running gray-bullet tool; those are NOT the
-                        // result (flipping shows a premature "complete: Waiting…"). Gray/unreadable stays pending →
-                        // the turn-end reload supplies the canonical result. Only a grid-provisioned slot.
+                        // Flip the preceding tool running→complete when its `●` bullet has SETTLED green (success) or red
+                        // (failure). claude paints `⎿ Waiting…`/`⎿ Running…` under a still-running gray-bullet tool; those
+                        // are NOT the result (flipping shows a premature "complete: Waiting…"). Gray/unreadable stays
+                        // pending → the turn-end reload supplies the canonical result. Only a grid-provisioned slot.
                         const sid = lastToolSlot >= 0 ? provToolSlotIds[lastToolSlot] : undefined;
-                        if (sid && !gridResultFlippedSlots.has(lastToolSlot) && lastToolColor === 'green' && card.text.trim()) {
+                        if (sid && !gridResultFlippedSlots.has(lastToolSlot) && (lastToolColor === 'green' || lastToolColor === 'red') && card.text.trim()) {
                             gridResultFlippedSlots.add(lastToolSlot);
-                            callbacks.onToolResult?.(sid, { success: true, output: card.text }, true);
+                            callbacks.onToolResult?.(sid, { success: lastToolColor === 'green', output: card.text }, true);
                         }
                         continue;
                     }
@@ -1715,7 +1767,7 @@ export class CliChatEngine {
                             lastToolColor = card.bulletColor;
                             if (card.bulletColor === 'green')
                                 h.seenGreen = true;
-                            flipDoneIfGreen(h.slot, card.bulletColor, cardIdx);
+                            flipToolSettled(h.slot, card.bulletColor, cardIdx);
                         }
                         continue;
                     }
@@ -1763,7 +1815,7 @@ export class CliChatEngine {
                         });
                         lastToolSlot = slot;
                         lastToolColor = card.bulletColor;
-                        flipDoneIfGreen(slot, card.bulletColor, cardIdx); // a tool already green on first sight = done
+                        flipToolSettled(slot, card.bulletColor, cardIdx); // a tool already green/red on first sight = settled
                     }
                     else if (card.kind === 'text') {
                         const slot = liveTextSlots++;