@inetafrica/open-claudia 3.5.1 → 3.5.4

package/channels/kazee/state.js

@@ -4,19 +4,29 @@
 // "messages since I last engaged" delta and advances it on every engage, so
 // group chatter the gate stayed silent through is caught up exactly once.
 // Parent-process only; small, atomic writes.
+//
+// Chat threads ("reply in thread") keep their own small record, keyed by the
+// thread's root message id: whether the bot has replied in it (a group thread
+// the bot is part of engages it without an @-mention), who posted the root
+// (fetched once, so the gate never asks twice), and the thread's own context
+// watermark. Bounded: the least recently touched threads are dropped first.
 
 const path = require("path");
 const { CONFIG_DIR } = require("../../core/config");
 const { atomicWriteFileSync, readJsonWithFallback } = require("../../core/fsutil");
 
 const STATE_FILE = path.join(CONFIG_DIR, "kazee-state.json");
+const MAX_THREADS = 2000;
 
 let store = null;
 
 function load() {
   if (store) return store;
   const raw = readJsonWithFallback(STATE_FILE, null) || {};
-  store = { chats: raw.chats && typeof raw.chats === "object" ? raw.chats : {} };
+  store = {
+    chats: raw.chats && typeof raw.chats === "object" ? raw.chats : {},
+    threads: raw.threads && typeof raw.threads === "object" && !Array.isArray(raw.threads) ? raw.threads : {},
+  };
   return store;
 }
 
@@ -39,4 +49,70 @@ function getContextWatermark(chatId) {
   return (c && c.contextAt) || null;
 }
 
-module.exports = { setContextWatermark, getContextWatermark, STATE_FILE };
+function getThread(rootId) {
+  const s = load();
+  const t = s.threads[String(rootId || "")];
+  return t && typeof t === "object" ? t : null;
+}
+
+// Merge `patch` into the thread's record. Writes only when something changed,
+// so the per-send "the bot replied here" mark costs one write per thread.
+function updateThread(rootId, patch = {}) {
+  const id = String(rootId || "");
+  if (!id) return null;
+  const s = load();
+  const prev = s.threads[id] || {};
+  const changed = Object.keys(patch).some((k) => patch[k] !== undefined && prev[k] !== patch[k]);
+  if (!changed) return prev;
+  const next = { ...prev };
+  for (const [k, v] of Object.entries(patch)) if (v !== undefined) next[k] = v;
+  next.at = Date.now();
+  s.threads[id] = next;
+  const ids = Object.keys(s.threads);
+  if (ids.length > MAX_THREADS) {
+    ids.sort((a, b) => (Number(s.threads[a].at) || 0) - (Number(s.threads[b].at) || 0));
+    for (const old of ids.slice(0, ids.length - MAX_THREADS)) delete s.threads[old];
+  }
+  save();
+  return next;
+}
+
+function markBotRepliedInThread(chatId, rootId) {
+  return updateThread(rootId, { chatId: String(chatId || ""), botReplied: true });
+}
+
+function botRepliedInThread(rootId) {
+  return getThread(rootId)?.botReplied === true;
+}
+
+function setThreadRootAuthor(chatId, rootId, authorId) {
+  if (!authorId) return null;
+  return updateThread(rootId, { chatId: String(chatId || ""), rootAuthor: String(authorId) });
+}
+
+function getThreadRootAuthor(rootId) {
+  return getThread(rootId)?.rootAuthor || null;
+}
+
+function setThreadWatermark(chatId, rootId, iso) {
+  if (!iso) return null;
+  return updateThread(rootId, { chatId: String(chatId || ""), contextAt: String(iso) });
+}
+
+function getThreadWatermark(rootId) {
+  return getThread(rootId)?.contextAt || null;
+}
+
+module.exports = {
+  setContextWatermark,
+  getContextWatermark,
+  getThread,
+  markBotRepliedInThread,
+  botRepliedInThread,
+  setThreadRootAuthor,
+  getThreadRootAuthor,
+  setThreadWatermark,
+  getThreadWatermark,
+  STATE_FILE,
+  MAX_THREADS,
+};

package/channels/types.js

@@ -19,7 +19,10 @@
  * @property {string} type            // "text" | "voice" | "audio" | "photo" | "document" | "action"
  * @property {string} [text]          // command text or message body
  * @property {string} [messageId]     // outer-channel message id
