pi-orchestrator-config 4.3.2 → 4.3.4

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) |
@@ -726,7 +726,8 @@ Then just run `pi-docker` from any project directory.
 > `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/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.2",
+  "version": "4.3.4",
   "description": "Orchestrator pattern for pi: specialist subagents, enforcement, code review loop, workflow commands",
   "keywords": [
     "pi-package"