@inetafrica/open-claudia 3.5.1 → 3.5.4

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" }, {

package/test-run-lock.js

@@ -1,63 +1,146 @@
-// P0-3: single-flight run-lock regression test. Under unified identity the
-// owner's Telegram and Kazee turns resolve to ONE canonical user and therefore
-// share ONE in-memory state object. If two of those turns could both pass the
-// "is a run in progress?" check they would race the shared state and the JSON
-// files behind it. acquireRunLock() closes that window by arming the lock
-// SYNCHRONOUSLY (no await between the check and the arm), so the second turn is
-// always refused and queued. This test pins that contract on the raw helper.
+// P0-3: single-flight run-lock regression test, per conversation LANE. A lane
+// is one conversation (the channel's main timeline, or one chat thread): turns
+// inside a lane are strictly one at a time, so two turns of one conversation
+// can never both pass the "is a run in progress?" check and race its provider
+// session and the JSON files behind it. acquireRunLock() closes that window by
+// arming the lane SYNCHRONOUSLY (no await between the check and the arm).
+//
+// Deliberate change (parallel conversations): under unified identity the
+// owner's Telegram DM and Kazee chat still resolve to ONE canonical state, but
+// they are DIFFERENT conversations (conversation keys), so they are separate
+// lanes and may now run at the same time, bounded by the per-speaker cap
+// (OC_MAX_PARALLEL_TURNS, default 4) and the global cap. The old test pinned
+// that the second channel was refused; what must hold now is that the SAME
+// conversation is refused, and that the caps bound the rest.
 
 const assert = require("assert");
 process.env.OPEN_CLAUDIA_TEST = "1";
 
-const { acquireRunLock } = require("./core/state");
+const stateApi = require("./core/state");
+const { acquireRunLock, admitLane, laneFor, peekLane, anyTurnActive, waitingLanes } = stateApi;
+
+const MAIN = "telegram:owner";
+const KAZEE = "kazee:owner-chat";
+const THREAD = "kazee:owner-chat#thread:aaaaaaaaaaaaaaaaaaaaaaaa";
+// Fixture states join the global slot count once they hold a lane; each block
+// releases its own so the global cap never carries over between blocks.
+const fixtures = [];
+const fresh = () => { const s = { userId: `owner-${Math.random()}` }; fixtures.push(s); return s; };
+const releaseAll = () => { for (const s of fixtures) { s.lanes?.clear(); stateApi.pruneIdleLanes(s); } };
 
 // A run-lock must be synchronous — its whole point is that no await can
 // interleave between the check and the arm. If this ever returned a Promise the
 // guarantee would silently evaporate.
 {
-  const r = acquireRunLock({ runningProcess: null, preparingRun: false });
+  const r = acquireRunLock(fresh(), MAIN);
   assert.strictEqual(typeof r, "boolean", "acquireRunLock must be synchronous (return a boolean, not a Promise)");
 }
 
-// Idle → acquires and arms preparingRun.
+// Idle lane → acquires and arms the lane's preparingRun, nothing on the state.
 {
-  const s = { runningProcess: null, preparingRun: false };
-  assert.strictEqual(acquireRunLock(s), true, "idle state acquires");
-  assert.strictEqual(s.preparingRun, true, "acquiring arms preparingRun");
+  const s = fresh();
+  assert.strictEqual(acquireRunLock(s, MAIN), true, "idle lane acquires");
+  assert.strictEqual(laneFor(s, MAIN).preparingRun, true, "acquiring arms the lane's preparingRun");
+  assert.strictEqual(s.preparingRun, undefined, "the speaker's state holds no run slot of its own");
+  assert.ok(!Object.keys(s).includes("lanes"), "lanes are not enumerable (never cloned or serialized)");
 }
 
 // Already preparing (armed but not yet spawned) → refused, lock left intact.
 {
-  const s = { runningProcess: null, preparingRun: true };
-  assert.strictEqual(acquireRunLock(s), false, "preparing state is refused");
-  assert.strictEqual(s.preparingRun, true, "refusal leaves the existing lock armed");
+  const s = fresh();
+  laneFor(s, MAIN).preparingRun = true;
+  const refused = admitLane(s, MAIN);
+  assert.strictEqual(refused.ok, false, "preparing lane is refused");
+  assert.strictEqual(refused.reason, "busy");
+  assert.strictEqual(laneFor(s, MAIN).preparingRun, true, "refusal leaves the existing lock armed");
+}
+
+// A process is actively running, or the lane is settling/compacting → refused.
+for (const field of ["runningProcess", "settling", "isCompacting"]) {
+  const s = fresh();
+  laneFor(s, MAIN)[field] = field === "runningProcess" ? { pid: 123 } : true;
+  assert.strictEqual(acquireRunLock(s, MAIN), false, `${field} lane is refused`);
 }
 