- * @property {string} [replyToId]     // id of message being replied to
+ * @property {string} [replyToId]     // id of message being replied to (a quote, not a thread)
+ * @property {string} [threadId]      // chat thread root id when the message was posted IN a thread
+ *                                    // (Kazee "reply in thread"); null/absent = the main timeline.
+ *                                    // A thread is its own conversation: own session, queue and lane.
  * @property {Object} [reply]         // {text, media?: MediaRef[], document, photo} for reply context
  * @property {Array<MediaRef>} [media]
  * @property {Object} [from]          // {id, name, username}
@@ -38,6 +41,8 @@
  *                                    // (telegram-native, accepted by both adapters)
  *                                    // or {buttons:[PortableButton]} (portable)
  * @property {string|number} [replyTo]
+ * @property {string} [threadId]      // post into this chat thread (Kazee threadRootId); core/io
+ *                                    // fills it from the turn's thread unless set explicitly
  *
  * @typedef {Object} CommandSpec
  * @property {string} name            // no leading slash
@@ -53,10 +58,11 @@
  *   send(channelId, text, opts): Promise<messageId|null>
  *   edit(channelId, messageId, text, opts): Promise<void>
  *   delete(channelId, messageId): Promise<void>
- *   sendVoice(channelId, oggPath): Promise<boolean>
- *   sendFile(channelId, filePath, caption?): Promise<boolean>
- *   typing(channelId, state?): Promise<void>  // state: "thinking" | "typing" (default). Non-socket channels ignore state.
- *   typingStop?(channelId): Promise<void>     // optional — socket channels only
+ *   sendVoice(channelId, oggPath, opts?): Promise<boolean>          // opts.threadId: post into that thread
+ *   sendFile(channelId, filePath, caption?, opts?): Promise<boolean> // opts.threadId: post into that thread
+ *   typing(channelId, state?, opts?): Promise<void>  // state: "thinking" | "typing" (default). Non-socket channels ignore state.
+ *                                             // opts.threadId: show the indicator inside that thread
+ *   typingStop?(channelId, opts?): Promise<void>     // optional — socket channels only
  *   downloadMedia(mediaRef): Promise<localPath|null>
  *   buildThreadContext?(envelope): Promise<{contextBlock: string, media?: MediaRef[]}|null>
  *   registerCommands(commands: CommandSpec[]): Promise<void>

package/core/actions.js

