@hwip/cli 0.1.11 → 0.1.13

package/README.md

@@ -239,13 +239,16 @@ back when it writes again.
 Detection is exact-match: a terminal keystroke racing a phone message
 can never false-flag. Muted projects are never flagged.
 
-Agents without that hook (Cursor, Windsurf, Copilot, Cline, Aider, OpenCode) have one
+Agents without that hook (Cursor, Windsurf, Copilot, Cline, Aider) have one
 other way in: a `hwip_ask` answer reporting `hwipState: "REMOTE"`. Their rule
 files therefore keep the after-real-work `hwip_ask` — the "Entering REMOTE
 without a prompt hook" preamble in `src/templates.ts` — so the phone always
 has a button to tap that starts the loop. The one exception is an answer sent
 with the phone's "send and exit": that turn carries out the instruction and
-ends without an ask. Agents with the hook drop that
+ends without an ask. OpenCode has no prompt hook either but leaves the
+preamble out: its after-work ask reached the phone on turns typed at the
+terminal, so it owes no ask in NORMAL, and a phone message to an OpenCode
+session gets the completion push rather than buttons. Agents with the hook drop that
 obligation while at the terminal — and their rule file carries only the
 NORMAL branch of the core (about a quarter of it), since it is read on every
 turn; the hook injects the REMOTE sections in full on the turn a phone