-// A process is actively running → refused.
+// THE guarantee: two turns of ONE conversation. Exactly one may acquire; the
+// other must be refused until the first fully releases.
 {
-  const s = { runningProcess: { pid: 123 }, preparingRun: false };
-  assert.strictEqual(acquireRunLock(s), false, "running process is refused");
+  const shared = fresh();
+  const first = acquireRunLock(shared, KAZEE);
+  const second = acquireRunLock(shared, KAZEE);
+  assert.strictEqual(first, true, "first turn wins the lane");
+  assert.strictEqual(second, false, "second turn of the same conversation is refused (no double-acquire)");
+  const lane = laneFor(shared, KAZEE);
+  lane.preparingRun = false;
+  lane.runningProcess = { pid: 1 };
+  assert.strictEqual(acquireRunLock(shared, KAZEE), false, "still refused while the process runs");
+  lane.runningProcess = null;
+  assert.strictEqual(acquireRunLock(shared, KAZEE), true, "lane is re-acquirable once the turn fully releases");
 }
 
-// THE guarantee: two turns sharing ONE state object (owner's Telegram + Kazee
-// under unified identity). Exactly one may acquire; the other must be refused
-// until the first fully releases.
+releaseAll();
+
+// Unified identity: the owner's channels and a thread are separate lanes of
+// ONE state and run in parallel.
 {
-  const shared = { runningProcess: null, preparingRun: false };
+  const owner = fresh();
+  assert.strictEqual(acquireRunLock(owner, MAIN), true, "Telegram DM lane");
+  assert.strictEqual(acquireRunLock(owner, KAZEE), true, "Kazee chat lane runs beside it");
+  assert.strictEqual(acquireRunLock(owner, THREAD), true, "a thread of that chat is its own lane too");
+  assert.strictEqual(laneFor(owner, THREAD).threadId, "aaaaaaaaaaaaaaaaaaaaaaaa", "a thread lane knows its thread");
+  assert.strictEqual(laneFor(owner, KAZEE).threadId, null, "the main timeline has no thread");
+  assert.strictEqual(anyTurnActive(), true, "anyTurnActive sees every lane of every state");
+  releaseAll();
+  assert.strictEqual(anyTurnActive(), false, "and nothing once they are released");
+}
 
-  const first = acquireRunLock(shared);   // Telegram turn arrives
-  const second = acquireRunLock(shared);  // Kazee turn arrives before the first releases
-  assert.strictEqual(first, true, "first turn wins the lock");
-  assert.strictEqual(second, false, "second concurrent turn is refused (no double-acquire)");
+releaseAll();
 
-  // First turn spawns its process, then finishes and clears both flags.
-  shared.preparingRun = false;
-  shared.runningProcess = { pid: 1 };     // spawned
-  assert.strictEqual(acquireRunLock(shared), false, "still refused while the process runs");
-  shared.runningProcess = null;           // turn complete
+// Caps: a speaker may run OC_MAX_PARALLEL_TURNS lanes; the next waits ("cap"),
+// and a lane that waits keeps new messages of its conversation behind it.
+{
+  const prior = process.env.OC_MAX_PARALLEL_TURNS;
+  process.env.OC_MAX_PARALLEL_TURNS = "2";
+  try {
+    const s = fresh();
+    assert.strictEqual(acquireRunLock(s, "k:1"), true);
+    assert.strictEqual(acquireRunLock(s, "k:2"), true);
+    const third = admitLane(s, "k:3");
+    assert.strictEqual(third.ok, false, "the third lane of the speaker waits");
+    assert.strictEqual(third.reason, "cap");
+    assert.strictEqual(third.running, 2, "the notice can say how many are running");
+    assert.strictEqual(third.lane.preparingRun, false, "a waiting lane is not armed");
+    third.lane.messageQueue.push({ queuedAt: 1, seq: 1 });
+    assert.strictEqual(admitLane(s, "k:3").reason, "waiting", "a waiting lane queues its next message behind the first");
+    assert.deepStrictEqual(waitingLanes().filter((w) => w.state === s).map((w) => w.lane.key), ["k:3"]);
+    const other = fresh();
+    assert.strictEqual(acquireRunLock(other, "k:1"), true, "another speaker has slots of its own");
+    laneFor(s, "k:1").preparingRun = false;
+    assert.strictEqual(admitLane(s, "k:4").reason, "cap", "a lane that did not wait still sees the cap while k:3 waits for the freed slot");
+  } finally {
+    releaseAll();
+    if (prior === undefined) delete process.env.OC_MAX_PARALLEL_TURNS;
+    else process.env.OC_MAX_PARALLEL_TURNS = prior;
+  }
+}
 
