@inetafrica/open-claudia 3.5.1 → 3.5.4

package/core/state.js

@@ -7,7 +7,7 @@ const path = require("path");
 const crypto = require("crypto");
 const {
   STATE_FILE, SESSIONS_FILE, IDENTITIES_FILE, CONFIG_DIR, CHAT_ID, UNIFIED_IDENTITY,
-  JOBS_FILE, CRONS_FILE, WORKSPACE,
+  JOBS_FILE, CRONS_FILE, WORKSPACE, config,
 } = require("./config");
 const {
   normalizeCanonicalUserId,
@@ -19,6 +19,7 @@ const {
   defaultCanonicalForChannel,
   channelKey,
   identities,
+  parseConversationKey,
 } = require("./identity");
 const { currentChannelId, currentCanonicalUserId, currentConversationKey, currentRoomKey } = require("./context");
 const { atomicWriteFileSync, readJsonWithFallback } = require("./fsutil");
@@ -32,6 +33,14 @@ const {
 const STATE_SCHEMA_VERSION = 3;
 const SESSIONS_SCHEMA_VERSION = 3;
 const MAX_USAGE_ENTRIES = 50;
+// Thread conversations get their own usage budget so a busy day of threads can
+// never evict the channels' own usage records (and vice versa).
+const MAX_THREAD_USAGE_ENTRIES = 200;
+// Every thread keeps its provider session pointer in activeSessions; without a
+// bound one speaker's state would grow by one entry per thread forever. Channel
+// keys (and anything that is not a thread) are never evicted.
+const MAX_THREAD_SESSIONS = 200;
+const THREAD_KEY_MARK = "#thread:";
 const MAX_SESSIONS_PER_PROJECT = 20;
 const MAX_SESSION_CALLBACKS = 200;
 const SESSION_CALLBACK_TTL_MS = 10 * 60 * 1000;
@@ -93,10 +102,18 @@ function normalizeActiveSessions(value) {
   return result;
 }
 
-function boundUsageBySession(value, limit = MAX_USAGE_ENTRIES) {
+// Usage keys start with the conversation key, so thread and channel records are
+// bounded separately (partitioned, oldest first out within each partition) and
+// a thread can never push a channel's usage out, nor one thread flood the rest.
+function boundUsageBySession(value, limit = MAX_USAGE_ENTRIES, threadLimit = MAX_THREAD_USAGE_ENTRIES) {
   const entries = Object.entries(cloneRecord(value))
     .filter(([key, usage]) => typeof key === "string" && key && isRecord(usage));
-  return Object.fromEntries(entries.slice(-Math.max(1, limit)));
+  const isThread = ([key]) => key.split("\u0000")[0].includes(THREAD_KEY_MARK);
+  const keep = new Set([
+    ...entries.filter((entry) => !isThread(entry)).slice(-Math.max(1, limit)),
+    ...entries.filter(isThread).slice(-Math.max(1, threadLimit)),
+  ]);
+  return Object.fromEntries(entries.filter((entry) => keep.has(entry)));
 }
 
 function freshUsage() {
@@ -398,11 +415,19 @@ function roomSettingsFor(roomKey) {
   return isRecord(entry) && isRecord(entry.settings) ? entry.settings : null;
 }
 
-// The room whose settings govern the state's current turn. Stamped in
-// getUserState from the live room key; null outside a chat turn (CLI, boot,
-// tests), which is what keeps those paths on the person's settings.
+// The room whose settings govern the current turn, read from the request
+// context (never from anything stamped on the shared state: one speaker can be
+// running in two rooms at once, and a stamp would follow whichever message came
+// last). A thread's room is its channel, so threads share the chat's settings.
+// null outside a chat turn (CLI, boot, tests), which is what keeps those paths
+// on the person's settings.
+function activeRoomKey() {
+  const key = currentRoomKey();
+  return key ? parseConversationKey(key).roomKey || null : null;
+}
+
 function roomOverlayFor(state) {
-  return roomSettingsFor(state && state.roomKey);
+  return roomSettingsFor(activeRoomKey());
 }
 
 function setRoomSetting(roomKey, key, value) {
@@ -459,10 +484,34 @@ function setProviderSession(state, providerId, projectName, sessionId) {
     throw new TypeError("provider, project, and sessionId are required");
   }
   if (!isRecord(state.activeSessions)) state.activeSessions = {};
-  state.activeSessions[project] = { ...cloneRecord(state.activeSessions[project]), [provider]: sessionId };
+  const bucket = { ...cloneRecord(state.activeSessions[project]), [provider]: sessionId };
+  // Re-insert so key order is recency order: eviction drops the oldest threads.
+  delete state.activeSessions[project];
+  state.activeSessions[project] = bucket;
+  evictIdleThreadSessions(state);
   return sessionId;
 }
 
+// Keep at most MAX_THREAD_SESSIONS thread pointers per speaker, dropping the
+// least recently written first. Channel keys are never evicted, and neither is
+// a thread whose lane is running or has work queued. An evicted thread simply
+// starts a fresh session if it is ever spoken to again.
+function evictIdleThreadSessions(state, limit = MAX_THREAD_SESSIONS) {
+  if (!isRecord(state?.activeSessions)) return 0;
+  const threads = Object.keys(state.activeSessions).filter((key) => key.includes(THREAD_KEY_MARK));
+  let excess = threads.length - Math.max(1, limit);
+  let evicted = 0;
+  for (const key of threads) {
+    if (excess <= 0) break;
+    const lane = peekLane(state, key);
+    if (lane && (laneBusy(lane) || lane.messageQueue.length)) continue;
+    delete state.activeSessions[key];
+    excess -= 1;
+    evicted += 1;
+  }
+  return evicted;
+}
+
 function clearProviderSession(state, providerId, projectName) {
   const project = getProjectKey(state, projectName);
   const provider = normalizeProviderId(providerId, null);
@@ -539,7 +588,7 @@ function backfillDefaults(bucket) {
 function resolveProviderSettings(state, providerId) {
   const provider = normalizeProviderId(providerId || getActiveProvider(state), null);
   if (!provider) return providerDefaults();
-  const roomKey = state && state.roomKey ? String(state.roomKey) : "";
+  const roomKey = activeRoomKey() || "";
   const room = roomKey && isRecord(savedState.rooms)
     && isRecord(savedState.rooms[roomKey])
     && isRecord(savedState.rooms[roomKey].providerSettings)
@@ -568,7 +617,7 @@ function getProviderSettings(state, providerId) {
   // gets the same assistant. The room's bucket is seeded from the speaker who
   // first pins it, then diverges — mutations by callers land on the room object
   // and persist with savedState.rooms.
-  const roomKey = state && state.roomKey ? String(state.roomKey) : "";
+  const roomKey = activeRoomKey() || "";
   if (roomKey) {
     if (!isRecord(savedState.rooms)) savedState.rooms = {};
     if (!isRecord(savedState.rooms[roomKey])) savedState.rooms[roomKey] = {};
@@ -670,28 +719,17 @@ function createUserState(userId) {
     userId: String(userId),
     channelId: currentChannelId(),
     currentSession: saved.currentSession || rootSession(),
-    runningProcess: null,
-    preparingRun: false,
-    cancelRequested: false,
-    typingHeartbeat: null,
-    statusMessageId: null,
-    // Channel the statusMessageId was minted on. Under unified identity the
-    // owner's Telegram + Kazee turns share ONE state object, but a message id
-    // is only valid on the channel that created it — editing a Telegram id on
-    // Kazee 500s. Guard every edit-in-place against this so a foreign-channel
-    // id is discarded (fresh send) instead of edited.
-    statusMessageChannel: null,
-    streamBuffer: "",
-    streamInterval: null,
     activeSessions: normalizeActiveSessions(saved.activeSessions),
     quarantinedSessions: boundQuarantinedSessions(saved.quarantinedSessions),
     providerSettings: normalizeProviderSettings(saved.providerSettings),
     usageBySession: boundUsageBySession(saved.usageBySession),
-    messageQueue: [],
     isFirstMessage: true,
-    lastInputWasVoice: false,
     settings,
     legacyProviderState: cloneRecord(saved.legacyProviderState),
+    // The durable compaction journal stays one slot per speaker even though
+    // compaction runs per lane: commitProviderCompaction is synchronous from
+    // prepare to cleanup (no await), so two lanes can never hold it at once,
+    // and the persisted recovery format stays unchanged.
     pendingCompaction: isRecord(saved.pendingCompaction) ? structuredClone(saved.pendingCompaction) : null,
     completedCompactions: cloneRecord(saved.completedCompactions),
     onboardingStep: null,
@@ -702,10 +740,18 @@ function createUserState(userId) {
     pendingClaudeAuthLabel: null,
     pendingCodexAuthProcess: null,
     pendingCodexAuthLabel: null,
-    isCompacting: false,
     lastCompactedAt: saved.lastCompactedAt || 0,
   };
   attachRuntimeAccessors(state);
+  // /voice clone arms the NEXT voice note of this conversation. The flag lives
+  // on the lane; this view keeps callers that only hold the state (the button
+  // handler in actions.js) on that same single copy.
+  Object.defineProperty(state, "pendingVoiceClone", {
+    configurable: true,
+    enumerable: false,
+    get() { return laneFor(state).pendingVoiceClone; },
+    set(value) { laneFor(state).pendingVoiceClone = value || null; },
+  });
   state.isFirstMessage = !getProviderSession(state, getActiveProvider(state), getProjectKey(state));
   return state;
 }
@@ -765,7 +811,6 @@ function getUserState(userId) {
     }
   }
   state.channelId = currentChannelId() || state.channelId;
-  state.roomKey = currentRoomKey() || null;
   try { seedConversationContinuity(state); } catch (e) {}
   return state;
 }
@@ -784,39 +829,244 @@ function resetSettings(state = currentState()) {
   attachRuntimeAccessors(state);
 }
 
-// Synchronous single-flight run-lock. Returns true and arms the lock if no turn
-// is running or preparing for this user; false if the caller must queue. There
-// must be NO await between calling this and the work it guards, so two turns for
-// one canonical user (owner's Telegram + Kazee sharing one state under unified
-// identity) can never both acquire and then race the shared state + JSON files.
-// Compaction owns the same admission boundary across its summary/seed gap.
-function acquireRunLock(state = currentState()) {
-  if (state.runningProcess || state.preparingRun || state.isCompacting) return false;
-  state.preparingRun = true;
-  return true;
+// ── Conversation lanes ───────────────────────────────────────────────
+// A lane is one conversation's run slot. The channel's main timeline and every
+// chat thread (each its own conversationKey) get a lane, so they can work at
+// the same time, while turns INSIDE one conversation stay strictly one at a
+// time: the same provider session must never run twice. Everything that
+// belongs to a running turn lives on its lane, never on the speaker's state:
+// the lock and queue, the /stop flag, the live preview, the typing heartbeat
+// and the voice flags. Lanes are created on demand and pruned once idle.
+//
+// Slots: a speaker may have OC_MAX_PARALLEL_TURNS (default 4) lanes running at
+// once, the whole bot OC_MAX_PARALLEL_TURNS_GLOBAL (default 8). Over a cap the
+// message waits in its own lane's queue; whenever any lane frees, the waiting
+// lanes are admitted oldest waiting message first (see waitingLanes()).
+// Compaction and side chats never take a slot of their own: compaction runs in
+// its lane (a compacting lane counts as one running lane, and it never waits
+// for a slot: it is the tail of the lane's turn or the lane's own /compact),
+// and a side chat is a read-only answer beside its lane's running turn.
+
+const laneStates = new Set();
+
+function freshLane(key) {
+  return {
+    key,
+    threadId: parseConversationKey(key).threadId,
+    // Lock + queue. `settling` holds the lane after the provider exited while
+    // the turn's tail (memory review, auto-compaction) finishes, so the next
+    // queued message never overtakes it.
+    runningProcess: null,
+    preparingRun: false,
+    settling: false,
+    isCompacting: false,
+    messageQueue: [],
+    waitingForSlot: false,
+    activeRunContext: null,
+    // The run that holds the lane (runner.executeAdmittedRun): only it may
+    // free the lane. Cleared when /stop's backstop frees a stuck run's lane,
+    // so that run's late unwind cannot free a lane another run has claimed.
+    ownerToken: null,
+    // /stop names the run it stops (see cancelFlagFor).
+    cancelRequested: false,
+    // Live preview of the running turn. previewRunId names the run that owns
+    // statusMessageId, so a run can only ever edit or settle its own message.
+    // statusMessageChannel is the channel the id was minted on: a message id
+    // is only valid on the channel that created it, so a foreign-channel id is
+    // discarded (fresh send) instead of edited.
+    statusMessageId: null,
+    statusMessageChannel: null,
+    streamBuffer: "",
+    streamInterval: null,
+    previewRunId: null,
+    // Typing heartbeat of the turn (see runner.startTypingHeartbeat).
+    typingHeartbeat: null,
+    typingTick: null,
+    typingTarget: null,
+    thinkingPhase: false,
+    // Voice: the reply to a voice note is spoken in the conversation it came from.
+    lastInputWasVoice: false,
+    voiceLat: null,
+    pendingVoiceClone: null,
+  };
+}
+
+function lanesOf(state) {
+  if (!state || typeof state !== "object") throw new TypeError("state is required");
+  // Not enumerable: lanes hold live processes and timers, and must never be
+  // cloned, spread into a prompt view, or serialized with the state.
+  if (!(state.lanes instanceof Map)) {
+    Object.defineProperty(state, "lanes", { value: new Map(), configurable: true, writable: true, enumerable: false });
+  }
+  return state.lanes;
+}
+
+// The lane of the current turn: its conversation key (a thread is its own),
+// else the state's project outside a chat turn (CLI, boot, tests).
+function currentLaneKey(state = currentState()) {
+  return currentConversationKey() || projectNameFrom(state?.currentSession) || "Workspace";
+}
+
+// The lane a captured run belongs to: fixed at admission, never re-read.
+function runLaneKey(runContext) {
+  return runContext?.laneKey || runContext?.project?.name || null;
+}
+
+function laneFor(state = currentState(), laneKey = null) {
+  const key = laneKey ? String(laneKey) : currentLaneKey(state);
+  const lanes = lanesOf(state);
+  let lane = lanes.get(key);
+  if (!lane) {
+    lane = freshLane(key);
+    lanes.set(key, lane);
+    laneStates.add(state);
+  }
+  return lane;
+}
+
+function laneForRun(state, runContext) {
+  return laneFor(state, runLaneKey(runContext));
+}
+
+// Look a lane up without creating it (status, /stop, eviction).
+function peekLane(state, laneKey = null) {
+  if (!state || !(state.lanes instanceof Map)) return null;
+  return state.lanes.get(laneKey ? String(laneKey) : currentLaneKey(state)) || null;
+}
+
+function laneBusy(lane) {
+  return !!(lane && (lane.runningProcess || lane.preparingRun || lane.settling || lane.isCompacting));
 }
 
-// /stop arms state.cancelRequested with the id of the run it stops (true only
+function laneIsIdle(lane) {
+  return !laneBusy(lane)
+    && !lane.messageQueue.length
+    && !lane.activeRunContext
+    && !lane.cancelRequested
+    && !lane.streamInterval
+    && !lane.statusMessageId
+    && !lane.typingHeartbeat
+    && !lane.lastInputWasVoice
+    && !lane.pendingVoiceClone;
+}
+
+// Drop lanes with nothing left on them (threads are many and mostly quiet).
+function pruneIdleLanes(state) {
+  if (!state || !(state.lanes instanceof Map)) return;
+  for (const [key, lane] of state.lanes) {
+    if (laneIsIdle(lane)) state.lanes.delete(key);
+  }
+  if (!state.lanes.size) laneStates.delete(state);
+}
+
+function statesWithLanes() {
+  const all = new Set(laneStates);
+  for (const state of userStates.values()) all.add(state);
+  return all;
+}
+
+function capSetting(name, fallback) {
+  const raw = config?.[name] ?? process.env[name];
+  const value = parseInt(raw, 10);
+  return Number.isSafeInteger(value) && value >= 1 ? value : fallback;
+}
+
+function maxParallelTurns() { return capSetting("OC_MAX_PARALLEL_TURNS", 4); }
+function maxParallelTurnsGlobal() { return capSetting("OC_MAX_PARALLEL_TURNS_GLOBAL", 8); }
+
+function runningLanes(state) {
+  if (!state || !(state.lanes instanceof Map)) return [];
+  return [...state.lanes.values()].filter(laneBusy);
+}
+
+function globalRunningLaneCount() {
+  let count = 0;
+  for (const state of statesWithLanes()) count += runningLanes(state).length;
+  return count;
+}
+
+// Why a new lane of this speaker cannot start now, or null when a slot is free.
+function slotBlocker(state) {
+  const mine = runningLanes(state).length;
+  if (mine >= maxParallelTurns()) return { scope: "speaker", running: mine };
+  const all = globalRunningLaneCount();
+  if (all >= maxParallelTurnsGlobal()) return { scope: "global", running: all };
+  return null;
+}
+
+// Synchronous single-flight admission into a lane. There must be NO await
+// between calling this and the work it guards, so two turns of one
+// conversation can never both acquire and then race its session. Returns
+// { ok: true } with the lane armed (preparingRun), or { ok: false, reason }:
+// "busy" (the conversation is running or compacting: queue behind it),
+// "waiting" (the conversation already waits for a slot: queue in order) or
+// "cap" (a parallel-turn cap is reached: wait for a slot). `running` is the
+// number of conversations holding the slots the message is waiting for.
+function admitLane(state = currentState(), laneKey = null) {
+  const lane = laneFor(state, laneKey);
+  if (laneBusy(lane)) return { ok: false, reason: "busy", lane };
+  const blocker = slotBlocker(state);
+  if (lane.messageQueue.length) return { ok: false, reason: "waiting", lane, running: blocker?.running || 0 };
+  if (blocker) {
+    lane.waitingForSlot = true;
+    return { ok: false, reason: "cap", lane, running: blocker.running, scope: blocker.scope };
+  }
+  // A freed slot goes to the lanes already waiting for one, oldest first: a
+  // newcomer queues behind them (the runner then admits in order).
+  if (waitingLanes().some((waiting) => waiting.lane !== lane && !slotBlocker(waiting.state))) {
+    lane.waitingForSlot = true;
+    return { ok: false, reason: "cap", lane, running: runningLanes(state).length, scope: "queue" };
+  }
+  lane.preparingRun = true;
+  lane.waitingForSlot = false;
+  return { ok: true, lane };
+}
+
+function acquireRunLock(state = currentState(), laneKey = null) {
+  return admitLane(state, laneKey).ok;
+}
+
+// Lanes with queued work and no run, oldest waiting message first. These are
+// the lanes waiting for a slot (or, right after a run ends, for their own next
+// turn); the runner admits them in this order whenever a lane frees.
+function waitingLanes() {
+  const waiting = [];
+  for (const state of statesWithLanes()) {
+    if (!(state.lanes instanceof Map)) continue;
+    for (const lane of state.lanes.values()) {
+      if (!laneBusy(lane) && lane.messageQueue.length) waiting.push({ state, lane });
+    }
+  }
+  const order = ({ lane }) => [Number(lane.messageQueue[0]?.queuedAt) || 0, Number(lane.messageQueue[0]?.seq) || 0];
+  return waiting.sort((a, b) => {
+    const [ta, sa] = order(a);
+    const [tb, sb] = order(b);
+    return ta - tb || sa - sb;
+  });
+}
+
+// /stop arms lane.cancelRequested with the id of the run it stops (true only
 // when no run context is known), and a run acts on the flag only when it names
 // that run. A bare boolean let a stop outlive its run and cancel the next one.
-function cancelFlagFor(state = currentState()) {
-  return state.activeRunContext?.runId || true;
+function cancelFlagFor(lane = laneFor(currentState())) {
+  return lane?.activeRunContext?.runId || true;
 }
 function cancelTargets(flag, runContext) {
   return flag === true || (!!flag && flag === runContext?.runId);
 }
 
-// True when ANY user has a turn running, admitted-and-preparing, compacting, or
-// waiting in its queue. Same busy predicate as acquireRunLock, but across every
-// user state rather than one — the Telegram poll-wedge backstop consults this
-// before a self-exit so a reboot never interrupts in-flight work. It fires on a
-// timer outside any channel context (no "current" user) and a reboot kills the
-// whole process, so it must scan all states, not just currentState().
+// True when ANY lane of any user has a turn running, admitted-and-preparing,
+// settling, compacting, or waiting in its queue. The Telegram poll-wedge
+// backstop consults this before a self-exit so a reboot never interrupts
+// in-flight work. It fires on a timer outside any channel context (no
+// "current" user) and a reboot kills the whole process, so it scans every
+// state and every lane.
 function anyTurnActive() {
-  for (const s of userStates.values()) {
-    if (!s) continue;
-    if (s.runningProcess || s.preparingRun || s.isCompacting) return true;
-    if (Array.isArray(s.messageQueue) && s.messageQueue.length) return true;
+  for (const state of statesWithLanes()) {
+    if (!state || !(state.lanes instanceof Map)) continue;
+    for (const lane of state.lanes.values()) {
+      if (laneBusy(lane) || lane.messageQueue.length) return true;
+    }
   }
   return false;
 }
@@ -1513,6 +1763,8 @@ module.exports = {
   STATE_SCHEMA_VERSION,
   SESSIONS_SCHEMA_VERSION,
   MAX_USAGE_ENTRIES,
+  MAX_THREAD_USAGE_ENTRIES,
+  MAX_THREAD_SESSIONS,
   MAX_SESSIONS_PER_PROJECT,
   MAX_SESSION_CALLBACKS,
   SESSION_CALLBACK_TTL_MS,
@@ -1525,6 +1777,7 @@ module.exports = {
   getActiveProvider,
   roomSettingsFor,
   roomOverlayFor,
+  activeRoomKey,
   setRoomSetting,
   clearRoomSettings,
   getProjectKey,
@@ -1545,6 +1798,20 @@ module.exports = {
   resetSessionUsage,
   resetSettings,
   acquireRunLock,
+  admitLane,
+  laneFor,
+  laneForRun,
+  peekLane,
+  laneBusy,
+  currentLaneKey,
+  runLaneKey,
+  runningLanes,
+  slotBlocker,
+  waitingLanes,
+  pruneIdleLanes,
+  maxParallelTurns,
+  maxParallelTurnsGlobal,
+  evictIdleThreadSessions,
   cancelFlagFor,
   cancelTargets,
   anyTurnActive,

package/core/system-prompt.js

@@ -6,8 +6,9 @@ const path = require("path");
 const { SOUL_FILE, CRONS_FILE, VAULT_FILE, FILES_DIR, BOT_DIR, config } = require("./config");
 const { canSpeak, canTranscribe } = require("./media");
 const CONFIG_DIR = require("../config-dir");
-const { currentState, getProjectKey, getProviderSession } = require("./state");
-const { currentAdapter, currentChannelId, currentUserId, currentSpeakerName } = require("./context");
+const { currentState, getProjectKey, getProviderSession, peekLane, runningLanes, runLaneKey } = require("./state");
+const { currentAdapter, currentChannelId, currentUserId, currentSpeakerName, currentConversationKey, currentThreadId } = require("./context");
+const { parseConversationKey } = require("./identity");
 const { vault } = require("./vault-store");
 const {
   transcriptPointerNoteForRun,
@@ -94,7 +95,7 @@ function promptState(opts = {}) {
     if (identity.sessionId) activeSessions[identity.project.name][identity.provider] = identity.sessionId;
     else delete activeSessions[identity.project.name][identity.provider];
   }
-  return {
+  const view = {
     ...state,
     userId: identity.canonicalUserId || state.userId,
     currentSession: identity.project.name || identity.project.dir
@@ -107,6 +108,47 @@ function promptState(opts = {}) {
     },
     activeSessions,
   };
+  // The live lanes (not copied by the spread) so the runtime state can see
+  // which other conversations are running.
+  if (state.lanes instanceof Map) Object.defineProperty(view, "lanes", { value: state.lanes, configurable: true, writable: true, enumerable: false });
+  return view;
+}
+
+// The injection-dedupe maps remember what a CONVERSATION has already been
+// shown. Keyed by the conversation (a thread is its own; the channel's main
+// timeline keeps the channel), never by the channel alone: a thread's session
+// has not seen what the main session was given, and vice versa.
+function dedupeScope(adapter, channelId, opts = {}) {
+  const convo = opts.runContext?.laneKey || currentConversationKey() || channelId || "?";
+  return `${adapter?.id || "?"}:${convo}`;
+}
+
+// A few words about another running conversation, for the runtime state:
+// which thread (or main timeline; another chat is named by its transport) and
+// what its turn is about.
+function laneSummary(lane, currentRoom) {
+  const { threadId, roomKey, transport } = parseConversationKey(lane.key);
+  const place = roomKey === currentRoom ? "" : ` in another ${transport || "chat"} chat`;
+  const where = `${threadId ? `thread …${String(threadId).slice(-6)}` : "main"}${place}`;
+  const words = String(lane.activeRunContext?.userPrompt || "")
+    .replace(/\[+[^\]]*\]+/g, " ").replace(/\s+/g, " ").trim().split(" ").slice(0, 5).join(" ");
+  return words ? `${where}: ${words.length > 40 ? `${words.slice(0, 39)}…` : words}` : where;
+}
+
+// Runtime-state lines about parallel work: whether this conversation is a chat
+// thread, and which other conversations of this speaker are running now.
+function parallelConversationLines(realState, runContext) {
+  const lines = [];
+  const threadId = runContext?.threadId || currentThreadId();
+  if (threadId) lines.push("- Thread: this conversation is a Kazee thread (replies go into the thread)");
+  const ownLane = runLaneKey(runContext) || currentConversationKey();
+  let others = [];
+  try { others = runningLanes(realState).filter((lane) => lane.key !== ownLane); } catch (_) { others = []; }
+  if (others.length) {
+    const currentRoom = parseConversationKey(ownLane).roomKey;
+    lines.push(`- Parallel conversations running now: ${others.length} (${others.slice(0, 4).map((lane) => laneSummary(lane, currentRoom)).join("; ")}${others.length > 4 ? "; …" : ""}). Do not edit a git checkout another conversation is using; make your own worktree.`);
+  }
+  return lines;
 }
 
 function buildPersonaBlock() {
@@ -472,7 +514,7 @@ function buildSpeakerContextBlock() {
 // bot restart, a new conversation, or a compaction (the captured run identity
 // changes in all three cases). Later turns get a one-line count; the
 // agent runs `open-claudia task list` when it needs detail.
-const taskTreeInjectedFor = new Map(); // `${adapterId}:${channelId}` -> captured run identity
+const taskTreeInjectedFor = new Map(); // `${adapterId}:${conversationKey}` -> captured run identity
 
 function buildDynamicContextBlock(opts = {}) {
   const state = promptState(opts);
@@ -491,11 +533,12 @@ function buildDynamicContextBlock(opts = {}) {
     `- Project: ${identity.project.name || identity.project.dir || "none"}`,
     `- Provider: ${identity.provider}`,
     `- Session: ${identity.sessionId ? "resuming existing conversation" : "new conversation"}`,
+    ...parallelConversationLines(opts.state || currentState(), opts.runContext),
   ];
   if (adapter && channelId) {
     const pending = tasksStore.pendingSummary(adapter.id, channelId);
     if (pending.length > 0) {
-      const key = `${adapter.id}:${channelId}`;
+      const key = dedupeScope(adapter, channelId, opts);
       if (taskTreeInjectedFor.get(key) !== dedupeIdentity) {
         taskTreeInjectedFor.set(key, dedupeIdentity);
         const tree = tasksStore.formatForInjection(adapter.id, channelId, { showIds: true });
@@ -514,7 +557,7 @@ function buildDynamicContextBlock(opts = {}) {
 // system prompt) for the same cache reason as the task tree above. Each
 // pack body is injected once per (channel, session, pack-version) — once
 // it's in the conversation the model keeps it until compaction.
-const packsInjectedFor = new Map(); // `${adapterId}:${channelId}:${dir}` -> `${sessionId}:${updated}`
+const packsInjectedFor = new Map(); // `${adapterId}:${conversationKey}:${dir}` -> `${sessionId}:${updated}`
 const PACK_INJECT_MAX_CHARS = 4000;
 const DEFAULT_MEMORY_RECALL_MAX_CHARS = 9000;
 const EXTRACTIVE_LINES_PER_SECTION = 4;
@@ -725,7 +768,7 @@ function buildPackBlock(matches, budget, opts = {}) {
       const pack = packsLib.readPack(m.dir);
       if (!pack) continue;
       used.push(m.dir);
-      const key = `${adapter?.id || "?"}:${channelId || "?"}:${m.dir}`;
+      const key = `${dedupeScope(adapter, channelId, opts)}:${m.dir}`;
       const stamp = `${runIdentity}:${pack.updated}`;
       const pending = pendingRemindersFor("pack", m.dir);
       const pendingText = pending.length ? renderReminders(pending) : "";
@@ -767,7 +810,7 @@ function buildPackBlock(matches, budget, opts = {}) {
 // Entity router: same idea as packs but for people/places/projects.
 // Same cache rationale (rides the user message) and same once-per
 // (channel, session, entity-version) dedupe.
-const entitiesInjectedFor = new Map(); // `${adapterId}:${channelId}:${slug}` -> `${sessionId}:${updated}`
+const entitiesInjectedFor = new Map(); // `${adapterId}:${conversationKey}:${slug}` -> `${sessionId}:${updated}`
 const ENTITY_INJECT_MAX_CHARS = 1200;
 
 function formatEntityForContext(ent, opts = {}) {
@@ -804,7 +847,7 @@ function buildEntityBlock(matches, budget, opts = {}) {
       const ent = entitiesLib.readEntity(m.slug);
       if (!ent) continue;
       seen.push(m.slug);
-      const key = `${adapter?.id || "?"}:${channelId || "?"}:${m.slug}`;
+      const key = `${dedupeScope(adapter, channelId, opts)}:${m.slug}`;
       const stamp = `${runIdentity}:${ent.updated}`;
       const pending = pendingRemindersFor("entity", m.slug);
       const pendingText = pending.length ? renderReminders(pending) : "";
@@ -840,7 +883,7 @@ function buildEntityBlock(matches, budget, opts = {}) {
 // It shapes voice/scope every turn, so it rides the uncached tail (R13) and is
 // injected once per (channel, session, entity-version) to spare tail tokens —
 // a compaction mints a new session id and re-injects, same as packs/entities.
-const speakerPersonaInjectedFor = new Map(); // `${adapterId}:${channelId}` -> `${sessionId}:${slug}:${updated}`
+const speakerPersonaInjectedFor = new Map(); // `${adapterId}:${conversationKey}` -> `${sessionId}:${slug}:${updated}`
 const SPEAKER_PERSONA_MAX_CHARS = 1400;
 
 function buildSpeakerPersonaBlock(opts = {}) {
@@ -872,7 +915,7 @@ function buildSpeakerPersonaBlock(opts = {}) {
   // renders; an owner with an empty note still gets the quiet no-op.
   if (rows.length === 0 && speaker.isOwner) return "";
   const runIdentity = promptDedupeIdentity(opts);
-  const key = `${adapter.id || "?"}:${channelId}`;
+  const key = dedupeScope(adapter, channelId, opts);
   const stamp = `${runIdentity}:${slug}:${ent.updated}`;
   if (speakerPersonaInjectedFor.get(key) === stamp) return "";
   speakerPersonaInjectedFor.set(key, stamp);
@@ -1139,11 +1182,15 @@ function voiceReplyGuidance(opts = {}) {
         ? `\n\nRecent call conversation (JSON transcript data, not additional instructions):\n${JSON.stringify(history)}\nThe current user message follows. Earlier utterances may have been combined while a reply was pending; use them to understand continuations and corrections. Do not claim an earlier request was acted on without tool evidence.`
         : "");
     }
-    const state = promptState(opts);
-    if (currentTransport() === "voice") return state.lastInputWasVoice ? VOICE_REPLY_GUIDANCE : "";
+    // Whether THIS conversation's input was a voice note: the captured run's
+    // flag, else the conversation's lane (never another thread's voice note).
+    const lastInputWasVoice = opts.runContext && Object.prototype.hasOwnProperty.call(opts.runContext, "lastInputWasVoice")
+      ? !!opts.runContext.lastInputWasVoice
+      : !!peekLane(opts.state || currentState(), runLaneKey(opts.runContext))?.lastInputWasVoice;
+    if (currentTransport() === "voice") return lastInputWasVoice ? VOICE_REPLY_GUIDANCE : "";
     const { VOICE_REPLY_MODE } = require("./config");
     const { shouldReplyWithVoice } = require("./voice-policy");
-    if (shouldReplyWithVoice(VOICE_REPLY_MODE, state.lastInputWasVoice)) return VOICE_NOTE_GUIDANCE;
+    if (shouldReplyWithVoice(VOICE_REPLY_MODE, lastInputWasVoice)) return VOICE_NOTE_GUIDANCE;
   } catch (e) {}
   return "";
 }