@@ -685,7 +688,9 @@ A tmux name is used again when an agent starts in the same folder, so each
 chunk also names its **run** — the tmux session it was recorded in (`runId`,
 tmux's `session_created` in epoch seconds). The app uses it to keep one run's
 conversation apart from the one before it under the same name; a chunk read
-after a restart keeps the run it was recorded in. The listener's record of past
+after a restart keeps the run it was recorded in. What a session writes with no
+run to name (a name whose tmux session has ended while its file is still written
+to) is not recorded: the server takes no chunk without a run. The listener's record of past
 sessions keeps runs apart the same way: closing `hwip cc` and starting it again
 in the same folder leaves the first run as a past session of its own (the
 newest ten runs of a name are kept, 100 in all, and up to 50 are reported to

package/dist/templates.d.ts

@@ -16,7 +16,16 @@ export declare const CLINE_RULE: string;
 export declare const AIDER_RULE: string;
 /** Pi — managed block in ~/.pi/agent/AGENTS.md. Extension = Stop-equivalent + prompt hook + waiting-on-you push (PI_EXTENSION), so NORMAL-only core. */
 export declare const PI_RULE: string;
-/** OpenCode — managed block in ~/.config/opencode/AGENTS.md. Stop hook via plugin, no prompt hook (v1). */
+/**
+ * OpenCode — managed block in ~/.config/opencode/AGENTS.md. Stop hook via plugin, no prompt hook.
+ *
+ * No REMOTE_ENTRY_NO_HOOK, unlike the other hook-less agents: its after-work
+ * ask landed on the phone while the user sat at the terminal (2026-10-29,
+ * OpenCode 2.1.3), and the 2.x plugin API (event stream only) has no per-turn
+ * hook to tell the two apart. So a NORMAL session owes no ask, and REMOTE
+ * starts only from an ask the agent chose to send. Full core, because no hook
+ * delivers the REMOTE sections on entry.
+ */
 export declare const OPENCODE_RULE: string;
 export declare const CURSOR_HOOKS: {
     version: number;

package/dist/templates.js

@@ -21,7 +21,8 @@
 // hook note (a phone message) or by a `hwip_ask` answer. Only Gemini, Codex
 // and Pi have that hook (remoteHookCmd below). Every other agent's only door is the
 // ask itself — so for them the NORMAL branch must still send one after real
-// work, or the phone loop can never begin. That is REMOTE_ENTRY_NO_HOOK.
+// work, or the phone loop can never begin. That is REMOTE_ENTRY_NO_HOOK
+// (OpenCode excepted — OPENCODE_RULE says why).
 //
 // The same axis decides how much of the core the static rule file carries.
 // That file is read on every turn, and a session is NORMAL nearly all of the
@@ -125,7 +126,7 @@ refactor, multi-file changes) call hwip_notify. Skip it for trivial
 operations (file reads, simple searches). Set priority "high" for
 errors/blockers.`;
 // REMOTE-entry preamble — agents with NO prompt-submit hook (Cursor, Windsurf,
-// Copilot, Cline, Aider, OpenCode). The shared core scopes Rules 1/2/8/9 to REMOTE
+// Copilot, Cline, Aider; OpenCode opts out, see OPENCODE_RULE). The shared core scopes Rules 1/2/8/9 to REMOTE
 // and tells a NORMAL session it owes no `hwip_ask`. That is right where a
 // hook can announce the phone message that starts REMOTE; here nothing can,
 // and the only remaining entry is a `hwip_ask` answer reporting REMOTE.
@@ -266,10 +267,18 @@ exports.PI_RULE = buildRule({
     pushSignal: PI_PUSH_SIGNAL,
     core: PROMPT_HOOK_CORE,
 });
-/** OpenCode — managed block in ~/.config/opencode/AGENTS.md. Stop hook via plugin, no prompt hook (v1). */
+/**
+ * OpenCode — managed block in ~/.config/opencode/AGENTS.md. Stop hook via plugin, no prompt hook.
+ *
+ * No REMOTE_ENTRY_NO_HOOK, unlike the other hook-less agents: its after-work
+ * ask landed on the phone while the user sat at the terminal (2026-10-29,
+ * OpenCode 2.1.3), and the 2.x plugin API (event stream only) has no per-turn
+ * hook to tell the two apart. So a NORMAL session owes no ask, and REMOTE
+ * starts only from an ask the agent chose to send. Full core, because no hook
+ * delivers the REMOTE sections on entry.
+ */
 exports.OPENCODE_RULE = buildRule({
     notify: HOOK_DRIVEN_NOTIFY,
-    remoteEntry: REMOTE_ENTRY_NO_HOOK,
     core: hwip_core_generated_js_1.HWIP_CORE_HOOK_DRIVEN,
 });
 // ── Hook configs ─────────────────────────────────────────────────

package/dist/turn-recorder-wire.js

@@ -98,7 +98,7 @@ const createChunkUploader = (opts) => {
         try {
             res = await (0, api_js_1.apiFetch)(fetchFn, (0, api_js_1.apiUrl)(opts.baseUrl, `/sessions/${encodeURIComponent(sessionKey)}/turns`), opts.apiKey, UPLOAD_TIMEOUT_MS, {
                 method: 'POST',
-                body: JSON.stringify({ seq: chunk.seq, firstAt: chunk.firstAt, lastAt: chunk.lastAt, ...(chunk.runId ? { runId: chunk.runId } : {}), sealed: chunk.sealed }),
+                body: JSON.stringify({ seq: chunk.seq, firstAt: chunk.firstAt, lastAt: chunk.lastAt, runId: chunk.runId, sealed: chunk.sealed }),
             });
         }
         catch (err) {

package/dist/turn-recorder.d.ts

@@ -98,8 +98,8 @@ export interface OutboxChunk {
     seq: number;
     firstAt: string;
     lastAt: string;
-    /** The run the events were recorded in. Absent from chunks made before runs were recorded. */
-    runId?: string;
+    /** The run the events were recorded in: the server takes no chunk without one. */
+    runId: string;
     sealed: SealedChunk;
 }
 export type UploadOutcome = 

package/dist/turn-recorder.js

@@ -90,7 +90,7 @@ const isOutboxChunk = (c) => {
     const o = c;
     const s = o.sealed;
     return (Number.isSafeInteger(o.seq) && typeof o.firstAt === 'string' && typeof o.lastAt === 'string' &&
-        !!s && typeof s.body === 'string' && typeof s.senderPublicKey === 'string' &&
+        typeof o.runId === 'string' && !!o.runId && !!s && typeof s.body === 'string' && typeof s.senderPublicKey === 'string' &&
         !!s.deviceKeyMap && typeof s.deviceKeyMap === 'object');
 };
 /** What is on disk, or null when it is missing or not ours (a bad file is a fresh start, never a crash). */
@@ -273,13 +273,21 @@ const createTurnRecorder = (deps) => {
         const chunks = [];
         const runId = runOf(live, live.tailPath);
         let seq = base.seq;
+        // No run to name (a session name that ended, its file still written to): the server takes no such chunk,
+        // so what was read is passed over rather than sealed and sent to be refused.
+        if (!runId && !live.noRunWarned) {
+            live.noRunWarned = true;
+            deps.log(`⧉ turn-recorder ${live.name}: no run to tag its chunks with — what it writes is not recorded`);
+        }
         try {
             for (const page of pages) {
+                if (!runId)
+                    break;
                 seq += 1;
                 const firstAt = eventAt(page, 'first', fallbackAt);
                 const lastAt = eventAt(page, 'last', fallbackAt);
                 const sealed = await deps.seal(JSON.stringify({ sessionKey: live.sessionKey, seq, events: page }), recipients);
-                chunks.push({ seq, firstAt, lastAt, ...(runId ? { runId } : {}), sealed });
+                chunks.push({ seq, firstAt, lastAt, runId, sealed });
             }
         }
         catch (err) {

package/dist/worktree.d.ts

@@ -136,9 +136,15 @@ export interface WorktreeStatus {
 /** What `hwip worktree` shows: every row with its state now. Read-only. */
 export declare const worktreeStatuses: (paneCwds: string[], run?: GitRun) => Promise<WorktreeStatus[]>;
 /**
- * The cwd of every live tmux pane, `[]` when there is no tmux server, null when
- * tmux could not be asked. The difference matters: an unreadable list read as
- * empty would make every worktree in use look abandoned.
+ * Where every live tmux pane started and where it is now, `[]` when there is no
+ * tmux server, null when tmux could not be asked. The difference matters: an
+ * unreadable list read as empty would make every worktree in use look abandoned.
+ *
+ * The start path (`new -c`) is read as well as the current one because the
+ * current one is not yet the pane's right after it starts: measured on tmux 3.6
+ * (ubuntu-26.04 runner), a pane read within ~10 ms of `new-session -c <dir>`
+ * reports the tmux server's cwd. The start path is the `-c` text unresolved,
+ * unlike the current one, so it is resolved like the worktree paths.
  */
 export declare const readPaneCwds: (tmux?: GitRun) => Promise<string[] | null>;
 //# sourceMappingURL=worktree.d.ts.map

package/dist/worktree.js

@@ -297,14 +297,23 @@ exports.worktreeStatuses = worktreeStatuses;
 // `error connecting to <socket> (No such file or directory)`; `(Permission denied)` and the rest are not "no panes".
 const NO_TMUX_SERVER = /^(no server running on |error connecting to .+ \(No such file or directory\)$)/;
 /**
- * The cwd of every live tmux pane, `[]` when there is no tmux server, null when
- * tmux could not be asked. The difference matters: an unreadable list read as
- * empty would make every worktree in use look abandoned.
+ * Where every live tmux pane started and where it is now, `[]` when there is no
+ * tmux server, null when tmux could not be asked. The difference matters: an
+ * unreadable list read as empty would make every worktree in use look abandoned.
+ *
+ * The start path (`new -c`) is read as well as the current one because the
+ * current one is not yet the pane's right after it starts: measured on tmux 3.6
+ * (ubuntu-26.04 runner), a pane read within ~10 ms of `new-session -c <dir>`
+ * reports the tmux server's cwd. The start path is the `-c` text unresolved,
+ * unlike the current one, so it is resolved like the worktree paths.
  */
 const readPaneCwds = async (tmux = exports.tmuxRun) => {
-    const out = await tmux(['list-panes', '-a', '-F', '#{pane_current_path}']);
-    if (out.ok)
-        return out.stdout.split('\n').filter(Boolean);
-    return NO_TMUX_SERVER.test(out.error) ? [] : null;
+    const out = await tmux(['list-panes', '-a', '-F', '#{pane_start_path}\t#{pane_current_path}']);
+    if (!out.ok)
+        return NO_TMUX_SERVER.test(out.error) ? [] : null;
+    return out.stdout.split('\n').filter(Boolean).flatMap((line) => {
+        const [start = '', current = ''] = line.split('\t');
+        return [start && realOrSelf(start), current].filter(Boolean);
+    });
 };
 exports.readPaneCwds = readPaneCwds;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hwip/cli",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Hwip CLI + push notification SDK for AI agents",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",