Respect current Pi compaction and queued user input (#213)

* Align with current Pi core package and events

Use the current @earendil-works/pi-coding-agent package for real integration tests, pinned to the latest 0.74.x patch baseline. Handle current compaction_start/compaction_end RPC events while preserving legacy auto_compaction_* aliases for older Pi binaries. Update compaction tests to exercise the canonical event names and keep alias coverage explicit.

* Handle modern compaction completion once

* Preserve prompt order around compaction retry

* Align runtime and CI with Pi 0.75.5

* Stabilize prompt recovery around compaction

* Stabilize prompt busy-state edges

---------

Co-authored-by: NicabarNimble <nicabar@gmail.com>

Author: dnouri

.github/workflows/nightly.yml

@@ -55,7 +55,7 @@ jobs:
           version: '30.1'
       - uses: actions/setup-node@v4
         with:
-          node-version: '20'
+          node-version: '24'
 
       - name: Get pi version
         run: |

.github/workflows/test-integration.yml

@@ -34,7 +34,7 @@ jobs:
           version: '30.1'
       - uses: actions/setup-node@v4
         with:
-          node-version: '20'
+          node-version: '24'
       - name: Setup Ollama model
         run: |
           # Wait for Ollama to be ready

Makefile

@@ -7,7 +7,8 @@ BATCH = $(EMACS) --batch -Q -L . \
 LOCAL_LOAD_PATH = --eval "(setq load-path (cons (expand-file-name \".\") load-path))"
 
 # Pi CLI version — single source of truth (workflows extract this automatically)
-PI_VERSION ?= 0.65.0
+PI_VERSION ?= 0.75.5
+PI_PACKAGE ?= @earendil-works/pi-coding-agent
 PI_BIN ?= .cache/pi/node_modules/.bin/pi
 PI_BIN_DIR = $(abspath $(dir $(PI_BIN)))
 
@@ -143,16 +144,16 @@ install-hooks:
 
 setup-pi:
 	@if [ -x "$(PI_BIN)" ]; then \
-		CURRENT=$$($(PI_BIN) --version 2>/dev/null); \
+		CURRENT=$$($(PI_BIN) --version 2>&1 | tr -d '\r' | grep -Eo '^[0-9]+[.][0-9]+[.][0-9]+' | tail -1); \
 		if [ "$$CURRENT" != "$(PI_VERSION)" ] && [ "$(PI_VERSION)" != "latest" ]; then \
 			echo "Cached pi@$$CURRENT differs from requested $(PI_VERSION), reinstalling..."; \
 			rm -rf .cache/pi; \
 		fi; \
 	fi
 	@if [ ! -x "$(PI_BIN)" ]; then \
-		echo "Installing pi@$(PI_VERSION) to .cache/pi/..."; \
+		echo "Installing $(PI_PACKAGE)@$(PI_VERSION) to .cache/pi/..."; \
 		rm -rf .cache/pi; \
-		npm install --prefix .cache/pi @mariozechner/pi-coding-agent@$(PI_VERSION) --silent; \
+		npm install --prefix .cache/pi --ignore-scripts $(PI_PACKAGE)@$(PI_VERSION) --silent; \
 	fi
 	@echo "Using pi: $(PI_BIN)"
 	@$(PI_BIN) --version || (echo "ERROR: pi not working"; exit 1)

README.org

@@ -19,10 +19,10 @@ shortest path to a usable session:
 
 #+begin_src bash
 # 1. Install the pi CLI
-npm install -g @mariozechner/pi-coding-agent
+npm install -g @earendil-works/pi-coding-agent@0.75.5
 
 # Or with mise
-mise use -g npm:@mariozechner/pi-coding-agent
+mise use -g npm:@earendil-works/pi-coding-agent@0.75.5
 
 # 2. Authenticate the CLI
 pi --login
@@ -65,7 +65,8 @@ needed for markdown rendering.  That requires a C compiler (=gcc= or =cc=).
 * Requirements
 
 - Emacs 29.1 or later (with tree-sitter support)
-- [[https://pi.dev][pi coding agent]] 0.65.0 or later, installed and in PATH
+- Node.js 22.19 or later for the pi CLI; Node 24 is used in CI
+- [[https://pi.dev][pi coding agent]] =@earendil-works/pi-coding-agent@0.75.5= or later, installed and in PATH
 - pi CLI authentication via =pi --login= or provider API keys
 - A C compiler (=gcc= or =cc=) for installing tree-sitter grammars
 

pi-coding-agent-core.el

@@ -241,14 +241,17 @@ containing EVENT, then clears this process's pending request tables."
                   (when stderr
                     (list :stderr stderr)))))
     (unwind-protect
-        (progn
-          (when pending
-            (maphash (lambda (_id callback)
-                       (funcall callback error-response))
-                     pending)
-            (clrhash pending))
-          (when pending-types
-            (clrhash pending-types)))
+        (unwind-protect
+            (progn
+              (when pending
+                (maphash (lambda (_id callback)
+                           (funcall callback error-response))
+                         pending)
+                (clrhash pending))
+              (when pending-types
+                (clrhash pending-types)))
+          (when-let* ((handler (process-get proc 'pi-coding-agent-exit-handler)))
+            (funcall handler error-response)))
       (pi-coding-agent--cleanup-process-stderr-buffer proc))))
 
 (defvar pi-coding-agent-executable)  ; forward decl — core.el cannot require ui.el
@@ -287,14 +290,27 @@ Returns the process object."
 
 (defvar-local pi-coding-agent--status 'idle
   "Current status of the pi session (buffer-local in chat buffer).
-One of: `idle', `streaming', `compacting'.
+One of: `idle', `sending', `streaming', `compacting'.
 This is the single source of truth for session activity state.
 
-Status transitions are driven by events from pi:
-- `idle' -> `streaming' on agent_start
-- `streaming' -> `idle' on agent_end
-- `idle' -> `compacting' on auto_compaction_start
-- `compacting' -> `idle' on auto_compaction_end")
+Runtime status transitions are driven by events from pi:
+- `idle' or `sending' -> `streaming' on agent_start
+- `streaming' -> `sending' on agent_end with willRetry
+- `streaming' -> `idle' on agent_end without retry
+- `idle' -> `compacting' on compaction_start
+- `compacting' -> `sending' on successful compaction_end with willRetry
+- `compacting' -> `sending' on successful compaction_end that resumes
+  prompt preflight
+- `compacting' -> `idle' on compaction_end without retry, failure, or abort
+
+Local commands may mark a session busy before the first event arrives,
+for example normal prompt submission and manual compaction during the
+RPC pre-event window.")
+
+(defvar-local pi-coding-agent--pre-compaction-status nil
+  "Status that was active before a compaction event sequence.
+Used to restore local prompt submission state when Pi compacts during prompt
+preflight before the agent turn has started.")
 
 (defvar-local pi-coding-agent--state nil
   "Current state of the pi session (buffer-local in chat buffer).
@@ -310,7 +326,7 @@ A plist with keys like :model, :thinking-level, :messages, etc.")
   "Return t if state should be verified with get_state.
 Verification is needed when:
 - State and timestamp exist
-- Session is idle (not streaming or compacting)
+- Session status is `idle'
 - Timestamp is older than `pi-coding-agent--state-verify-interval' seconds."
   (and pi-coding-agent--state
        pi-coding-agent--state-timestamp
@@ -340,10 +356,33 @@ Use when reading JSON fields that may be null or string.
 JSON null (:null) and non-strings become nil."
   (and (stringp value) value))
 
+(defun pi-coding-agent--compaction-result-from-event (event)
+  "Return EVENT's successful compaction result, or nil when absent."
+  (let ((result (plist-get event :result)))
+    (unless (or (null result)
+                (pi-coding-agent--json-null-p result))
+      result)))
+
+(defun pi-coding-agent--compaction-end-success-p (event)
+  "Return non-nil when EVENT reports a completed, non-aborted compaction."
+  (and (not (pi-coding-agent--normalize-boolean (plist-get event :aborted)))
+       (not (null (pi-coding-agent--compaction-result-from-event event)))))
+
+(defun pi-coding-agent--compaction-end-will-retry-p (event)
+  "Return non-nil when EVENT indicates Pi will retry after compaction.
+A retry is only considered pending for a successful compaction result;
+failed or aborted compactions must not leave the session busy."
+  (and (pi-coding-agent--normalize-boolean (plist-get event :willRetry))
+       (pi-coding-agent--compaction-end-success-p event)))
+
+(defun pi-coding-agent--compaction-end-resumes-preflight-p (event)
+  "Return non-nil when EVENT can resume a pre-compaction prompt."
+  (and (eq pi-coding-agent--pre-compaction-status 'sending)
+       (pi-coding-agent--compaction-end-success-p event)))
+
 (defun pi-coding-agent--update-state-from-event (event)
   "Update status and state based on EVENT.
-Handles agent lifecycle, message events, and error/retry events.
-Sets status to `streaming' on agent_start, `idle' on agent_end."
+Handles agent lifecycle, message events, compaction, and error/retry events."
   (let ((type (plist-get event :type)))
     (pcase type
       ("agent_start"
@@ -352,7 +391,10 @@ Sets status to `streaming' on agent_start, `idle' on agent_end."
        (plist-put pi-coding-agent--state :last-error nil)
        (setq pi-coding-agent--state-timestamp (float-time)))
       ("agent_end"
-       (setq pi-coding-agent--status 'idle)
+       (setq pi-coding-agent--status
+             (if (pi-coding-agent--normalize-boolean (plist-get event :willRetry))
+                 'sending
+               'idle))
        (plist-put pi-coding-agent--state :is-retrying nil)
        (plist-put pi-coding-agent--state :messages (plist-get event :messages))
        (setq pi-coding-agent--state-timestamp (float-time)))
@@ -366,13 +408,33 @@ Sets status to `streaming' on agent_start, `idle' on agent_end."
        (pi-coding-agent--handle-tool-update event))
       ("tool_execution_end"
        (pi-coding-agent--handle-tool-end event))
+      ("compaction_start"
+       (setq pi-coding-agent--pre-compaction-status
+             (unless (eq pi-coding-agent--status 'compacting)
+               pi-coding-agent--status))
+       (setq pi-coding-agent--status 'compacting)
+       (setq pi-coding-agent--state-timestamp (float-time)))
+      ("compaction_end"
+       (setq pi-coding-agent--status
+             (cond
+              ((pi-coding-agent--compaction-end-will-retry-p event)
+               'sending)
+              ((pi-coding-agent--compaction-end-resumes-preflight-p event)
+               'sending)
+              (t
+               'idle)))
+       (setq pi-coding-agent--pre-compaction-status nil)
+       (setq pi-coding-agent--state-timestamp (float-time)))
       ("auto_retry_start"
+       (setq pi-coding-agent--status 'sending)
        (plist-put pi-coding-agent--state :is-retrying t)
        (plist-put pi-coding-agent--state :retry-attempt (plist-get event :attempt))
        (plist-put pi-coding-agent--state :last-error (plist-get event :errorMessage)))
       ("auto_retry_end"
        (plist-put pi-coding-agent--state :is-retrying nil)
        (unless (eq (plist-get event :success) t)
+         (when (eq pi-coding-agent--status 'sending)
+           (setq pi-coding-agent--status 'idle))
          (plist-put pi-coding-agent--state :last-error (plist-get event :finalError))))
       ("extension_error"
        (plist-put pi-coding-agent--state :last-error (plist-get event :error))))))

pi-coding-agent-input.el

@@ -303,13 +303,15 @@ The /compact command is handled locally; other slash commands sent to pi."
   (interactive)
   (let* ((text (string-trim (buffer-string)))
          (chat-buf (pi-coding-agent--get-chat-buffer))
-         (status (and chat-buf (buffer-local-value 'pi-coding-agent--status chat-buf)))
-         (busy (and status (memq status '(streaming sending compacting)))))
+         (busy (and chat-buf (pi-coding-agent--session-busy-p chat-buf))))
     (cond
      ((string-empty-p text) nil)
+     ((and busy (pi-coding-agent--builtin-command-text-p text))
+      (message "Pi: Cannot queue /%s while Pi is busy"
+               (pi-coding-agent--builtin-command-name text)))
      (busy
       (pi-coding-agent--queue-followup-text chat-buf text)
-      (message "Pi: Message queued (will send after current response)"))
+      (message "Pi: Message queued (will send when Pi is ready)"))
      (t
       (pi-coding-agent--accept-input-text text)
       (with-current-buffer chat-buf
@@ -542,23 +544,29 @@ it back via message_start at the correct position (after current
 assistant output completes).
 
 When compaction is in progress, steering text is queued as a local
-follow-up and sent after compaction completes."
+follow-up.  It is sent after non-retry compaction, or after Pi's
+automatic overflow retry turn finishes."
   (interactive)
   (let ((text (string-trim (buffer-string))))
     (unless (string-empty-p text)
       (let ((chat-buf (pi-coding-agent--get-chat-buffer)))
         (when chat-buf
           (let ((status (buffer-local-value 'pi-coding-agent--status chat-buf)))
             (cond
-             ((eq status 'idle)
+             ((and (eq status 'idle)
+                   (not (pi-coding-agent--session-busy-p chat-buf)))
               (message "Pi: Nothing to interrupt - use C-c C-c to send"))
-             ((eq status 'compacting)
+             ((or (eq status 'compacting)
+                  (and (eq status 'idle)
+                       (pi-coding-agent--session-busy-p chat-buf)))
               (pi-coding-agent--queue-followup-text chat-buf text)
-              (message "Pi: Steering queued (will send after compaction)"))
-             (t
+              (message "Pi: Steering queued (will send when Pi is ready)"))
+             ((memq status '(sending streaming))
               (when (pi-coding-agent--send-steer-message text)
                 (pi-coding-agent--accept-input-text text)
-                (message "Pi: Steering message sent"))))))))))
+                (message "Pi: Steering message sent")))
+             (t
+              (message "Pi: Cannot steer while session status is %s" status)))))))))
 
 (defun pi-coding-agent-queue-followup ()
   "Queue current input as a follow-up message.