pi-orchestrator-config 4.3.3 → 4.3.5

package/README.md

@@ -15,7 +15,7 @@ Single extension that provides:
 | **Subagent tool** | Delegate tasks to specialist agents (single, parallel, chain, async modes); optional `model` param for model override |
 | **`list_models`** | List available models and providers for subagent model override |
 | **Async background agents** | Spawn agents in background with `async: true` — results surface automatically when complete. Fullscreen overlay dashboard with live output, keyboard nav, and kill support (`/async-status`, `/async-kill`). On **acpx** parents, optional async is coerced to sync; dream/cron need `internal_operations_provider` + `internal_operations_model`. `cli-*` providers support async natively (see `dev-docs/cli-provider.md`) |
-| **CLI / ACPX providers** | Optional `cli_agents` / `acpx_agents` register `cli-*` / `acpx-*` via native `createProvider` (pi ≥ 0.84): `/login cli-<agent>` or `/login acpx-<agent>`, model refresh, filter when unavailable. Missing context window / maxTokens / cost filled from models.dev (`~/.pi/pi-config/models.dev.json`, 1-day refresh). Cold-start default restore (#753): gates `startup`\|`new`, empty `enabledModels`, trusted project merge — see `dev-docs/cli-provider.md` |
+| **CLI / ACPX providers** | Optional `cli_agents` / `acpx_agents` register `cli-*` / `acpx-*` via native `createProvider` (pi ≥ 0.84): `/login cli-<agent>` or `/login acpx-<agent>`, model refresh, filter when unavailable. Missing context window / maxTokens / cost filled from models.dev (`~/.pi/pi-config/models.dev.json`, 1-day refresh). Cold-start default restore (#753): gates `startup`\|`new`, empty `enabledModels`, trusted project merge — see `dev-docs/cli-provider.md`. Headless Cursor `--approve-mcps` when `CLI_APPROVE_MCPS` is set (`false` opts out) or the process is a sidecar (`SIDECAR_PORT`; `startSidecar()` stamps it while running and restores it on `close()`). Executable sidecar consumers should call `bindSidecarListenExit()` so bind/`stopped` fatals exit 1. Headless Gemini defaults `GEMINI_CLI_TRUST_WORKSPACE=true` and preserves an explicit parent value (including `false`). |
 | **`/btw` command** | Quick side questions without polluting conversation history — ephemeral overlay |
 | **`/async-status` command** | Show status of background agents — select one for live output streaming |
 | **`/async-kill` command** | Kill async agents (overlay picker or by name/id) |
@@ -452,28 +452,34 @@ variables. Pi-config settings (image_model, acpx_agents, vertex_claude_1m, etc.)
 go in `.pi/pi-config-settings.json` — not here:
 
 ```env
-# Timezone (host timezone for correct timestamps)
-TZ=Asia/Jerusalem
+# Timezone (host timezone for correct timestamps) — plain value, no inline comment:
+# `docker run --env-file` does not strip trailing comments.
+TZ=America/New_York
 
 # Host username (creates /home/<user> -> container home symlink so host paths resolve)
-PI_HOST_USER=myakove
+PI_HOST_USER=youruser
+
+# Host UID/GID belong on the docker alias (see below), not hardcoded here:
+#   -e PI_HOST_UID="$(id -u)" -e PI_HOST_GID="$(id -g)"
+# The entrypoint remaps user `node` to those ids so bind-mounted 0600/0700
+# files (~/.npmrc, ~/.ssh) are readable. IPA/LDAP users are not UID 1000.
 
 # Google Cloud / Vertex AI
 GOOGLE_CLOUD_PROJECT=your-project-id
 GOOGLE_CLOUD_LOCATION=us-east5
-GOOGLE_APPLICATION_CREDENTIALS=/home/myakove/.config/gcloud/application_default_credentials.json
+GOOGLE_APPLICATION_CREDENTIALS=/home/youruser/.config/gcloud/application_default_credentials.json
 
 # GitHub
 GITHUB_TOKEN=ghp_xxx
 GITHUB_API_TOKEN=ghp_xxx
-GH_CONFIG_DIR=/home/myakove/.config/gh
+GH_CONFIG_DIR=/home/youruser/.config/gh
 
 # Gemini (optional — required for image generation)
 GEMINI_API_KEY=xxx
 
 # mcpl (MCP Launchpad) config path inside the container (must match mount target)
 # Use your actual home path — it resolves inside the container via the PI_HOST_USER symlink
-MCPL_CONFIG_FILES=/home/myakove/.config/mcpl/mcp.json
+MCPL_CONFIG_FILES=/home/youruser/.config/mcpl/mcp.json
 ```
 
 Pass via `--env-file /path/to/.env` in the docker run command.
@@ -645,6 +651,7 @@ PI_PIDIFF_ENABLE=false pi
 | `kubectl` / `oc` | Kubernetes and OpenShift CLI |
 | `agent-browser` | Browser automation CLI (navigate, click, screenshot, forms) |
 | `procps` | Process utilities (ps, top, pgrep, pkill) |
+| `passwd` | `usermod`/`groupmod` — init remaps user `node` to `PI_HOST_UID`/`PI_HOST_GID` |
 | `docker` / `podman` | Container CLIs (used via `docker-safe` read-only wrapper) |
 | `docker-safe` | Restricted Docker/Podman wrapper — container only (ps, logs, inspect, top, stats) |
 | `jq` | JSON processing |
@@ -701,6 +708,8 @@ alias pi-docker='docker pull ghcr.io/myk-org/pi-config:latest && \
   --name "pi-config-$(basename $PWD)-$(date +%s)" \
   --network host \
   --env-file "$HOME/.pi/.env" \
+  -e PI_HOST_UID="$(id -u)" \
+  -e PI_HOST_GID="$(id -g)" \
   -v "$PWD":"$PWD":rw \
   -v "$HOME/.pi":"$HOME/.pi":rw \
   -v "$HOME/.gitconfig":"$HOME/.gitconfig":ro \
@@ -722,11 +731,15 @@ alias pi-docker='docker pull ghcr.io/myk-org/pi-config:latest && \
 
 Then just run `pi-docker` from any project directory.
 
-> **Startup note:** The container runs as non-root user `node` (UID 1000).
+> **Startup note:** The container runs as non-root user `node`. At start the
+> entrypoint remaps `node` to `PI_HOST_UID`/`PI_HOST_GID` (pass `$(id -u)` /
+> `$(id -g)` on the alias) so bind-mounted secrets match the host user.
+> Without those env vars, `node` stays UID 1000 (breaks IPA/LDAP hosts).
 > `pi install` runs on each start.
 > A `WARNING` on stderr is normal when the package is already cached in `~/.pi`.
 > If pi misbehaves or the warning persists, verify network connectivity
-> and run `pi install git:github.com/myk-org/pi-config` manually.
+> and run `pi install git:github.com/myk-org/pi-config` and
+> `pi install git:github.com/myk-org/pi-config/packages/pi-vertex-claude` manually.
 
 ## Discord Bot
 

package/extensions/cli-provider/agents/cursor.ts

@@ -54,11 +54,35 @@ function discoverCursorModels(): DiscoveredCliModel[] {
   return models;
 }
 
+/**
+ * Headless Cursor MCP: `--approve-mcps` is opt-in, not unconditional.
+ * `CLI_APPROVE_MCPS` wins; otherwise sidecar processes (`SIDECAR_PORT`, stamped
+ * by `startSidecar()` while running) get it because they have no TTY.
+ * Interactive pi omits the flag.
+ */
+export function shouldApproveCursorMcps(
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  const explicit = env.CLI_APPROVE_MCPS;
+  if (typeof explicit === "string" && explicit.length > 0) {
+    const on = ["1", "true", "yes", "on"].includes(explicit.toLowerCase());
+    log.debug(`cursor --approve-mcps CLI_APPROVE_MCPS=${explicit} -> ${on}`);
+    return on;
+  }
+  const sidecar = typeof env.SIDECAR_PORT === "string" && env.SIDECAR_PORT.length > 0;
+  log.debug(`cursor --approve-mcps SIDECAR_PORT set=${sidecar}`);
+  return sidecar;
+}
+
 export const cursorProvider: CliProviderDef = {
   name: "cursor",
   binary: "agent",
   buildBaseArgs: (model, cwd) => {
-    // --trust: workspace; --force: auto-approve; stream-partial-output: live tokens
+    // --trust: workspace; --force: auto-approve tools
+    const approveMcps = shouldApproveCursorMcps();
+    log.debug(
+      `cursor buildBaseArgs approveMcps=${approveMcps} modelOverride=${Boolean(model && model !== "default")}`,
+    );
     const args = [
       "--print",
       "--trust",
@@ -69,6 +93,9 @@ export const cursorProvider: CliProviderDef = {
       "--workspace",
       cwd,
     ];
+    if (approveMcps) {
+      args.push("--approve-mcps");
+    }
     if (model && model !== "default") {
       args.unshift("--model", model);
     }

package/extensions/cli-provider/agents/gemini.ts

@@ -81,7 +81,8 @@ export const geminiProvider: CliProviderDef = {
   name: "gemini",
   binary: "gemini",
   buildBaseArgs: (model) => {
-    // --skip-trust: workspace; --yolo: auto-approve all tool actions
+    // --skip-trust: skip TTY trust dialog (MCP still needs GEMINI_CLI_TRUST_WORKSPACE)
+    // --yolo: auto-approve all tool actions
     const args = [
       "--skip-trust",
       "--yolo",

package/extensions/cli-provider/providers.ts

@@ -15,6 +15,7 @@ import { geminiProvider } from "./agents/gemini.js";
  * |---------|--------|--------|--------|
  * | Workspace trust | `--trust` | skipped by `-p` | `--skip-trust` |
  * | Tool/command approve | `--force` (`--yolo` alias) | `--dangerously-skip-permissions` | `--yolo` |
+ * | Project MCP | `--approve-mcps` if `CLI_APPROVE_MCPS` or `SIDECAR_PORT` (`startSidecar()` stamps it while running) | n/a | `GEMINI_CLI_TRUST_WORKSPACE=true` unless parent already set |
  *
  * Trust alone is NOT enough: without auto-approve, tool calls that need
  * confirmation hang or fail (no interactive user).

package/extensions/cli-provider/runner.ts

@@ -3,8 +3,11 @@
  */
 
 import { spawn } from "node:child_process";
+import { createLogger } from "../shared/logger.js";
 import type { CliAgentName } from "./providers.js";
 import { buildCliCommand } from "./providers.js";
+
+const log = createLogger("cli_provider");
 import {
   parseCliOutput,
   StreamJsonAccumulator,
@@ -54,9 +57,23 @@ const STRIP_ENV = [
   "CURSOR_TRACE_ID",
 ];
 
-function childEnv(): NodeJS.ProcessEnv {
+function childEnv(agent: CliAgentName): NodeJS.ProcessEnv {
   const env = { ...process.env };
   for (const k of STRIP_ENV) delete env[k];
+  // --skip-trust skips the TTY dialog; Gemini still treats /tmp (and other
+  // unsigned folders) as untrusted and will not connect project MCP unless
+  // this env is set (same class of headless gap as Cursor --approve-mcps).
+  // Default true for headless MCP; preserve an explicit parent value (e.g. false).
+  if (agent === "gemini") {
+    if (env.GEMINI_CLI_TRUST_WORKSPACE === undefined) {
+      env.GEMINI_CLI_TRUST_WORKSPACE = "true";
+      log.debug("gemini spawn: defaulting GEMINI_CLI_TRUST_WORKSPACE=true for project MCP");
+    } else {
+      log.debug(
+        `gemini spawn: preserving parent GEMINI_CLI_TRUST_WORKSPACE=${env.GEMINI_CLI_TRUST_WORKSPACE}`,
+      );
+    }
+  }
   return env;
 }
 
@@ -80,9 +97,12 @@ export function runCliAgent(opts: CliRunOptions): Promise<CliRunResult> {
       return;
     }
 
+    log.debug(
+      `runCliAgent spawn agent=${opts.agent} stream=${stream} timeoutMs=${timeoutMs ?? "none"} cwdBound=${Boolean(opts.cwd)}`,
+    );
     const child = spawn(binary, argv, {
       cwd: opts.cwd,
-      env: childEnv(),
+      env: childEnv(opts.agent),
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
     });

package/extensions/orchestrator/async-agents.ts

@@ -919,15 +919,31 @@ export function registerAsyncAgents(
     }), { mode: 0o600 });
 
     // Find the runner script
-    const runnerPath = path.join(path.dirname(new URL(import.meta.url).pathname), "async-runner.ts");
+    const runnerPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "async-runner.ts");
 
     // Find jiti for TypeScript execution
     let jitiCliPath: string | undefined;
     // Strategy 1: resolve from pi's own require context
+    // NOTE: newer pi SDK "exports" maps hide ./package.json — fall back to
+    // resolving the main entry and walking up to its package root.
     try {
-      const piPkgDir = path.dirname(require.resolve("@earendil-works/pi-coding-agent/package.json"));
-      const candidate = path.join(piPkgDir, "node_modules/jiti/lib/jiti-cli.mjs");
-      if (fs.existsSync(candidate)) jitiCliPath = candidate;
+      const req = createRequire(import.meta.url);
+      let piPkgJsonPath: string | undefined;
+      try {
+        piPkgJsonPath = req.resolve("@earendil-works/pi-coding-agent/package.json");
+      } catch {
+        const entry = req.resolve("@earendil-works/pi-coding-agent");
+        let dir = path.dirname(entry);
+        while (dir !== path.dirname(dir)) {
+          const pj = path.join(dir, "package.json");
+          if (fs.existsSync(pj) && JSON.parse(fs.readFileSync(pj, "utf8"))?.name === "@earendil-works/pi-coding-agent") { piPkgJsonPath = pj; break; }
+          dir = path.dirname(dir);
+        }
+      }
+      if (piPkgJsonPath) {
+        const candidate = path.join(path.dirname(piPkgJsonPath), "node_modules/jiti/lib/jiti-cli.mjs");
+        if (fs.existsSync(candidate)) jitiCliPath = candidate;
+      }
     } catch (e: any) {
       log.debug(`jiti strategy 1 (require.resolve) failed: ${e?.message || e}`);
     }
@@ -947,6 +963,28 @@ export function registerAsyncAgents(
       }
     }
 
+    // Strategy 3: this package's own node_modules — git/stow installs ship
+    // jiti themselves (npm consumers are covered by strategies 1-2).
+    if (!jitiCliPath) {
+      try {
+        const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+        const candidate = path.join(pkgRoot, "node_modules/jiti/lib/jiti-cli.mjs");
+        if (fs.existsSync(candidate)) jitiCliPath = candidate;
+      } catch (e: any) {
+        log.debug(`jiti strategy 3 (package root) failed: ${e?.message || e}`);
+      }
+    }
+
+    // Fail fast with a self-explanatory error instead of spawning a child that
+    // cannot load TypeScript (bare node dies on ".js"→".ts" specifiers).
+    if (!jitiCliPath) {
+      log.error(`async-spawn: ${id} — no jiti-cli.mjs found (strategies 1-3 failed); refusing to spawn`);
+      // Clean up the artifacts we already created — nothing will consume them.
+      try { fs.rmSync(configPath, { force: true }); } catch {}
+      try { fs.rmSync(workerDir, { recursive: true, force: true }); } catch {}
+      return { id, error: "jiti-cli.mjs not found — cannot execute async agent (see orchestrator logs)" };
+    }
+
     const spawnArgs = jitiCliPath
       ? [jitiCliPath, runnerPath, configPath]
       : [runnerPath, configPath];
@@ -957,6 +995,10 @@ export function registerAsyncAgents(
       PI_SUBAGENT_CHILD: "1",
       PI_AGENT_NAME: agentName,
       PI_PRIMARY_MODEL: process.env.PI_PRIMARY_MODEL || process.env.PI_MODEL || "",
+      // Isolate children from the shared jiti FS cache — other sessions running
+      // different node/jiti versions can poison it and kill children at boot.
+      JITI_CACHE: "false",
+      JITI_FS_CACHE: "false",
       __PI_CONFIG_SESSION_ID: (globalThis as any).__piConfigSessionId || "",
       __PI_PARENT_SESSION_ID: (globalThis as any).__piConfigSessionId || "",
     };
@@ -1004,14 +1046,21 @@ export function registerAsyncAgents(
     };
     asyncState.jobs.set(id, job);
 
+    const stderrLogPath = path.join(workerDir, "child-stderr.log");
+    const stderrLog = fs.createWriteStream(stderrLogPath, { flags: "w" });
+    stderrLog.on("error", () => {}); // never let a log write failure crash the session
+    log.debug(`async-spawn: ${job.id} stderr → ${stderrLogPath}`);
+
     const proc = spawn(process.execPath, spawnArgs, {
       cwd,
-      stdio: "ignore",
+      stdio: ["ignore", "ignore", "pipe"],
       windowsHide: true,
       env: spawnEnv,
     });
+    proc.stderr?.pipe(stderrLog);
 
     proc.once("error", (err) => {
+      try { stderrLog.destroy(); } catch {}
       log.info(`spawn-error: ${job.id} — ${err.message}`);
       if (job.status === "complete" || job.status === "failed") return;
       job.status = "failed";
@@ -1037,8 +1086,27 @@ export function registerAsyncAgents(
         setTimeout(() => {
           if (job.status === "complete" || job.status === "failed") return;
           log.info(`spawn-exit: ${job.id} — code=${code} signal=${signal}`);
+          let stderrTail = "";
+          try {
+            if (fs.existsSync(stderrLogPath)) {
+              // Tail-read only — the log can be arbitrarily large on noisy failures.
+              const size = fs.statSync(stderrLogPath).size;
+              const start = Math.max(0, size - 4096);
+              let raw = "";
+              if (size > 0) {
+                const fd = fs.openSync(stderrLogPath, "r");
+                try {
+                  const buf = Buffer.alloc(Math.min(size - start, 4096));
+                  fs.readSync(fd, buf, 0, buf.length, start);
+                  raw = buf.toString("utf8");
+                } finally { fs.closeSync(fd); }
+              }
+              stderrTail = raw.trim().slice(-1200);
+            }
+          } catch {}
+          log.warn(`async-child failed: ${job.id} code=${code}${stderrTail ? " (see child-stderr.log)" : " (no stderr captured)"}`);
           job.status = "failed";
-          job.output = `Process exited with code ${code} signal ${signal}`;
+          job.output = `Process exited with code ${code} signal ${signal}${stderrTail ? `\n--- child stderr (tail) ---\n${stderrTail}` : ""}`;
           job.durationMs = Date.now() - job.startedAt;
           job.updatedAt = Date.now();
           job.sideEffectsApplied = true;

package/extensions/orchestrator/utils.ts

@@ -152,18 +152,28 @@ export const MIN_PI_VERSION = "0.84.0";
 
 /** Get the installed pi version from its package.json. */
 export function getPiVersion(): string | null {
+  // 1) Resolve from the running binary — walk up until we find the package
+  // root (works for any layout: dist/cli.js, dist/bundle/cli.js, src/…).
   try {
-    // Resolve from pi's own install location (process.argv[1] → dist/cli.js → package root)
     const piScript = process.argv[1];
     if (piScript) {
-      const realPath = fs.realpathSync(piScript);
-      const piPkgPath = path.join(path.dirname(path.dirname(realPath)), "package.json");
-      if (fs.existsSync(piPkgPath)) {
-        const pkg = JSON.parse(fs.readFileSync(piPkgPath, "utf-8"));
-        if (pkg.name === "@earendil-works/pi-coding-agent" && pkg.version) return pkg.version;
+      let dir = path.dirname(fs.realpathSync(piScript));
+      while (dir !== path.dirname(dir)) {
+        const pkgPath = path.join(dir, "package.json");
+        if (fs.existsSync(pkgPath)) {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+          if (pkg.name === "@earendil-works/pi-coding-agent" && pkg.version) return pkg.version;
+        }
+        dir = path.dirname(dir);
       }
     }
   } catch {}
+  // 2) Ask the CLI the user actually runs — authoritative for wrapper/bundle layouts.
+  try {
+    const out = execFileSync("pi", ["--version"], { timeout: 5000, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+    const m = out.match(/\d+\.\d+\.\d+(?:-[\w.]+)?/);
+    if (m) return m[0];
+  } catch {}
   return null;
 }
 

package/extensions/providers/acpx-driver.ts

@@ -35,6 +35,7 @@ import { loadAcpxRuntime, type AcpxRuntimeModule } from "../acpx-provider/load-r
 import { modelIdToDisplayName } from "../acpx-provider/runtime-models.js";
 import { buildExternalSystemPrompt } from "../shared/build-system-prompt.js";
 import { fileLog } from "../shared/file-logger.js";
+import { resolveAdapterCwd, adapterMemoryKey } from "../shared/session-cwd.js";
 import { resolveBinary } from "../shared/resolve-binary.js";
 
 const LOG_DOMAIN = "acpx-driver";
@@ -73,34 +74,42 @@ type AcpRuntimeHandle = Awaited<ReturnType<AcpxRuntime["ensureSession"]>>;
 // Adapter
 // ---------------------------------------------------------------------------
 
-function createAcpxAdapter(
+export function createAcpxAdapter(
   config: AcpxConfig,
   cwd: string,
   runtime: AcpxRuntime,
-  cwdSlug: string,
   initialHandle?: AcpRuntimeHandle,
 ): ProviderAdapterShape {
+  fileLog(LOG_DOMAIN, "debug", LOG_DOMAIN,
+    `createAcpxAdapter bootCwdBound=${Boolean(cwd)} agent=${config.agent}`);
   const handles = new Map<string, AcpRuntimeHandle>();
   const prevCumulative = new Map<string, { inputTokens?: number; outputTokens?: number; totalTokens?: number }>();
-  // Seed with the discovery handle so the first turn reuses it
+  // Seed with the discovery handle so the first turn reuses it when cwd matches boot
   if (initialHandle) {
-    handles.set("default", initialHandle);
+    handles.set(adapterMemoryKey("default", cwd), initialHandle);
   }
   const pendingHandles = new Map<string, Promise<AcpRuntimeHandle>>();
   const systemPromptSent = new Set<string>();
+  const knownSessionIds = new Set<string>();
 
-  function sessionKey(modelId?: string): string {
+  function handleMapKey(modelId: string | undefined, turnCwd: string): string {
+    return adapterMemoryKey(modelId, turnCwd);
+  }
+
+  function sessionKey(modelId: string | undefined, turnCwd: string): string {
+    const slug = createHash("sha256").update(turnCwd).digest("hex").slice(0, 12);
     const model = modelId && modelId !== "default"
       ? `-${modelId.replace(/[^a-zA-Z0-9.-]/g, "_")}`
       : "";
-    return `pi-${config.agent}${model}-${cwdSlug}`;
+    return `pi-${config.agent}${model}-${slug}`;
   }
 
   async function ensureHandle(
     acpxModelId: string | undefined,
-    systemPrompt?: string,
+    systemPrompt: string | undefined,
+    turnCwd: string,
   ): Promise<AcpRuntimeHandle> {
-    const key = acpxModelId || "default";
+    const key = handleMapKey(acpxModelId, turnCwd);
 
     const existing = handles.get(key);
     if (existing) return existing;
@@ -118,11 +127,13 @@ function createAcpxAdapter(
           sessionOpts.systemPrompt = systemPrompt;
         }
 
+        fileLog(LOG_DOMAIN, "debug", LOG_DOMAIN,
+          `ensureSession agent=${config.agent} cwd=${turnCwd} boot=${cwd} model=${acpxModelId || "default"}`);
         const handle = await runtime.ensureSession({
-          sessionKey: sessionKey(acpxModelId),
+          sessionKey: sessionKey(acpxModelId, turnCwd),
           agent: config.agent,
           mode: "persistent",
-          cwd,
+          cwd: turnCwd,
           ...(Object.keys(sessionOpts).length > 0
             ? { sessionOptions: sessionOpts }
             : {}),
@@ -142,13 +153,17 @@ function createAcpxAdapter(
   return {
     startSession: async (opts: SessionStartOptions): Promise<SessionHandle> => {
       const model = opts.model || "default";
+      const turnCwd = resolveAdapterCwd(opts, cwd);
       const systemPrompt = opts.systemPrompt
         ? opts.systemPrompt
-        : buildExternalSystemPrompt({ systemPrompt: undefined }, cwd);
-      const handle = await ensureHandle(model, systemPrompt);
+        : buildExternalSystemPrompt({ systemPrompt: undefined }, turnCwd);
+      await ensureHandle(model, systemPrompt, turnCwd);
+      const sessionId = sessionKey(model, turnCwd);
+      knownSessionIds.add(sessionId);
       return {
-        sessionId: sessionKey(model),
+        sessionId,
         model,
+        cwd: turnCwd,
       };
     },
 
@@ -157,13 +172,14 @@ function createAcpxAdapter(
       prompt: string,
       opts?: TurnOptions,
     ): Promise<TurnResult> => {
-      const handleKey = handle.model || "default";
+      const turnCwd = resolveAdapterCwd(handle, cwd);
+      const handleKey = handleMapKey(handle.model, turnCwd);
       const needsSystemPrompt = !systemPromptSent.has(handleKey);
       const systemPrompt = needsSystemPrompt
-        ? buildExternalSystemPrompt({ systemPrompt: undefined }, cwd)
+        ? buildExternalSystemPrompt({ systemPrompt: undefined }, turnCwd)
         : undefined;
 
-      const acpxHandle = await ensureHandle(handle.model, systemPrompt);
+      const acpxHandle = await ensureHandle(handle.model, systemPrompt, turnCwd);
       if (needsSystemPrompt) {
         systemPromptSent.add(handleKey);
       }
@@ -259,7 +275,7 @@ function createAcpxAdapter(
           const su = status.usage;
           if (su?.cumulative) {
             const c = su.cumulative;
-            const key = handle.model || "default";
+            const key = handleMapKey(handle.model, turnCwd);
             const prev = prevCumulative.get(key) || { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
             const deltaInput = (c.inputTokens ?? 0) - (prev.inputTokens ?? 0);
             const deltaOutput = (c.outputTokens ?? 0) - (prev.outputTokens ?? 0);
@@ -287,7 +303,8 @@ function createAcpxAdapter(
     },
 
     stopSession: async (handle: SessionHandle): Promise<void> => {
-      const key = handle.model || "default";
+      const turnCwd = resolveAdapterCwd(handle, cwd);
+      const key = handleMapKey(handle.model, turnCwd);
       const acpxHandle = handles.get(key);
       if (acpxHandle) {
         await runtime.close({ handle: acpxHandle, reason: "session stop" }).catch((err: unknown) => {
@@ -298,6 +315,7 @@ function createAcpxAdapter(
       }
       systemPromptSent.delete(key);
       prevCumulative.delete(key);
+      knownSessionIds.delete(sessionKey(handle.model, turnCwd));
     },
 
     stopAll: async (): Promise<void> => {
@@ -315,15 +333,11 @@ function createAcpxAdapter(
       pendingHandles.clear();
       systemPromptSent.clear();
       prevCumulative.clear();
+      knownSessionIds.clear();
     },
 
     hasSession: (sessionId: string): boolean => {
-      for (const key of handles.keys()) {
-        if (sessionKey(key === "default" ? undefined : key) === sessionId) {
-          return true;
-        }
-      }
-      return false;
+      return knownSessionIds.has(sessionId);
     },
   };
 }
@@ -467,7 +481,7 @@ export const AcpxDriver: ProviderDriver<AcpxConfig> = {
     });
 
     // Create adapter
-    const adapter = createAcpxAdapter(config, cwd, runtime, cwdSlug, initialHandle);
+    const adapter = createAcpxAdapter(config, cwd, runtime, initialHandle);
 
     return {
       instanceId,

package/extensions/providers/claude-driver.ts

@@ -46,6 +46,7 @@ import {
 } from "../cli-provider/sessions.js";
 import { buildExternalSystemPrompt } from "../shared/build-system-prompt.js";
 import { fileLog } from "../shared/file-logger.js";
+import { resolveAdapterCwd, adapterMemoryKey, deleteKeysForCwd } from "../shared/session-cwd.js";
 
 const LOG_DOMAIN = "claude-driver";
 const DRIVER_KIND = "claude-cli";
@@ -82,14 +83,14 @@ function createClaudeAdapter(
   instanceId: string,
 ): ProviderAdapterShape & {
   bindPiSessionId: (sid: string) => void;
-  handleSessionStart: (reason: string, sid: string | null) => void;
+  handleSessionStart: (reason: string, sid: string | null, sessionCwd?: string) => void;
 } {
   let piSessionId = createProvisionalPiSessionId();
   const systemPromptSent = new Set<string>();
   const storedSystemPrompts = new Map<string, string>();
 
-  function sessionKeyFor(model: string): CliSessionKey {
-    return { cwd, agent: "claude", model, piSessionId };
+  function sessionKeyFor(model: string, turnCwd: string = cwd): CliSessionKey {
+    return { cwd: turnCwd, agent: "claude", model, piSessionId };
   }
 
   return {
@@ -97,21 +98,27 @@ function createClaudeAdapter(
       if (sid) piSessionId = sid;
     },
 
-    handleSessionStart: (reason: string, _sid: string | null) => {
+    handleSessionStart: (reason: string, _sid: string | null, sessionCwd?: string) => {
       if (reason === "new" || reason === "resume") {
-        systemPromptSent.clear();
-        storedSystemPrompts.clear();
+        const turnCwd = sessionCwd || cwd;
+        deleteKeysForCwd(systemPromptSent, turnCwd);
+        deleteKeysForCwd(storedSystemPrompts, turnCwd);
       }
     },
 
     startSession: async (opts: SessionStartOptions): Promise<SessionHandle> => {
       const model = opts.model || "default";
-      if (opts.systemPrompt) storedSystemPrompts.set(model, opts.systemPrompt);
-      const key = sessionKeyFor(model);
+      const turnCwd = resolveAdapterCwd(opts, cwd);
+      const memKey = adapterMemoryKey(model, turnCwd);
+      if (opts.systemPrompt) storedSystemPrompts.set(memKey, opts.systemPrompt);
+      const key = sessionKeyFor(model, turnCwd);
       const existingId = loadCliSessionId(key);
+      fileLog(LOG_DOMAIN, "debug", LOG_DOMAIN,
+        `startSession model=${model} cwd=${turnCwd} boot=${cwd}`);
       return {
         sessionId: existingId || `claude-${instanceId}-${model}`,
         model,
+        cwd: turnCwd,
       };
     },
 
@@ -120,9 +127,10 @@ function createClaudeAdapter(
       prompt: string,
       opts?: TurnOptions,
     ): Promise<TurnResult> => {
-      const key = sessionKeyFor(handle.model);
+      const turnCwd = resolveAdapterCwd(handle, cwd);
+      const key = sessionKeyFor(handle.model, turnCwd);
       const sessionId = loadCliSessionId(key);
-      const handleKey = handle.model || "default";
+      const handleKey = adapterMemoryKey(handle.model, turnCwd);
       const needsSystemPrompt = !systemPromptSent.has(handleKey);
 
       // Prefer the system prompt stored at startSession over rebuilding
@@ -130,7 +138,7 @@ function createClaudeAdapter(
       if (needsSystemPrompt) {
         systemPrompt =
           storedSystemPrompts.get(handleKey) ||
-          buildExternalSystemPrompt({ systemPrompt: undefined }, cwd);
+          buildExternalSystemPrompt({ systemPrompt: undefined }, turnCwd);
       }
 
       // Apply system prompt to the prompt text
@@ -157,7 +165,7 @@ function createClaudeAdapter(
         runCliAgent({
           agent: "claude",
           model: handle.model === "default" ? "default" : handle.model,
-          cwd,
+          cwd: turnCwd,
           prompt: p,
           sessionId: sid,
           signal: opts?.signal,
@@ -215,9 +223,10 @@ function createClaudeAdapter(
     },
 
     stopSession: async (handle: SessionHandle): Promise<void> => {
-      const key = sessionKeyFor(handle.model);
+      const turnCwd = resolveAdapterCwd(handle, cwd);
+      const key = sessionKeyFor(handle.model, turnCwd);
       clearCliSessionId(key);
-      const handleKey = handle.model || "default";
+      const handleKey = adapterMemoryKey(handle.model, turnCwd);
       systemPromptSent.delete(handleKey);
       storedSystemPrompts.delete(handleKey);
     },

package/extensions/providers/cursor-acpx-driver.ts

@@ -35,6 +35,7 @@ import { loadAcpxRuntime, type AcpxRuntimeModule } from "../acpx-provider/load-r
 import { modelIdToDisplayName } from "../acpx-provider/runtime-models.js";
 import { buildExternalSystemPrompt } from "../shared/build-system-prompt.js";
 import { fileLog } from "../shared/file-logger.js";
+import { resolveAdapterCwd, adapterMemoryKey } from "../shared/session-cwd.js";
 
 const LOG_DOMAIN = "cursor-acpx-driver";
 const DRIVER_KIND = "cursor-acpx";
@@ -76,24 +77,30 @@ function createCursorAcpxAdapter(
   config: CursorAcpxConfig,
   cwd: string,
   runtime: AcpxRuntime,
-  cwdSlug: string,
 ): ProviderAdapterShape {
   const handles = new Map<string, AcpRuntimeHandle>();
   const pendingHandles = new Map<string, Promise<AcpRuntimeHandle>>();
   const systemPromptSent = new Set<string>();
+  const knownSessionIds = new Set<string>();
 
-  function sessionKey(modelId?: string): string {
+  function handleMapKey(modelId: string | undefined, turnCwd: string): string {
+    return adapterMemoryKey(modelId, turnCwd);
+  }
+
+  function sessionKey(modelId: string | undefined, turnCwd: string): string {
+    const slug = createHash("sha256").update(turnCwd).digest("hex").slice(0, 12);
     const model = modelId && modelId !== "default"
       ? `-${modelId.replace(/[^a-zA-Z0-9.-]/g, "_")}`
       : "";
-    return `pi-${config.agent}${model}-${cwdSlug}`;
+    return `pi-${config.agent}${model}-${slug}`;
   }
 
   async function ensureHandle(
     acpxModelId: string | undefined,
-    systemPrompt?: string,
+    systemPrompt: string | undefined,
+    turnCwd: string,
   ): Promise<AcpRuntimeHandle> {
-    const key = acpxModelId || "default";
+    const key = handleMapKey(acpxModelId, turnCwd);
 
     const existing = handles.get(key);
     if (existing) return existing;
@@ -111,11 +118,13 @@ function createCursorAcpxAdapter(
           sessionOpts.systemPrompt = systemPrompt;
         }
 
+        fileLog(LOG_DOMAIN, "debug", LOG_DOMAIN,
+          `ensureSession agent=${config.agent} cwd=${turnCwd} boot=${cwd} model=${acpxModelId || "default"}`);
         const handle = await runtime.ensureSession({
-          sessionKey: sessionKey(acpxModelId),
+          sessionKey: sessionKey(acpxModelId, turnCwd),
           agent: config.agent,
           mode: "persistent",
-          cwd,
+          cwd: turnCwd,
           ...(Object.keys(sessionOpts).length > 0
             ? { sessionOptions: sessionOpts }
             : {}),
@@ -135,13 +144,17 @@ function createCursorAcpxAdapter(
   return {
     startSession: async (opts: SessionStartOptions): Promise<SessionHandle> => {
       const model = opts.model || "default";
+      const turnCwd = resolveAdapterCwd(opts, cwd);
       const systemPrompt = opts.systemPrompt
         ? opts.systemPrompt
-        : buildExternalSystemPrompt({ systemPrompt: undefined }, cwd);
-      const handle = await ensureHandle(model, systemPrompt);
+        : buildExternalSystemPrompt({ systemPrompt: undefined }, turnCwd);
+      await ensureHandle(model, systemPrompt, turnCwd);
+      const sessionId = sessionKey(model, turnCwd);
+      knownSessionIds.add(sessionId);
       return {
-        sessionId: sessionKey(model),
+        sessionId,
         model,
+        cwd: turnCwd,
       };
     },
 
@@ -150,13 +163,14 @@ function createCursorAcpxAdapter(
       prompt: string,
       opts?: TurnOptions,
     ): Promise<TurnResult> => {
-      const handleKey = handle.model || "default";
+      const turnCwd = resolveAdapterCwd(handle, cwd);
+      const handleKey = handleMapKey(handle.model, turnCwd);
       const needsSystemPrompt = !systemPromptSent.has(handleKey);
       const systemPrompt = needsSystemPrompt
-        ? buildExternalSystemPrompt({ systemPrompt: undefined }, cwd)
+        ? buildExternalSystemPrompt({ systemPrompt: undefined }, turnCwd)
         : undefined;
 
-      const acpxHandle = await ensureHandle(handle.model, systemPrompt);
+      const acpxHandle = await ensureHandle(handle.model, systemPrompt, turnCwd);
       if (needsSystemPrompt) {
         systemPromptSent.add(handleKey);
       }
@@ -207,7 +221,8 @@ function createCursorAcpxAdapter(
     },
 
     stopSession: async (handle: SessionHandle): Promise<void> => {
-      const key = handle.model || "default";
+      const turnCwd = resolveAdapterCwd(handle, cwd);
+      const key = handleMapKey(handle.model, turnCwd);
       const acpxHandle = handles.get(key);
       if (acpxHandle) {
         await runtime.close({ handle: acpxHandle, reason: "session stop" }).catch((err: unknown) => {
@@ -217,6 +232,7 @@ function createCursorAcpxAdapter(
         handles.delete(key);
       }
       systemPromptSent.delete(key);
+      knownSessionIds.delete(sessionKey(handle.model, turnCwd));
     },
 
     stopAll: async (): Promise<void> => {
@@ -233,15 +249,11 @@ function createCursorAcpxAdapter(
       handles.clear();
       pendingHandles.clear();
       systemPromptSent.clear();
+      knownSessionIds.clear();
     },
 
     hasSession: (sessionId: string): boolean => {
-      for (const key of handles.keys()) {
-        if (sessionKey(key === "default" ? undefined : key) === sessionId) {
-          return true;
-        }
-      }
-      return false;
+      return knownSessionIds.has(sessionId);
     },
   };
 }
@@ -376,7 +388,7 @@ export const CursorAcpxDriver: ProviderDriver<CursorAcpxConfig> = {
     });
 
     // Create adapter
-    const adapter = createCursorAcpxAdapter(config, cwd, runtime, cwdSlug);
+    const adapter = createCursorAcpxAdapter(config, cwd, runtime);
 
     return {
       instanceId,

package/extensions/providers/cursor-cli-driver.ts

@@ -53,10 +53,28 @@ import {
 } from "../cli-provider/sessions.js";
 import { buildExternalSystemPrompt } from "../shared/build-system-prompt.js";
 import { fileLog } from "../shared/file-logger.js";
+import { resolveAdapterCwd, adapterMemoryKey, deleteKeysForCwd } from "../shared/session-cwd.js";
 
 const LOG_DOMAIN = "cursor-cli-driver";
 const DRIVER_KIND = "cursor-cli";
 
+/**
+ * Per-turn history reseed. Cwd-scoped `session_start` must not force a fresh
+ * CLI session on a different workspace. `forceHistorySeedGlobal` is only
+ * `setForceHistorySeed()` (explicit adapter-wide override).
+ */
+export function cursorTurnNeedsHistorySeed(
+  turnCwd: string,
+  forceHistorySeedCwds: ReadonlySet<string>,
+  forceHistorySeedGlobal: boolean,
+): boolean {
+  const cwdListed = forceHistorySeedCwds.has(turnCwd);
+  const needed = forceHistorySeedGlobal || cwdListed;
+  fileLog(LOG_DOMAIN, "debug", LOG_DOMAIN,
+    `cursorTurnNeedsHistorySeed cwd=${turnCwd} global=${forceHistorySeedGlobal} cwdListed=${cwdListed} needed=${needed}`);
+  return needed;
+}
+
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
@@ -147,7 +165,7 @@ function buildPromptWithHistory(
 // Adapter
 // ---------------------------------------------------------------------------
 
-function createCursorCliAdapter(
+export function createCursorCliAdapter(
   config: CursorCliConfig,
   cwd: string,
   instanceId: string,
@@ -155,28 +173,45 @@ function createCursorCliAdapter(
   /** Bind the real pi session UUID (from sessionManager). */
   bindPiSessionId: (sid: string) => void;
   /** Handle session_start event (reseed, marker cleanup). */
-  handleSessionStart: (reason: string, sid: string | null) => void;
+  handleSessionStart: (reason: string, sid: string | null, sessionCwd?: string) => void;
   /** Force history re-seed on next turn. */
   setForceHistorySeed: (force: boolean) => void;
 } {
+  fileLog(LOG_DOMAIN, "debug", LOG_DOMAIN,
+    `createCursorCliAdapter bootCwdBound=${Boolean(cwd)} instance=${instanceId}`);
   let activePiSessionId: string | null = null;
   const provisionalPiSessionId = createProvisionalPiSessionId();
   let forceHistorySeed = false;
+  const forceHistorySeedCwds = new Set<string>();
   const systemPromptSent = new Set<string>();
   const storedSystemPrompts = new Map<string, string>();
   const sessionKeys = new Map<string, CliSessionKey>();
 
+  function memoryKey(model: string | undefined, turnCwd: string): string {
+    return adapterMemoryKey(model, turnCwd);
+  }
+
+  function markerCwds(): string[] {
+    const found = new Set<string>([cwd]);
+    for (const key of sessionKeys.values()) {
+      if (key.cwd) found.add(key.cwd);
+    }
+    return [...found];
+  }
+
   function resolvedPiSessionId(): string {
     return activePiSessionId || provisionalPiSessionId;
   }
 
-  function sessionKeyFor(model: string): CliSessionKey {
-    return { cwd, agent: "cursor", model, piSessionId: resolvedPiSessionId() };
+  function sessionKeyFor(model: string, turnCwd: string = cwd): CliSessionKey {
+    return { cwd: turnCwd, agent: "cursor", model, piSessionId: resolvedPiSessionId() };
   }
 
   function migrateMarkersToRealPiSessionId(sid: string): void {
     if (!sid || sid === provisionalPiSessionId) return;
-    migrateAllCliSessionMarkers(cwd, provisionalPiSessionId, sid);
+    for (const markerCwd of markerCwds()) {
+      migrateAllCliSessionMarkers(markerCwd, provisionalPiSessionId, sid);
+    }
     for (const [handleKey, prevKey] of sessionKeys) {
       if (
         !prevKey.piSessionId ||
@@ -202,9 +237,10 @@ function createCursorCliAdapter(
       migrateMarkersToRealPiSessionId(sid);
     },
 
-    handleSessionStart: (reason: string, sid: string | null) => {
+    handleSessionStart: (reason: string, sid: string | null, sessionCwd?: string) => {
       const prevSid = activePiSessionId;
       const resolvedSid = sid || activePiSessionId;
+      const turnCwd = sessionCwd || cwd;
       if (sid) {
         activePiSessionId = sid;
         migrateMarkersToRealPiSessionId(sid);
@@ -215,22 +251,27 @@ function createCursorCliAdapter(
         prevPiSessionId: prevSid,
         nextPiSessionId: resolvedSid,
       });
-      forceHistorySeed = decision.forceHistorySeed;
+      if (decision.forceHistorySeed) {
+        forceHistorySeedCwds.add(turnCwd);
+        fileLog(LOG_DOMAIN, "debug", LOG_DOMAIN,
+          `handleSessionStart reseed cwd=${turnCwd} (not adapter-global)`);
+      }
 
       if (decision.action === "keep") {
         return;
       }
       if (decision.action === "reseed" && resolvedSid) {
         try {
-          clearCliSessionsForPiSession(cwd, resolvedSid, {
+          clearCliSessionsForPiSession(turnCwd, resolvedSid, {
             includeLegacyDefault: prevSid == null || prevSid === "" || prevSid === "default",
           });
         } catch (err) {
           fileLog(LOG_DOMAIN, "warn", LOG_DOMAIN,
             `session_start marker cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
         }
-        systemPromptSent.clear();
-        storedSystemPrompts.clear();
+        deleteKeysForCwd(systemPromptSent, turnCwd);
+        deleteKeysForCwd(storedSystemPrompts, turnCwd);
+        deleteKeysForCwd(sessionKeys, turnCwd);
       }
     },
 
@@ -240,13 +281,18 @@ function createCursorCliAdapter(
 
     startSession: async (opts: SessionStartOptions): Promise<SessionHandle> => {
       const model = opts.model || "default";
-      if (opts.systemPrompt) storedSystemPrompts.set(model, opts.systemPrompt);
-      const key = sessionKeyFor(model);
-      sessionKeys.set(model, key);
+      const turnCwd = resolveAdapterCwd(opts, cwd);
+      const memKey = memoryKey(model, turnCwd);
+      if (opts.systemPrompt) storedSystemPrompts.set(memKey, opts.systemPrompt);
+      const key = sessionKeyFor(model, turnCwd);
+      sessionKeys.set(memKey, key);
       const existingId = loadCliSessionId(key);
+      fileLog(LOG_DOMAIN, "debug", LOG_DOMAIN,
+        `startSession model=${model} cwd=${turnCwd} boot=${cwd}`);
       return {
         sessionId: existingId || `cursor-${instanceId}-${model}`,
         model,
+        cwd: turnCwd,
       };
     },
 
@@ -255,8 +301,9 @@ function createCursorCliAdapter(
       prompt: string,
       opts?: TurnOptions,
     ): Promise<TurnResult> => {
-      const handleKey = handle.model || "default";
-      const key = sessionKeyFor(handle.model);
+      const turnCwd = resolveAdapterCwd(handle, cwd);
+      const handleKey = memoryKey(handle.model, turnCwd);
+      const key = sessionKeyFor(handle.model, turnCwd);
       // Read previous key BEFORE updating so legacy-marker adoption can compare categories
       const prevKey = sessionKeys.get(handleKey);
       sessionKeys.set(handleKey, key);
@@ -268,23 +315,30 @@ function createCursorCliAdapter(
         sessionId = loadCliSessionId(key);
       }
 
-      const needsSystemPrompt = !systemPromptSent.has(handleKey) || forceHistorySeed;
+      const reseedThisCwd = cursorTurnNeedsHistorySeed(
+        turnCwd,
+        forceHistorySeedCwds,
+        forceHistorySeed,
+      );
+      const needsSystemPrompt = !systemPromptSent.has(handleKey) || reseedThisCwd;
+      fileLog(LOG_DOMAIN, "debug", LOG_DOMAIN,
+        `sendTurn model=${handle.model} cwd=${turnCwd} boot=${cwd} reseed=${reseedThisCwd}`);
 
       // Prefer the system prompt stored at startSession over rebuilding
       let systemPrompt: string | undefined;
       if (needsSystemPrompt) {
         systemPrompt =
           storedSystemPrompts.get(handleKey) ||
-          buildExternalSystemPrompt({ systemPrompt: undefined }, cwd);
+          buildExternalSystemPrompt({ systemPrompt: undefined }, turnCwd);
       }
 
       // Resolve history seed plan
       const seedPlan = resolveCliHistorySeed({
         hasCliSession: !!sessionId,
-        forceHistorySeed,
+        forceHistorySeed: reseedThisCwd,
       });
       // Stale marker after /resume: drop it so we open a fresh CLI chat
-      if (forceHistorySeed && sessionId) {
+      if (reseedThisCwd && sessionId) {
         clearCliSessionId(key);
       }
       const effectiveSessionId = seedPlan.useCliSession ? sessionId : null;
@@ -315,7 +369,7 @@ function createCursorCliAdapter(
         runCliAgent({
           agent: "cursor",
           model: handle.model === "default" ? "default" : handle.model,
-          cwd,
+          cwd: turnCwd,
           prompt: p,
           sessionId: sid,
           signal: opts?.signal,
@@ -335,7 +389,8 @@ function createCursorCliAdapter(
         if (needsSystemPrompt) {
           systemPromptSent.add(handleKey);
         }
-        if (forceHistorySeed) {
+        forceHistorySeedCwds.delete(turnCwd);
+        if (forceHistorySeed && reseedThisCwd) {
           forceHistorySeed = false;
         }
 
@@ -366,7 +421,8 @@ function createCursorCliAdapter(
           if (needsSystemPrompt) {
             systemPromptSent.add(handleKey);
           }
-          if (forceHistorySeed) {
+          forceHistorySeedCwds.delete(turnCwd);
+          if (forceHistorySeed && reseedThisCwd) {
             forceHistorySeed = false;
           }
           return {
@@ -382,12 +438,14 @@ function createCursorCliAdapter(
     },
 
     stopSession: async (handle: SessionHandle): Promise<void> => {
-      const key = sessionKeyFor(handle.model);
+      const turnCwd = resolveAdapterCwd(handle, cwd);
+      const memKey = memoryKey(handle.model, turnCwd);
+      const key = sessionKeyFor(handle.model, turnCwd);
       clearCliSessionId(key);
-      const handleKey = handle.model || "default";
-      sessionKeys.delete(handleKey);
-      systemPromptSent.delete(handleKey);
-      storedSystemPrompts.delete(handleKey);
+      sessionKeys.delete(memKey);
+      systemPromptSent.delete(memKey);
+      storedSystemPrompts.delete(memKey);
+      forceHistorySeedCwds.delete(turnCwd);
     },
 
     stopAll: async (): Promise<void> => {

package/extensions/providers/gemini-driver.ts

@@ -42,6 +42,7 @@ import {
 } from "../cli-provider/sessions.js";
 import { buildExternalSystemPrompt } from "../shared/build-system-prompt.js";
 import { fileLog } from "../shared/file-logger.js";
+import { resolveAdapterCwd, adapterMemoryKey, deleteKeysForCwd } from "../shared/session-cwd.js";
 
 const LOG_DOMAIN = "gemini-driver";
 const DRIVER_KIND = "gemini-cli";
@@ -78,14 +79,14 @@ function createGeminiAdapter(
   instanceId: string,
 ): ProviderAdapterShape & {
   bindPiSessionId: (sid: string) => void;
-  handleSessionStart: (reason: string, sid: string | null) => void;
+  handleSessionStart: (reason: string, sid: string | null, sessionCwd?: string) => void;
 } {
   let piSessionId = createProvisionalPiSessionId();
   const systemPromptSent = new Set<string>();
   const storedSystemPrompts = new Map<string, string>();
 
-  function sessionKeyFor(model: string): CliSessionKey {
-    return { cwd, agent: "gemini", model, piSessionId };
+  function sessionKeyFor(model: string, turnCwd: string = cwd): CliSessionKey {
+    return { cwd: turnCwd, agent: "gemini", model, piSessionId };
   }
 
   return {
@@ -93,21 +94,27 @@ function createGeminiAdapter(
       if (sid) piSessionId = sid;
     },
 
-    handleSessionStart: (reason: string, _sid: string | null) => {
+    handleSessionStart: (reason: string, _sid: string | null, sessionCwd?: string) => {
       if (reason === "new" || reason === "resume") {
-        systemPromptSent.clear();
-        storedSystemPrompts.clear();
+        const turnCwd = sessionCwd || cwd;
+        deleteKeysForCwd(systemPromptSent, turnCwd);
+        deleteKeysForCwd(storedSystemPrompts, turnCwd);
       }
     },
 
     startSession: async (opts: SessionStartOptions): Promise<SessionHandle> => {
       const model = opts.model || "default";
-      if (opts.systemPrompt) storedSystemPrompts.set(model, opts.systemPrompt);
-      const key = sessionKeyFor(model);
+      const turnCwd = resolveAdapterCwd(opts, cwd);
+      const memKey = adapterMemoryKey(model, turnCwd);
+      if (opts.systemPrompt) storedSystemPrompts.set(memKey, opts.systemPrompt);
+      const key = sessionKeyFor(model, turnCwd);
       const existingId = loadCliSessionId(key);
+      fileLog(LOG_DOMAIN, "debug", LOG_DOMAIN,
+        `startSession model=${model} cwd=${turnCwd} boot=${cwd}`);
       return {
         sessionId: existingId || `gemini-${instanceId}-${model}`,
         model,
+        cwd: turnCwd,
       };
     },
 
@@ -116,16 +123,17 @@ function createGeminiAdapter(
       prompt: string,
       opts?: TurnOptions,
     ): Promise<TurnResult> => {
-      const key = sessionKeyFor(handle.model);
+      const turnCwd = resolveAdapterCwd(handle, cwd);
+      const key = sessionKeyFor(handle.model, turnCwd);
       const sessionId = loadCliSessionId(key);
-      const handleKey = handle.model || "default";
+      const handleKey = adapterMemoryKey(handle.model, turnCwd);
       const needsSystemPrompt = !systemPromptSent.has(handleKey);
 
       let systemPrompt: string | undefined;
       if (needsSystemPrompt) {
         systemPrompt =
           storedSystemPrompts.get(handleKey) ||
-          buildExternalSystemPrompt({ systemPrompt: undefined }, cwd);
+          buildExternalSystemPrompt({ systemPrompt: undefined }, turnCwd);
       }
 
       let finalPrompt = prompt;
@@ -150,7 +158,7 @@ function createGeminiAdapter(
         runCliAgent({
           agent: "gemini",
           model: handle.model === "default" ? "default" : handle.model,
-          cwd,
+          cwd: turnCwd,
           prompt: p,
           sessionId: sid,
           signal: opts?.signal,
@@ -202,9 +210,10 @@ function createGeminiAdapter(
     },
 
     stopSession: async (handle: SessionHandle): Promise<void> => {
-      const key = sessionKeyFor(handle.model);
+      const turnCwd = resolveAdapterCwd(handle, cwd);
+      const key = sessionKeyFor(handle.model, turnCwd);
       clearCliSessionId(key);
-      const handleKey = handle.model || "default";
+      const handleKey = adapterMemoryKey(handle.model, turnCwd);
       systemPromptSent.delete(handleKey);
       storedSystemPrompts.delete(handleKey);
     },

package/extensions/providers/index.ts

@@ -59,6 +59,10 @@ import {
   readPiSessionIdFromManager,
 } from "../cli-provider/sessions.js";
 import { fileLog } from "../shared/file-logger.js";
+import {
+  enterSessionCwd,
+  resolveProviderStreamCwd,
+} from "../shared/session-cwd.js";
 import { isCliAgentName } from "../cli-provider/providers.js";
 import {
   isProvidersInitialized,
@@ -152,14 +156,19 @@ function makeStreamFunction(
         const colonIdx = model.id.indexOf(":");
         const driverModelId = colonIdx >= 0 ? model.id.substring(colonIdx + 1) : "default";
 
+        const turnCwd = resolveProviderStreamCwd(projectCwd);
+        log.debug(
+          `${kind}-${agent} stream cwd=${turnCwd} boot=${projectCwd} model=${driverModelId}`,
+        );
+
         // Build system prompt
-        const systemPrompt = buildExternalSystemPrompt(context, projectCwd);
+        const systemPrompt = buildExternalSystemPrompt(context, turnCwd);
 
         // Ensure session
         const handle = await instance.adapter.startSession({
           model: driverModelId,
           systemPrompt,
-          cwd: projectCwd,
+          cwd: turnCwd,
         });
 
         // Extract latest user message
@@ -283,10 +292,22 @@ async function registerAcpxAgent(
 const log = createLogger("providers");
 log.debug("providers module loaded");
 
+const cwdHookBound = new WeakSet<object>();
+
 export default async function (pi: ExtensionAPI) {
   // pi --help / --version — skip discovery
   if (isPiMetaInvocation()) return;
 
+  // Always bind this AgentSession's cwd, even when the factory early-returns.
+  // Sidecar user sessions load this extension after the internal registrar
+  // already marked initialized — without this hook they never stash cwd (#768).
+  if (!cwdHookBound.has(pi)) {
+    cwdHookBound.add(pi);
+    pi.on("before_agent_start", (_event, ctx) => {
+      enterSessionCwd(typeof ctx.cwd === "string" ? ctx.cwd : "");
+    });
+  }
+
   // Idempotency guard — shims re-export this default, so it may be called
   // multiple times (cli-provider shim, acpx-provider shim, providers dir).
   // Only run once per session; session_shutdown resets so /new|/resume|/fork
@@ -358,7 +379,7 @@ export default async function (pi: ExtensionAPI) {
       for (const inst of cliInstances.values()) {
         const adapter = inst.adapter as any;
         if (typeof adapter.handleSessionStart === "function") {
-          adapter.handleSessionStart(reason, sid);
+          adapter.handleSessionStart(reason, sid, ctx.cwd);
         }
       }
     });

package/extensions/shared/provider-driver.ts

@@ -117,6 +117,8 @@ export interface SessionStartOptions {
 export interface SessionHandle {
   readonly sessionId: string;
   readonly model: string;
+  /** Session/project cwd for this turn's CLI/ACPX spawn (#768). */
+  readonly cwd?: string;
 }
 
 /** Options for sending a turn. */

package/extensions/shared/session-cwd.ts

@@ -0,0 +1,109 @@
+/**
+ * Per-turn session cwd for CLI/ACPX spawn (#768).
+ *
+ * Pi stream() has no cwd. Sidecar sessions and extension before_agent_start
+ * stash the folder here. Drivers read it instead of process.cwd() from boot.
+ *
+ * Store lives on globalThis via Symbol.for so jiti, tsx, and sidecar share
+ * one AsyncLocalStorage even when this file is loaded more than once.
+ */
+
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createLogger } from "./logger.js";
+
+const log = createLogger("providers");
+
+/** Must match packages/pi-sidecar/src/session-cwd.ts — do not change one copy. */
+export const SESSION_CWD_ALS_ID = "pi-config.sessionCwdAls";
+const ALS_KEY = Symbol.for(SESSION_CWD_ALS_ID);
+
+/** Unit separator — model ids and paths cannot contain this. */
+const MEMORY_SEP = "\x1f";
+
+function getAls(): AsyncLocalStorage<string> {
+  const g = globalThis as unknown as Record<
+    symbol,
+    AsyncLocalStorage<string> | undefined
+  >;
+  let als = g[ALS_KEY];
+  if (!als) {
+    als = new AsyncLocalStorage<string>();
+    g[ALS_KEY] = als;
+    log.debug("session cwd ALS created on globalThis");
+  }
+  return als;
+}
+
+/** Cwd bound for the current async turn, if any. */
+export function getSessionCwd(): string | undefined {
+  const value = getAls().getStore();
+  const cwd = typeof value === "string" && value.length > 0 ? value : undefined;
+  log.debug(`getSessionCwd bound=${cwd !== undefined}`);
+  return cwd;
+}
+
+/** Bind cwd for the rest of this async resource (before_agent_start). */
+export function enterSessionCwd(cwd: string): void {
+  if (typeof cwd !== "string" || cwd.length === 0) {
+    log.warn("enterSessionCwd skipped: empty cwd");
+    return;
+  }
+  if (getSessionCwd()) {
+    log.debug(`enterSessionCwd skipped: ALS already bound cwd=${getSessionCwd()} incoming=${cwd}`);
+    return;
+  }
+  getAls().enterWith(cwd);
+  log.debug(`enterSessionCwd cwd=${cwd}`);
+}
+
+/** Run fn with cwd bound for the full async tree (sidecar prompt()). */
+export function runWithSessionCwd<T>(cwd: string, fn: () => T): T {
+  if (typeof cwd !== "string" || cwd.length === 0) {
+    log.warn("runWithSessionCwd empty cwd; running unbound");
+    return fn();
+  }
+  log.debug(`runWithSessionCwd cwd=${cwd}`);
+  return getAls().run(cwd, fn);
+}
+
+/** Stream path: ALS session cwd, else boot projectCwd. */
+export function resolveProviderStreamCwd(bootCwd: string): string {
+  const fromAls = getSessionCwd();
+  if (fromAls) {
+    log.debug(`stream cwd from ALS=${fromAls} boot=${bootCwd}`);
+    return fromAls;
+  }
+  log.warn(`stream cwd fallback boot=${bootCwd} (ALS empty)`);
+  return bootCwd;
+}
+
+/** Spawn path: handle.cwd from startSession, else adapter create-time cwd. */
+export function resolveAdapterCwd(
+  handle: { cwd?: string },
+  fallback: string,
+): string {
+  if (typeof handle.cwd === "string" && handle.cwd.length > 0) {
+    return handle.cwd;
+  }
+  return fallback;
+}
+
+/** In-memory adapter maps: one entry per model+cwd so sidecar jobs stay isolated. */
+export function adapterMemoryKey(model: string | undefined, turnCwd: string): string {
+  return `${model || "default"}${MEMORY_SEP}${turnCwd}`;
+}
+
+/** True when `key` was built for this cwd via adapterMemoryKey. */
+export function adapterMemoryKeyMatchesCwd(key: string, turnCwd: string): boolean {
+  return key.endsWith(`${MEMORY_SEP}${turnCwd}`);
+}
+
+/** Drop in-memory adapter entries for one session cwd (leave other jobs alone). */
+export function deleteKeysForCwd(
+  store: { keys(): IterableIterator<string>; delete(key: string): unknown },
+  turnCwd: string,
+): void {
+  for (const k of [...store.keys()]) {
+    if (adapterMemoryKeyMatchesCwd(k, turnCwd)) store.delete(k);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-orchestrator-config",
-  "version": "4.3.3",
+  "version": "4.3.5",
   "description": "Orchestrator pattern for pi: specialist subagents, enforcement, code review loop, workflow commands",
   "keywords": [
     "pi-package"