@@ -205,13 +205,14 @@ function makeProviderSession(input: {
   readonly providerSessionId: ProviderSessionId;
   readonly now: DateTime.Utc;
   readonly capabilities?: OrchestrationV2ProviderCapabilities;
+  readonly cwd?: string | null;
 }): OrchestrationV2ProviderSession {
   return {
     id: input.providerSessionId,
     driver: CODEX_DRIVER,
     providerInstanceId: modelSelection.instanceId,
     status: "ready",
-    cwd: process.cwd(),
+    cwd: input.cwd ?? process.cwd(),
     model: "gpt-5.4",
     capabilities: input.capabilities ?? CodexCapabilities,
     createdAt: input.now,
@@ -381,6 +382,7 @@ const makeProviderAdapter = Effect.fnUntraced(function* (
         const session = makeProviderSession({
           providerSessionId: input.providerSessionId,
           now,
+          cwd: input.runtimePolicy.cwd,
           ...(options.capabilities === undefined ? {} : { capabilities: options.capabilities }),
         });
         yield* Ref.update(state, (current) => {
@@ -955,6 +957,62 @@ it.effect("ProviderSessionManagerV2 closes every live session for a provider ins
   }),
 );
 
+it.effect("ProviderSessionManagerV2 reopens an idle session when the agent cwd moves", () =>
+  Effect.gen(function* () {
+    const state = yield* Ref.make(emptyState);
+    const effect = Effect.gen(function* () {
+      const eventSink = yield* EventSink.EventSinkV2;
+      const idAllocator = yield* IdAllocator.IdAllocatorV2;
+      const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
+      const fileSystem = yield* FileSystem.FileSystem;
+      const now = yield* DateTime.now;
+      const checkout = yield* fileSystem.makeTempDirectoryScoped();
+      const nested = `${checkout}/ios`;
+      yield* fileSystem.makeDirectory(nested);
+      const threadId = ThreadId.make("thread-provider-session-manager-cwd-move");
+      const providerSessionId = yield* idAllocator.allocate.providerSession({
+        providerInstanceId: modelSelection.instanceId,
+        threadId,
+      });
+      yield* eventSink.write({
+        events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
+      });
+      const open = (cwd: string) =>
+        manager.open({
+          threadId,
+          providerSessionId,
+          modelSelection,
+          runtimePolicy: { ...runtimePolicy, cwd },
+        });
+
+      const atRoot = yield* open(checkout);
+      assert.equal(atRoot.providerSession.cwd, checkout);
+      assert.strictEqual(yield* open(checkout), atRoot);
+
+      const atNested = yield* open(nested);
+      assert.equal(atNested.providerSession.cwd, nested);
+      const backAtRoot = yield* open(checkout);
+      assert.equal(backAtRoot.providerSession.cwd, checkout);
+      const current = yield* Ref.get(state);
+      assert.equal(current.openCount, 3);
+      assert.equal(current.closeCount, 2);
+    });
+
+    yield* effect.pipe(
+      Effect.scoped,
+      Effect.provide(
+        Layer.merge(
+          layerTest({
+            state,
+            idleTimeoutMs: 60_000,
+          }),
+          NodeServices.layer,
+        ),
+      ),
+    );
+  }),
+);
+
 it.effect("ProviderSessionManagerV2 opens a duplicate session only once", () =>
   Effect.gen(function* () {
     const state = yield* Ref.make(emptyState);
 
@@ -2118,7 +2118,31 @@ export const layerWithOptions = (
                 }
               }
               const key = sessionKey(input.providerSessionId);
-              const existing = (yield* Ref.get(sessions)).get(key);
+              let existing = (yield* Ref.get(sessions)).get(key);
+              // A subdirectory project's worktree thread moves its agent cwd when
+              // a branch gains or drops the subdirectory. A provider keeps its
+              // spawn cwd, so an idle session is reopened there and resumes.
+              if (
+                existing !== undefined &&
+                cwd !== null &&
+                existing.runtime.providerSession.cwd !== cwd &&
+                existing.busyTurns.size === 0 &&
+                [...existing.attachedThreadIds].every((threadId) => threadId === input.threadId) &&
+                !(existing.runtime.hasPendingBackgroundWork === undefined
+                  ? false
+                  : yield* existing.runtime.hasPendingBackgroundWork.pipe(
+                      Effect.catchCause(() => Effect.succeed(true)),
+                    ))
+              ) {
+                yield* releaseEntry({
+                  providerSessionId: input.providerSessionId,
+                  reason: "manual_shutdown",
+                  detail: "The agent's working directory changed.",
+                  gracefulSubscribers: true,
+                  onlyIfIdleGeneration: existing.idleGeneration,
+                }).pipe(logReleaseFailure(input.providerSessionId));
+                existing = (yield* Ref.get(sessions)).get(key);
+              }
               if (existing !== undefined) {
                 const attached = existing.attachedThreadIds.has(input.threadId);
                 if (!attached && !existing.supportsMultipleProviderThreads) {
 
@@ -259,6 +259,8 @@ it.each([
 
 function makeLocalCommandHarness(input: {
   readonly text: string;
+  readonly context?: OrchestrationV2ThreadProjection["messages"][number]["context"];
+  readonly agentCwd?: string;
   readonly worktreePath?: string;
   readonly worktreesDir?: string;
   readonly fileSystem?: FileSystem.FileSystem;
@@ -334,6 +336,7 @@ function makeLocalCommandHarness(input: {
     nodeId: rootNodeId,
     role: "user",
     text: input.text,
+    ...(input.context === undefined ? {} : { context: input.context }),
     attachments: [],
     streaming: false,
     createdBy: "user",
@@ -666,7 +669,9 @@ function makeLocalCommandHarness(input: {
   );
   const resolveRuntimePolicy = vi.fn(
     ({ thread }: Parameters<RuntimePolicy.RuntimePolicyV2Shape["resolve"]>[0]) =>
-      Effect.succeed({ cwd: thread.worktreePath ?? "/tmp/native-account-command" } as never),
+      Effect.succeed({
+        cwd: input.agentCwd ?? thread.worktreePath ?? "/tmp/native-account-command",
+      } as never),
   );
   const createWorktree = vi.fn(() => Effect.succeed({} as never));
   const getThreadRecords = vi.fn<ProjectionStore.ProjectionStoreV2Shape["getThreadRecords"]>(() =>
@@ -796,6 +801,38 @@ effectIt.effect("recovers an abandoned failed turn before continuing its native
   }),
 );
 
+effectIt.effect.each([
+  { agentCwd: "/tmp/checkout/ios", expected: "path: /tmp/checkout/README.md" },
+  { agentCwd: "/tmp/checkout", expected: "path: README.md" },
+])("resolves saved checkout mentions for an agent cwd of $agentCwd", ({ agentCwd, expected }) =>
+  Effect.gen(function* () {
+    const harness = makeLocalCommandHarness({
+      text: "Read [README.md](t3-context://v1/mention/ctx_readme)",
+      context: {
+        version: 1,
+        records: [
+          {
+            version: 1,
+            contextId: "ctx_readme",
+            label: "README.md",
+            kind: "mention",
+            path: "README.md",
+          },
+        ],
+      } as never,
+      worktreePath: "/tmp/checkout",
+      agentCwd,
+      previousTurn: { runStatus: "completed", turnStatus: "completed" },
+    });
+
+    yield* harness.start;
+
+    const text = harness.startRootRun.mock.calls[0]?.[0].message.text;
+    expect(text).toContain(expected);
+    expect(text).not.toContain("path: /tmp/checkout/ios/");
+  }),
+);
+
 effectIt.effect.each([
   { runStatus: "failed", turnStatus: "completed" },
   { runStatus: "completed", turnStatus: "completed" },
 
@@ -1032,9 +1032,25 @@ export const layer: Layer.Layer<
       const routableSubagents = projection.subagents.filter((subagent) =>
         RunExecutionService.canRouteRelatedSubagent(subagent.status),
       );
+      // Mentions are saved relative to the checkout; an agent in a subdirectory
+      // of it would otherwise read them against its own cwd.
+      const checkoutRoot = projection.thread.worktreePath;
+      const mentionRoot =
+        checkoutRoot !== null &&
+        resolvedRuntimePolicy.cwd !== null &&
+        path.resolve(checkoutRoot) !== path.resolve(resolvedRuntimePolicy.cwd)
+          ? checkoutRoot
+          : null;
       const userText = projectComposerContextForProvider({
         text: message.text,
-        records: message.context?.records ?? [],
+        records: (message.context?.records ?? []).map((record) =>
+          mentionRoot !== null &&
+          record.kind === "mention" &&
+          "path" in record &&
+          !path.isAbsolute(record.path)
+            ? { ...record, path: path.join(mentionRoot, record.path) }
+            : record,
+        ),
       });
       // Delivered once: this run's provider turn marks the work as told. A
       // restart continuation is prompted by its own text or resumes natively.
 
@@ -763,7 +763,8 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
   const previewFile = composerFiles.find((file) => file.id === previewFileId);
   const composerContextActions = {
     environmentId,
-    cwd: gitCwd ?? undefined,
+    // Mention chips name paths relative to the file panel's root.
+    cwd: workspaceRoot ?? gitCwd ?? undefined,
     expandImage: (imageId: string) => {
       const preview = buildExpandedImagePreview(composerImages, imageId);
       if (preview) onExpandImage(preview);