kernelpm 0.1.10 → 0.1.12

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;
@@ -132,13 +142,24 @@ class ServeOpencodeDriver {
         await this.ensureSession(resume);
         this.startStreaming();
         this.startPoll();
+        // Once the serve is up and the session is bound, the session is ready and
+        // waiting for its first user message. Without this transition the meta
+        // stays 'starting' forever, and the app — which derives its typing
+        // indicator from `isWorking(status)` — keeps showing "escribiendo…" on a
+        // brand-new session that has never received a prompt. Only transition if
+        // no SSE event (e.g. an early session.status=busy) has moved the status
+        // already, so we don't clobber a legitimately-working resumed session.
+        if (this.status === 'starting')
+            this.emitStatus('awaiting_input');
     }
     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() {
@@ -456,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)
@@ -575,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/package.json

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