chatroom-cli 1.116.2 → 1.116.3

package/dist/index.js

@@ -27767,7 +27767,8 @@ var init_base_cli_agent_service = __esm(() => {
 // src/daemon/services/agent-process-service/service/agent-process-manager-service.ts
 import { randomUUID } from "node:crypto";
 function messageGroupId(input) {
-  return `${input.chatroomId}:${input.role.toLowerCase()}`;
+  const base = `${input.chatroomId}:${input.role.toLowerCase()}`;
+  return input.workingDir ? `${base}:${input.workingDir}` : base;
 }
 function commandMessage(command) {
   const input = command.input;
@@ -27930,7 +27931,7 @@ function createAgentProcessManagerService(deps) {
       await deps.commandBus.stop();
     },
     handleExit: (input) => deps.execution.handleExit(input),
-    getSlot: (chatroomId, role) => deps.execution.getSlot(chatroomId, role),
+    getSlot: (chatroomId, role, workingDir) => workingDir === undefined ? deps.execution.getSlot(chatroomId, role) : deps.execution.getSlot(chatroomId, role, workingDir),
     listActive: () => deps.execution.listActive(),
     clearStuckStoppingSlot: (chatroomId, role, options) => deps.execution.clearStuckStoppingSlot(chatroomId, role, options),
     whenTurnEndsIdle: () => deps.execution.whenTurnEndsIdle(),
@@ -28184,10 +28185,18 @@ function isAgentSlotStartInFlight(slot) {
 function isAgentSlotActive(slot) {
   return isAgentSlotStarted(slot) || isAgentSlotStartInFlight(slot);
 }
-function agentKey(chatroomId, role) {
-  return `${chatroomId}:${role.toLowerCase()}`;
+function agentKey(chatroomId, role, workingDir) {
+  return [chatroomId, role.toLowerCase(), workingDir ?? ""].join(AGENT_KEY_SEPARATOR);
+}
+function parseAgentKey(key) {
+  const [chatroomId, role, workingDir] = key.split(AGENT_KEY_SEPARATOR);
+  return {
+    chatroomId,
+    role,
+    ...workingDir ? { workingDir } : {}
+  };
 }
-var AGENT_SLOT_STATE, AGENT_START_DISPOSITION, idleSlot = () => ({ state: AGENT_SLOT_STATE.IDLE });
+var AGENT_SLOT_STATE, AGENT_START_DISPOSITION, idleSlot = () => ({ state: AGENT_SLOT_STATE.IDLE }), AGENT_KEY_SEPARATOR = "\x00";
 var init_agent_slot = __esm(() => {
   AGENT_SLOT_STATE = {
     IDLE: "idle",
@@ -30740,10 +30749,10 @@ function createStopAgentTargetsDeps(args2) {
   };
 }
 async function runRoleScopedStop(args2) {
-  args2.apm.markStopIntent(args2.chatroomId, args2.role, args2.reason);
+  args2.apm.markStopIntent(args2.chatroomId, args2.role, args2.reason, undefined, args2.workingDir);
   const deps = createStopAgentTargetsDeps(args2);
   const discovered = await args2.apm.discoverStopTargets(args2.chatroomId);
-  const targets = discovered.filter((target) => normalizeAgentStopRole(target.role) === normalizeAgentStopRole(args2.role));
+  const targets = discovered.filter((target) => normalizeAgentStopRole(target.role) === normalizeAgentStopRole(args2.role) && (!args2.workingDir || target.workingDir === args2.workingDir));
   return stopAgentTargets(deps, {
     chatroomId: args2.chatroomId,
     scope: { kind: "agent", role: args2.role },
@@ -30934,6 +30943,17 @@ var init_agent_lifecycle_service = __esm(() => {
     const ports = yield* AgentLifecyclePorts;
     const slotsRef = yield* exports_Ref.make(new Map);
     const getSlotFromRef = (key) => exports_Ref.get(slotsRef).pipe(exports_Effect.map((map18) => map18.get(key)));
+    const findSlotKey = (chatroomId, role, workingDir) => exports_Ref.get(slotsRef).pipe(exports_Effect.map((map18) => {
+      if (workingDir !== undefined) {
+        const key = agentKey(chatroomId, role, workingDir);
+        return map18.has(key) ? key : undefined;
+      }
+      const candidates = [...map18.keys()].filter((key) => {
+        const identity5 = parseAgentKey(key);
+        return identity5.chatroomId === chatroomId && identity5.role === role.toLowerCase();
+      });
+      return candidates.length === 1 ? candidates[0] : undefined;
+    }));
     const setSlotInRef = (key, slot) => exports_Ref.update(slotsRef, (map18) => map18.set(key, slot));
     const removeSlotFromRef = (key) => exports_Ref.update(slotsRef, (map18) => {
       const next4 = new Map(map18);
@@ -30989,7 +31009,7 @@ var init_agent_lifecycle_service = __esm(() => {
       return { success: true, pid: slot.pid, disposition: AGENT_START_DISPOSITION.STARTED };
     });
     const ensureRunning = (opts) => exports_Effect.gen(function* () {
-      const key = agentKey(opts.chatroomId, opts.role);
+      const key = agentKey(opts.chatroomId, opts.role, opts.workingDir);
       const currentSlot = yield* getSlotFromRef(key);
       if (currentSlot && isAgentSlotActive(currentSlot)) {
         return {
@@ -31010,7 +31030,9 @@ var init_agent_lifecycle_service = __esm(() => {
       return result;
     });
     const stop3 = (opts) => exports_Effect.gen(function* () {
-      const key = agentKey(opts.chatroomId, opts.role);
+      const key = yield* findSlotKey(opts.chatroomId, opts.role, opts.workingDir);
+      if (!key)
+        return { success: false };
       const slot = yield* getSlotFromRef(key);
       if (!slot) {
         return { success: false };
@@ -31036,7 +31058,7 @@ var init_agent_lifecycle_service = __esm(() => {
       return { success: true };
     });
     const handleExit = (opts) => exports_Effect.gen(function* () {
-      const key = agentKey(opts.chatroomId, opts.role);
+      const key = agentKey(opts.chatroomId, opts.role, opts.workingDir);
       const slot = yield* getSlotFromRef(key);
       if (!slot) {
         return;
@@ -31064,23 +31086,22 @@ var init_agent_lifecycle_service = __esm(() => {
       yield* setSlotInRef(key, exitedSlot);
       yield* removeSlotFromRef(key);
     });
-    const getSlot = (chatroomId, role) => getSlotFromRef(agentKey(chatroomId, role));
+    const getSlot = (chatroomId, role, workingDir) => findSlotKey(chatroomId, role, workingDir).pipe(exports_Effect.flatMap((key) => key ? getSlotFromRef(key) : exports_Effect.succeed(undefined)));
     const listActive = () => exports_Ref.get(slotsRef).pipe(exports_Effect.map((map18) => {
       const results = [];
       for (const [key, slot] of map18) {
         if (isAgentSlotActive(slot)) {
-          const [chatroomId, role] = key.split(":");
-          results.push({ chatroomId, role, slot });
+          const identity5 = parseAgentKey(key);
+          results.push({ chatroomId: identity5.chatroomId, role: identity5.role, slot });
         }
       }
       return results;
     }));
     const reset = (input) => exports_Ref.update(slotsRef, (map18) => {
       const next4 = new Map(map18);
-      const prefix = `${input.chatroomId}:`;
-      const exactKey = input.scope === "chatroom-role" && input.role ? `${input.chatroomId}:${input.role.toLowerCase()}` : undefined;
       for (const key of next4.keys()) {
-        if (input.scope === "chatroom" ? key.startsWith(prefix) : key === exactKey) {
+        const identity5 = parseAgentKey(key);
+        if (identity5.chatroomId === input.chatroomId && (input.scope === "chatroom" || input.role !== undefined && identity5.role === input.role.toLowerCase())) {
           next4.delete(key);
         }
       }
@@ -31408,8 +31429,15 @@ var init_native_spawn_presence = __esm(() => {
 });
 
 // src/daemon/services/agent-process-service/infrastructure/agent-process-manager.ts
-function agentKey2(chatroomId, role) {
-  return `${chatroomId}:${role.toLowerCase()}`;
+function agentKey2(chatroomId, role, workingDir) {
+  return [chatroomId, role.toLowerCase(), workingDir ?? ""].join(AGENT_KEY_SEPARATOR2);
+}
+function parseAgentKey2(key) {
+  const [chatroomId, role, workingDir] = key.split(AGENT_KEY_SEPARATOR2);
+  return { chatroomId, role, ...workingDir ? { workingDir } : {} };
+}
+function serializedAgentKey(chatroomId, role, workingDir) {
+  return agentKey2(chatroomId, role, workingDir);
 }
 
 class AgentProcessManager {
@@ -31439,7 +31467,7 @@ class AgentProcessManager {
     this.lifecycle = createAgentLifecycleRuntime(portAdapterDeps);
   }
   runSerializedForAgent(key, operation) {
-    const serializedKey = agentKey2(key.chatroomId, key.role);
+    const serializedKey = serializedAgentKey(key.chatroomId, key.role, key.workingDir);
     const previous = this.serializedOperationTails.get(serializedKey) ?? Promise.resolve();
     const current = previous.catch(() => {
       return;
@@ -31458,7 +31486,7 @@ class AgentProcessManager {
     return current;
   }
   updateSlotsMirror(chatroomId, role, slot) {
-    const key = agentKey2(chatroomId, role);
+    const key = agentKey2(chatroomId, role, slot.workingDir);
     const existing = this.slots.get(key);
     if (!existing || existing.state !== slot.state || existing.pid !== slot.pid) {
       this.slots.set(key, {
@@ -31474,8 +31502,17 @@ class AgentProcessManager {
       });
     }
   }
-  getSlotFromMirror(chatroomId, role) {
-    return this.slots.get(agentKey2(chatroomId, role));
+  getSlotFromMirror(chatroomId, role, workingDir) {
+    if (workingDir !== undefined)
+      return this.slots.get(agentKey2(chatroomId, role, workingDir));
+    const legacy = this.slots.get(agentKey2(chatroomId, role));
+    if (legacy)
+      return legacy;
+    const matches = [...this.slots.entries()].filter(([key]) => {
+      const identity5 = parseAgentKey2(key);
+      return identity5.chatroomId === chatroomId && identity5.role === role.toLowerCase();
+    });
+    return matches.length === 1 ? matches[0]?.[1] : undefined;
   }
   whenTurnEndsIdle() {
     return (async () => {
@@ -31502,7 +31539,6 @@ class AgentProcessManager {
     slot.harness = undefined;
     slot.harnessSessionId = undefined;
     slot.model = undefined;
-    slot.workingDir = undefined;
     slot.startedAt = undefined;
     slot.pendingOperation = undefined;
     slot.stoppingSince = undefined;
@@ -31514,8 +31550,9 @@ class AgentProcessManager {
     slot.stopGeneration = (slot.stopGeneration ?? 0) + 1;
     return slot.stopGeneration;
   }
-  markStopIntent(chatroomId, role, reason, pid) {
-    const slot = this.getOrCreateSlot(agentKey2(chatroomId, role));
+  markStopIntent(chatroomId, role, reason, pid, workingDir) {
+    const resolvedWorkingDir = workingDir ?? [...this.slots.entries()].map(([key]) => ({ identity: parseAgentKey2(key) })).filter(({ identity: identity5 }) => identity5.chatroomId === chatroomId && identity5.role === role.toLowerCase() && identity5.workingDir !== undefined).map(({ identity: identity5 }) => identity5.workingDir).filter((candidate, index, candidates) => candidates.indexOf(candidate) === index)[0];
+    const slot = this.getOrCreateSlot(agentKey2(chatroomId, role, resolvedWorkingDir));
     if (slot.stopRequested)
       return slot.stopGeneration ?? 0;
     const generation = this.bumpStopGeneration(slot);
@@ -31527,12 +31564,12 @@ class AgentProcessManager {
   markChatroomStopIntent(chatroomId, reason) {
     for (const { chatroomId: cid, role, slot } of this.listAllSlots()) {
       if (cid === chatroomId) {
-        this.markStopIntent(chatroomId, role, reason, slot.pid);
+        this.markStopIntent(chatroomId, role, reason, slot.pid, slot.workingDir);
       }
     }
   }
-  isStopRequested(chatroomId, role, generation) {
-    const slot = this.slots.get(agentKey2(chatroomId, role));
+  isStopRequested(chatroomId, role, generation, workingDir) {
+    const slot = this.getSlotFromMirror(chatroomId, role, workingDir);
     if (!slot)
       return false;
     if (generation !== undefined && slot.stopGeneration !== generation)
@@ -31548,7 +31585,7 @@ class AgentProcessManager {
     if (isChatroomStopScopeActive(opts.chatroomId)) {
       return { success: false, error: "stop_in_progress" };
     }
-    const key = agentKey2(opts.chatroomId, opts.role);
+    const key = agentKey2(opts.chatroomId, opts.role, opts.workingDir);
     const slot = this.getOrCreateSlot(key);
     if (isExplicitDaemonStart(opts.reason)) {
       this.bumpStopGeneration(slot);
@@ -31582,8 +31619,7 @@ class AgentProcessManager {
     return operation;
   }
   async resumeTurnForSlot(args2) {
-    const key = agentKey2(args2.chatroomId, args2.role);
-    const slot = this.slots.get(key);
+    const slot = this.getSlotFromMirror(args2.chatroomId, args2.role, args2.workingDir);
     if (!slot?.pid || !slot.harness) {
       throw new Error(`No running agent for ${args2.role}@${args2.chatroomId}`);
     }
@@ -31602,10 +31638,14 @@ class AgentProcessManager {
     }
   }
   async stop(opts) {
-    const key = agentKey2(opts.chatroomId, opts.role);
-    const slot = this.slots.get(key);
-    this.markStopIntent(opts.chatroomId, opts.role, opts.reason, opts.pid ?? slot?.pid);
-    const earlyResult = await this.handleStopEarlyReturns(slot, opts, key);
+    const slot = this.getSlotFromMirror(opts.chatroomId, opts.role, opts.workingDir);
+    const resolvedOpts = {
+      ...opts,
+      ...opts.workingDir === undefined && slot?.workingDir ? { workingDir: slot.workingDir } : {}
+    };
+    const key = agentKey2(opts.chatroomId, opts.role, resolvedOpts.workingDir);
+    this.markStopIntent(resolvedOpts.chatroomId, resolvedOpts.role, resolvedOpts.reason, opts.pid ?? slot?.pid, resolvedOpts.workingDir);
+    const earlyResult = await this.handleStopEarlyReturns(slot, resolvedOpts, key);
     if (earlyResult) {
       return earlyResult;
     }
@@ -31625,7 +31665,8 @@ class AgentProcessManager {
         chatroomId: cid,
         role,
         pid: slot.pid,
-        agentHarness: slot.harness
+        agentHarness: slot.harness,
+        workingDir: slot.workingDir
       });
       targets.set(target.targetKey, target);
     }
@@ -31638,7 +31679,8 @@ class AgentProcessManager {
           chatroomId: cid,
           role,
           pid: entry.pid,
-          agentHarness: entry.harness
+          agentHarness: entry.harness,
+          workingDir: entry.workingDir
         });
         targets.set(target.targetKey, target);
       }
@@ -31660,26 +31702,26 @@ class AgentProcessManager {
     };
   }
   bindStopTarget(args2) {
-    const slot = this.slots.get(agentKey2(args2.chatroomId, args2.role));
+    const slot = this.slots.get(agentKey2(args2.chatroomId, args2.role, args2.workingDir));
     if (!slot || slot.pid !== args2.pid || slot.state !== AGENT_SLOT_STATE.STOPPING)
       return;
     slot.stopCommandId = args2.stopCommandId;
     slot.stopTargetKey = args2.targetKey;
   }
   async withScopedRoleStop(opts, fn2) {
-    const key = agentKey2(opts.chatroomId, opts.role);
+    const key = agentKey2(opts.chatroomId, opts.role, opts.workingDir);
     const slot = this.slots.get(key);
     if (!slot || !slot.pid || slot.state === AGENT_SLOT_STATE.IDLE)
       return { ok: false, reason: "no_slot" };
     if (slot.state === AGENT_SLOT_STATE.STOPPING || slot.pendingOperation)
       return { ok: false, reason: "concurrent" };
-    this.markStopIntent(opts.chatroomId, opts.role, opts.reason, slot.pid);
+    this.markStopIntent(opts.chatroomId, opts.role, opts.reason, slot.pid, opts.workingDir);
     slot.state = AGENT_SLOT_STATE.STOPPING;
     slot.stoppingSince = this.deps.clock.now();
     try {
       const value = await fn2();
       this.resetSlotAfterStop(slot);
-      await this.clearAgentPidQuietly(opts.chatroomId, opts.role);
+      await this.clearAgentPidQuietly(opts.chatroomId, opts.role, opts.workingDir);
       return { ok: true, value };
     } catch (error) {
       slot.state = AGENT_SLOT_STATE.RUNNING;
@@ -31729,7 +31771,7 @@ class AgentProcessManager {
     this.recordAgentExit(opts.role, exitArgs, "Failed to record agent exit (idle cleanup)");
   }
   async runHandleAgentEnd(opts) {
-    const slot = this.slots.get(agentKey2(opts.chatroomId, opts.role));
+    const slot = [...this.slots.entries()].find(([candidateKey, candidate]) => candidateKey === agentKey2(opts.chatroomId, opts.role, opts.workingDir) && candidate.pid === opts.pid)?.[1];
     if (!slot || slot.pid !== opts.pid || slot.harness !== opts.harness || slot.state !== AGENT_SLOT_STATE.RUNNING) {
       console.log(`[AgentProcessManager] Ignoring stale agent_end: role=${opts.role} callbackPid=${opts.pid} currentPid=${slot?.pid ?? "none"} currentState=${slot?.state ?? "none"}`);
       return;
@@ -31799,8 +31841,7 @@ class AgentProcessManager {
     }
   }
   async handleExit(opts) {
-    const key = agentKey2(opts.chatroomId, opts.role);
-    const slot = this.slots.get(key);
+    const slot = this.getSlotFromMirror(opts.chatroomId, opts.role, opts.workingDir);
     if (!slot || slot.pid !== opts.pid || slot.state === AGENT_SLOT_STATE.STOPPING) {
       return;
     }
@@ -31821,6 +31862,7 @@ class AgentProcessManager {
       yield* svc.handleExit({
         chatroomId: opts.chatroomId,
         role: opts.role,
+        workingDir: slot.workingDir,
         pid: opts.pid,
         code: opts.code,
         signal: opts.signal
@@ -31829,7 +31871,7 @@ class AgentProcessManager {
     this.resetSlotAfterExit(slot);
     this.emitExitEvent(slot, opts, ctx);
     try {
-      await this.deps.persistence.clearAgentPid(this.deps.machineId, opts.chatroomId, opts.role);
+      await this.deps.persistence.clearAgentPid(this.deps.machineId, opts.chatroomId, opts.role, slot.workingDir);
     } catch {}
     this.untrackAllServices(opts.pid);
     lifecyclePromise.catch(() => {});
@@ -31901,15 +31943,15 @@ class AgentProcessManager {
       emittedAt: this.deps.clock.now()
     })).catch(() => {});
   }
-  getSlot(chatroomId, role) {
-    return this.getSlotFromMirror(chatroomId, role);
+  getSlot(chatroomId, role, workingDir) {
+    return this.getSlotFromMirror(chatroomId, role, workingDir);
   }
   listActive() {
     const result = [];
     for (const [key, slot] of this.slots) {
       if (slot.state === AGENT_SLOT_STATE.RUNNING || slot.state === AGENT_SLOT_STATE.SPAWNING) {
-        const [chatroomId, role] = key.split(":");
-        result.push({ chatroomId, role, slot });
+        const identity5 = parseAgentKey2(key);
+        result.push({ chatroomId: identity5.chatroomId, role: identity5.role, slot });
       }
     }
     return result;
@@ -31917,17 +31959,17 @@ class AgentProcessManager {
   listAllSlots() {
     const result = [];
     for (const [key, slot] of this.slots) {
-      const [chatroomId, role] = key.split(":");
-      result.push({ chatroomId, role, slot });
+      const identity5 = parseAgentKey2(key);
+      result.push({ chatroomId: identity5.chatroomId, role: identity5.role, slot });
     }
     return result;
   }
   async clearStuckStoppingSlot(chatroomId, role, options) {
-    const key = agentKey2(chatroomId, role);
-    const slot = this.slots.get(key);
+    const slot = this.getSlotFromMirror(chatroomId, role, options?.workingDir);
     if (!slot || slot.state !== AGENT_SLOT_STATE.STOPPING) {
       return false;
     }
+    const key = agentKey2(chatroomId, role, slot.workingDir);
     const elapsed3 = slot.stoppingSince ? this.deps.clock.now() - slot.stoppingSince : STOPPING_TIMEOUT_MS;
     if (elapsed3 < STOPPING_TIMEOUT_MS) {
       return false;
@@ -31938,8 +31980,8 @@ class AgentProcessManager {
   }
   async clearAllStuckStoppingSlots() {
     let cleared = 0;
-    for (const { chatroomId, role } of this.listAllSlots()) {
-      if (await this.clearStuckStoppingSlot(chatroomId, role)) {
+    for (const { chatroomId, role, slot } of this.listAllSlots()) {
+      if (await this.clearStuckStoppingSlot(chatroomId, role, { workingDir: slot.workingDir })) {
         cleared++;
       }
     }
@@ -31953,11 +31995,12 @@ class AgentProcessManager {
       if (!matchesScope(slotChatroomId, role))
         continue;
       if (slot.pid && slot.harness) {
-        knownEntries.set(agentKey2(slotChatroomId, role), {
+        knownEntries.set(agentKey2(slotChatroomId, role, slot.workingDir), {
           chatroomId: slotChatroomId,
           role,
           pid: slot.pid,
-          harness: slot.harness
+          harness: slot.harness,
+          workingDir: slot.workingDir
         });
       }
     }
@@ -31969,17 +32012,18 @@ class AgentProcessManager {
       } of await this.deps.persistence.listAgentEntries(this.deps.machineId)) {
         if (!matchesScope(entryChatroomId, role))
           continue;
-        knownEntries.set(agentKey2(entryChatroomId, role), {
+        knownEntries.set(agentKey2(entryChatroomId, role, entry.workingDir), {
           chatroomId: entryChatroomId,
           role,
           pid: entry.pid,
-          harness: entry.harness
+          harness: entry.harness,
+          workingDir: entry.workingDir
         });
       }
     } catch {}
-    for (const { chatroomId, role, pid, harness } of knownEntries.values()) {
+    for (const { chatroomId, role, pid, harness, workingDir } of knownEntries.values()) {
       await this.stopPersistedProcess(pid, harness);
-      await this.clearAgentPidQuietly(chatroomId, role);
+      await this.clearAgentPidQuietly(chatroomId, role, workingDir);
     }
     for (let i2 = this.exitRetryQueue.length - 1;i2 >= 0; i2--) {
       const item = this.exitRetryQueue[i2];
@@ -31989,8 +32033,8 @@ class AgentProcessManager {
     if (this.exitRetryQueue.length === 0)
       this.stopExitRetryTimer();
     for (const key of [...this.slots.keys()]) {
-      const [keyChatroomId, keyRole] = key.split(":");
-      if (matchesScope(keyChatroomId, keyRole))
+      const identity5 = parseAgentKey2(key);
+      if (matchesScope(identity5.chatroomId, identity5.role))
         this.slots.delete(key);
     }
     await this.lifecycle.runPromise(exports_Effect.gen(function* () {
@@ -32023,38 +32067,38 @@ class AgentProcessManager {
     }
     untrackChildPid(pid);
   }
-  async killExistingBeforeSpawn(chatroomId, role) {
-    const key = agentKey2(chatroomId, role);
-    await this.killInMemorySlotIfAlive(key, chatroomId, role);
-    await this.killPersistedProcessIfAlive(chatroomId, role);
+  async killExistingBeforeSpawn(chatroomId, role, workingDir) {
+    const key = agentKey2(chatroomId, role, workingDir);
+    await this.killInMemorySlotIfAlive(key, chatroomId, role, workingDir);
+    await this.killPersistedProcessIfAlive(chatroomId, role, workingDir);
   }
-  async killInMemorySlotIfAlive(key, chatroomId, role) {
+  async killInMemorySlotIfAlive(key, chatroomId, role, workingDir) {
     const slot = this.slots.get(key);
     if (slot?.pid && isProcessAlive(this.deps.processes.kill, slot.pid) && (slot.state === AGENT_SLOT_STATE.RUNNING || slot.state === AGENT_SLOT_STATE.SPAWNING)) {
       const pid = slot.pid;
       slot.state = AGENT_SLOT_STATE.STOPPING;
       const stopGeneration = this.bumpStopGeneration(slot);
       slot.stoppingSince = this.deps.clock.now();
-      await this.doStop(key, slot, pid, { chatroomId, role, reason: "daemon.respawn" }, stopGeneration);
+      await this.doStop(key, slot, pid, { chatroomId, role, reason: "daemon.respawn", workingDir }, stopGeneration);
     }
   }
-  async killPersistedProcessIfAlive(chatroomId, role) {
+  async killPersistedProcessIfAlive(chatroomId, role, workingDir) {
     let entries2 = [];
     try {
       entries2 = await this.deps.persistence.listAgentEntries(this.deps.machineId);
     } catch {
       return;
     }
-    const persisted = entries2.find((e) => e.chatroomId === chatroomId && e.role.toLowerCase() === role.toLowerCase());
+    const persisted = entries2.find((e) => e.chatroomId === chatroomId && e.role.toLowerCase() === role.toLowerCase() && (!workingDir || !e.entry.workingDir || e.entry.workingDir === workingDir));
     if (!persisted) {
       return;
     }
     const { pid, harness } = persisted.entry;
     if (!isProcessAlive(this.deps.processes.kill, pid)) {
-      await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role).catch(() => {});
+      await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role, workingDir).catch(() => {});
       return;
     }
-    const key = agentKey2(chatroomId, role);
+    const key = agentKey2(chatroomId, role, workingDir);
     const currentSlot = this.slots.get(key);
     if (currentSlot?.pid === pid && currentSlot.state !== AGENT_SLOT_STATE.IDLE) {
       return;
@@ -32072,11 +32116,11 @@ class AgentProcessManager {
       agentHarness: harness
     };
     this.recordAgentExit(role, exitArgs, "Failed to record agent exit before respawn");
-    await this.clearAgentPidQuietly(chatroomId, role);
+    await this.clearAgentPidQuietly(chatroomId, role, workingDir);
   }
   async executeEnsureRunning(key, slot, opts) {
     try {
-      await this.killExistingBeforeSpawn(opts.chatroomId, opts.role);
+      await this.killExistingBeforeSpawn(opts.chatroomId, opts.role, opts.workingDir);
       const result = await this.doEnsureRunning(key, slot, opts);
       return result;
     } finally {
@@ -32097,19 +32141,19 @@ class AgentProcessManager {
       console.log(`   ⚠️  Failed to enqueue agent exited lifecycle fact: ${err.message}`);
     });
   }
-  async clearAgentPidQuietly(chatroomId, role) {
+  async clearAgentPidQuietly(chatroomId, role, workingDir) {
     try {
-      await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role);
+      await this.deps.persistence.clearAgentPid(this.deps.machineId, chatroomId, role, workingDir);
     } catch {}
   }
   async syncSlotsAfterScopedStop(result) {
     for (const { target } of result.targets) {
-      const slot = this.slots.get(agentKey2(target.chatroomId, target.role));
+      const slot = this.slots.get(agentKey2(target.chatroomId, target.role, target.workingDir));
       this.notifyAgentSessionLost(target.chatroomId, target.role, slot?.pid === target.pid ? slot.harnessSessionId : undefined);
       if (!slot || slot.pid !== target.pid)
         continue;
       this.resetSlotAfterStop(slot);
-      await this.clearAgentPidQuietly(target.chatroomId, target.role);
+      await this.clearAgentPidQuietly(target.chatroomId, target.role, target.workingDir);
     }
   }
   notifyAgentSessionLost(chatroomId, role, harnessSessionId) {
@@ -32322,12 +32366,13 @@ class AgentProcessManager {
     });
     spawnResult.onExit(({ code: code2, signal }) => {
       const reconcileExit = async () => {
-        const currentSlot = this.slots.get(agentKey2(opts.chatroomId, opts.role));
+        const currentSlot = [...this.slots.entries()].find(([candidateKey, candidate]) => candidateKey === agentKey2(opts.chatroomId, opts.role, opts.workingDir) && candidate.pid === pid)?.[1];
         const hasUnresolvedNativeTurn = currentSlot?.pid === pid && currentSlot.nativeTurnPhase === "turn_in_flight" && !this.typedCompletionSeenPids.has(pid);
         if (hasUnresolvedNativeTurn) {
-          await this.runSerializedForAgent({ chatroomId: opts.chatroomId, role: opts.role }, () => this.runHandleAgentEnd({
+          await this.runSerializedForAgent({ chatroomId: opts.chatroomId, role: opts.role, workingDir: opts.workingDir }, () => this.runHandleAgentEnd({
             chatroomId: opts.chatroomId,
             role: opts.role,
+            workingDir: opts.workingDir,
             pid,
             harness: opts.agentHarness,
             completion: {
@@ -32342,6 +32387,7 @@ class AgentProcessManager {
         await this.handleExit({
           chatroomId: opts.chatroomId,
           role: opts.role,
+          workingDir: opts.workingDir,
           pid,
           code: code2,
           signal
@@ -32354,9 +32400,10 @@ class AgentProcessManager {
     if (spawnResult.onTurnResult) {
       spawnResult.onTurnResult((completion) => {
         this.typedCompletionSeenPids.add(pid);
-        this.runSerializedForAgent({ chatroomId: opts.chatroomId, role: opts.role }, () => this.runHandleAgentEnd({
+        this.runSerializedForAgent({ chatroomId: opts.chatroomId, role: opts.role, workingDir: opts.workingDir }, () => this.runHandleAgentEnd({
           chatroomId: opts.chatroomId,
           role: opts.role,
+          workingDir: opts.workingDir,
           pid,
           harness: opts.agentHarness,
           completion
@@ -32366,9 +32413,10 @@ class AgentProcessManager {
       });
     } else if (spawnResult.onAgentEnd) {
       spawnResult.onAgentEnd(() => {
-        this.runSerializedForAgent({ chatroomId: opts.chatroomId, role: opts.role }, () => this.runHandleAgentEnd({
+        this.runSerializedForAgent({ chatroomId: opts.chatroomId, role: opts.role, workingDir: opts.workingDir }, () => this.runHandleAgentEnd({
           chatroomId: opts.chatroomId,
           role: opts.role,
+          workingDir: opts.workingDir,
           pid,
           harness: opts.agentHarness
         })).catch((error) => {
@@ -32391,7 +32439,7 @@ class AgentProcessManager {
     this.assignRunningSlotState(key, slot, opts, spawnResult, wantResume, pid);
     await this.emitSpawnedAgentUpdate(slot, opts, spawnResult, pid);
     try {
-      await this.deps.persistence.persistAgentPid(this.deps.machineId, opts.chatroomId, opts.role, pid, opts.agentHarness);
+      await this.deps.persistence.persistAgentPid(this.deps.machineId, opts.chatroomId, opts.role, pid, opts.agentHarness, opts.workingDir);
     } catch {}
     this.registerSpawnCallbacks(slot, opts, spawnResult, pid);
     if (getHarnessCapabilities(opts.agentHarness).supportsNativeIntegration) {
@@ -32524,11 +32572,12 @@ class AgentProcessManager {
         stopReason: reason,
         exitCode: undefined,
         signal: "SIGKILL",
-        agentHarness: harness
+        agentHarness: harness,
+        workingDir: slot.workingDir
       };
       this.recordAgentExit(role, exitArgs, "Failed to record stop-timeout exit");
     }
-    await this.clearAgentPidQuietly(chatroomId, role);
+    await this.clearAgentPidQuietly(chatroomId, role, slot.workingDir);
   }
   async doStop(key, slot, pid, opts, stopGeneration) {
     try {
@@ -32554,7 +32603,8 @@ class AgentProcessManager {
             chatroomId: opts.chatroomId,
             role: opts.role,
             pid,
-            agentHarness: harness
+            agentHarness: harness,
+            workingDir: opts.workingDir
           }),
           reason: opts.reason
         });
@@ -32571,12 +32621,12 @@ class AgentProcessManager {
     }
     this.resetSlotAfterStop(slot);
     try {
-      await this.deps.persistence.clearAgentPid(this.deps.machineId, opts.chatroomId, opts.role);
+      await this.deps.persistence.clearAgentPid(this.deps.machineId, opts.chatroomId, opts.role, opts.workingDir);
     } catch {}
     return { success: true };
   }
 }
-var AGENT_EXIT_RETRY_INTERVAL_MS = 1e4, STOPPING_TIMEOUT_MS = 30000;
+var AGENT_KEY_SEPARATOR2 = "\x00", AGENT_EXIT_RETRY_INTERVAL_MS = 1e4, STOPPING_TIMEOUT_MS = 30000;
 var init_agent_process_manager = __esm(() => {
   init_agent();
   init_types();
@@ -41534,8 +41584,8 @@ var init_storage2 = __esm(() => {
 import * as fs5 from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import { join as join14 } from "node:path";
-function agentKey3(chatroomId, role) {
-  return `${chatroomId}/${role}`;
+function agentKey3(chatroomId, role, workingDir) {
+  return workingDir ? `${chatroomId}/${role}/${encodeURIComponent(workingDir)}` : `${chatroomId}/${role}`;
 }
 async function ensureStateDir() {
   await fs5.mkdir(STATE_DIR, { recursive: true, mode: 448 });
@@ -41571,24 +41621,33 @@ async function loadOrCreate(machineId) {
     agents: {}
   };
 }
-async function persistAgentPid(machineId, chatroomId, role, pid, harness) {
+async function persistAgentPid(machineId, chatroomId, role, pid, harness, workingDir) {
   const state = await loadOrCreate(machineId);
-  state.agents[agentKey3(chatroomId, role)] = {
+  state.agents[agentKey3(chatroomId, role, workingDir)] = {
     pid,
     harness,
-    startedAt: new Date().toISOString()
+    startedAt: new Date().toISOString(),
+    ...workingDir ? { workingDir } : {}
   };
   state.updatedAt = new Date().toISOString();
   await saveDaemonState(state);
 }
-async function clearAgentPid(machineId, chatroomId, role) {
+async function clearAgentPid(machineId, chatroomId, role, workingDir) {
   const state = await loadDaemonState(machineId);
   if (!state)
     return;
-  const key = agentKey3(chatroomId, role);
-  if (!(key in state.agents))
-    return;
-  delete state.agents[key];
+  const key = agentKey3(chatroomId, role, workingDir);
+  if (!(key in state.agents)) {
+    if (workingDir === undefined)
+      return;
+    const legacyKey = agentKey3(chatroomId, role);
+    const legacy = state.agents[legacyKey];
+    if (!legacy || legacy.workingDir !== workingDir)
+      return;
+    delete state.agents[legacyKey];
+  } else {
+    delete state.agents[key];
+  }
   state.updatedAt = new Date().toISOString();
   await saveDaemonState(state);
 }
@@ -41598,12 +41657,22 @@ async function listAgentEntries(machineId) {
     return [];
   const results = [];
   for (const [key, entry] of Object.entries(state.agents)) {
-    const separatorIndex = key.lastIndexOf("/");
-    if (separatorIndex === -1)
+    const parts2 = key.split("/");
+    if (parts2.length < 2)
       continue;
-    const chatroomId = key.substring(0, separatorIndex);
-    const role = key.substring(separatorIndex + 1);
-    results.push({ chatroomId, role, entry });
+    const chatroomId = parts2[0];
+    const role = parts2[1];
+    if (parts2.length === 2) {
+      results.push({ chatroomId, role, entry });
+      continue;
+    }
+    try {
+      results.push({
+        chatroomId,
+        role,
+        entry: { ...entry, workingDir: decodeURIComponent(parts2.slice(2).join("/")) }
+      });
+    } catch {}
   }
   return results;
 }
@@ -89828,8 +89897,8 @@ var AgentLifecycleOutboxService, AgentLifecycleOutboxServiceLive = (registry2, m
   enqueue: (fact) => exports_Effect.promise(() => enqueueAgentLifecycleFact(registry2, machineId, fact)),
   stopAll: () => exports_Effect.promise(() => registry2.stopAll())
 }), DaemonMachineService, DaemonMachineServiceLive = (ops) => exports_Layer.succeed(DaemonMachineService, {
-  clearAgentPid: (machineId, chatroomId, role) => exports_Effect.promise(() => ops.clearAgentPid(machineId, chatroomId, role)),
-  persistAgentPid: (machineId, chatroomId, role, pid, harness) => exports_Effect.promise(() => ops.persistAgentPid(machineId, chatroomId, role, pid, harness)),
+  clearAgentPid: (machineId, chatroomId, role, workingDir) => exports_Effect.promise(() => workingDir === undefined ? ops.clearAgentPid(machineId, chatroomId, role) : ops.clearAgentPid(machineId, chatroomId, role, workingDir)),
+  persistAgentPid: (machineId, chatroomId, role, pid, harness, workingDir) => exports_Effect.promise(() => ops.persistAgentPid(machineId, chatroomId, role, pid, harness, workingDir)),
   listAgentEntries: (machineId) => exports_Effect.promise(() => ops.listAgentEntries(machineId)),
   persistEventCursor: (machineId, lastSeenEventId) => exports_Effect.promise(() => ops.persistEventCursor(machineId, lastSeenEventId)),
   loadEventCursor: (machineId) => exports_Effect.promise(() => ops.loadEventCursor(machineId))
@@ -89839,7 +89908,7 @@ var AgentLifecycleOutboxService, AgentLifecycleOutboxServiceLive = (registry2, m
   ensureRunning: (opts) => exports_Effect.promise(() => mgr.ensureRunning(opts)),
   stop: (opts) => exports_Effect.promise(() => mgr.stop(opts)),
   handleExit: (opts) => exports_Effect.promise(() => mgr.handleExit(opts)),
-  getSlot: (chatroomId, role) => mgr.getSlot(chatroomId, role),
+  getSlot: (chatroomId, role, workingDir) => workingDir === undefined ? mgr.getSlot(chatroomId, role) : mgr.getSlot(chatroomId, role, workingDir),
   listActive: () => mgr.listActive(),
   clearStuckStoppingSlot: (chatroomId, role, options) => exports_Effect.promise(() => mgr.clearStuckStoppingSlot(chatroomId, role, options)),
   whenTurnEndsIdle: () => exports_Effect.promise(() => mgr.whenTurnEndsIdle()),
@@ -96032,13 +96101,13 @@ function sleep6(ms) {
   return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 async function waitForHarnessSessionId2(deps, event) {
-  const initial = deps.agentMgr.getSlot(event.chatroomId, event.role);
+  const initial = deps.agentMgr.getSlot(event.chatroomId, event.role, event.workingDir);
   if (initial?.harnessSessionId) {
     return initial.harnessSessionId;
   }
   const deadline = Date.now() + HARNESS_SESSION_READY_TIMEOUT_MS;
   while (Date.now() < deadline) {
-    const slot = deps.agentMgr.getSlot(event.chatroomId, event.role);
+    const slot = deps.agentMgr.getSlot(event.chatroomId, event.role, event.workingDir);
     if (slot?.harnessSessionId) {
       return slot.harnessSessionId;
     }
@@ -96063,8 +96132,8 @@ async function runRestartOrchestrator(deps, event) {
     resetRoleDeliveryState(chatroomId, role);
     await emitPhase(deps, event, "reset");
     await emitPhase(deps, event, "spawn");
-    const spawnResult = await deps.runSerializedForAgent({ chatroomId, role }, { timeoutMs: HARNESS_SESSION_READY_TIMEOUT_MS }, async (ops, context5) => {
-      await ops.stopAgent({ chatroomId, role, reason: "user.restart" }, context5.signal);
+    const spawnResult = await deps.runSerializedForAgent({ chatroomId, role, workingDir: event.workingDir }, { timeoutMs: HARNESS_SESSION_READY_TIMEOUT_MS }, async (ops, context5) => {
+      await ops.stopAgent({ chatroomId, role, reason: "user.restart", workingDir: event.workingDir }, context5.signal);
       return ops.startAgent({
         chatroomId,
         role,
@@ -96082,7 +96151,13 @@ async function runRestartOrchestrator(deps, event) {
     await emitPhase(deps, event, "await_session");
     const harnessSessionId = await waitForHarnessSessionId2(deps, event);
     if (!harnessSessionId) {
-      await deps.runSerializedForAgent({ chatroomId, role }, { timeoutMs: HARNESS_SESSION_READY_TIMEOUT_MS }, (ops, context5) => ops.stopAgent({ chatroomId, role, reason: "user.restart", pid: spawnResult.pid }, context5.signal));
+      await deps.runSerializedForAgent({ chatroomId, role, workingDir: event.workingDir }, { timeoutMs: HARNESS_SESSION_READY_TIMEOUT_MS }, (ops, context5) => ops.stopAgent({
+        chatroomId,
+        role,
+        reason: "user.restart",
+        pid: spawnResult.pid,
+        workingDir: event.workingDir
+      }, context5.signal));
       await emitPhase(deps, event, "failed", "harnessSessionId timeout");
       return;
     }
@@ -103925,17 +104000,17 @@ var init_deps = __esm(() => {
 // src/daemon/entry/execute-chatroom-stop-command.ts
 async function executeChatroomStopCommand(args2) {
   if (args2.role)
-    args2.apm.markStopIntent(args2.chatroomId, args2.role, "user.stop");
-  else {
+    args2.apm.markStopIntent(args2.chatroomId, args2.role, "user.stop", undefined, args2.workingDir);
+  else if (!args2.workingDir) {
     args2.apm.markChatroomStopIntent(args2.chatroomId, "user.stop");
     await abortEnhancerSpawnsForChatroom(args2.chatroomId);
   }
   const confirmedDeps = args2.apm.getConfirmedStopAdapterDeps();
   const targets = await args2.apm.discoverStopTargets(args2.chatroomId);
   const roles = [
-    ...new Set(targets.filter((target) => !args2.role || target.role.toLowerCase() === args2.role.toLowerCase()).map((target) => target.role.toLowerCase()))
+    ...new Set(targets.filter((target) => (!args2.role || target.role.toLowerCase() === args2.role.toLowerCase()) && (!args2.workingDir || target.workingDir === args2.workingDir)).map((target) => target.role.toLowerCase()))
   ];
-  const results = await Promise.allSettled(roles.map((role) => args2.runSerializedForAgent({ chatroomId: args2.chatroomId, role }, { timeoutMs: AGENT_LIFECYCLE_OPERATION_TIMEOUT_MS }, async (_ops, context5) => {
+  const results = await Promise.allSettled(roles.map((role) => args2.runSerializedForAgent({ chatroomId: args2.chatroomId, role, workingDir: args2.workingDir }, { timeoutMs: AGENT_LIFECYCLE_OPERATION_TIMEOUT_MS }, async (_ops, context5) => {
     if (context5.signal.aborted)
       throw context5.signal.reason;
     await runRoleScopedStop({
@@ -103943,7 +104018,8 @@ async function executeChatroomStopCommand(args2) {
       confirmedDeps,
       chatroomId: args2.chatroomId,
       role,
-      reason: "user.stop"
+      reason: "user.stop",
+      workingDir: args2.workingDir
     });
   })));
   for (const result of results)
@@ -133735,6 +133811,7 @@ async function startDaemon() {
         chatroomId: stopCommand.chatroomId,
         commandId: stopCommand.commandId,
         role: stopCommand.role,
+        workingDir: stopCommand.workingDir,
         finalizeChatroom: stopCommand.finalizeChatroom,
         runSerializedForAgent: init2.agentProcessManagerService.runSerializedForAgent
       });
@@ -135008,4 +135085,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=F7D4048085B1B4E264756E2164756E21
+//# debugId=0132031C48F1331264756E2164756E21