@kelceyp/caw-server 1.0.280 → 1.0.281

package/dist/pty-wrapper.mjs

@@ -406,8 +406,33 @@ let armedAt = null;
 // that eventually calls `teardown(TEARDOWN_REASONS.WATCHDOG)`. Overwritten on
 // every deferral, so it always holds the LAST deferral's counts — that is the
 // documented last-seen-snapshot semantic (design.md §Data on the wire).
+//
+// As1062 Task 9 extends the binding with a third property, `types` — a
+// `Map<label,count>` histogram derived from the SAME `background_tasks` array
+// the count was computed from. Normalisation collapses whitespace in friendly
+// labels (`"MCP task"` → `MCP_task`) so the emitted `pendingBgTypes` token
+// stays a single greppable word per label. Missing/empty types become
+// `unknown`. Layered onto the same object rather than a parallel binding so
+// the LAST-deferral-wins semantic covers types too.
 let lastDeferredCounts = null;
 
+// As1062 Task 9 — renders `lastDeferredCounts.types` (a `Map<label,count>`)
+// into the single-token form emitted as `pendingBgTypes` on the WATCHDOG
+// teardown line: sorted alphabetically by label for deterministic output,
+// comma-joined `label:count` pairs, whitespace-free by construction. Returns
+// the literal `'none'` on an empty histogram (crons-only deferral) so the
+// rendered line reads `pendingBgTypes=none` — distinct from the splitter's
+// `-` sentinel that flags non-watchdog reasons. Never returns `''` — the
+// wrapper-side empty-string guard the design calls for.
+const renderPendingBgTypes = (types) => {
+    if (!types || types.size === 0) return 'none';
+    const rendered = [...types.entries()]
+        .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+        .map(([label, count]) => `${label}:${count}`)
+        .join(',');
+    return rendered || 'none';
+};
+
 // Forward declarations (assigned after ptyProcess is created)
 let ptyProcess = null;
 
@@ -473,7 +498,11 @@ const teardown = (reason = TEARDOWN_REASONS.STOP) => {
         reason,
         ...(armedAt !== null ? { elapsedSinceArmMs: Date.now() - armedAt } : {}),
         ...(reason === TEARDOWN_REASONS.WATCHDOG && lastDeferredCounts !== null
-            ? { pendingBgCount: lastDeferredCounts.bgCount, pendingCronCount: lastDeferredCounts.cronCount }
+            ? {
+                pendingBgCount: lastDeferredCounts.bgCount,
+                pendingCronCount: lastDeferredCounts.cronCount,
+                pendingBgTypes: renderPendingBgTypes(lastDeferredCounts.types)
+            }
             : {})
     });
     if (watchdogTimer) { clearTimeout(watchdogTimer); watchdogTimer = null; }
