kernelpm 0.1.11 → 0.1.13

package/dist/opencodeDriver.js

@@ -116,6 +116,16 @@ class ServeOpencodeDriver {
     status = 'starting';
     /** Timestamp (ms) of the last `working` emit; null when not working. */
     workingSince = null;
+    /**
+     * True when no assistant turn is in flight. Arms the next `session.status=
+     * busy` handler: opencode's SSE stream occasionally emits a stray `busy`
+     * event AFTER the assistant message has already completed (and we've emit
+     * `awaiting_input`). Honoring it would flip the status back to `working`
+     * right after a finished turn, leaving the app stuck on "escribiendo…"
+     * until the watchdog's hard timeout (3 min). We only treat `busy` as
+     * genuinely working when the user has armed it by sending a prompt.
+     */
+    turnDone = true;
     constructor(sessionId, cwd, title, opts, cb, initial) {
         this.sessionId = sessionId;
         this.cwd = cwd;
@@ -144,10 +154,12 @@ class ServeOpencodeDriver {
     }
     async sendMessage(text) {
         await this.prompt(text);
+        this.turnDone = false; // arm: the next `busy` is a legit in-flight turn
         this.emitStatus('working');
     }
     async answer(option) {
         await this.prompt(option.send);
+        this.turnDone = false;
         this.emitStatus('working');
     }
     async isAlive() {
@@ -465,10 +477,20 @@ class ServeOpencodeDriver {
     onSessionStatus(p) {
         if (p.sessionID !== this.opencodeId || !p.status)
             return;
-        if (p.status.type === 'busy' || p.status.type === 'retry')
+        if (p.status.type === 'busy' || p.status.type === 'retry') {
+            // Ignore `busy` events that arrive after a turn already completed.
+            // opencode's SSE stream occasionally emits a stale busy in the wake of a
+            // message.updated with time.completed, and honoring it would flip us
+            // back to 'working' right after we just emitted 'awaiting_input',
+            // leaving the app stuck on "escribiendo…" until the watchdog's hard
+            // timeout. The user's next prompt re-arms `turnDone`.
+            if (this.turnDone)
+                return;
             this.emitStatus('working');
-        else if (p.status.type === 'idle')
+        }
+        else if (p.status.type === 'idle') {
             this.handleIdle();
+        }
     }
     onSessionIdle(p) {
         if (p.sessionID !== this.opencodeId)
@@ -584,6 +606,10 @@ class ServeOpencodeDriver {
         this.emittedTurn.add(messageId);
         this.lastAssistantMessageId = messageId;
         this.lastAssistantText = text;
+        // The turn is over: disarm so any subsequent stray `session.status=busy`
+        // from opencode's SSE stream doesn't flip us back to 'working' before the
+        // user's next prompt.
+        this.turnDone = true;
         this.cb.onEvents(events);
         const decision = (0, decisions_1.parseDecision)(text);
         if (decision)

package/dist/session.js

@@ -27,6 +27,12 @@ class Session {
         return this.enqueue(async () => {
             if (this.meta.pendingDecision)
                 await this.clearDecision();
+            // Persist the user's prompt as a `user_text` event so it round-trips
+            // through the store like the assistant's reply: attached clients see it
+            // live (via the push fan-out), and a session reopened later replays it
+            // from `sessions/<id>.jsonl`. Without this, the daemon only persisted
+            // assistant events and resume showed the AI half of the conversation.
+            await this.appendBody({ kind: 'user_text', text });
             await this.driver.sendMessage(text);
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelpm",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "kernelpm daemon — keeps opencode sessions alive on a server (via `opencode serve`) and exposes them over a local control socket.",
   "license": "MIT",
   "bin": {