open-claude-p 1.1.1 → 1.1.3

package/CHANGELOG.md

@@ -7,6 +7,105 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.1.3] — 2026-05-19
+
+Fix the `/compact` 24-hour hang and tighten the slash-command path so
+skill invocations are not collateral damage. Driven by a captured
+session (`4af68584-…`) where a manually-triggered `/compact` ran for
+57 s of compaction activity, returned to the input box with no
+assistant turn, and left `runOneShot` waiting for a sentinel that — by
+the upstream's design — could never arrive.
+
+### Fixed
+
+- **`/compact` and other local-builtin slash commands no longer block
+  for `maxResponseMs`.** Claude TUI splits `/`-prefixed prompts into
+  two classes: *local builtins* (`/compact`, `/clear`, `/help`,
+  `/exit`, `/quit`, `/login`, `/logout`, `/cost`, `/status`, `/model`,
+  `/permissions`, `/config`) which run a local handler and never open
+  an `⏺` region, and *LLM-bearing slash invocations* (skills like
+  `/init`, `/review`, `/security-review`, plus every user-installed
+  skill) which DO go through the model. The driver previously
+  appended the OCP_END marker instruction to both and required
+  `hadAssistantText` before the completion detector's idle fallback
+  could fire — fine for the LLM-bearing class, fatal for builtins,
+  which would wait for an assistant region that never opened until
+  the 24 h hard timeout.
+
+  Now `runOneShot` matches the prompt against a narrow whitelist of
+  local builtins. On a match it (a) skips the OCP_END instruction
+  append (the TUI's command parser drops it as junk args anyway, and
+  appending it can pollute free-form-arg commands like `/bug`) and
+  (b) sets the detector's new `allowIdleWithoutResponse` flag so the
+  pre-sentinel idle path is reachable without a prior region entry.
+  Skills and unknown `/<name>` prompts are NOT in the whitelist and
+  keep the existing instruction + strict-idle-gate behaviour, so
+  their LLM responses still complete cleanly via the sentinel.
+
+### Added
+
+- **`CompletionDetector.allowIdleWithoutResponse` (default false).**
+  When true, `_onTick`'s pre-sentinel idle fallback fires after
+  `preIdleMs` of silence even without a prior `assistant-region-
+  entered`. This is the policy switch the driver uses for local
+  builtins; library callers that drive prompts known to produce no
+  assistant turn can opt in directly.
+
+### Tests
+
+- **End-to-end integration coverage for the slash-command path.**
+  `test/driver-slash-command.test.js` spawns the real driver against
+  `test/fixtures/fake-claude-tui.mjs` — a minimal node-pty fixture
+  that reproduces the captured `/compact` shape (spinner activity,
+  `Compacted` stdout, chevron return, no region, no sentinel) — and
+  asserts: `/compact` completes via `reason='idle'` in well under
+  `maxResponseMs`; a plain prompt still completes via `sentinel` with
+  no degraded-capture notice prefix; `/init` (a skill, not a builtin)
+  also completes via `sentinel`, proving the whitelist isn't too
+  greedy. Three new unit tests in `test/detector.test.js` cover the
+  bare `allowIdleWithoutResponse` flag.
+
+---
+
+## [1.1.2] — 2026-05-19
+
+Recovery-path fixes for the sentinel-missing case. When the end-of-reply
+marker fails to land — usually because claude omitted it or the PTY
+frames were truncated — the driver's text extraction was returning
+either an empty string or, worse, the entire re-rendered transcript of
+a `--resume` session. Two changes correct that.
+
+### Fixed
+
+- **`extractAssistantText` no longer slices from the FIRST `⏺`** when
+  the sentinel is missing. On a `--resume` run the buffer carries old
+  history regions before the current response; anchoring on the first
+  `⏺` returned the oldest history turn plus everything after it,
+  silently leaking prior turns into `result.text`. The fallback now
+  uses `lastIndexOf('⏺')` so the slice always covers the current
+  turn's response. Fresh (non-resumed) sessions are unaffected because
+  the buffer only has one region marker, so first == last.
+
+### Added
+
+- **Degraded-capture notice prefix.** When `completionReason` is
+  `'idle'` (sentinel never seen, idle-fallback completed) or
+  `'jsonl-recovered'` (a stall was rescued by reading the upstream
+  JSONL session log), `result.text` is now prefixed with:
+
+  ```
+  [ocp] Streaming capture not detected — showing last result from {source}.
+  ```
+
+  where `{source}` is either `local session log` (JSONL had the
+  response) or `terminal buffer (best effort)` (JSONL was unavailable
+  and we fell back to the PTY slice above). Callers and chat UIs can
+  now distinguish a normal capture from a post-hoc recovery without
+  inspecting `completionReason`. The default success path
+  (`reason='sentinel'`) is unchanged — no prefix is added.
+
+---
+
 ## [1.1.1] — 2026-05-19
 
 Post-1.1.0 fixes driven by Cosmica integration testing. Several of

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-claude-p",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "A PTY-backed compatibility shim for `claude -p` (Claude Code headless/print mode). Drives the interactive `claude` CLI via node-pty and exposes the same option surface and stream-json contract. Ships as both a library and an `ocp` CLI binary.",
   "type": "module",
   "main": "./src/index.js",