@@ -506,7 +535,23 @@ process.on('SIGUSR1', () => {
         // As1012 Task 13 — capture BEFORE arming so the counts are already in
         // place if the timer subsequently fires. Members named to match the
         // locals above; the lift is a zero-translation copy.
-        lastDeferredCounts = { bgCount, cronCount };
+        //
+        // As1062 Task 9 — extend the same capture with a normalised `type`
+        // histogram of `background_tasks` entries so the WATCHDOG line's
+        // `pendingBgTypes=` token can carry a per-label breakdown. Normalisation
+        // (`String(entry?.type ?? '').trim().replace(/\s+/g, '_') || 'unknown'`)
+        // collapses whitespace in friendly labels (`"MCP task"` → `MCP_task`,
+        // `"auto-mode scan"` → `auto-mode_scan`) so the emitted token stays
+        // greppable as one word per label, and rescues missing/empty types to
+        // `unknown` rather than dropping them silently.
+        const types = new Map();
+        if (Array.isArray(payload.background_tasks)) {
+            for (const entry of payload.background_tasks) {
+                const label = String(entry?.type ?? '').trim().replace(/\s+/g, '_') || 'unknown';
+                types.set(label, (types.get(label) ?? 0) + 1);
+            }
+        }
+        lastDeferredCounts = { bgCount, cronCount, types };
         startOrResetWatchdog();
         return;
     }
@@ -546,7 +591,7 @@ ptyProcess = pty.spawn(claudePath, claudeArgs, {
     cols: 120,
     rows: 40,
     cwd: process.cwd(),
-    env: { ...process.env, CLAUBBIT: '1' }
+    env: { ...process.env, CLAUBBIT: '1', CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS: '0' }
 });
 
 log(`PID: ${ptyProcess.pid}`);
@@ -558,6 +603,61 @@ writeFileSync(claudePidPath, String(ptyProcess.pid));
 
 let ttyBuffer = '';
 let permissionConfirmed = false;
+
+// As1063 Task 3 item 5: streaming prompt-too-long detection (mechanism (d) fix).
+//
+// Named mechanism from Task 1 evidence ([Aj20482 trace](Ad84181)): Claude Code
+// CLI treats "Prompt is too long" from the Anthropic API as an assistant-message
+// response — it writes the text to the transcript, prints it to the tty, and
+// awaits the next user input rather than exiting. No Stop hook fires (this is
+// not a normal completion). The wrapper's onExit-side detection at :822 depends
+// on the child exiting, so it never runs. This streaming detection catches the
+// phrase during onData and forces the pty child to exit via SIGTERM, which then
+// drives the existing onExit path (emitResult / prompt-too-long fallback /
+// process exit) unchanged.
+//
+// Debounce (500 ms of tty silence after the phrase is seen) reduces the
+// false-positive risk of a legitimate Claude response that mentions the
+// phrase mid-stream — a real response keeps writing (streaming JSON events,
+// further text) and pushes the timer out; only an idle tty — the observed
+// prompt-too-long signature — lets the timer fire. `seenPromptTooLong` is
+// persistent because `ttyBuffer` is trimmed to the last 5000 chars on
+// overflow, and we do not want to lose the signal to a later burst of output.
+// Budget rationale: the observed prod trace (Aj20482) had no post-phrase tty
+// output for 5+ minutes; 500 ms is comfortably above any streaming inter-chunk
+// gap for a real turn and well below any human-perceptible terminal-transition
+// latency erosion (AC5).
+//
+// `CAW_PTY_PROMPT_TOO_LONG_DEBOUNCE_MS` overrides the default (test-only
+// configuration knob per Task 3 item 17 — fault-injection for the pre-fix /
+// post-fix pairing regression test; production leaves the default in place).
+const PROMPT_TOO_LONG_DEBOUNCE_MS = (() => {
+    const raw = process.env.CAW_PTY_PROMPT_TOO_LONG_DEBOUNCE_MS;
+    if (!raw) return 500;
+    const parsed = parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 500;
+})();
+let seenPromptTooLong = false;
+let streamingPromptTooLongEmitted = false;
+let promptTooLongTimer = null;
+const schedulePromptTooLongEmit = () => {
+    if (promptTooLongTimer) clearTimeout(promptTooLongTimer);
+    promptTooLongTimer = setTimeout(() => {
+        promptTooLongTimer = null;
+        if (resultEmitted || failureEmitted) return;
+        log('Prompt-too-long: detected in streaming path — emitting failure and killing pty');
+        process.stdout.write(JSON.stringify({
+            type: 'error',
+            error: 'prompt_too_long',
+            message: 'Prompt is too long'
+        }) + '\n');
+        failureEmitted = true;
+        streamingPromptTooLongEmitted = true;
+        // Kill the pty so onExit fires and the wrapper shuts down cleanly.
+        try { ptyProcess.kill('SIGTERM'); } catch { /* ignore */ }
+    }, PROMPT_TOO_LONG_DEBOUNCE_MS);
+};
+
 ptyProcess.onData((data) => {
     ttyBuffer += data;
     if (!permissionConfirmed && ttyBuffer.includes('Yes') && ttyBuffer.includes('No')) {
@@ -566,6 +666,16 @@ ptyProcess.onData((data) => {
         setTimeout(() => ptyProcess.write('\r'), 200); // Enter
         permissionConfirmed = true;
     }
+    // As1063 Task 3: streaming prompt-too-long detection with debounce.
+    // Latch `seenPromptTooLong` on first observation, then reset the debounce
+    // on every subsequent onData chunk — the timer only fires after tty has
+    // been idle for PROMPT_TOO_LONG_DEBOUNCE_MS.
+    if (!seenPromptTooLong && ttyBuffer.includes('Prompt is too long')) {
+        seenPromptTooLong = true;
+        schedulePromptTooLongEmit();
+    } else if (seenPromptTooLong && !resultEmitted && !failureEmitted) {
+        schedulePromptTooLongEmit();
+    }
     // Keep buffer bounded
     if (ttyBuffer.length > 10000) ttyBuffer = ttyBuffer.slice(-5000);
 });
@@ -779,6 +889,11 @@ ptyProcess.onExit(({ exitCode }) => {
 
     // Clear watchdog and stop polling (sentinelPath still exists on disk at this point)
     if (watchdogTimer) { clearTimeout(watchdogTimer); watchdogTimer = null; }
+    // As1063 Task 3: cancel any pending streaming-prompt-too-long debounce
+    // timer — the child has exited, so either the streaming detection already
+    // fired (failureEmitted is true and its guard would no-op) or a normal
+    // exit path is running (do not want a late stale emission).
+    if (promptTooLongTimer) { clearTimeout(promptTooLongTimer); promptTooLongTimer = null; }
     stopPolling();
 
     // Hoisted Stop-hook sentinel read at the onExit → pre-emitResult seam.
@@ -841,11 +956,13 @@ ptyProcess.onExit(({ exitCode }) => {
     // affecting the wrapper's stdout emission contract.
     const branchTaken = resultEmitted
         ? 'emitted-result'
-        : matchedPromptTooLong
-            ? 'matched-prompt-too-long'
-            : failureEmitted
-                ? 'emitted-failure'
-                : 'no-emission';
+        : streamingPromptTooLongEmitted
+            ? 'streaming-prompt-too-long'
+            : matchedPromptTooLong
+                ? 'matched-prompt-too-long'
+                : failureEmitted
+                    ? 'emitted-failure'
+                    : 'no-emission';
     // Cap the tty tail to 256 chars and escape newlines so the line stays on
     // one log entry regardless of what claude last wrote.
     const ttyTail = ttyBuffer.slice(-256).replace(/\n/g, '\\n').replace(/\r/g, '\\r');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kelceyp/caw-server",
-  "version": "1.0.280",
+  "version": "1.0.281",
   "description": "CAW server - REST API, MCP server and core features",
   "type": "module",
   "main": "dist/main.js",