@@ -622,6 +622,7 @@ async function handleAction(envelope) {
           adapter: "",
           adapterType: rec.adapter,
           channelId: String(rec.channelId),
+          threadId: rec.threadId || null,
           canonicalUserId: rec.canonicalUserId,
           userId: rec.userId || null,
           provider: rec.provider,
@@ -692,6 +693,9 @@ async function handleAction(envelope) {
           adapter: isExternalAction ? "" : (rec.adapter || (adapter && adapter.id) || ""),
           adapterType: isExternalAction ? (rec.adapter || (adapter && adapter.type)) : (adapter && adapter.type),
           channelId: String(rec.channelId || envelope.channelId),
+          // Back into the thread the held run was in (the press itself may
+          // come from another room: the owner's approver channel).
+          threadId: rec.threadId || (rec.channelId ? null : envelope.threadId || null),
           canonicalUserId: rec.canonicalUserId,
           userId: rec.userId || null,
           provider: rec.provider,
@@ -991,6 +995,8 @@ async function handleAction(envelope) {
       adapter: envelope.adapter.id,
       adapterType: envelope.adapter.type,
       channelId: String(envelope.channelId),
+      // A preset picked in a thread fires in that thread.
+      threadId: envelope.threadId || null,
       canonicalUserId: envelope.canonicalUserId,
       project: cronProject,
       prompt: p.prompt,

package/core/approvals.js

@@ -19,6 +19,7 @@ const path = require("path");
 const crypto = require("crypto");
 const CONFIG_DIR = require("../config-dir");
 const { atomicWriteFileSync } = require("./fsutil");
+const { currentChannelId, currentThreadId } = require("./context");
 
 const APPROVALS_DIR = process.env.APPROVALS_DIR || path.join(CONFIG_DIR, "approvals");
 const MAX_AGE_MS = 24 * 60 * 60 * 1000;
@@ -124,17 +125,25 @@ function create({
   // room holds many people they are different values, so recording only the
   // room would hand one member's grant to everyone in it.
   speakerId = "", room = "",
+  // The chat thread of the ORIGIN turn (null = main timeline), so a re-run
+  // this approval wakes lands back in that thread. Unset: taken from the
+  // current turn when it is in the origin channel.
+  threadId = undefined,
 } = {}) {
   fs.mkdirSync(APPROVALS_DIR, { recursive: true, mode: 0o700 });
   prune();
   const id = `apr_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
   const exactCommand = approvedCommand(command);
+  const originThread = threadId !== undefined
+    ? threadId
+    : (currentThreadId() && String(currentChannelId() || "") === String(channelId || "") ? currentThreadId() : null);
   const rec = {
     id, status: "pending",
     tool: String(tool || ""), verb: String(verb || ""), tier: String(tier || ""),
     command: exactCommand,
     commandHash: commandHash(exactCommand),
     channelId: String(channelId || ""), adapter: String(adapter || ""),
+    threadId: originThread ? String(originThread) : null,
     canonicalUserId: String(canonicalUserId || ""), userId: String(userId || ""),
     provider: String(provider || ""), providerSettings: providerSettings && typeof providerSettings === "object" ? structuredClone(providerSettings) : {},
     project: String(project || ""), projectDir: String(projectDir || ""),

package/core/context.js

@@ -6,8 +6,8 @@ const { AsyncLocalStorage } = require("node:async_hooks");
 
 const chatContext = new AsyncLocalStorage();
 
-function runInChat({ adapter, channelId, canonicalUserId, userId, transport, raw, conversationKey, roomKey, inboundText, speakerName, triageApprovalId, isGroup }, fn) {
-  return chatContext.run({ adapter, channelId, canonicalUserId, userId, transport, raw, conversationKey, roomKey, inboundText, speakerName, triageApprovalId, isGroup: !!isGroup }, fn);
+function runInChat({ adapter, channelId, threadId, canonicalUserId, userId, transport, raw, conversationKey, roomKey, inboundText, speakerName, triageApprovalId, isGroup }, fn) {
+  return chatContext.run({ adapter, channelId, threadId: threadId ? String(threadId) : null, canonicalUserId, userId, transport, raw, conversationKey, roomKey, inboundText, speakerName, triageApprovalId, isGroup: !!isGroup }, fn);
 }
 
 function currentStore() {
@@ -24,6 +24,14 @@ function currentChannelId() {
   return s ? s.channelId : null;
 }
 
+// The chat thread this turn belongs to (a Kazee thread's root message id), or
+// null for the channel's main timeline. A thread is its own conversation: its
+// own session, transcript, queue and run lane, and every reply goes back into it.
+function currentThreadId() {
+  const s = currentStore();
+  return s && s.threadId ? s.threadId : null;
+}
+
 function currentCanonicalUserId() {
   const s = currentStore();
   return s ? s.canonicalUserId : null;
@@ -114,6 +122,7 @@ module.exports = {
   runInChat,
   currentAdapter,
   currentChannelId,
+  currentThreadId,
   currentCanonicalUserId,
   currentUserId,
   currentTransport,

package/core/handlers.js

@@ -20,8 +20,10 @@ const {
   getProviderSettings, resolveProviderSettings,
   getProjectSessions, getLastProjectSession, userOwnsProviderSession,
   createSessionCallbackToken, linkIdentity,
-  roomSettingsFor, setRoomSetting, cancelFlagFor,
+  roomSettingsFor, setRoomSetting, cancelFlagFor, activeRoomKey,
+  laneFor, peekLane, runningLanes, laneBusy, currentLaneKey,
 } = require("./state");
+const { parseConversationKey } = require("./identity");
 const { canonicalForChannel, canonicalForTelegram, normalizeCanonicalUserId, channelKey, identities, isConfiguredOwnerChannel, removeIdentityMapping } = require("./identity");
 const { isChatAuthorized, isChatOwner, recordPendingAuthRequest, authRequestLabel, hasOwner, bootstrapOwner } = require("./access");
 const { isOnboarded, startOnboarding } = require("./onboarding");
@@ -85,12 +87,25 @@ function cancelledQueueResult(item, reason) {
   };
 }
 
-function clearTransientQueue(state, reason = "Session context changed before the queued run started") {
-  const queued = Array.isArray(state?.messageQueue) ? state.messageQueue.splice(0) : [];
+// Drops every message queued in one lane: each one's caller gets a cancelled
+// result (no hanging promise), and an idle lane loses its typing heartbeat (the
+// chip would stay on, and the lane could never be pruned). Returns the items.
+function dropLaneQueue(lane, reason) {
+  if (!lane) return [];
+  const queued = lane.messageQueue.splice(0);
+  lane.waitingForSlot = false;
   for (const item of queued) {
+    try { item?.disposeCallListener?.(); } catch (_) {}
     try { item?.deferred?.resolve(cancelledQueueResult(item, reason)); } catch (_) {}
   }
-  return queued.length;
+  if (!laneBusy(lane)) require("./runner").stopLaneTyping(lane);
+  return queued;
+}
+
+// Clears the CURRENT conversation's queue only: /new, /end or a project change
+// in one thread must not drop what another conversation has waiting.
+function clearTransientQueue(state, reason = "Session context changed before the queued run started") {
+  return dropLaneQueue(state ? peekLane(state) : null, reason).length;
 }
 
 function persistSessionControl(state, options, rollback) {
@@ -216,7 +231,7 @@ function switchProviderState(providerId, options = {}) {
   // stays updated as their default for rooms they have never pinned. Without
   // the room write, switching provider only moved the switcher — everyone else
   // in the room, and every job it spawned, stayed on the old one.
-  const roomKey = state.roomKey ? String(state.roomKey) : "";
+  const roomKey = activeRoomKey() || "";
   const previousRoomBackend = roomKey ? (roomSettingsFor(roomKey)?.backend ?? null) : null;
   if (roomKey) setRoomSetting(roomKey, "backend", provider);
   state.settings.backend = provider;
@@ -297,7 +312,8 @@ function endCurrentSession(options = {}) {
   clearTransientQueue(state, "The conversation ended before the queued run started");
   state.currentSession = rootSession();
   state.isFirstMessage = true;
-  state.cancelRequested = false;
+  const lane = peekLane(state);
+  if (lane) lane.cancelRequested = false;
   const persisted = persistSessionControl(state, options, () => {
     state.currentSession = previous.currentSession;
     state.isFirstMessage = previous.isFirstMessage;
@@ -1413,10 +1429,10 @@ register({
     if (arg) {
       const low = arg.toLowerCase();
       if (low === "clone") {
-        state.pendingVoiceClone = { at: Date.now() };
+        laneFor(state).pendingVoiceClone = { at: Date.now() };
         return send("🎙️ Send me a voice note now — 5–15s of clear speech and I'll clone it as your voice. Send /voice to cancel.");
       }
-      state.pendingVoiceClone = null;
+      laneFor(state).pendingVoiceClone = null;
       if (low === "default" || low === "reset") {
         ttsVoice.clearVoice();
         return send(`🎙️ Voice reset to default (${ttsVoice.getVoiceLabel()}).`);
@@ -1431,7 +1447,7 @@ register({
       ttsVoice.setVoice(arg, null);
       return send(`🎙️ Voice set: ${arg}`);
     }
-    state.pendingVoiceClone = null;
+    laneFor(state).pendingVoiceClone = null;
     const rows = ttsVoice.presets().map((p) => [{ text: p.label, callback_data: `vc:p:${p.key}` }]);
     rows.push([
       { text: "🎙️ Clone from a clip", callback_data: "vc:clone" },
@@ -1643,63 +1659,148 @@ register({
 });
 
 // How long /stop waits for a stopped child to report its exit before it
-// releases the room anyway (SIGKILL follows SIGTERM after 3 s).
+// releases the conversation anyway (SIGKILL follows SIGTERM after 3 s).
 const STOP_RELEASE_MS = 30 * 1000;
-function releaseStuckStop(state, proc, stopped) {
-  if (state.runningProcess !== proc) return;
-  if (proc.exitCode != null || proc.signalCode != null) return; // exited: its unwind releases the room
-  console.warn(`[stop] child ${proc.pid} never reported its exit; releasing the room`);
-  state.runningProcess = null;
-  if (state.cancelRequested === stopped) state.cancelRequested = false;
+function releaseStuckStop(state, lane, proc, stopped) {
+  if (lane.runningProcess !== proc) return;
+  if (proc.exitCode != null || proc.signalCode != null) return; // exited: its unwind releases the lane
+  console.warn(`[stop] child ${proc.pid} never reported its exit; releasing the conversation`);
+  lane.runningProcess = null;
+  lane.ownerToken = null;
+  if (lane.cancelRequested === stopped) lane.cancelRequested = false;
+  try { require("./runner").drainQueuedMessages(state); } catch (_) {}
+}
+
+// Stop one lane's turn. Same kill semantics as a single /stop always had:
+// SIGTERM the tree now, SIGKILL after 3 s, keep the lane busy until the run
+// unwinds (its own finally frees it and admits what waits). Returns what was
+// stopped: "running", "preparing", or null when the lane had nothing to stop.
+function stopLane(state, lane) {
+  const { stopLaneTyping } = require("./runner");
+  if (lane.runningProcess && !lane.activeRunContext) {
+    // Only a compaction runs here (a /compact, or the auto-compaction tail of
+    // a turn that already answered). Kill it and let it fail on its own; a
+    // bare cancel flag would outlive it and silently eat the next message.
+    const pid = lane.runningProcess.pid;
+    const { killProcessTree } = require("./process-tree");
+    killProcessTree(pid, "SIGTERM");
+    setTimeout(() => killProcessTree(pid, "SIGKILL"), 3000);
+    stopLaneTyping(lane);
+    return "running";
+  }
+  if (lane.runningProcess) {
+    const proc = lane.runningProcess;
+    const pid = proc.pid;
+    const { killProcessTree } = require("./process-tree");
+    // Quiet unwind: deliverForegroundResult consumes this flag to suppress
+    // the "run failed" diagnostic the SIGTERM exit would otherwise emit. It
+    // names the run it stops, so it can never cancel a different one.
+    const stopped = cancelFlagFor(lane);
+    lane.cancelRequested = stopped;
+    killProcessTree(pid, "SIGTERM");
+    setTimeout(() => killProcessTree(pid, "SIGKILL"), 3000);
+    // The lane stays busy until the stopped run has unwound: its own finally
+    // releases it, clears this flag and admits the queue. Releasing it here
+    // let a message sent in those seconds start, meet the flag and be
+    // cancelled "before the provider started" (24 Sep: three messages lost
+    // after one /stop). Backstop: a child that never reports its exit must
+    // not pin the conversation.
+    setTimeout(() => releaseStuckStop(state, lane, proc, stopped), STOP_RELEASE_MS).unref?.();
+    // Stop pending preview flushes but keep statusMessageId/Channel: the
+    // killed run's delivery unwind edits the preview to drop its footer.
+    if (lane.streamInterval) { clearTimeout(lane.streamInterval); lane.streamInterval = null; }
+    // Clearing the heartbeat here orphans the run's own stopper (ownership
+    // check makes it a no-op), so the explicit typing:stop must go out now.
+    stopLaneTyping(lane);
+    return "running";
+  }
+  if (lane.preparingRun) {
+    // Turn is mid-recall/prompt-build — no process to kill yet. Flag it so
+    // the runner's pre-spawn shouldAbort checkpoint bails before spawning.
+    lane.cancelRequested = cancelFlagFor(lane);
+    stopLaneTyping(lane);
+    return "preparing";
+  }
+  return null;
+}
+
+const STOP_DROP_REASON = "Dropped by /stop before it started";
+
+// "Dropped 2 queued: "reboot pe2", "and check the…"": what /stop dropped, a
+// few words of each message (the first few in full, then a count).
+function droppedNote(items, kind) {
+  const words = (item) => {
+    const all = String(item?.text || item?.runContext?.userPrompt || item?.pendingSideChat?.originalRunContext?.userPrompt || "").replace(/\s+/g, " ").trim().split(" ").filter(Boolean);
+    const head = all.slice(0, 3).join(" ");
+    const short = head.length > 24 ? `${head.slice(0, 23)}…` : (all.length > 3 ? `${head}…` : head);
+    return `"${short || "…"}"`;
+  };
+  const n = items.length;
+  const shown = items.slice(0, 3).map(words);
+  if (n > shown.length) shown.push(`+${n - shown.length} more`);
+  const label = kind === "waiting"
+    ? `${n} waiting message${n === 1 ? "" : "s"}`
+    : `${n} queued`;
+  return `Dropped ${label}: ${shown.join(", ")}`;
+}
+
+// A few words about a conversation: main timeline or which thread, and what
+// its turn is about.
+function describeLane(lane, currentRoom = null) {
+  const { threadId, roomKey } = parseConversationKey(lane.key);
+  const where = `${threadId ? `thread …${threadId.slice(-6)}` : "main"}${currentRoom && roomKey !== currentRoom ? ` (${roomKey})` : ""}`;
+  const words = String(lane.activeRunContext?.userPrompt || "")
+    .replace(/\s+/g, " ").trim().split(" ").slice(0, 6).join(" ");
+  const what = lane.isCompacting ? "compacting" : (words ? `"${words.length > 48 ? `${words.slice(0, 47)}…` : words}"` : "working");
+  return `${where}: ${what}`;
+}
+
+function runningConversationLines(state) {
+  const lanes = runningLanes(state);
+  const waiting = state.lanes instanceof Map
+    ? [...state.lanes.values()].filter((lane) => !laneBusy(lane) && lane.messageQueue.length).length
+    : 0;
+  if (!lanes.length && !waiting) return [];
+  return [
+    `Running conversations: ${lanes.length}${waiting ? ` (${waiting} waiting for a slot)` : ""}`,
+    ...lanes.map((lane) => `- ${describeLane(lane, parseConversationKey(currentLaneKey(state)).roomKey)}`),
+  ];
 }
 
 register({
-  name: "stop", description: "Cancel running task",
-  handler: async (env) => {
+  name: "stop", description: "Cancel the running task here (/stop all: every conversation)", args: "[all]",
+  handler: async (env, { tail } = {}) => {
     if (!authorized(env)) return;
     const state = currentState();
-    const sideCancellation = require("./side-chat").sideChatCoordinator.cancel(state.userId);
-    // /stop cancels the CURRENT turn only. Messages queued behind it stay
-    // queued — the cancelled run's unwind drains them as usual.
-    const queuedNote = () => {
-      const n = Array.isArray(state.messageQueue) ? state.messageQueue.length : 0;
-      return n ? ` ${n} queued message${n === 1 ? "" : "s"} will run next.` : "";
-    };
-    if (state.runningProcess) {
-      const proc = state.runningProcess;
-      const pid = proc.pid;
-      const { killProcessTree } = require("./process-tree");
-      // Quiet unwind: deliverForegroundResult consumes this flag to suppress
-      // the "run failed" diagnostic the SIGTERM exit would otherwise emit. It
-      // names the run it stops, so it can never cancel a different one.
-      const stopped = cancelFlagFor(state);
-      state.cancelRequested = stopped;
-      killProcessTree(pid, "SIGTERM");
-      setTimeout(() => killProcessTree(pid, "SIGKILL"), 3000);
-      // The room stays busy until the stopped run has unwound: its own
-      // finally releases the lock, clears this flag and drains the queue.
-      // Releasing it here let a message sent in those seconds start, meet the
-      // flag and be cancelled "before the provider started" (24 Sep: three
-      // messages lost after one /stop). Backstop: a child that never reports
-      // its exit must not pin the room.
-      setTimeout(() => releaseStuckStop(state, proc, stopped), STOP_RELEASE_MS).unref?.();
-      // Stop pending preview flushes but keep statusMessageId/Channel: the
-      // killed run's delivery unwind edits the preview to drop its footer.
-      if (state.streamInterval) { clearTimeout(state.streamInterval); state.streamInterval = null; }
-      // Clearing the interval here orphans the run's own stopper (ownership
-      // check makes it a no-op), so the explicit typing:stop must go out now.
-      if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; state.thinkingPhase = false; state.typingTick = null; }
-      try { currentAdapter()?.typingStop?.(currentChannelId()); } catch (_) {}
+    const { sideChatCoordinator } = require("./side-chat");
+    if (String(tail || "").trim().toLowerCase() === "all") {
+      const sideCancellation = sideChatCoordinator.cancel(state.userId);
+      const lanes = state.lanes instanceof Map ? [...state.lanes.values()] : [];
+      // Drop the queues first, so no stopped lane's unwind admits them.
+      const dropped = lanes.flatMap((lane) => dropLaneQueue(lane, STOP_DROP_REASON));
+      const stopped = lanes.filter((lane) => stopLane(state, lane)).length;
+      const sideStopped = await sideCancellation;
+      if (!stopped && !dropped.length) return send(sideStopped ? "Cancelled side response." : "Nothing running.");
+      const parts = [];
+      if (stopped) parts.push(`Cancelled ${stopped} running conversation${stopped === 1 ? "" : "s"}.`);
+      if (dropped.length) parts.push(droppedNote(dropped, stopped ? "queued" : "waiting"));
+      return send(parts.join(" "));
+    }
+    // /stop cancels the CURRENT conversation's turn only (other threads keep
+    // running) and drops what was queued in it before the /stop: the person
+    // meant "stop", not "stop this one and start the next". A message sent
+    // after the /stop still queues behind the unwinding run and then runs.
+    const lane = laneFor(state);
+    const sideCancellation = sideChatCoordinator.cancel(state.userId, lane.key);
+    const dropped = dropLaneQueue(lane, STOP_DROP_REASON);
+    if (stopLane(state, lane)) {
       await sideCancellation;
-      await send(`Cancelled.${queuedNote()}`);
-    } else if (state.preparingRun) {
-      // Turn is mid-recall/prompt-build — no process to kill yet. Flag it so
-      // the runner's pre-spawn shouldAbort checkpoint bails before spawning.
-      state.cancelRequested = cancelFlagFor(state);
-      if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; state.thinkingPhase = false; state.typingTick = null; }
-      try { currentAdapter()?.typingStop?.(currentChannelId()); } catch (_) {}
+      await send(dropped.length ? `Cancelled. ${droppedNote(dropped, "queued")}` : "Cancelled.");
+    } else if (dropped.length) {
+      // Nothing to cancel: the dropped messages were waiting for a slot (or
+      // queued behind a turn that is only finishing its tail).
       await sideCancellation;
-      await send(`Cancelled.${queuedNote()}`);
+      await send(droppedNote(dropped, laneBusy(lane) ? "queued" : "waiting"));
     } else if (await sideCancellation) await send("Cancelled side response.");
     else await send("Nothing running.");
   },
@@ -1741,7 +1842,8 @@ register({
       `Recall engine: ${activeEngine}`,
       `Auto-compact: ${formatCompactWindow(state)}`,
       `Vault: ${vault.isUnlocked() ? "unlocked" : "locked"} | Crons: ${cronCount}`,
-      state.runningProcess ? "Working..." : "Ready.",
+      laneBusy(peekLane(state)) ? "Working..." : "Ready.",
+      ...runningConversationLines(state),
     ].join("\n"));
   },
 });

package/core/identity.js

@@ -18,14 +18,42 @@ function defaultCanonicalForChannel(transport, channelId) {
   return channelKey(transport, channelId);
 }
 
-// The conversation (thread) key for a channel. Deliberately identical to the
-// pre-unification default canonical: a thread is keyed by its raw channel
+// The conversation key for a channel. Deliberately identical to the
+// pre-unification default canonical: a conversation is keyed by its raw channel
 // identity, never by the unified speaker canonical. This is what keeps each
 // surface's live conversation separate even when the speaker is one being.
-function conversationKeyFor(transport, channelId) {
+// A chat THREAD (Kazee "reply in thread") is a conversation of its own inside
+// the channel: `<transport>:<channelId>#thread:<rootId>`. The channel's main
+// timeline keeps the bare channel key, so nothing existing changes. The room
+// (settings, grants) stays the channel key: use roomKeyFor for that.
+const THREAD_SEP = "#thread:";
+function conversationKeyFor(transport, channelId, threadId) {
+  const base = channelKey(transport, channelId);
+  const t = String(threadId || "").trim();
+  return t ? `${base}${THREAD_SEP}${t}` : base;
+}
+
+function roomKeyFor(transport, channelId) {
   return channelKey(transport, channelId);
 }
 
+// Split a conversation key back into its parts. The channel id may itself
+// contain ':' (e.g. spaces "task:42"), so only the first ':' separates the
+// transport. Returns {transport, channelId, threadId|null, roomKey}.
+function parseConversationKey(key) {
+  const k = String(key || "");
+  const i = k.indexOf(THREAD_SEP);
+  const room = i >= 0 ? k.slice(0, i) : k;
+  const threadId = i >= 0 ? k.slice(i + THREAD_SEP.length) || null : null;
+  const c = room.indexOf(":");
+  return {
+    transport: c >= 0 ? room.slice(0, c) : room,
+    channelId: c >= 0 ? room.slice(c + 1) : "",
+    threadId,
+    roomKey: room,
+  };
+}
+
 function loadIdentities() {
   const raw = readJsonWithFallback(IDENTITIES_FILE, null);
   return {
@@ -196,6 +224,8 @@ module.exports = {
   channelKey,
   defaultCanonicalForChannel,
   conversationKeyFor,
+  roomKeyFor,
+  parseConversationKey,
   isConfiguredOwnerChannel,
   ownerCanonical,
   channelIsOwner,