@hellcoder/companion 0.109.0 → 0.109.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hellcoder/companion",
-  "version": "0.109.0",
+  "version": "0.109.1",
   "type": "module",
   "description": "Web UI for launching and interacting with Claude Code agents — Moritz Edition (fork of the-companion)",
   "license": "MIT",

package/server/session-state-machine.test.ts

@@ -81,9 +81,15 @@ describe("SessionStateMachine", () => {
     it("initializing -> terminated", () =>
       expectValidTransition("initializing", "terminated"));
 
-    // ready -> streaming, compacting, reconnecting, terminated
+    // ready -> streaming, awaiting_permission, compacting, reconnecting, terminated
     it("ready -> streaming", () =>
       expectValidTransition("ready", "streaming"));
+    // Reattach replays a pending permission while the session is idle: the CLI
+    // emits system_init (phase -> ready) and the resumed process immediately
+    // re-requests the permission it was already blocked on. This edge must be
+    // legal or the request is dropped and the phase stays "ready".
+    it("ready -> awaiting_permission", () =>
+      expectValidTransition("ready", "awaiting_permission"));
     it("ready -> compacting", () =>
       expectValidTransition("ready", "compacting"));
     it("ready -> reconnecting", () =>
@@ -561,6 +567,46 @@ describe("SessionStateMachine", () => {
       }
     });
 
+    it("handles a permission replayed on reattach: reconnecting -> initializing -> ready -> awaiting_permission", () => {
+      // Regression: a session that drops while awaiting permission gets its
+      // pending request replayed by the resumed CLI. ws-bridge forces the phase
+      // to "ready" on system_init, so the replayed request arrives in "ready".
+      // If that edge is illegal the transition is blocked, which has two
+      // consequences beyond the dropped request:
+      //   1. No transition event fires, so no session_phase frame is broadcast
+      //      and the client keeps showing the session as idle while it is in
+      //      fact blocked on an approval dialog.
+      //   2. handleCLIClose derives interruptedMidTurn from the phase, so a
+      //      second drop is logged as a clean idle disconnect and the in-flight
+      //      turn is orphaned rather than flagged.
+      const reattached = new SessionStateMachine("reattach", "awaiting_permission");
+      const events: SessionTransitionEvent[] = [];
+      reattached.onTransition((e) => events.push(e));
+
+      // Socket drops while the approval dialog is still open.
+      expect(reattached.transition("reconnecting", "cli_ws_closed")).toBe(true);
+      // CLI reattaches and re-initializes.
+      expect(reattached.transition("initializing", "cli-ws-reconnected")).toBe(true);
+      expect(reattached.transition("ready", "system_init")).toBe(true);
+
+      // The resumed CLI immediately re-requests the still-pending permission.
+      expect(reattached.transition("awaiting_permission", "permission_requested")).toBe(true);
+      expect(reattached.phase).toBe("awaiting_permission");
+
+      // The transition must emit an event — this is what drives the
+      // session_phase broadcast that moves the client off "idle".
+      expect(events.map((e) => `${e.from}->${e.to}`)).toEqual([
+        "awaiting_permission->reconnecting",
+        "reconnecting->initializing",
+        "initializing->ready",
+        "ready->awaiting_permission",
+      ]);
+
+      // A subsequent drop is now correctly attributable to a mid-turn state.
+      expect(reattached.canRespondToPermission()).toBe(true);
+      expect(reattached.isIdle()).toBe(false);
+    });
+
     it("handles early user message: starting -> streaming -> initializing -> ready", () => {
       // When a user sends a message before the CLI connects, the session
       // transitions starting -> streaming. When the CLI later connects,

package/server/session-state-machine.ts

@@ -55,6 +55,12 @@ export const VALID_TRANSITIONS: ReadonlyMap<
     "ready",
     new Set<SessionPhase>([
       "streaming",
+      // A permission request can arrive while the session is idle: on reattach
+      // the CLI emits system_init (forcing phase -> ready), then the resumed
+      // process immediately re-requests its still-pending permission. Without
+      // this edge the transition is blocked and the phase stays "ready", so the
+      // session reads as idle while it is in fact awaiting approval.
+      "awaiting_permission",
       "compacting",
       "reconnecting",
       "terminated",

package/server/ws-bridge.test.ts

@@ -1858,6 +1858,71 @@ describe("CLI message routing", () => {
     expect(permBroadcast.request.tool_name).toBe("Bash");
   });
 
+  // Regression: a permission request arriving while the session is idle must
+  // move the phase to awaiting_permission AND reach the browser as a
+  // session_phase frame.
+  //
+  // This is the reattach path: a session drops while a permission dialog is
+  // open, the CLI is resumed, it emits system.init (which forces phase ->
+  // ready), and the resumed process immediately re-requests the permission it
+  // was already blocked on. So the request lands in "ready", not "streaming".
+  //
+  // Before the ready -> awaiting_permission edge was added to VALID_TRANSITIONS
+  // the transition was blocked. The permission itself still rendered (it is
+  // stored and broadcast independently), but no transition event fired, so no
+  // session_phase frame was emitted and the client stayed on the "idle" status
+  // set by the preceding system.init — showing an idle session that was in fact
+  // blocked on an approval dialog.
+  it("control_request: broadcasts session_phase when a permission arrives in the ready phase", async () => {
+    const cli = makeCliSocket("s1");
+    bridge.handleCLIOpen(cli, "s1");
+
+    // system.init drives the session to "ready", as it does on every reattach.
+    await bridge.handleCLIMessage(cli, makeInitMsg());
+    const session = bridge.getSession("s1")!;
+    expect(session.stateMachine.phase).toBe("ready");
+
+    const browser = makeBrowserSocket("s1");
+    bridge.handleBrowserOpen(browser, "s1");
+    // Drop the connect-time frames so we only assert on what the permission
+    // request itself produces.
+    browser.send.mockClear();
+
+    // The resumed CLI replays its pending permission while still idle.
+    await bridge.handleCLIMessage(cli, JSON.stringify({
+      type: "control_request",
+      request_id: "req-reattach",
+      request: {
+        subtype: "can_use_tool",
+        tool_name: "Edit",
+        input: { file_path: "/test.ts" },
+        tool_use_id: "tu-reattach",
+      },
+    }));
+
+    // The transition is legal, so the phase actually advances.
+    expect(session.stateMachine.phase).toBe("awaiting_permission");
+
+    const calls = browser.send.mock.calls.map(([arg]: [string]) => JSON.parse(arg));
+
+    // The frame that unsticks the client status. src/ws.ts maps
+    // awaiting_permission -> "running"; without this frame the session renders
+    // as idle.
+    expect(calls).toContainEqual(
+      expect.objectContaining({
+        type: "session_phase",
+        phase: "awaiting_permission",
+        previousPhase: "ready",
+      }),
+    );
+
+    // The dialog still renders — this part was never broken, and asserting it
+    // here guards against a fix that trades one for the other.
+    const permBroadcast = calls.find((c: any) => c.type === "permission_request");
+    expect(permBroadcast).toBeDefined();
+    expect(permBroadcast.request.request_id).toBe("req-reattach");
+  });
+
   it("tool_progress: broadcasts", async () => {
     const msg = JSON.stringify({
       type: "tool_progress",