@staff0rd/assist 0.326.1 → 0.327.1

package/README.md

@@ -277,13 +277,14 @@ From WSL, the selector can also surface and drive Windows-host repos (requires `
 
 - `sessions.windowsProjectsRoot` — the Windows `.claude/projects` directory as seen from WSL (e.g. `/mnt/c/Users/<user>/.claude/projects`); enables discovery of Windows-host repos, tagged with a `Windows` badge. Selecting one launches a native assist daemon on Windows and runs an interactive session there.
 - `sessions.windowsDaemonHost` / `sessions.windowsDaemonPort` — where the WSL daemon reaches the native Windows daemon (defaults `127.0.0.1` / `51764`; set the host to the Windows IP on WSL2 NAT-mode networking).
+- `sessions.windowsVersionCheck` — how the WSL↔Windows daemon handshake reacts to a protocol-version mismatch: `block` (default) refuses creates and auto-heals the host, `warn` logs and proceeds anyway, `off` skips the check. Use `warn`/`off` to keep working across an unfixable version gap.
 
-When iterating on assist itself: web server changes only need the `assist sessions` process restarted — sessions survive. Daemon/session-core changes need `assist daemon restart` to load the new code; this kills the PTYs, then claude sessions — including assist sessions that wrap claude, like `assist draft` — are auto-respawned via `claude --resume` with scrollback starting fresh, while run sessions (and assist sessions whose claude sessionId was never discovered) reappear as not-restored tiles that can be retried.
+When iterating on assist itself: web server changes only need the `assist sessions` process restarted — sessions survive. Daemon/session-core changes need `assist daemon restart` to load the new code; this kills the PTYs, then claude sessions — including assist sessions that wrap claude, like `assist draft` — are auto-respawned via `claude --resume` with scrollback starting fresh, while run sessions (and assist sessions whose claude sessionId was never discovered) reappear as not-restored tiles that can be retried. A `--once` draft/bug/refine session is respawned through its assist wrapper instead of bare `claude --resume`, so its `assist signal done` watcher is re-established and the card still auto-closes.
 
 - `assist next [id] [--once]` - Alias for `backlog next [id]`; `--once` exits after the first completed item run instead of prompting for another
-- `assist draft [description] [--once]` (alias: `feat`) - Launch Claude in `/draft` mode, chain into next on `/next` signal; an optional `description` is forwarded as `/draft <description>`; `--once` exits when the done signal arrives after the initial draft completes
-- `assist bug [description] [--once]` - Launch Claude in `/bug` mode, chain into next on `/next` signal; an optional `description` is forwarded as `/bug <description>`; `--once` exits when the done signal arrives after the initial bug report completes
-- `assist refine [id] [--once]` - Launch Claude in `/refine` mode to refine a backlog item; prompts for selection when no id given; `--once` exits when the done signal arrives after refinement completes
+- `assist draft [description] [--once]` (alias: `feat`) - Launch Claude in `/draft` mode, chain into next on `/next` signal; an optional `description` is forwarded as `/draft <description>`; `--once` exits when the done signal arrives after the initial draft completes; `--resume-session <id>` resumes an interrupted Claude session (used by the sessions daemon when it restarts a running item)
+- `assist bug [description] [--once]` - Launch Claude in `/bug` mode, chain into next on `/next` signal; an optional `description` is forwarded as `/bug <description>`; `--once` exits when the done signal arrives after the initial bug report completes; `--resume-session <id>` resumes an interrupted Claude session (used by the sessions daemon when it restarts a running item)
+- `assist refine [id] [--once]` - Launch Claude in `/refine` mode to refine a backlog item; prompts for selection when no id given; `--once` exits when the done signal arrives after refinement completes; `--resume-session <id>` resumes an interrupted Claude session (used by the sessions daemon when it restarts a running item)
 - `assist review-comments [number]` - Launch Claude in `/review-comments` mode to process PR review comments (single session, no chaining); when a PR number is supplied, checks out that PR via `gh pr checkout` first
 - `assist signal next [id]` - Write a next signal to chain into `assist next`; when `id` is supplied, the parent launcher runs that backlog item directly
 - `assist signal done [id]` - Write a done signal marking the session's initial task complete; an optional `id` surfaces the backlog item the session created onto its session card; `--once` launch sessions exit when it arrives, plain sessions ignore it

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.326.1",
+  version: "0.327.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -285,7 +285,8 @@ var assistConfigSchema = z2.strictObject({
     // why: host the WSL daemon dials to reach the native Windows daemon over TCP (WSL can't use the Windows named pipe); defaults to 127.0.0.1 (WSL2 mirrored networking). NAT-mode users set the Windows host IP.
     windowsDaemonHost: z2.string().optional(),
     // why: TCP port the native Windows daemon listens on for the WSL bridge; defaults to 51764
-    windowsDaemonPort: z2.number().optional()
+    windowsDaemonPort: z2.number().optional(),
+    windowsVersionCheck: z2.enum(["block", "warn", "off"]).default("block")
   }).optional(),
   database: z2.strictObject({
     url: z2.string().optional()
@@ -7571,9 +7572,10 @@ function buildSlashCommand(slashCommand, description) {
   return trimmed ? `/${slashCommand} ${trimmed}` : `/${slashCommand}`;
 }
 async function launchMode(slashCommand, options2) {
-  pullIfConfigured();
+  const resumeSessionId = options2?.resumeSessionId;
+  if (!resumeSessionId) pullIfConfigured();
   process.env.ASSIST_SESSION_ID ??= String(process.pid);
-  const claudeSessionId = randomUUID2();
+  const claudeSessionId = resumeSessionId ?? randomUUID2();
   emitActivity({
     kind: "command",
     name: slashCommand,
@@ -7582,8 +7584,8 @@ async function launchMode(slashCommand, options2) {
     claudeSessionId
   });
   const { child, done: done2 } = spawnClaude(
-    buildSlashCommand(slashCommand, options2?.description),
-    { allowEdits: true, sessionId: claudeSessionId }
+    resumeSessionId ? buildResumePrompt() : buildSlashCommand(slashCommand, options2?.description),
+    { allowEdits: true, sessionId: claudeSessionId, resumeSessionId }
   );
   watchForMarker(child, { actOnDone: options2?.once });
   const launched = await awaitClaude(done2, `/${slashCommand}`);
@@ -12242,23 +12244,51 @@ async function reviewComments(number) {
 }
 
 // src/commands/registerLaunch.ts
-function registerLaunch(program2) {
+var RESUME_SESSION_FLAG = "Resume an interrupted Claude session (used by the sessions daemon on restart)";
+function registerNext(program2) {
   program2.command("next").argument("[id]", "Backlog item ID to run first").description("Alias for backlog next").option("--once", "Exit after the first completed item run").action(
     (id2, opts) => next({ allowEdits: true, once: opts.once }, id2)
   );
-  program2.command("draft").alias("feat").argument("[description]", "Text to forward to the /draft slash command").description(
-    "Launch Claude in /draft mode, chain into next on /next signal"
-  ).option("--once", "Exit when the initial task completes").action(
-    (description, opts) => launchMode("draft", { once: opts.once, description })
-  );
-  program2.command("bug").argument("[description]", "Text to forward to the /bug slash command").description("Launch Claude in /bug mode, chain into next on /next signal").option("--once", "Exit when the initial task completes").action(
-    (description, opts) => launchMode("bug", { once: opts.once, description })
+}
+function registerDescriptionLaunch(program2, name, slashCommand, description, alias) {
+  const command = program2.command(name).argument(
+    "[description]",
+    `Text to forward to the /${slashCommand} slash command`
+  ).description(description).option("--once", "Exit when the initial task completes").option("--resume-session <id>", RESUME_SESSION_FLAG).action(
+    (text6, opts) => launchMode(slashCommand, {
+      once: opts.once,
+      description: text6,
+      resumeSessionId: opts.resumeSession
+    })
   );
+  if (alias) command.alias(alias);
+}
+function registerReviewComments(program2) {
   program2.command("review-comments").argument("[number]", "PR number to check out first").description("Launch Claude in /review-comments mode (single session)").action((number) => reviewComments(number));
-  program2.command("refine").argument("[id]", "Backlog item ID").description("Launch Claude in /refine mode to refine a backlog item").option("--once", "Exit when the initial task completes").action(
-    (id2, opts) => refine(id2, { once: opts.once })
+}
+function registerRefine(program2) {
+  program2.command("refine").argument("[id]", "Backlog item ID").description("Launch Claude in /refine mode to refine a backlog item").option("--once", "Exit when the initial task completes").option("--resume-session <id>", RESUME_SESSION_FLAG).action(
+    (id2, opts) => refine(id2, { once: opts.once, resumeSessionId: opts.resumeSession })
   );
 }
+function registerLaunch(program2) {
+  registerNext(program2);
+  registerDescriptionLaunch(
+    program2,
+    "draft",
+    "draft",
+    "Launch Claude in /draft mode, chain into next on /next signal",
+    "feat"
+  );
+  registerDescriptionLaunch(
+    program2,
+    "bug",
+    "bug",
+    "Launch Claude in /bug mode, chain into next on /next signal"
+  );
+  registerReviewComments(program2);
+  registerRefine(program2);
+}
 
 // src/commands/registerList.ts
 function registerList(program2) {
@@ -20882,8 +20912,8 @@ function errorSession(id2, persisted, error) {
   };
 }
 
-// src/commands/sessions/daemon/backlogRunArgs.ts
-function backlogRunArgs(persisted) {
+// src/commands/sessions/daemon/assistResumeArgs.ts
+function assistResumeArgs(persisted) {
   const args = ["assist", ...persisted.assistArgs];
   return persisted.claudeSessionId ? [...args, "--resume-session", persisted.claudeSessionId] : args;
 }
@@ -20904,6 +20934,46 @@ function runningSession(base, persisted, pty2) {
   };
 }
 
+// src/commands/sessions/daemon/restoreInteractiveSession.ts
+function restoreInteractiveSession(id2, persisted, base) {
+  if (persisted.commandType !== "run" && persisted.claudeSessionId) {
+    return resumeViaClaude(id2, persisted, base);
+  }
+  if (persisted.commandType === "claude") {
+    return unrecoverableClaude(id2, persisted);
+  }
+  return notRestoredStub(base, persisted);
+}
+function resumeViaClaude(id2, persisted, base) {
+  const pty2 = spawnClaude2({
+    resumeSessionId: persisted.claudeSessionId,
+    prompt: buildResumePrompt(),
+    cwd: persisted.cwd,
+    sessionId: id2
+  });
+  return runningSession(base, persisted, pty2);
+}
+function unrecoverableClaude(id2, persisted) {
+  return errorSession(
+    id2,
+    persisted,
+    "no claude session id was recorded before the daemon stopped, so the conversation cannot be resumed"
+  );
+}
+function notRestoredStub(base, persisted) {
+  return {
+    ...base,
+    status: "done",
+    startedAt: persisted.startedAt,
+    runningMs: persisted.runningMs ?? 0,
+    runningSince: null,
+    pty: null,
+    runName: persisted.runName,
+    runArgs: persisted.runArgs,
+    restored: false
+  };
+}
+
 // src/commands/sessions/daemon/updatedSession.ts
 function updatedSession(id2, persisted) {
   return {
@@ -20923,41 +20993,22 @@ function isUpdate(persisted) {
 function restoreSession(id2, persisted) {
   const base = restoreBase(id2, persisted);
   if (isUpdate(persisted)) return updatedSession(id2, persisted);
-  if (isBacklogRun(persisted)) {
-    const pty2 = spawnPty(backlogRunArgs(persisted), persisted.cwd, id2);
+  if (needsWrapperRelaunch(persisted)) {
+    const pty2 = spawnPty(assistResumeArgs(persisted), persisted.cwd, id2);
     return runningSession(base, persisted, pty2);
   }
-  if (persisted.commandType !== "run" && persisted.claudeSessionId) {
-    const pty2 = spawnClaude2({
-      resumeSessionId: persisted.claudeSessionId,
-      prompt: buildResumePrompt(),
-      cwd: persisted.cwd,
-      sessionId: id2
-    });
-    return runningSession(base, persisted, pty2);
-  }
-  if (persisted.commandType === "claude") {
-    return errorSession(
-      id2,
-      persisted,
-      "no claude session id was recorded before the daemon stopped, so the conversation cannot be resumed"
-    );
-  }
-  return {
-    ...base,
-    status: "done",
-    startedAt: persisted.startedAt,
-    runningMs: persisted.runningMs ?? 0,
-    runningSince: null,
-    pty: null,
-    runName: persisted.runName,
-    runArgs: persisted.runArgs,
-    restored: false
-  };
+  return restoreInteractiveSession(id2, persisted, base);
+}
+function needsWrapperRelaunch(persisted) {
+  return isBacklogRun(persisted) || isOnceLaunch(persisted) && !!persisted.claudeSessionId;
 }
 function isBacklogRun(persisted) {
   return persisted.commandType === "assist" && persisted.assistArgs?.[0] === "backlog" && persisted.assistArgs?.[1] === "run";
 }
+var LAUNCH_COMMANDS = ["draft", "feat", "bug", "refine"];
+function isOnceLaunch(persisted) {
+  return persisted.commandType === "assist" && !!persisted.assistArgs && LAUNCH_COMMANDS.includes(persisted.assistArgs[0]) && persisted.assistArgs.includes("--once");
+}
 
 // src/commands/sessions/daemon/restoreOne.ts
 function restoreOne(persisted, spawn12, sessions) {
@@ -21342,18 +21393,6 @@ function stripOutboundSessionId(data) {
   return { ...data, sessionId: stripWindowsSessionId(data.sessionId) };
 }
 
-// src/commands/sessions/daemon/buildHello.ts
-var ASSIST_VERSION = package_default.version;
-function buildHello() {
-  return { type: "hello", version: ASSIST_VERSION };
-}
-function isHello(msg) {
-  return msg.type === "hello" && typeof msg.version === "string";
-}
-function versionsMatch(a, b) {
-  return a === b;
-}
-
 // src/commands/sessions/daemon/WindowsProxyState.ts
 var MAX_SCROLLBACK2 = 256 * 1024;
 var DEFAULT_CREATE_TIMEOUT_MS = 5e3;
@@ -21399,6 +21438,59 @@ function appendScrollback2(state, sessionId, data) {
   );
 }
 
+// src/commands/sessions/daemon/handleSessions.ts
+function handleSessions(state, msg) {
+  state.windowsSessions = msg.sessions.map((s) => ({
+    ...s,
+    id: toWindowsSessionId(s.id)
+  }));
+  const live = new Set(state.windowsSessions.map((s) => s.id));
+  for (const id2 of state.scrollback.keys())
+    if (!live.has(id2)) state.scrollback.delete(id2);
+  state.onSessionsChanged();
+}
+
+// src/commands/sessions/daemon/buildHello.ts
+var ASSIST_VERSION = package_default.version;
+var PROTOCOL_VERSION = 1;
+function buildHello() {
+  return { type: "hello", version: ASSIST_VERSION, protocol: PROTOCOL_VERSION };
+}
+function isHello(msg) {
+  return msg.type === "hello" && typeof msg.version === "string" && (msg.protocol === void 0 || typeof msg.protocol === "number");
+}
+function helloCompatible(msg) {
+  if (typeof msg.protocol === "number")
+    return msg.protocol === PROTOCOL_VERSION;
+  return msg.version === ASSIST_VERSION;
+}
+
+// src/commands/sessions/daemon/windowsVersionCheck.ts
+function windowsVersionCheck() {
+  return loadConfig().sessions?.windowsVersionCheck ?? "block";
+}
+
+// src/commands/sessions/daemon/handleHello.ts
+function handleHello(state, msg) {
+  if (!isHello(msg) || helloCompatible(msg)) return;
+  const mode = windowsVersionCheck();
+  const detail = `protocol ${msg.protocol ?? "legacy"} version ${msg.version} (wsl protocol ${PROTOCOL_VERSION} version ${ASSIST_VERSION})`;
+  if (mode === "off") {
+    daemonLog(
+      `windows daemon protocol mismatch: ${detail}; check disabled (sessions.windowsVersionCheck=off), proceeding`
+    );
+    return;
+  }
+  if (mode === "warn") {
+    daemonLog(
+      `windows daemon protocol mismatch: ${detail}; proceeding with warning (sessions.windowsVersionCheck=warn)`
+    );
+    return;
+  }
+  daemonLog(`windows daemon protocol mismatch: ${detail}`);
+  state.onVersionMismatch(msg.version);
+}
+
 // src/commands/sessions/daemon/handleInbound.ts
 function handleInbound(state, line) {
   let msg;
@@ -21424,14 +21516,6 @@ var inbound = {
     state.broadcast(msg);
   }
 };
-function handleHello(state, msg) {
-  if (isHello(msg) && !versionsMatch(msg.version, ASSIST_VERSION)) {
-    daemonLog(
-      `windows daemon version mismatch: ${msg.version} (wsl ${ASSIST_VERSION})`
-    );
-    state.onVersionMismatch(msg.version);
-  }
-}
 function handleCreated(state, msg) {
   daemonLog(`windows daemon: created session ${nsId(msg)}`);
   const client = takePendingCreator(state);
@@ -21443,16 +21527,6 @@ function handleCreated(state, msg) {
     });
   else daemonLog("windows daemon: created with no pending creator (dropped)");
 }
-function handleSessions(state, msg) {
-  state.windowsSessions = msg.sessions.map((s) => ({
-    ...s,
-    id: toWindowsSessionId(s.id)
-  }));
-  const live = new Set(state.windowsSessions.map((s) => s.id));
-  for (const id2 of state.scrollback.keys())
-    if (!live.has(id2)) state.scrollback.delete(id2);
-  state.onSessionsChanged();
-}
 function handleOutput(state, msg) {
   const sessionId = nsId(msg);
   const data = msg.data;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.326.1",
+	"version": "0.327.1",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {