@inetafrica/open-claudia 3.5.1 → 3.5.7

package/test-provider-compaction.js

@@ -26,6 +26,9 @@ const stateApi = require("./core/state");
 const runner = require("./core/runner");
 
 const state = stateApi.currentState();
+// Compaction runs in ONE conversation lane: outside a chat turn that is the
+// state's project ("alpha" here).
+const alphaLane = () => stateApi.laneFor(state, "alpha");
 
 function result(overrides = {}) {
   return {
@@ -58,9 +61,7 @@ function resetFixture(provider = "claude") {
   state.pendingCompaction = null;
   state.completedCompactions = {};
   state.lastCompactedAt = 0;
-  state.isCompacting = false;
-  state.runningProcess = null;
-  state.preparingRun = false;
+  state.lanes?.clear();
   state.isFirstMessage = false;
   stateApi.replaceProjectSessions(state.userId, "alpha", [
     {
@@ -92,9 +93,9 @@ function serviceWith(runCapture, extra = {}) {
 
 async function immutableSuccessProbe() {
   resetFixture("claude");
-  state.isCompacting = true;
+  alphaLane().isCompacting = true;
   assert.strictEqual(stateApi.acquireRunLock(state), false, "foreground admission stays closed between compaction stages");
-  state.isCompacting = false;
+  alphaLane().isCompacting = false;
   const contexts = [];
   const service = serviceWith(async (_prompt, _cwd, options) => {
     assert.strictEqual(options.persist, false, "compaction provider stages have no ordinary capture persistence");
@@ -152,17 +153,17 @@ async function immutableSuccessProbe() {
   const usage = stateApi.getUsageForSession(state, "alpha", "claude", "new-claude");
   assert.strictEqual(usage.turns, 0, "seed is not billed as a user turn");
   assert.strictEqual(usage.compactionCheckpoint.previousSessionId, "old-claude");
-  assert.strictEqual(state.isCompacting, false);
+  assert.strictEqual(alphaLane().isCompacting, false);
 }
 
 async function failureProbe() {
   resetFixture("claude");
-  state.runningProcess = { pid: 123 };
+  alphaLane().runningProcess = { pid: 123 };
   let busyCalls = 0;
   const busy = await serviceWith(async () => { busyCalls += 1; return result(); }).compact(alphaDir);
   assert.strictEqual(busy.compacted, false);
   assert.strictEqual(busyCalls, 0, "manual compaction never overlaps an active provider run");
-  state.runningProcess = null;
+  alphaLane().runningProcess = null;
 
   resetFixture("claude");
   let summaryCalls = 0;
@@ -354,15 +355,15 @@ async function deferredWatchAcrossCompactionProbe() {
       },
     });
 
-    state.runningProcess = { pid: 4242 };
+    alphaLane().runningProcess = { pid: 4242 };
     assert.strictEqual((await scheduler.fireJob("watch-long-turn")).deferred, true, "a watch that passes mid-turn is queued");
     for (let i = 0; i < 3; i++) await timers.at(-1).fn();
-    state.runningProcess = null;
+    alphaLane().runningProcess = null;
     let calls = 0;
     const compaction = serviceWith(async () => {
       calls += 1;
       if (calls === 1) {
-        assert.strictEqual(state.isCompacting, true);
+        assert.strictEqual(alphaLane().isCompacting, true);
         assert.strictEqual((await timers.at(-1).fn()).deferred, true, "the delivery waits out the compaction");
         return result({ sessionId: "old-claude" });
       }
@@ -381,6 +382,43 @@ async function deferredWatchAcrossCompactionProbe() {
   }
 }
 
+// Compaction is per conversation: compacting one lane keeps only THAT lane
+// closed, and the recent turns it seeds from come from that conversation's
+// transcript — not the state's legacy "Workspace" session.
+async function perLaneProbe() {
+  resetFixture("claude");
+  const { runInChat } = require("./core/context");
+  const convo = "telegram:fixture";
+  const thread = "telegram:fixture#thread:eeeeeeeeeeeeeeeeeeeeeeee";
+  state.currentSession = stateApi.rootSession();
+  stateApi.setProviderSession(state, "claude", convo, "old-claude");
+  const views = [];
+  let lanesDuringCompaction = null;
+  const service = serviceWith(async () => {
+    if (!lanesDuringCompaction) {
+      lanesDuringCompaction = {
+        own: stateApi.acquireRunLock(state, convo),
+        thread: stateApi.acquireRunLock(state, thread),
+        compacting: stateApi.laneFor(state, convo).isCompacting,
+      };
+      stateApi.laneFor(state, thread).preparingRun = false;
+      return result({ sessionId: "old-claude" });
+    }
+    return result({ sessionId: "lane-new-claude" });
+  }, { collectRecentTurns: (view) => { views.push(view); return null; } });
+  const compacted = await runInChat({ channelId: "fixture", conversationKey: convo, roomKey: convo, canonicalUserId: state.userId },
+    () => service.compact(workspace, { operationId: "compact-lane" }));
+  assert.strictEqual(compacted.compacted, true, compacted.reason);
+  assert.deepStrictEqual(lanesDuringCompaction, { own: false, thread: true, compacting: true },
+    "only the compacting conversation is closed; a thread of the same chat can start");
+  assert.strictEqual(stateApi.laneFor(state, convo).isCompacting, false);
+  assert.strictEqual(views.length, 1);
+  assert.strictEqual(views[0].currentSession.name, convo, "recent turns are read from the conversation's own transcript");
+  assert.strictEqual(stateApi.getProviderSession(state, "claude", convo), "lane-new-claude");
+  assert.strictEqual(runner.shouldAutoCompact(state, { laneKey: thread }), false, "a thread with no session never auto-compacts");
+  state.lanes.clear();
+}
+
 function duplicateCommitProbe() {
   resetFixture("claude");
   const transaction = {
@@ -457,6 +495,7 @@ function restartRecoveryProbe() {
     await failureProbe();
     await codexRestrictionProbe();
     await deferredWatchAcrossCompactionProbe();
+    await perLaneProbe();
     duplicateCommitProbe();
     restartRecoveryProbe();
     console.log("provider compaction OK");

package/test-provider-gateway.js

@@ -37,13 +37,12 @@ async function routerProbe() {
       claude: { model: "claude-fixture" },
       codex: { model: "codex-fixture" },
     },
-    messageQueue: [],
     pendingCodexAuthProcess: null,
     pendingClaudeAuthProcess: null,
     pendingVaultUnlock: false,
     onboardingStep: null,
-    lastInputWasVoice: false,
   };
+  const lane = { messageQueue: [], lastInputWasVoice: false, pendingVoiceClone: null };
   const admissions = [];
   const runs = [];
   const sends = [];
@@ -55,6 +54,10 @@ async function routerProbe() {
     autoLinkOwnerChannel: () => null,
     getActiveProvider: (s) => (s || state).settings?.backend || null,
     getProjectKey: (s) => (s || state).currentSession?.name || "",
+    laneFor: () => lane,
+    peekLane: () => lane,
+    laneBusy: (l) => !!(l && (l.runningProcess || l.preparingRun)),
+    slotBlocker: () => null,
   });
   // The up-front triage gate is pinned in test-enforcer.js; here it must only
   // be CONSULTED with the routed text + provider/project pinning, then let the
@@ -327,12 +330,16 @@ async function schedulerProbe() {
     getProviderSession: (_state, provider, project) => (
       state.activeSessions?.[project]?.[provider] || null
     ),
+    peekLane: () => null,
+    laneBusy: () => false,
+    slotBlocker: () => null,
     userStates: new Map(),
   });
   installStub("./core/identity", {
     canonicalForTelegram: () => "fixture-user",
     canonicalForChannel: () => "fixture-user",
     conversationKeyFor: (transport, channelId) => `${transport}:${channelId}`,
+    parseConversationKey: (key) => ({ threadId: null, roomKey: String(key || "") }),
   });
   installStub("./core/io", {
     send: async () => {
@@ -420,10 +427,15 @@ async function queueProbe() {
       claude: { model: "claude-fixture", effort: "high" },
       codex: { model: "codex-fixture", effort: "low" },
     },
+  };
+  // The conversation's lane is busy preparing a turn, so new work queues in it.
+  const lane = {
+    key: "project-a",
     messageQueue: [],
     preparingRun: true,
     runningProcess: null,
     isCompacting: false,
+    activeRunContext: null,
     lastInputWasVoice: false,
   };
   const store = Object.freeze({
@@ -441,7 +453,15 @@ async function queueProbe() {
     recordSession: () => {},
     userOwnsProviderSession: () => false,
     resetSessionUsage: () => {},
-    acquireRunLock: () => false,
+    admitLane: () => ({ ok: false, reason: "busy", lane }),
+    laneFor: () => lane,
+    laneForRun: () => lane,
+    peekLane: () => lane,
+    laneBusy: () => true,
+    runLaneKey: (runContext) => runContext?.laneKey || runContext?.project?.name || null,
+    waitingLanes: () => [],
+    slotBlocker: () => null,
+    pruneIdleLanes: () => {},
   });
   installStub("./core/context", {
     chatContext: { getStore: () => store, run: (_store, fn) => fn() },
@@ -449,6 +469,7 @@ async function queueProbe() {
     currentAdapter: () => store.adapter,
     currentUserId: () => store.userId,
     currentConversationKey: () => store.conversationKey || null,
+    currentThreadId: () => null,
   });
   installStub("./core/io", {
     send: async () => ({ ok: true, messageId: "queued", editable: true }),
@@ -462,8 +483,8 @@ async function queueProbe() {
   const { runAgent } = require("./core/runner");
   const pending = runAgent("queued prompt", projectA, "message-queued", { runId: "queued-run" });
   assert.strictEqual(typeof pending.then, "function");
-  assert.strictEqual(state.messageQueue.length, 1);
-  const queued = state.messageQueue[0];
+  assert.strictEqual(lane.messageQueue.length, 1);
+  const queued = lane.messageQueue[0];
   assert.ok(Object.isFrozen(queued.runContext));
   assert.ok(Object.isFrozen(queued.runContext.project));
   assert.ok(Object.isFrozen(queued.runContext.providerSettings));
@@ -483,14 +504,14 @@ async function queueProbe() {
   store.adapter.liveCall = true;
   store.adapter.callTurn = { signal: obsoleteCall.signal };
   const callPending = runAgent("obsolete call question", projectA, null, { runId: "obsolete-call" });
-  assert.strictEqual(state.messageQueue.length, 2);
+  assert.strictEqual(lane.messageQueue.length, 2);
   obsoleteCall.abort();
-  assert.strictEqual(state.messageQueue.length, 1, "superseded call entry is removed immediately, ordinary queued work is preserved");
+  assert.strictEqual(lane.messageQueue.length, 1, "superseded call entry is removed immediately, ordinary queued work is preserved");
   assert.strictEqual((await callPending).status, "cancelled");
-  assert.strictEqual(state.messageQueue[0], queued);
+  assert.strictEqual(lane.messageQueue[0], queued);
   const alreadyEnded = await runAgent("late call dispatch", projectA, null, { runId: "late-call" });
   assert.strictEqual(alreadyEnded.status, "cancelled");
-  assert.strictEqual(state.messageQueue.length, 1, "an already-ended call never joins the queue");
+  assert.strictEqual(lane.messageQueue.length, 1, "an already-ended call never joins the queue");
   delete store.adapter.callTurn;
   delete store.adapter.liveCall;
   console.log("provider gateway immutable queue OK");
@@ -521,7 +542,7 @@ function staticChecks() {
   }
   assert.match(source["core/router.js"], /\badmitRunContext\b/, "media/text ingress captures before preparation awaits");
   assert.match(source["core/scheduler.js"], /result\.ok/, "scheduler consumes terminal RunResult success");
-  assert.match(source["core/runner.js"], /messageQueue\.push\(\{ runContext,/, "queued work stores its immutable run context");
+  assert.match(source["core/runner.js"], /queueInLane\(lane, \{ runContext,/, "queued work stores its immutable run context in its lane");
   assert.match(source["core/runner.js"], /executeAdmittedRun\(item\.runContext,/, "queue drain executes the admitted context");
   assert.match(source["bin/cli.js"], /Open Claudia agent task/);
   assert.ok(!source["bin/cli.js"].includes("inside a running Claude task"));

package/test-provider-language.js

@@ -519,7 +519,13 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // own bot (ancestor listener, not started in a staff turn); staff watch checks
 // get an allowlist env and owner checks the bot's env again; a partial chat
 // origin is a non-owner; wider staff shell screen, documented as no boundary.
-assert.strictEqual(pkg.version, "3.5.1", "release version must remain unchanged without explicit approval");
+// 3.5.7 approved by Sumeet 2026-09-29 17:37 EAT ("also roll out the open claudia
+// threads feature"): 3.5.5 (Kazee threads + thread naming, approved 12:22 and 16:29
+// EAT) plus the fix that kept it off the fleet: the staff-turn credential scrub
+// only where its sandbox can run (the fleet's containers cannot). 3.5.6 never
+// built (a test needed Claude Code on the build machine); 3.5.7 = 3.5.6 + that
+// test fix. Canary on network-bot + procurement-specialist first, then the fleet.
+assert.strictEqual(pkg.version, "3.5.7", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }

package/test-provider-scheduler.js

@@ -392,10 +392,9 @@ function schedulerHarness(createSchedulerService, seed, options = {}) {
         newSessionId: "claude-after-compact",
       },
     },
-    runningProcess: null,
-    preparingRun: false,
   };
   const outcomes = options.outcomes || [];
+  const chats = [];
   let occurrenceSequence = 0;
   const service = createSchedulerService({
     jobsStore,
@@ -416,7 +415,7 @@ function schedulerHarness(createSchedulerService, seed, options = {}) {
       crons.push(task);
       return task;
     },
-    runInChat: async (_ctx, fn) => fn(),
+    runInChat: async (ctx, fn) => { chats.push(ctx); return fn(); },
     getUserState: () => state,
     send: async (text) => { sends.push(text); if (options.onSend) await options.onSend(state); return { ok: true }; },
     admitRunContext(prompt, cwd, _replyTo, opts) {
@@ -449,7 +448,7 @@ function schedulerHarness(createSchedulerService, seed, options = {}) {
     missedGraceMs: 60 * 60 * 1000,
     ...(options.runWatchCheck ? { runWatchCheck: options.runWatchCheck } : {}),
   });
-  return { service, jobsStore, scheduled, crons, admissions, runCalls, sends, state };
+  return { service, jobsStore, scheduled, crons, admissions, runCalls, sends, state, chats };
 }
 
 async function firetimeSelectionProbe(createSchedulerService) {
@@ -601,8 +600,6 @@ async function detachedHistoricalBranchProbe(createSchedulerService) {
     settings: { backend: "claude" },
     activeSessions: { alpha: { claude: "unrelated-live-session" } },
     completedCompactions: {},
-    runningProcess: null,
-    preparingRun: false,
   };
   const h = schedulerHarness(createSchedulerService, [baseJob({ id: "historical", occurrenceId: "occ-historical" })], {
     state,
@@ -625,9 +622,8 @@ async function busyRestartAndMissedProbe(createSchedulerService) {
     settings: { backend: "claude" },
     activeSessions: { alpha: { claude: "session" } },
     completedCompactions: {},
-    runningProcess: { pid: 1 },
-    preparingRun: false,
   };
+  jobLane(busyState).runningProcess = { pid: 1 };
   const busy = schedulerHarness(createSchedulerService, [baseJob({ id: "busy", sessionId: "session" })], { state: busyState });
   const deferredBusy = await busy.service.fireJob("busy");
   assert.strictEqual(deferredBusy.deferred, true);
@@ -648,6 +644,52 @@ async function busyRestartAndMissedProbe(createSchedulerService) {
   assert.strictEqual(missedTimers.length, 1, "a missed wakeup gets exactly one startup attempt");
 }
 
+// Parallel conversations: a job is busy only when ITS conversation is. A
+// wakeup made in a thread fires while the speaker's main timeline (or another
+// thread) runs, and its scope carries the thread so the notice and the reply
+// land in that thread; the room stays the channel.
+async function threadLaneProbe(createSchedulerService) {
+  const THREAD = "cccccccccccccccccccccccc";
+  const threadKey = `telegram:fixture-channel#thread:${THREAD}`;
+  const h = schedulerHarness(createSchedulerService, [
+    baseJob({ id: "in-thread", project: threadKey, threadId: THREAD }),
+    baseJob({ id: "legacy-thread", project: threadKey }),
+    baseJob({ id: "in-main", project: "telegram:fixture-channel" }),
+    baseJob({ id: "thread-waiting", project: threadKey, threadId: THREAD }),
+  ], { outcomes: [succeededRun(), succeededRun(), succeededRun()] });
+  jobLane(h.state, "telegram:fixture-channel").runningProcess = { pid: 1 };
+  jobLane(h.state, "telegram:fixture-channel#thread:dddddddddddddddddddddddd").runningProcess = { pid: 2 };
+  const fired = await h.service.fireJob("in-thread");
+  assert.strictEqual(fired.ok, true, "a thread's wakeup fires while other conversations of the speaker run");
+  assert.strictEqual(h.runCalls.length, 1);
+  const scope = h.chats.at(-1);
+  assert.strictEqual(scope.threadId, THREAD, "the firing scope carries the job's thread");
+  assert.strictEqual(scope.conversationKey, threadKey, "and resumes the thread's conversation");
+  assert.strictEqual(scope.roomKey, "telegram:fixture-channel", "the room is the channel");
+  assert.strictEqual((await h.service.fireJob("legacy-thread")).ok, true);
+  assert.strictEqual(h.chats.at(-1).threadId, THREAD, "a job without threadId reads it off its conversation key");
+  const blocked = await h.service.fireJob("in-main");
+  assert.strictEqual(blocked.deferred, true, "a job whose own conversation runs is deferred");
+  assert.strictEqual(h.chats.at(-1).threadId, null, "a main-timeline job has no thread");
+  jobLane(h.state, threadKey).messageQueue.push({ queuedAt: 1 });
+  assert.strictEqual((await h.service.fireJob("thread-waiting")).deferred, true, "messages waiting in the job's conversation defer it too");
+  jobLane(h.state, threadKey).messageQueue.length = 0;
+
+  // A job whose project is not its chat's key (--project myrepo) still waits
+  // for the conversation it replies INTO; its own project lane is free.
+  const r = schedulerHarness(createSchedulerService, [
+    baseJob({ id: "repo-in-thread", project: "myrepo", threadId: THREAD }),
+    baseJob({ id: "repo-in-main", project: "myrepo" }),
+  ], { outcomes: [succeededRun()] });
+  jobLane(r.state, threadKey).runningProcess = { pid: 3 };
+  assert.strictEqual((await r.service.fireJob("repo-in-thread")).deferred, true, "a job replying into a busy thread waits for it");
+  assert.strictEqual(r.runCalls.length, 0);
+  jobLane(r.state, threadKey).runningProcess = null;
+  jobLane(r.state, "telegram:fixture-channel").messageQueue.push({ queuedAt: 1 });
+  assert.strictEqual((await r.service.fireJob("repo-in-main")).deferred, true, "and one replying into a timeline with messages waiting too");
+  jobLane(r.state, "telegram:fixture-channel").messageQueue.length = 0;
+}
+
 async function busyWatchNoticeProbe(createSchedulerService) {
   // A watch alarm waiting behind a busy room: silent for 15 minutes, then one
   // plain line, never a second for the same occurrence; the next occurrence
@@ -658,7 +700,7 @@ async function busyWatchNoticeProbe(createSchedulerService) {
     id: "alarm", kind: "cron", schedule: "*/15 * * * *", check: "fixture-check", repeat: true,
     label: "Phone alarm", expiresAt: clock + 24 * 60 * 60 * 1000,
   })], { now: () => clock, runWatchCheck: async () => { checks++; return { code: 0 }; } });
-  h.state.runningProcess = { pid: 1 };
+  jobLane(h.state).runningProcess = { pid: 1 };
   await h.service.fireJob("alarm");                    // triggers and latches
   assert.strictEqual(checks, 1);
   for (const minutes of [5, 10, 14]) {
@@ -679,7 +721,7 @@ async function busyWatchNoticeProbe(createSchedulerService) {
 
   // A wakeup waiting behind the same run stays quiet.
   const w = schedulerHarness(createSchedulerService, [baseJob({ id: "wake" })], { now: () => clock });
-  w.state.runningProcess = { pid: 1 };
+  jobLane(w.state).runningProcess = { pid: 1 };
   clock += 60 * 60_000;
   await w.service.fireJob("wake");
   assert.strictEqual(w.sends.length, 0);
@@ -701,6 +743,12 @@ async function tick(task) {
   for (let i = 0; i < 3; i++) await nextTurn();
 }
 
+// The scheduler's busy check looks at the job's OWN conversation lane (its
+// project), not the speaker's whole state: other conversations may run.
+function jobLane(state, project = "alpha") {
+  return require("./core/state").laneFor(state, project);
+}
+
 function repeatingWatch(overrides = {}) {
   return baseJob({
     kind: "cron",
@@ -731,7 +779,7 @@ async function pendingDeliveryPollingProbe(createSchedulerService) {
   h.service.init();
   assert.strictEqual(h.crons.length, 1);
   const poll = h.crons[0];
-  h.state.runningProcess = { pid: 1 };
+  jobLane(h.state).runningProcess = { pid: 1 };
   await tick(poll);
   assert.strictEqual(h.jobsStore.get("bus").status, "deferred");
   assert.strictEqual(poll.stopped, false, "a repeating watch keeps its poll schedule while the delivery waits");
@@ -766,7 +814,7 @@ async function pendingDeliveryPollingProbe(createSchedulerService) {
   assert.strictEqual(bus.watchLastClearAt, at(30));
   assert.strictEqual(h.runCalls.length, 0);
 
-  h.state.runningProcess = null;
+  jobLane(h.state).runningProcess = null;
   clock = at(46);
   assert.strictEqual((await h.scheduled.at(-1).fn()).ok, true);
   assert.strictEqual(h.runCalls.length, 1, "one delivery for the whole wait");
@@ -867,12 +915,12 @@ async function pendingDeliveryPollingProbe(createSchedulerService) {
     outcomes: [succeededRun()],
   });
   race.service.init();
-  race.state.runningProcess = { pid: 1 };
+  jobLane(race.state).runningProcess = { pid: 1 };
   await tick(race.crons[0]);
   release = () => {};
   race.crons[0].callback();
   await nextTurn();
-  race.state.runningProcess = null;
+  jobLane(race.state).runningProcess = null;
   assert.strictEqual((await race.scheduled.at(-1).fn()).ok, true);
   release({ code: 0 });
   for (let i = 0; i < 3; i++) await nextTurn();
@@ -886,7 +934,7 @@ async function pendingDeliveryPollingProbe(createSchedulerService) {
     runWatchCheck: async () => { onceChecks++; return { code: 0 }; },
   });
   once.service.init();
-  once.state.runningProcess = { pid: 1 };
+  jobLane(once.state).runningProcess = { pid: 1 };
   await tick(once.crons[0]);
   assert.strictEqual(once.crons[0].stopped, true, "a one-shot watch parks on its retry timer alone");
   await tick(once.crons[0]);
@@ -944,7 +992,7 @@ async function checkTimeoutAlarmProbe(createSchedulerService) {
     now: () => clock,
     runWatchCheck: async () => hungResult,
   });
-  hung.state.runningProcess = { pid: 1 };
+  jobLane(hung.state).runningProcess = { pid: 1 };
   const raisedAt = clock;
   await hung.service.fireJob("hung");
   clock = raisedAt + 16 * 60_000;
@@ -1111,12 +1159,12 @@ async function strandedDeliveryProbe(createSchedulerService) {
       admitError: setup.admitError || null,
     };
     const h = schedulerHarness(createSchedulerService, [], options);
-    if (setup.busy) h.state.runningProcess = { pid: 1 };
+    if (setup.busy) jobLane(h.state).runningProcess = { pid: 1 };
     const first = await h.service.fireJob("w");
     assert.strictEqual(faults, 1, `${name}: the write failed`);
     assert.strictEqual(first.ok, false, name);
     assert.strictEqual(h.scheduled.length, 1, `${name}: a retry stays armed after the failed write`);
-    h.state.runningProcess = null;
+    jobLane(h.state).runningProcess = null;
     options.admitError = null;
     clock += 60_000;
     assert.strictEqual((await h.scheduled.at(-1).fn()).ok, true, `${name}: delivered at the next idle moment`);
@@ -1168,7 +1216,7 @@ async function durablePendingProbe(createSchedulerService, jobsApi) {
         jobsStore: store, now: () => clock,
         runWatchCheck: async () => { checks++; return { code: kind === "expiry" ? 1 : 0 }; },
       });
-      h.state.runningProcess = { pid: 1 };
+      jobLane(h.state).runningProcess = { pid: 1 };
       for (let tick = 0; tick < 12; tick++) {
         clock += 60 * 60 * 1000;
         const result = await h.service.fireJob(kind);
@@ -1297,8 +1345,10 @@ function creationEnrichmentProbe(createSchedulerService) {
     settings: { backend: "codex" },
     activeSessions: { alpha: { codex: "thread-alpha" } },
     providerSettings: { codex: { model: "gpt-scheduled", effort: "high" } },
-    activeRunContext: { runId: "origin-run" },
   };
+  // The origin-run fallback reads the job's own conversation only.
+  jobLane(state, "telegram:fixture-channel#thread:bbbbbbbbbbbbbbbbbbbbbbbb").activeRunContext = { runId: "another-thread-run" };
+  jobLane(state, "alpha").activeRunContext = { runId: "origin-run" };
   const service = createSchedulerService({
     jobsStore: memoryJobsStore([]),
     currentState: () => state,
@@ -1325,6 +1375,12 @@ function creationEnrichmentProbe(createSchedulerService) {
   });
   assert.strictEqual(enriched.originRunId, "origin-run");
   assert.strictEqual(enriched.occurrenceId, "origin-occurrence");
+  jobLane(state, "alpha").activeRunContext = null;
+  const unrelated = service.enrichJobSpec({
+    kind: "wakeup", adapter: "telegram-fixture", adapterType: "telegram", channelId: "fixture-channel",
+    canonicalUserId: "fixture-user", project: "alpha", prompt: "later", fireAt: 1,
+  });
+  assert.strictEqual(unrelated.originRunId, null, "another conversation's running turn is never the origin");
 }
 
 function loopbackMetadataProbe(runner, loopbackClient) {
@@ -1576,6 +1632,7 @@ async function main() {
   await failureAndRetryProbe(schedulerApi.createSchedulerService);
   await detachedHistoricalBranchProbe(schedulerApi.createSchedulerService);
   await busyRestartAndMissedProbe(schedulerApi.createSchedulerService);
+  await threadLaneProbe(schedulerApi.createSchedulerService);
   await durablePendingProbe(schedulerApi.createSchedulerService, jobsApi);
   await busyWatchNoticeProbe(schedulerApi.createSchedulerService);
   await pendingDeliveryPollingProbe(schedulerApi.createSchedulerService);

package/test-provider-session-commands.js

@@ -79,16 +79,25 @@ function newEndAndContinueProbe() {
   state.currentSession = { name: "alpha", dir: path.join(workspace, "alpha") };
   state.settings.backend = "codex";
   const settled = [];
-  state.messageQueue = [{ deferred: { resolve: (value) => settled.push(value) } }];
+  const otherSettled = [];
+  // /new clears the CURRENT conversation's queue only (here the lane of the
+  // "alpha" project); another conversation's waiting message survives.
+  const lane = stateApi.laneFor(state, "alpha");
+  const other = stateApi.laneFor(state, "telegram:other#thread:aaaaaaaaaaaaaaaaaaaaaaaa");
+  lane.messageQueue.push({ deferred: { resolve: (value) => settled.push(value) } });
+  other.messageQueue.push({ deferred: { resolve: (value) => otherSettled.push(value) } });
 
   const fresh = handlers.startNewConversation({ state, persist: false });
   assert.strictEqual(fresh.ok, true);
   assert.strictEqual(stateApi.getProviderSession(state, "codex", "alpha"), null);
   assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "claude-alpha");
   assert.strictEqual(stateApi.userOwnsProviderSession(state.userId, "alpha", "codex", "codex-alpha"), true, "new does not delete history");
-  assert.strictEqual(state.messageQueue.length, 0);
+  assert.strictEqual(lane.messageQueue.length, 0);
   assert.strictEqual(settled.length, 1);
   assert.strictEqual(settled[0].status, "cancelled");
+  assert.strictEqual(other.messageQueue.length, 1, "another conversation's queue is untouched");
+  assert.strictEqual(otherSettled.length, 0);
+  other.messageQueue.length = 0;
 
   stateApi.setProviderSession(state, "codex", "alpha", "codex-alpha");
   const continueOptions = handlers.activeContinueOptions(state);

package/test-provider-side-chat.js

@@ -279,6 +279,28 @@ async function coordinatorProbe() {
   assert.strictEqual(failed.ok, false);
   assert.strictEqual(deliveryAttempts.length, 1, "delivery failure must not trigger a second send");
   assert.strictEqual(failingDelivery.isActive("fixture-user"), false);
+
+  // Side chats are per (speaker, conversation): a side answer in one thread
+  // does not make another conversation "busy", and cancelling one
+  // conversation's side chat leaves the other's running.
+  const laneGate = deferred();
+  const perLane = new SideChatCoordinator({
+    tokenFactory: (() => { let n = 0; return () => `lane-token-${++n}`; })(),
+    runSideChat: async () => { await laneGate.promise; return { ok: true, text: "lane answer" }; },
+    deliver: async () => ({ ok: true }),
+    enqueueMain: () => ({ queued: true }),
+  });
+  const threadRun = Object.freeze({ ...first, laneKey: "telegram:x#thread:aaaaaaaaaaaaaaaaaaaaaaaa", runId: "thread-side" });
+  const mainRun = Object.freeze({ ...first, laneKey: "telegram:x", runId: "main-side" });
+  const inThread = perLane.respond({ runContext: threadRun, activeRunContext: active });
+  const inMain = perLane.respond({ runContext: mainRun, activeRunContext: active });
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.strictEqual(perLane.isActive("fixture-user", "telegram:x#thread:aaaaaaaaaaaaaaaaaaaaaaaa"), true);
+  assert.strictEqual(perLane.isActive("fixture-user", "telegram:x"), true, "the main timeline gets its own side answer");
+  assert.strictEqual(await perLane.cancel("fixture-user", "telegram:x"), true);
+  laneGate.resolve();
+  assert.strictEqual((await inMain).status, "cancelled", "the cancelled conversation's side answer is dropped");
+  assert.notStrictEqual((await inThread).status, "cancelled", "the other conversation's side answer is delivered");
 }
 
 function modeAndLineageProbe() {
@@ -294,13 +316,19 @@ function modeAndLineageProbe() {
   assert.strictEqual(readRuntimeMode(modeDir), "agent");
 
   const state = mainState("claude");
-  state.runningProcess = { pid: 123 };
+  // The run slot is the conversation's lane (outside a chat turn: the project).
+  const lane = require("./core/state").laneFor(state, "project-a");
+  lane.runningProcess = { pid: 123 };
   const incoming = captureMainRun(state, "queue me", "lineage-incoming");
   const active = captureMainRun(state, "fresh main", "lineage-main");
-  state.activeRunContext = active;
+  lane.activeRunContext = active;
+  assert.strictEqual(incoming.laneKey, "project-a", "the captured run names its lane");
   assert.strictEqual(shouldStartSideChat(state, incoming, {}, { enabled: () => false }), false);
   assert.strictEqual(shouldStartSideChat(state, incoming, {}, { enabled: () => true }), true);
   assert.strictEqual(shouldStartSideChat(state, incoming, { sideChat: false }, { enabled: () => true }), false);
+  const otherConversation = Object.freeze({ ...incoming, laneKey: "project-a#thread:ffffffffffffffffffffffff" });
+  assert.strictEqual(shouldStartSideChat(state, otherConversation, {}, { enabled: () => true }), false,
+    "another conversation of the speaker is not busy: it runs in its own lane, no side chat");
 
   const request = createSideChatRequest({ runContext: incoming, activeRunContext: active, token: "lineage-token" });
   const pending = createSideChatQueueItem(request, { id: "origin" }, {