@turns/dev 0.0.17 → 0.0.19

package/dist/agent-anchor.js

@@ -198,11 +198,21 @@ class LineTransport {
         }
     }
 }
+/**
+ * How long a background notification's `result` is held before it is taken as
+ * the end of the prompt's turn. Claude answers a task notification with a turn
+ * of its own, stamped `origin.kind: "task-notification"`; when a prompt is
+ * waiting behind it, that turn's `result` arrives first and the prompt's turn
+ * starts right after it. If Claude instead folded the prompt into the
+ * notification's turn, nothing follows, and the held result is the prompt's.
+ */
+const CLAUDE_NOTIFICATION_RESULT_GRACE_MS = 2_000;
 class ClaudeTransport extends LineTransport {
     sessionId;
     permissionMode;
     turnWaiter;
     control;
+    heldResult = null;
     constructor(anchor, createSession) {
         const profile = { command: 'claude' };
         const nativePermissionMode = anchor.permissionMode === 'default' ? 'manual' : anchor.permissionMode;
@@ -238,6 +248,13 @@ class ClaudeTransport extends LineTransport {
     onFrame(frame) {
         if (!frame || typeof frame !== 'object')
             return;
+        // Another turn starting means a held notification result was not the
+        // prompt's: keep waiting for the result of the turn now running.
+        if (this.heldResult &&
+            ((frame.type === 'system' && frame.subtype === 'init') || frame.type === 'stream_event' || frame.type === 'assistant')) {
+            clearTimeout(this.heldResult.timer);
+            this.heldResult = null;
+        }
         if (frame.type === 'system' && frame.subtype === 'init' && frame.session_id) {
             this.sessionId = String(frame.session_id);
             if (this.sessionId !== this.anchor.agentSessionId)
@@ -245,11 +262,20 @@ class ClaudeTransport extends LineTransport {
             return;
         }
         if (frame.type === 'result' && this.turnWaiter) {
-            const waiter = this.turnWaiter;
-            this.turnWaiter = null;
-            frame.is_error
-                ? waiter.reject(new Error(frame.result || frame.subtype || 'Claude turn failed.'))
-                : waiter.resolve(frame);
+            if (frame.origin?.kind === 'task-notification') {
+                if (this.heldResult)
+                    clearTimeout(this.heldResult.timer);
+                const timer = setTimeout(() => {
+                    if (this.heldResult?.frame !== frame)
+                        return;
+                    this.heldResult = null;
+                    this.settleTurn(frame);
+                }, CLAUDE_NOTIFICATION_RESULT_GRACE_MS);
+                timer.unref?.();
+                this.heldResult = { frame, timer };
+                return;
+            }
+            this.settleTurn(frame);
             return;
         }
         if (frame.type === 'control_response') {
@@ -266,7 +292,20 @@ class ClaudeTransport extends LineTransport {
         if (frame.type === 'control_request')
             void this.answerReverse(frame);
     }
+    settleTurn(frame) {
+        const waiter = this.turnWaiter;
+        if (!waiter)
+            return;
+        this.turnWaiter = null;
+        frame.is_error
+            ? waiter.reject(new Error(frame.result || frame.subtype || 'Claude turn failed.'))
+            : waiter.resolve(frame);
+    }
     onClose(error) {
+        if (this.heldResult) {
+            clearTimeout(this.heldResult.timer);
+            this.heldResult = null;
+        }
         if (this.turnWaiter) {
             this.turnWaiter.reject(error);
             this.turnWaiter = null;
@@ -330,6 +369,28 @@ class ClaudeTransport extends LineTransport {
         timer.unref?.();
         return waiter.promise.finally(() => clearTimeout(timer));
     }
+    /**
+     * Claude Code folds a stdin `user` frame that arrives during a turn into that
+     * turn: the model reads it after the tool calls in flight finish, within the
+     * same `result`, and the transcript records it as a `queued_command`
+     * attachment rather than a new user row (verified on 2.1.280). `priority`
+     * selects what happens to the running work. `next` is the fold described
+     * above and matches what the interactive TUI does when the user types while
+     * Claude works. `now` would end the running turn with `aborted_tools` and
+     * answer the message as a fresh turn, which is the interrupt fallback the
+     * queue already offers, so it is not used here.
+     */
+    steer(text, _messageId = '') {
+        if (!this.turnWaiter)
+            throw new Error('Claude has no active turn to steer.');
+        this.emit({
+            type: 'user',
+            session_id: this.sessionId,
+            message: { role: 'user', content: [{ type: 'text', text }] },
+            parent_tool_use_id: null,
+            priority: 'next',
+        });
+    }
     async interrupt() {
         try {
             await this.controlRequest('interrupt');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turns/dev",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Upload local AI agent sessions to turns.dev",
   "license": "MIT",
   "type": "module",