@inetafrica/open-claudia 3.5.0 → 3.5.4

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,
 };