-  // Now the queued second turn (drained from messageQueue) can proceed.
-  assert.strictEqual(acquireRunLock(shared), true, "lock is re-acquirable once the turn fully releases");
+// The global cap bounds every speaker together.
+{
+  const prior = process.env.OC_MAX_PARALLEL_TURNS_GLOBAL;
+  process.env.OC_MAX_PARALLEL_TURNS_GLOBAL = "1";
+  try {
+    const a = fresh();
+    const b = fresh();
+    assert.strictEqual(acquireRunLock(a, "g:1"), true);
+    const blocked = admitLane(b, "g:2");
+    assert.strictEqual(blocked.ok, false, "another speaker waits when the bot-wide cap is reached");
+    assert.strictEqual(blocked.scope, "global");
+    assert.strictEqual(anyTurnActive(), true, "anyTurnActive sees a running lane of any state");
+  } finally {
+    releaseAll();
+    if (prior === undefined) delete process.env.OC_MAX_PARALLEL_TURNS_GLOBAL;
+    else process.env.OC_MAX_PARALLEL_TURNS_GLOBAL = prior;
+  }
 }
 
 // A /stop flag names the run it stops. Only that run (or a legacy bare `true`)
@@ -65,7 +148,7 @@ const { acquireRunLock } = require("./core/state");
 // "before the provider started" (24 Sep, three messages lost after one /stop).
 {
   const { cancelFlagFor, cancelTargets } = require("./core/state");
-  assert.strictEqual(cancelFlagFor({ activeRunContext: { runId: "run-a" } }), "run-a", "the flag names the active run");
+  assert.strictEqual(cancelFlagFor({ activeRunContext: { runId: "run-a" } }), "run-a", "the flag names the lane's active run");
   assert.strictEqual(cancelFlagFor({ activeRunContext: null }), true, "no known run: a bare flag");
   assert.strictEqual(cancelTargets("run-a", { runId: "run-a" }), true, "the stopped run sees its stop");
   assert.strictEqual(cancelTargets("run-a", { runId: "run-b" }), false, "another run never does");
@@ -82,13 +165,13 @@ const { acquireRunLock } = require("./core/state");
   assert.strictEqual(queuedNotice(null, t0), "Queued.");
   assert.strictEqual(queuedNotice({ admittedAt: t0, userPrompt: "hi" }, t0 + 60_000), "Queued.", "a short wait stays terse");
   assert.strictEqual(queuedNotice({ admittedAt: t0, userPrompt: "hi" }, t0 + 5 * 60_000),
-    "Queued behind an earlier message (running 5 min). /stop cancels it.");
+    "Queued behind an earlier message (running 5 min). /stop cancels it (and drops this message).");
   assert.strictEqual(queuedNotice({ admittedAt: t0, userPrompt: '[Watch triggered "Phone alarm" fired at x; occurrence y]\nbody' }, t0 + 42 * 60_000),
-    'Queued behind the watch "Phone alarm" (running 42 min). /stop cancels it.');
+    'Queued behind the watch "Phone alarm" (running 42 min). /stop cancels it (and drops this message).');
   assert.strictEqual(queuedNotice({ admittedAt: t0, userPrompt: '[Scheduled wakeup "Check CI" fired at x]' }, t0 + 3 * 60_000),
-    'Queued behind the wakeup "Check CI" (running 3 min). /stop cancels it.');
+    'Queued behind the wakeup "Check CI" (running 3 min). /stop cancels it (and drops this message).');
   assert.strictEqual(queuedNotice({ admittedAt: t0, userPrompt: '[Watch check timing out "Phone health" fired at x; occurrence y]' }, t0 + 20 * 60_000),
-    'Queued behind the watch "Phone health" (running 20 min). /stop cancels it.', "a check-timeout alarm is a watch run too");
+    'Queued behind the watch "Phone health" (running 20 min). /stop cancels it (and drops this message).', "a check-timeout alarm is a watch run too");
   const long = queuedNotice({ admittedAt: t0, userPrompt: `[Watch triggered "${"x".repeat(90)}" fired at x]` }, t0 + 3 * 60_000);
   assert.ok(long.includes(`"${"x".repeat(59)}…"`), "a long label is shortened to 60 characters");
 }