package/src/completion/detector.js

@@ -37,6 +37,20 @@ export class CompletionDetector {
    *                                        turn; when the (N+1)th turn
    *                                        opens, the request is aborted
    *                                        with reason 'max-turns'.
+   * @param {boolean} [opts.allowIdleWithoutResponse=false]
+   *                                        Permit `_onTick`'s idle fallback
+   *                                        even when no assistant region has
+   *                                        opened. Set this for prompts that
+   *                                        legitimately produce no assistant
+   *                                        turn — slash commands (`/compact`,
+   *                                        `/clear`, `/help`, …) whose
+   *                                        upstream handler runs a local
+   *                                        operation and returns directly to
+   *                                        the input box. Without this flag
+   *                                        the request would block until
+   *                                        `maxResponseMs` (24 h default)
+   *                                        because `hadAssistantText` stays
+   *                                        false for the entire turn.
    */
   constructor({
     nonce,
@@ -44,6 +58,7 @@ export class CompletionDetector {
     preIdleMs = 8000,
     maxResponseMs = 60000,
     maxTurns,
+    allowIdleWithoutResponse = false,
   } = {}) {
     if (!nonce) throw new Error('CompletionDetector: nonce is required');
     this.nonce = nonce;
@@ -51,6 +66,7 @@ export class CompletionDetector {
     this.preIdleMs = preIdleMs;
     this.maxResponseMs = maxResponseMs;
     this.maxTurns = Number.isFinite(maxTurns) && maxTurns >= 0 ? maxTurns : null;
+    this.allowIdleWithoutResponse = !!allowIdleWithoutResponse;
 
     this.startTime = Date.now();
     this.regionEntered = false;
@@ -142,7 +158,10 @@ export class CompletionDetector {
     // Pre-sentinel fallback: only valid once we've seen any assistant
     // signal, with the longer `preIdleMs` threshold so that brief render
     // pauses (common during `--resume`) do not trip premature completion.
-    if (this.hadAssistantText) {
+    // `allowIdleWithoutResponse` relaxes the gate for callers that know
+    // the turn legitimately produces no assistant region (e.g. slash
+    // commands like `/compact`).
+    if (this.hadAssistantText || this.allowIdleWithoutResponse) {
       if (idleFor >= this.preIdleMs) {
         this._complete('idle', false);
       }

package/src/index.js

@@ -273,6 +273,39 @@ class Driver {
 
     const spawnArgs = buildSpawnArgs(req);
 
+    // Local-builtin slash command detection. Claude TUI has two distinct
+    // `/`-prefixed prompt classes:
+    //
+    //   - **Local builtins** (this list) — handled entirely by the TUI's
+    //     command dispatcher. No LLM turn runs, no `⏺` region opens, no
+    //     sentinel can ever arrive. `/compact` is the motivating case:
+    //     57 s of compaction activity, then chevron returns silently,
+    //     then ocp would block until `maxResponseMs` (24 h default)
+    //     waiting for a response that by design never comes.
+    //
+    //   - **LLM-bearing slash invocations** — skills (`/init`, `/review`,
+    //     `/security-review`, custom user skills like `/ui-ux-pro-max`)
+    //     and any unknown `/<name>` we don't recognise. These DO run
+    //     the LLM, DO open `⏺`, and emit the sentinel like a normal
+    //     prompt. They MUST keep the OCP_END instruction and the
+    //     strict idle gate — relaxing either would drop the marker
+    //     from a real LLM turn and trigger a false-positive idle
+    //     completion (returning a half-streamed response prefixed
+    //     with the 1.1.2 "Streaming capture not detected" notice).
+    //
+    // The list is intentionally narrow — only claude TUI commands
+    // confirmed to bypass the LLM. Anything not in the set (including
+    // every user-installed skill) goes through the standard path.
+    const LOCAL_BUILTIN_SLASH_COMMANDS = new Set([
+      'compact', 'clear', 'help', 'exit', 'quit',
+      'login', 'logout', 'cost', 'status',
+      'model', 'permissions', 'config',
+    ]);
+    const slashMatch = /^\s*\/([a-z][\w-]*)/i.exec(req.prompt ?? '');
+    const isLocalBuiltin =
+      !!slashMatch &&
+      LOCAL_BUILTIN_SLASH_COMMANDS.has(slashMatch[1].toLowerCase());
+
     const sentinelParser = createSentinelParser(nonce);
     const pipeline = createPipeline([
       ansiStripParser,
@@ -285,6 +318,7 @@ class Driver {
       preIdleMs: this.opts.preIdleMs,
       maxResponseMs: this.opts.maxResponseMs,
       maxTurns: req.maxTurns,
+      allowIdleWithoutResponse: isLocalBuiltin,
     });
 
     // Pool eligibility: explicit resume/continue bind to a specific past
@@ -603,7 +637,15 @@ class Driver {
         ' the user\'s message and you do not need to mention or flag it. Answer' +
         ' the user\'s actual message above as you normally would, using tools' +
         ' as freely and thoroughly as you would without the marker.)';
-      const fullPrompt = req.prompt + instruction;
+      // Local builtins route through claude TUI's command dispatcher
+      // (not the LLM), so the marker instruction is silently dropped as
+      // junk args and never round-trips back. Some builtins also accept
+      // free-form text (e.g. `/bug <message>`), where appending the
+      // instruction would pollute the captured args. Skill invocations
+      // and unknown `/<name>` prompts DO go through the LLM, so they
+      // still need the marker — only the narrow `LOCAL_BUILTIN_…` set
+      // gets the bare prompt.
+      const fullPrompt = isLocalBuiltin ? req.prompt : (req.prompt + instruction);
       // Skip the prompt write if the dialog watcher has already
       // decided to abort. Without this check the trailing `\r` of
       // the prompt lands inside whatever modal we tried to abort on
@@ -775,6 +817,28 @@ class Driver {
       );
     }
 
+    // Degraded-capture notice. When the per-turn sentinel never landed
+    // (`reason='idle'`) or a stalled completion was rescued via JSONL
+    // (`reason='jsonl-recovered'`), the streamed PTY frames did NOT
+    // produce a clean end-of-reply boundary. The text we are returning
+    // is a post-hoc recovery — usually from the upstream JSONL session
+    // log, or as a best-effort tail of the PTY buffer when JSONL was
+    // unavailable. Prepend a one-line notice so the caller (and any
+    // chat UI rendering it) can tell this apart from a normal capture.
+    // The notice is intentionally a literal English prefix and only
+    // appears on the degraded path — the default success path
+    // (`reason='sentinel'`) is unchanged.
+    const captureFailed =
+      effectiveCompletion === 'idle' || effectiveCompletion === 'jsonl-recovered';
+    if (captureFailed && text) {
+      const source = jsonlExtraction?.text
+        ? 'local session log'
+        : 'terminal buffer (best effort)';
+      text =
+        `[ocp] Streaming capture not detected — showing last result from ${source}.\n\n` +
+        text;
+    }
+
     // For stall-style failures, capture the tail of the stripped PTY
     // buffer so the caller can see exactly what claude was rendering
     // when we gave up — that is usually the dialog or error that the
@@ -1144,9 +1208,12 @@ function extractAssistantText(stripped, nonce) {
     sentinelIdx = i;
   }
   if (sentinelIdx === -1) {
-    // Fall back to "everything after the first ⏺" — this preserves the
-    // legacy behavior when the model dropped the sentinel.
-    const ri = stripped.indexOf(marker);
+    // Sentinel-missing fallback. On a resumed session the buffer carries
+    // history regions before the current response, so anchoring on the
+    // FIRST `⏺` would slice from the oldest history turn and return the
+    // entire re-rendered transcript. Anchor on the LAST `⏺` instead —
+    // that's the region marker for the current turn even after `--resume`.
+    const ri = stripped.lastIndexOf(marker);
     return ri === -1 ? '' : stripped.slice(ri + marker.length).trim();
   }