@inetafrica/open-claudia 3.5.1 → 3.5.4

package/core/io.js

@@ -2,7 +2,16 @@
 // here so that the right adapter is invoked for the in-flight message
 // without each handler having to know about transports.
 
-const { currentAdapter, currentChannelId, currentUserId } = require("./context");
+const { currentAdapter, currentChannelId, currentUserId, currentThreadId } = require("./context");
+
+// The chat thread a delivery belongs to. An explicit opts.threadId wins (null =
+// the channel's main timeline); a send aimed at ANOTHER channel never inherits
+// this turn's thread; otherwise it goes back into the thread the turn is in.
+function threadFor(opts = {}) {
+  if (opts && Object.prototype.hasOwnProperty.call(opts, "threadId")) return opts.threadId || null;
+  if (opts && opts.channelId && String(opts.channelId) !== String(currentChannelId() || "")) return null;
+  return currentThreadId();
+}
 
 // Adapters historically overloaded their send() return value: a message id
 // (Telegram numeric, Kazee ObjectId string) on success, a bare `true` when
@@ -32,7 +41,8 @@ async function send(text, opts = {}) {
     console.error("send() called outside chat context");
     return { ok: false, messageId: null, editable: false };
   }
-  return normalizeSendResult(await adapter.send(channelId, text, opts));
+  const threadId = threadFor(opts);
+  return normalizeSendResult(await adapter.send(channelId, text, threadId ? { ...opts, threadId } : opts));
 }
 
 async function editMessage(messageId, text, opts = {}) {
@@ -49,11 +59,12 @@ async function deleteMessage(messageId) {
   return adapter.delete(channelId, messageId);
 }
 
-async function sendVoice(oggPath) {
+async function sendVoice(oggPath, opts = {}) {
   const adapter = currentAdapter();
   const channelId = currentChannelId();
   if (!adapter || !channelId) return false;
-  return adapter.sendVoice(channelId, oggPath);
+  const threadId = threadFor(opts);
+  return threadId ? adapter.sendVoice(channelId, oggPath, { threadId }) : adapter.sendVoice(channelId, oggPath);
 }
 
 // Signal the end of a streamed multi-clip spoken reply. Only the voice channel
@@ -66,7 +77,7 @@ async function sendVoiceEnd() {
   return adapter.sendVoiceEnd(channelId);
 }
 
-async function sendFile(filePath, caption) {
+async function sendFile(filePath, caption, opts = {}) {
   const adapter = currentAdapter();
   const channelId = currentChannelId();
   if (!adapter || !channelId) return false;
@@ -79,14 +90,16 @@ async function sendFile(filePath, caption) {
       return false;
     }
   } catch (e) { /* fail open only on classification error; primary gate is loopback.handleSend */ }
-  return adapter.sendFile(channelId, filePath, caption);
+  const threadId = threadFor(opts);
+  return threadId ? adapter.sendFile(channelId, filePath, caption, { threadId }) : adapter.sendFile(channelId, filePath, caption);
 }
 
 async function typing(state) {
   const adapter = currentAdapter();
   const channelId = currentChannelId();
   if (!adapter || !channelId) return;
-  return adapter.typing(channelId, state);
+  const threadId = currentThreadId();
+  return threadId ? adapter.typing(channelId, state, { threadId }) : adapter.typing(channelId, state);
 }
 
 function splitMessage(text, maxLen = 4000) {
@@ -96,4 +109,4 @@ function splitMessage(text, maxLen = 4000) {
   return chunks;
 }
 
-module.exports = { send, editMessage, deleteMessage, sendVoice, sendVoiceEnd, sendFile, typing, splitMessage, normalizeSendResult };
+module.exports = { threadFor, send, editMessage, deleteMessage, sendVoice, sendVoiceEnd, sendFile, typing, splitMessage, normalizeSendResult };

package/core/jobs.js

@@ -145,6 +145,9 @@ function normalizeRunnableJob(record, options = {}) {
     adapter: context.adapter,
     adapterType: context.adapterType,
     channelId: context.channelId,
+    // The chat thread the job fires back into (null = the channel's main
+    // timeline; jobs from before threads have none).
+    threadId: nonEmpty(record.threadId),
     canonicalUserId: context.canonicalUserId,
     userId: nonEmpty(record.userId),
     provider,

package/core/loopback.js

@@ -137,6 +137,26 @@ function jobCreatorRecord(creator) {
   };
 }
 
+// The chat thread a delivery or a job belongs to. The runner hands a thread
+// turn OC_THREAD_ID, which the CLI sends as `threadId`. For a live, attested
+// run the run decides, never the payload: in its own channel the run's thread
+// (null on the main timeline, so a main turn cannot post into some other
+// thread), and in any other channel no thread (a thread id belongs to its
+// channel). A mismatching claim is logged. A caller with no live run is
+// trusted exactly as its channelId is.
+function threadForCaller(caller, channelId, claimed) {
+  const claim = claimed ? String(claimed) : null;
+  if (caller && caller.attributed) {
+    const sameChannel = String(caller.channelId || "") === String(channelId || "");
+    const attested = sameChannel && caller.threadId ? String(caller.threadId) : null;
+    if (claim && claim !== attested) {
+      console.error(`loopback: payload thread ${claim} does not match the running turn's thread ${attested || "(none)"}; using the turn's`);
+    }
+    return attested;
+  }
+  return claim;
+}
+
 // Owner gate for every owner-only kind: true only for a LIVE run the bot
 // registered as acting for the owner. The id attest (OC_SPEAKER_ATTEST) is no
 // longer enough: it is valid for the whole boot and can be lifted from another
@@ -182,18 +202,27 @@ async function handleSend(req, res, url, kind) {
     }
   } catch (e) { /* classification failure → fall through; still owner-scoped in practice */ }
 
+  // Raw-body kinds carry the run attest in headers (the body is the file).
+  const caller = callerOf({
+    originRunId: req.headers["x-oc-run-id"] || "",
+    runAttest: req.headers["x-oc-run-attest"] || "",
+  });
+  const threadId = threadForCaller(caller, channelId, url.searchParams.get("threadId"));
+
   const safeName = path.basename(fileName).replace(/[^A-Za-z0-9._-]/g, "_") || `file-${Date.now()}`;
-  const tmp = path.join(os.tmpdir(), `oc-loopback-${process.pid}-${Date.now()}-${safeName}`);
+  // Unique per request: parallel conversations may send the same file name
+  // in the same millisecond.
+  const tmp = path.join(os.tmpdir(), `oc-loopback-${process.pid}-${Date.now()}-${crypto.randomBytes(4).toString("hex")}-${safeName}`);
   await readBodyToFile(req, tmp);
 
   let ok = false;
   try {
     if (kind === "send-voice") {
-      ok = await adapter.sendVoice(channelId, tmp);
+      ok = threadId ? await adapter.sendVoice(channelId, tmp, { threadId }) : await adapter.sendVoice(channelId, tmp);
     } else if (kind === "send-photo" && typeof adapter.sendPhoto === "function") {
-      ok = await adapter.sendPhoto(channelId, tmp, caption);
+      ok = threadId ? await adapter.sendPhoto(channelId, tmp, caption, { threadId }) : await adapter.sendPhoto(channelId, tmp, caption);
     } else {
-      ok = await adapter.sendFile(channelId, tmp, caption);
+      ok = threadId ? await adapter.sendFile(channelId, tmp, caption, { threadId }) : await adapter.sendFile(channelId, tmp, caption);
     }
   } finally {
     if (kind !== "send-voice") { try { fs.unlinkSync(tmp); } catch (e) {} }
@@ -228,6 +257,7 @@ async function handleJson(req, res, url, kind) {
   // room, and all of their guards apply when it runs. An unattributed caller
   // (a process detached from any live turn) cannot schedule anything.
   let jobCreator = null;
+  let jobThreadId = null;
   if (JOB_CREATE_KINDS.has(kind)) {
     const caller = callerOf(payload);
     if (!caller.attributed) {
@@ -243,6 +273,8 @@ async function handleJson(req, res, url, kind) {
       owner: caller.owner === true,
       name: caller.name || null,
     };
+    // A job created in a thread fires back into that thread.
+    jobThreadId = threadForCaller(caller, jobCreator.channelId, payload.threadId);
   }
 
   // Owner-only kinds: notes, tasks, and the people reads. Tasks and people
@@ -290,9 +322,10 @@ async function handleJson(req, res, url, kind) {
     }
     if (!voicePath) return reply(res, 503, { error: "no TTS route available" });
 
+    const threadId = threadForCaller(callerOf(payload), channelId, payload.threadId);
     let ok = false;
     try {
-      ok = await adapter.sendVoice(channelId, voicePath);
+      ok = threadId ? await adapter.sendVoice(channelId, voicePath, { threadId }) : await adapter.sendVoice(channelId, voicePath);
     } catch (e) {
       try { fs.unlinkSync(voicePath); } catch (_) {}
       return reply(res, 500, { error: `voice send failed: ${e.message}` });
@@ -363,6 +396,7 @@ async function handleJson(req, res, url, kind) {
       adapter: jobCreator.adapter,
       adapterType: jobCreator.adapterType,
       channelId: jobCreator.channelId,
+      threadId: jobThreadId,
       canonicalUserId: jobCreator.canonicalUserId,
       userId: jobCreator.userId,
       createdBy: jobCreatorRecord(jobCreator),
@@ -394,6 +428,7 @@ async function handleJson(req, res, url, kind) {
       adapter: jobCreator.adapter,
       adapterType: jobCreator.adapterType,
       channelId: jobCreator.channelId,
+      threadId: jobThreadId,
       canonicalUserId: jobCreator.canonicalUserId,
       userId: jobCreator.userId,
       createdBy: jobCreatorRecord(jobCreator),
@@ -442,6 +477,7 @@ async function handleJson(req, res, url, kind) {
       adapter: jobCreator.adapter,
       adapterType: jobCreator.adapterType,
       channelId: jobCreator.channelId,
+      threadId: jobThreadId,
       canonicalUserId: jobCreator.canonicalUserId,
       userId: jobCreator.userId,
       createdBy: jobCreatorRecord(jobCreator),
@@ -777,7 +813,12 @@ async function handleJson(req, res, url, kind) {
         targetChannel = caller.channelId;
       }
       if (!targetAdapter || !targetChannel) return reply(res, 400, { error: "need adapter+channelId or person" });
-      const entries = readRecentTranscript(targetAdapter, targetChannel, limit);
+      // Optional thread filter: "main" = the channel's main timeline only, a
+      // thread id = that thread only; absent = the whole channel.
+      const thread = payload.thread === undefined || payload.thread === null || payload.thread === ""
+        ? undefined
+        : (String(payload.thread) === "main" ? null : String(payload.thread));
+      const entries = readRecentTranscript(targetAdapter, targetChannel, limit, { thread });
       return reply(res, 200, { ok: true, adapter: targetAdapter, channelId: targetChannel, entries });
     } catch (e) { return reply(res, 400, { error: e.message }); }
   }
@@ -830,9 +871,11 @@ async function handleJson(req, res, url, kind) {
         approverAdapter = owner.adapter;
         approverChannel = owner.channelId;
       }
+      const originThread = threadForCaller(callerOf(payload), channelId, payload.threadId);
       const rec = approvals.create({
         tool: payload.tool, verb: payload.verb || "", tier: payload.tier || "destructive",
         command: payload.command, channelId, adapter: adapterId,
+        threadId: originThread,
         canonicalUserId: payload.canonicalUserId || null,
         userId: payload.userId || null,
         provider: payload.provider || null,
@@ -860,6 +903,8 @@ async function handleJson(req, res, url, kind) {
       // <pre> needs Telegram's HTML parse mode to render; other adapters ignore it.
       const sendOpts = { keyboard };
       if (buttonAdapter.type === "telegram") sendOpts.parseMode = "HTML";
+      // The card goes into the thread the run is in, when it goes to that room.
+      if (originThread && buttonAdapter === adapter && String(buttonChannel) === String(channelId)) sendOpts.threadId = originThread;
       const { normalizeSendResult } = require("./io");
       const sent = normalizeSendResult(await buttonAdapter.send(buttonChannel, text, sendOpts));
       if (!sent.ok) { approvals.decide(rec.id, "denied", "send-failed"); return reply(res, 500, { error: "could not deliver approval prompt" }); }
@@ -875,7 +920,7 @@ async function handleJson(req, res, url, kind) {
   return reply(res, 404, { error: "not found" });
 }
 
-function readRecentTranscript(adapter, channelId, limit) {
+function readRecentTranscript(adapter, channelId, limit, { thread } = {}) {
   if (!TRANSCRIPTS_DIR) return [];
   try {
     if (!fs2.existsSync(TRANSCRIPTS_DIR)) return [];
@@ -904,11 +949,14 @@ function readRecentTranscript(adapter, channelId, limit) {
           const objChannel = String(obj.chat?.id ?? obj.channelId ?? "");
           if (objAdapter !== adapterPrefix) continue;
           if (objChannel !== channelStr) continue;
+          const objThread = obj.chat?.threadId ? String(obj.chat.threadId) : null;
+          if (thread !== undefined && objThread !== thread) continue;
           out.push({
             at: obj.at || obj.timestamp || null,
             role: obj.role || obj.author || null,
             text: typeof obj.text === "string" ? obj.text.slice(0, 600) : null,
             kind: obj.kind || null,
+            threadId: objThread,
           });
           if (out.length >= limit) break;
         } catch (e) {}

package/core/providers/claude.js

@@ -85,8 +85,12 @@ function appendSessionArgs(args, context) {
     throw providerError("INVALID_PROVIDER_CONTEXT", "resumeSessionId and continueSession are mutually exclusive");
   }
   if (context.fresh) return;
-  if (context.resumeSessionId) args.push("--resume", String(context.resumeSessionId));
-  else if (context.continueSession) args.push("--continue");
+  if (context.resumeSessionId) {
+    args.push("--resume", String(context.resumeSessionId));
+    // A thread seeded from the main conversation (OC_THREAD_SEED=fork) resumes
+    // it into a new session of its own, leaving the main session untouched.
+    if (context.forkSession === true) args.push("--fork-session");
+  } else if (context.continueSession) args.push("--continue");
   else if (context.sessionId) args.push("--resume", String(context.sessionId));
 }
 

package/core/router.js

@@ -5,13 +5,13 @@
 const fs = require("fs");
 const path = require("path");
 const { runInChat } = require("./context");
-const { conversationKeyFor } = require("./identity");
+const { conversationKeyFor, roomKeyFor } = require("./identity");
 const { dispatch } = require("./commands");
 const { handleAction } = require("./actions");
 const { isChatAuthorized } = require("./access");
 const introFlow = require("./intro-flow");
 const { send, deleteMessage } = require("./io");
-const { currentState, saveState, autoLinkOwnerChannel, getActiveProvider, getProjectKey } = require("./state");
+const { currentState, saveState, autoLinkOwnerChannel, getActiveProvider, getProjectKey, laneFor, peekLane, laneBusy, slotBlocker } = require("./state");
 const { admitRunContext, runAgent, startTypingHeartbeat } = require("./runner");
 const { transcribeAudio, cloneVoiceFromClip } = require("./media");
 const { hydrateContextMedia } = require("./context-media");
@@ -89,11 +89,13 @@ function scope(envelope, fn) {
   return runInChat({
     adapter: envelope.adapter,
     channelId: envelope.channelId,
+    threadId: envelope.threadId || null,
     canonicalUserId: envelope.canonicalUserId,
     userId: envelope.userId,
     transport: envelope.adapter?.type,
     raw: envelope.raw,
-    conversationKey: conversationKeyFor(envelope.adapter?.type, envelope.channelId),
+    conversationKey: conversationKeyFor(envelope.adapter?.type, envelope.channelId, envelope.threadId),
+    roomKey: roomKeyFor(envelope.adapter?.type, envelope.channelId),
     inboundText: envelope.text || "",
     speakerName: envelope.from?.name || envelope.from?.username || "",
     isGroup: envelope.isGroup === true || envelope.surface === "group",
@@ -219,9 +221,13 @@ async function admitGuardedTurn(askText, envelope, state = currentState()) {
 // runAgent — many seconds with no feedback. Start the "thinking" heartbeat as
 // soon as a turn-bound message arrives; the run's own heartbeat supersedes it
 // at executeAdmittedRun, after which this stopper is a no-op. Skipped while a
-// run is active — the chip is already owned by that turn.
+// run is active in this conversation — the chip is already owned by that turn
+// (another conversation's run has its own chip and does not matter here) —
+// and when the message will WAIT (the conversation already has a queue, or no
+// slot is free): nothing is thinking about it yet.
 function startPreTurnTyping(state) {
-  if (state.runningProcess || state.preparingRun) return () => {};
+  const lane = peekLane(state);
+  if (laneBusy(lane) || lane?.messageQueue?.length || slotBlocker(state)) return () => {};
   try { return startTypingHeartbeat(state); } catch (_) { return () => {}; }
 }
 
@@ -237,9 +243,10 @@ async function handleVoice(envelope) {
     }
     // /voice clone armed this channel: the next clip is a cloning sample, not a
     // prompt. Consume the flag (fresh only) before the normal transcribe path.
-    if (state.pendingVoiceClone) {
-      const fresh = Date.now() - state.pendingVoiceClone.at < 5 * 60 * 1000;
-      state.pendingVoiceClone = null;
+    const lane = laneFor(state);
+    if (lane.pendingVoiceClone) {
+      const fresh = Date.now() - lane.pendingVoiceClone.at < 5 * 60 * 1000;
+      lane.pendingVoiceClone = null;
       if (fresh) return captureVoiceClone(envelope, media);
     }
     const runContext = admitRunContext("", state.currentSession.dir, envelope.messageId, {
@@ -256,9 +263,13 @@ async function handleVoice(envelope) {
     if (!transcript) return send("Couldn't transcribe. Try typing it.");
     await send(`Heard: "${transcript}"`, { replyTo: envelope.messageId });
     if (!(await admitGuardedTurn(transcript, envelope, state))) return;
-    state.lastInputWasVoice = true;
+    // Voice flags live on the conversation's lane: a voice note in one thread
+    // never makes another conversation's reply speak. Resolved again after the
+    // awaits: an idle lane may have been pruned and recreated meanwhile.
+    const voiceLane = laneFor(state);
+    voiceLane.lastInputWasVoice = true;
     // Per-stage latency for the voice pipeline; the runner fills in the rest.
-    state.voiceLat = { startAt: tStart, downloadMs: tAfterDownload - tStart, sttMs: tAfterStt - tAfterDownload };
+    voiceLane.voiceLat = { startAt: tStart, downloadMs: tAfterDownload - tStart, sttMs: tAfterStt - tAfterDownload };
     return runWithContext(transcript, runContext, envelope, {
       runContext,
       attachments: [{ type: "voice", path: oggPath, mimeType: media.mimeType || "audio/ogg", fileName: media.fileName || null }],
@@ -276,9 +287,10 @@ async function handleAudio(envelope) {
   try {
     const media = envelope.media?.[0];
     if (!media) return;
-    if (state.pendingVoiceClone) {
-      const fresh = Date.now() - state.pendingVoiceClone.at < 5 * 60 * 1000;
-      state.pendingVoiceClone = null;
+    const lane = laneFor(state);
+    if (lane.pendingVoiceClone) {
+      const fresh = Date.now() - lane.pendingVoiceClone.at < 5 * 60 * 1000;
+      lane.pendingVoiceClone = null;
       if (fresh) return captureVoiceClone(envelope, media);
     }
     const runContext = admitRunContext("", state.currentSession.dir, envelope.messageId, {

package/core/run-context.js

@@ -2,8 +2,9 @@
 
 const crypto = require("crypto");
 const path = require("path");
-const { currentConversationKey } = require("./context");
-const { resolveProviderSettings } = require("./state");
+const { currentConversationKey, currentThreadId } = require("./context");
+const { resolveProviderSettings, peekLane } = require("./state");
+const { parseConversationKey } = require("./identity");
 
 function cloneSerializable(value, label = "run context value") {
   if (value === undefined) return undefined;
@@ -51,6 +52,28 @@ function projectSnapshot(state, cwd, requestedProject) {
   return { name: dir ? path.basename(dir) : null, dir };
 }
 
+// OC_THREAD_SEED=fork (Claude only): a thread's FIRST turn resumes the
+// channel's main conversation with --fork-session, so the thread inherits the
+// whole main context in a session of its own. Default "fresh": a new thread
+// starts a new session, seeded only with the thread's own messages. Codex has
+// no fork, so it always starts fresh.
+function threadSeedMode() {
+  let value = process.env.OC_THREAD_SEED;
+  try { value = require("./config").config?.OC_THREAD_SEED ?? value; } catch (_) {}
+  return String(value || "fresh").trim().toLowerCase() === "fork" ? "fork" : "fresh";
+}
+
+function threadForkSession(state, { provider, laneKey, threadId, activeSessionId, opts, liveCall }) {
+  if (provider !== "claude" || !threadId || activeSessionId || liveCall) return null;
+  if (opts.fresh || opts.resumeSessionId || opts.continueSession || opts.project !== undefined) return null;
+  if ((opts.purpose || "foreground") !== "foreground") return null;
+  if (threadSeedMode() !== "fork") return null;
+  const mainKey = parseConversationKey(laneKey).roomKey;
+  const mainSessionId = mainKey && mainKey !== laneKey ? state.activeSessions?.[mainKey]?.claude || null : null;
+  if (!mainSessionId || state.quarantinedSessions?.[mainSessionId]) return null;
+  return mainSessionId;
+}
+
 function serializableOrigin(origin, fallback = {}) {
   const source = origin || fallback || {};
   return {
@@ -102,14 +125,22 @@ function captureRunContext({
   // session associated with the same chat room.
   const liveCall = store?.adapter?.liveCall === true;
   const activeSessionId = state.activeSessions?.[project.name]?.[provider] || null;
+  // The run's lane (its conversation: a thread is its own) and thread are
+  // fixed here, at admission: queueing, /stop, preview, typing and delivery all
+  // follow the lane the message arrived in, never a later one.
+  const laneKey = String(opts.laneKey || currentConversationKey() || project.name || "Workspace");
+  const threadId = (store && store.threadId) || currentThreadId() || parseConversationKey(laneKey).threadId || null;
+  const lane = peekLane(state, laneKey);
+  const forkFromSessionId = threadForkSession(state, { provider, laneKey, threadId, activeSessionId, opts, liveCall });
   const requestedSessionId = opts.fresh || liveCall
     ? null
-    : (opts.resumeSessionId || activeSessionId || null);
+    : (opts.resumeSessionId || activeSessionId || forkFromSessionId || null);
   // A quarantined session's provider-side context tripped a safety refusal;
   // resuming would re-send the flagged context and refuse again. Force the
   // turn fresh instead (explicit resume requests included).
   const quarantinedResume = !!(requestedSessionId && state.quarantinedSessions?.[requestedSessionId]);
   const admittedSessionId = quarantinedResume ? null : requestedSessionId;
+  const forkedFromMain = !!forkFromSessionId && admittedSessionId === forkFromSessionId;
   const origin = serializableOrigin(opts.origin, store || {});
   const resolvedChannelId = channelId != null
     ? String(channelId)
@@ -132,12 +163,18 @@ function captureRunContext({
       ? crypto.randomUUID()
       : `run-${now}-${Math.random().toString(36).slice(2, 10)}`),
     admittedAt: now,
+    laneKey,
+    threadId: threadId ? String(threadId) : null,
     canonicalUserId: canonicalUserId || state.userId || origin.canonicalUserId || null,
     project,
     provider,
     providerSettings,
-    sessionId: admittedSessionId,
-    admittedSessionId,
+    // A fork turn resumes the MAIN session only to copy it: the turn's own
+    // session does not exist until the provider reports it. Never expose the
+    // main id as this run's session (OC_SESSION_ID, jobs and approvals made in
+    // the turn), or a later wakeup would --resume the main conversation.
+    sessionId: forkedFromMain ? null : admittedSessionId,
+    admittedSessionId: forkedFromMain ? null : admittedSessionId,
     previousSessionId: activeSessionId,
     purpose: opts.purpose || (opts.label ? String(opts.label) : "foreground"),
     channelId: resolvedChannelId,
@@ -147,15 +184,18 @@ function captureRunContext({
     userPrompt: prompt,
     fresh: !!opts.fresh || liveCall || quarantinedResume,
     continueSession: quarantinedResume || liveCall ? false : !!opts.continueSession,
-    resumeSessionId: quarantinedResume || liveCall ? null : (opts.resumeSessionId || null),
+    resumeSessionId: quarantinedResume || liveCall ? null : (opts.resumeSessionId || forkFromSessionId || null),
+    // Claude --fork-session: resume the main conversation into a NEW session
+    // (the thread's own), leaving the main session untouched.
+    forkSession: !!forkFromSessionId && !quarantinedResume,
     quarantinedResume,
     skipAutoCompact: liveCall || !!opts.skipAutoCompact,
     timeoutMs: Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : null,
     maxTurns: Number.isFinite(opts.maxTurns) ? opts.maxTurns : null,
     imagePaths: cloneSerializable(opts.imagePaths || opts.images || [], "image paths"),
     attachments: cloneSerializable(opts.attachments || [], "attachments"),
-    lastInputWasVoice: !!state.lastInputWasVoice,
-    voiceStream: !!opts.voiceStream || (!!state.lastInputWasVoice && origin.transport === "voice"),
+    lastInputWasVoice: !!lane?.lastInputWasVoice,
+    voiceStream: !!opts.voiceStream || (!!lane?.lastInputWasVoice && origin.transport === "voice"),
     liveCall,
     callHistory: liveCall
       ? cloneSerializable(store.adapter.callHistory || [], "call history") : [],
@@ -221,4 +261,5 @@ module.exports = {
   deepFreeze,
   sameCapturedProject,
   serializableOrigin,
+  threadSeedMode,
 };