Fix a chosen project being forgotten when the daemon restarts

Author: KenKaiii

CLAUDE.md

@@ -16,6 +16,7 @@ Mobile remote control for **desktop coding agents** (Claude Code, Codex, Gemini
 - **Spawned children need `error` *and* `spawn` listeners** — an unresolvable command emits `error` async, and unhandled it kills the daemon and every other session.
 - **The useful half of an agent failure is JSON-RPC `data.details`** (sometimes double-encoded), and it arrives twice: as message text, then a rejection. `humanError()` (`errors.ts`) normalises at the one point all transports share. A clean exit is not an error — closing a session always fires `kind: "exit"`.
 - **`resolveWorkspace()` (`workspace.ts`) is the only cwd default** (explicit → `PEW2_WORKSPACE` → daemon cwd → home). Under launchd cwd is `/` and agents treat cwd as project root — GG Coder died on `mkdir '/.gg'`. Session start *and* the capability probe go through it; a third spawn path reintroduces the bug.
+- **A client's `cwd` is honoured only via `knownProject()`, and that check has to outlive the process** — the app re-sends its chosen project on every reconnect and every new conversation, for days. Browsed paths lived in memory alone, so a daemon restart made a genuine pick unknown, and both readers failed *silently*: `workspace.status` answered with the agent's previous project (the composer named a repo the user never picked) and `session.start` then refused the same path. Acceptance is written to `known-projects.json`, and the check reads the probe cache when no probe has landed yet — the app asks in the same breath as the probe it triggers, so recognition must never be a race against a spawn. `session.resume` still falls back rather than refusing (it arrives before the probe), but it may not *guess a project*: it takes the cwd the agent recorded for that conversation, because dropping to the provider's last workspace reopened a chat about one repo with the agent rooted in another.
 - **Two prefs files, deliberately.** `config-prefs.json` (one file for all providers — read-modify-write it) seeds the *next new* session; `session-prefs.json` is replayed on `session/load`, because ACP resumes a transcript but hands back the agent's *default* selectors. Never apply the provider pref to a resume — that rewrites a desk-started conversation to match the phone's last pick.
 - **Session ids die with the daemon; the app's list does not.** `needsResume()` (`agentHistory.ts`) is the single rule for opening a conversation, and an undefined `activeSessions` (older daemon) means *assume live*. Without it a restarted daemon answers `Unknown session '<id>'`.
 - **Projects fold from the *uncapped* session list**, before `SESSION_HISTORY_LIMIT` (`projects.ts`) — the capped list is a recent-work window, so grouping it hides every repo not touched this week. Message counts hydrate per project on demand, never at probe time.

packages/daemon/src/handler.test.ts

@@ -8,8 +8,24 @@
  * anyone holding the pairing token can send.
  */
 import { expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { handleMessage } from "./handler.js";
 import { Daemon } from "./index.js";
+import { readKnownProjects } from "./known-projects.js";
+import { writeProbeCache } from "./probe-cache.js";
+
+/**
+ * A state directory of this test's own.
+ *
+ * Accepting a project writes it down (`known-projects.json`), so a daemon built
+ * on the real environment would both read the developer's own projects and add
+ * to them.
+ */
+function scratchHome(): NodeJS.ProcessEnv {
+  return { ...process.env, PEW2_HOME: mkdtempSync(join(tmpdir(), "pew2-handler-")) };
+}
 
 /**
  * A daemon whose project bookkeeping is real and whose spawning is not.
@@ -18,8 +34,8 @@ import { Daemon } from "./index.js";
  * so they are the production ones; only the parts that would start an agent are
  * replaced.
  */
-function stubbed() {
-  const daemon = new Daemon({ id: "test", name: "test" }, true);
+function stubbed(env: NodeJS.ProcessEnv = scratchHome()) {
+  const daemon = new Daemon({ id: "test", name: "test" }, true, env);
   const started: Array<{ providerId: string; cwd: string }> = [];
   const resumed: Array<{ agentSessionId: string; cwd: string }> = [];
   const listed: string[] = [];
@@ -110,6 +126,103 @@ test("a browsed directory can still be started in", async () => {
   expect(announced?.cwd).toBe("/Users/someone/code/api");
 });
 
+test("a project chosen from the app outlives the daemon that offered it", async () => {
+  // The bug this exists for: browsing to a project, then restarting the daemon
+  // (an update, a crash, a development restart) while the app still holds that
+  // project selected. The app re-sends the same path on every reconnect and
+  // every new conversation, so "offered seconds ago" was never the real
+  // lifetime of a pick.
+  const env = scratchHome();
+  const first = stubbed(env);
+  first.daemon.rememberOfferedWorkspaces(["/Users/someone/code/api"]);
+  await send(first.daemon, {
+    t: "workspace.status",
+    providerId: "echo",
+    cwd: "/Users/someone/code/api",
+  });
+  // Written down on acceptance, not merely on offer.
+  expect(await readKnownProjects(env)).toEqual(["/Users/someone/code/api"]);
+
+  // A second process, with nothing in memory: exactly what the app reconnects
+  // to after an update.
+  const restarted = stubbed(env);
+  const out = await send(restarted.daemon, {
+    t: "session.start",
+    providerId: "echo",
+    cwd: "/Users/someone/code/api",
+  });
+
+  expect(restarted.started).toEqual([
+    { providerId: "echo", cwd: "/Users/someone/code/api" },
+  ]);
+  expect(out.find((m) => m.t === "session.started")?.cwd).toBe("/Users/someone/code/api");
+});
+
+test("a restart does not silently answer with a different project", async () => {
+  // The visible half of the same bug, and the reason it was so confusing: the
+  // composer named the agent's *previous* project, so a new conversation looked
+  // locked to the last repo no matter which one was picked.
+  const env = scratchHome();
+  const first = stubbed(env);
+  first.daemon.rememberOfferedWorkspaces(["/Users/someone/code/api"]);
+  await send(first.daemon, {
+    t: "workspace.status",
+    providerId: "echo",
+    cwd: "/Users/someone/code/api",
+  });
+
+  const restarted = stubbed(env);
+  const out = await send(restarted.daemon, {
+    t: "workspace.status",
+    providerId: "echo",
+    cwd: "/Users/someone/code/api",
+  });
+
+  expect(out[0]?.t).toBe("workspace");
+  expect(out[0]?.cwd).toBe("/Users/someone/code/api");
+  expect(out[0]?.folder).toBe("api");
+});
+
+test("a directory that was never published stays unknown across a restart", async () => {
+  // The containment is what survives, not the path: nothing is stored unless
+  // this daemon published it and a client then chose it.
+  const env = scratchHome();
+  await send(stubbed(env).daemon, { t: "session.start", providerId: "echo", cwd: "/etc" });
+  expect(await readKnownProjects(env)).toEqual([]);
+
+  const out = await send(stubbed(env).daemon, {
+    t: "session.start",
+    providerId: "echo",
+    cwd: "/etc",
+  });
+  expect(out[0]?.t).toBe("error");
+  expect(out[0]?.message).toContain("unknown project");
+});
+
+test("a project with agent history is recognised before any probe has landed", async () => {
+  // The app asks where the next prompt will land the instant it reconnects,
+  // in the same breath as the probe that fills the in-memory project history.
+  // Reading only that map made recognising a genuine project a race against an
+  // agent spawn, and losing it looked identical to the bug above: the composer
+  // named whatever the agent had open last.
+  const env = scratchHome();
+  await writeProbeCache(
+    "echo",
+    { canResume: true, configOptions: [], sessions: [] },
+    env,
+    [{ sessionId: "s1", cwd: "/Users/someone/code/api", updatedAt: "2026-08-10T12:00:00Z" }],
+  );
+
+  const { daemon, started } = stubbed(env);
+  await send(daemon, {
+    t: "session.start",
+    providerId: "echo",
+    cwd: "/Users/someone/code/api",
+  });
+
+  expect(started).toEqual([{ providerId: "echo", cwd: "/Users/someone/code/api" }]);
+});
+
 test("naming no project at all still falls back to the agent's last one", async () => {
   // The phone has no file picker, so most sessions arrive with no `cwd`. That
   // path never involved a client-supplied string and must keep working.
@@ -181,6 +294,57 @@ test("resuming falls back instead of refusing an unrecognised directory", async
   });
 });
 
+test("reopening a conversation uses the project the agent recorded for it", async () => {
+  // The fallback above may not guess a *different* project. Dropping to the
+  // provider's last workspace reopens a conversation about one repo with the
+  // agent rooted in another — every file tool in that turn then works on the
+  // wrong project, and the `session.started` tells every client to file the
+  // conversation there too.
+  //
+  // The agent's own history says where its session lives, so no guess is
+  // needed. This is also the older app, which sends no `cwd` at all.
+  const env = scratchHome();
+  await writeProbeCache("echo", { canResume: true, configOptions: [], sessions: [] }, env, [
+    { sessionId: "agent-1", cwd: "/Users/someone/code/api", updatedAt: "2026-08-10T12:00:00Z" },
+  ]);
+  const { daemon, resumed } = stubbed(env);
+
+  const out = await send(daemon, {
+    t: "session.resume",
+    providerId: "echo",
+    agentSessionId: "agent-1",
+  });
+
+  expect(resumed).toEqual([{ agentSessionId: "agent-1", cwd: "/Users/someone/code/api" }]);
+  // And the announcement agrees, so no client files it under the fallback.
+  expect(out.find((m) => m.t === "session.started")?.cwd).toBe("/Users/someone/code/api");
+});
+
+test("the agent's record beats a client naming some other project", async () => {
+  // Both paths are ones this daemon published, so this is not containment — it
+  // is which of two honest answers is about *this* conversation. A phone can be
+  // holding a stale row, or simply the project it currently has selected.
+  const env = scratchHome();
+  await writeProbeCache("echo", { canResume: true, configOptions: [], sessions: [] }, env, [
+    { sessionId: "agent-1", cwd: "/Users/someone/code/api", updatedAt: "2026-08-10T12:00:00Z" },
+  ]);
+  const { daemon, resumed } = stubbed(env);
+  daemon.rememberOfferedWorkspaces(["/Users/someone/code/www"]);
+
+  await send(daemon, {
+    t: "session.resume",
+    providerId: "echo",
+    agentSessionId: "agent-1",
+    cwd: "/Users/someone/code/www",
+  });
+
+  expect(resumed).toEqual([{ agentSessionId: "agent-1", cwd: "/Users/someone/code/api" }]);
+  // The path the client sent is not even consulted, so it is not filed as a
+  // project this client opened — it named where it happened to be looking, not
+  // what it was reopening.
+  expect(await readKnownProjects(env)).toEqual(["/Users/someone/code/api"]);
+});
+
 test("a push token is kept against the device that proved who it was", async () => {
   const { daemon } = stubbed();
 

packages/daemon/src/handler.ts

@@ -54,8 +54,8 @@ export interface HandlerContext {
  * refusal deliberately says nothing about whether the path exists — answering
  * that for an arbitrary string is a filesystem oracle in its own right.
  */
-function namedProject(daemon: Daemon, providerId: string, cwd: string): string {
-  const known = daemon.knownProject(providerId, cwd);
+async function namedProject(daemon: Daemon, providerId: string, cwd: string): Promise<string> {
+  const known = await daemon.knownProject(providerId, cwd);
   if (!known) throw new Error("unknown project");
   return known;
 }
@@ -156,7 +156,7 @@ export async function handleMessage(raw: string, ctx: HandlerContext): Promise<v
         // broadcast: it is a menu choice on one phone, not a change to the
         // session log every client shares.
         const providerId = message.providerId;
-        const projectCwd = namedProject(daemon, providerId, message.cwd);
+        const projectCwd = await namedProject(daemon, providerId, message.cwd);
         const sessions = await daemon.sessionsForProject(providerId, projectCwd);
         reply({
           t: "provider.sessions",
@@ -183,11 +183,27 @@ export async function handleMessage(raw: string, ctx: HandlerContext): Promise<v
         // break reopening a session every time the daemon was updated. The
         // containment is unchanged either way: the client's string is used only
         // when this daemon published it, and otherwise never reaches a spawn.
-        const named = message.cwd
-          ? daemon.knownProject(message.providerId, message.cwd)
-          : undefined;
-        const workspace =
-          named ?? (await daemon.lastWorkspace(message.providerId)) ?? cwd;
+        //
+        // What the fallback must not do is *guess a different project*, which is
+        // what it used to: dropping to the provider's last workspace reopened a
+        // conversation about one repo with the agent rooted in another, and told
+        // every client to file it there. So the agent's own record for this
+        // conversation comes first — it is the authority on where its own
+        // session lives, it needs no client to be up to date, and it is right
+        // even for an older app that sends no `cwd` at all.
+        const recorded = await daemon.agentSessionCwd(
+          message.providerId,
+          message.agentSessionId,
+        );
+        // Only asked when the agent had no record: checking a path also files it
+        // as a project this client has opened, and the one it sent here is not
+        // the one being opened.
+        const named =
+          recorded ??
+          (message.cwd
+            ? await daemon.knownProject(message.providerId, message.cwd)
+            : undefined);
+        const workspace = named ?? (await daemon.lastWorkspace(message.providerId)) ?? cwd;
         const pending = daemon.beginResumeSession(
           message.providerId,
           message.agentSessionId,
@@ -235,15 +251,15 @@ export async function handleMessage(raw: string, ctx: HandlerContext): Promise<v
         // has no file picker, and defaulting to the home directory gives the
         // agent no project to work in and no project commands to offer.
         const workspace = message.cwd
-          ? namedProject(daemon, message.providerId, message.cwd)
+          ? await namedProject(daemon, message.providerId, message.cwd)
           : ((await daemon.lastWorkspace(message.providerId)) ?? cwd);
         const sessionId = await daemon.startSession(message.providerId, workspace);
         broadcast({
           t: "session.started",
           sessionId,
           providerId: message.providerId,
           // The project the session was actually started in, which is not
-          // always the one asked for: an unrecognised `cwd` falls back to the
+          // always the one asked for: a request naming no project opens in the
           // agent's last workspace above. Sending the resolved value means a
           // client files the row where the work is really happening, and a
           // second device — which never saw the request — can file it at all.
@@ -402,7 +418,7 @@ export async function handleMessage(raw: string, ctx: HandlerContext): Promise<v
         // directory the answer already listed.
         const chosen =
           message.providerId && message.cwd
-            ? daemon.knownProject(message.providerId, message.cwd)
+            ? await daemon.knownProject(message.providerId, message.cwd)
             : undefined;
         const root =
           (message.sessionId ? daemon.sessionCwd(message.sessionId) : undefined) ??