@inetafrica/open-claudia 3.5.0 → 3.5.4

package/test-thread-lanes.js

@@ -0,0 +1,530 @@
+#!/usr/bin/env node
+
+"use strict";
+
+// Parallel conversations: the main timeline of a chat and each of its threads
+// are separate LANES. End to end through router.onMessage, the real state,
+// runner, handlers and scheduler, with the hermetic fake agent as the provider
+// (it logs when each run starts and answers, with its OC_THREAD_ID/OC_PROJECT):
+//   - two threads run at the same time (their runs overlap);
+//   - a second message in one thread queues behind the first, then runs;
+//   - the main timeline runs beside a busy thread;
+//   - the per-speaker cap holds: the 5th conversation waits with a notice and
+//     starts when a slot frees;
+//   - /stop in thread X spares thread Y; "/stop all" stops every lane;
+//   - a wakeup made in thread X fires while Y runs and answers inside X;
+//   - typing and the live preview carry each lane's thread;
+//   - anyTurnActive; /compact acts on its own lane while another runs;
+//   - OC_THREAD_SEED=fork seeds a new thread from the main session;
+//   - the runtime state tells the agent about threads and parallel lanes.
+// Plus the wiring around lanes: bounded thread state, room settings resolved
+// from the turn's own context, the run attestation's thread, and injection
+// dedupe per conversation.
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const root = fs.mkdtempSync(path.join(os.tmpdir(), "oc-thread-lanes-"));
+const configDir = path.join(root, "config");
+const workspace = path.join(root, "workspace");
+const runLog = path.join(root, "runs.jsonl");
+fs.mkdirSync(configDir, { recursive: true });
+fs.mkdirSync(workspace, { recursive: true });
+const OWNER = "owner-chat-777";
+process.env.OPEN_CLAUDIA_TEST = "1";
+process.env.OPEN_CLAUDIA_CONFIG_DIR = configDir;
+process.env.WORKSPACE = workspace;
+process.env.TELEGRAM_CHAT_ID = OWNER;
+process.env.CHANNELS = "";
+process.env.PACK_REVIEW = "off";
+process.env.PEOPLE_FILE = path.join(configDir, "people.json");
+process.env.ENTITIES_DIR = path.join(root, "entities");
+process.env.APPROVALS_DIR = path.join(root, "approvals");
+delete process.env.OC_MAX_PARALLEL_TURNS;
+delete process.env.OC_MAX_PARALLEL_TURNS_GLOBAL;
+delete process.env.OC_THREAD_SEED;
+fs.writeFileSync(process.env.PEOPLE_FILE, JSON.stringify([{
+  id: "person_owner", name: "Owner", isOwner: true,
+  handles: [{ adapter: "telegram", channelId: OWNER, canonicalUserId: `telegram:${OWNER}` }],
+  primaryChannel: { adapter: "telegram", channelId: OWNER }, notes: [],
+}]));
+
+const fixture = path.join(__dirname, "test-fixtures", "fake-agent-cli.js");
+
+// ── Provider and prompt: the production runner with the fake agent CLI. The
+// prompt builder is replaced by one that records the REAL runtime-state block.
+const providers = require("./core/providers");
+const { createClaudeProvider } = require("./core/providers/claude");
+const provider = createClaudeProvider({
+  hookTransport: false,
+  resolveExecutable: () => fixture,
+  defaultModel: "claude-fixture-model",
+  getAuthStatus: () => ({ state: "authenticated", reason: null }),
+  buildEnv: () => ({
+    HOME: root,
+    PATH: process.env.PATH || path.dirname(process.execPath),
+    FAKE_AGENT_KIND: "claude",
+    FAKE_AGENT_RUN_LOG: runLog,
+    FAKE_AGENT_UNIQUE_SESSIONS: "1",
+    FAKE_AGENT_TOOL: "1",
+    FAKE_AGENT_NARRATION: "Looking into it first",
+    FAKE_AGENT_TEXT: "fixture answer",
+  }),
+});
+providers.resolveProviderForRun = () => provider;
+const systemPrompt = require("./core/system-prompt");
+const runtimeBlocks = new Map(); // tag -> runtime-state block the run was given
+systemPrompt.buildTurnPrompt = async (prompt, opts = {}) => {
+  const tag = /\[\[tag:([\w-]+)\]\]/.exec(String(prompt))?.[1];
+  let dynamicContext = "";
+  try { dynamicContext = systemPrompt.buildDynamicContextBlock(opts); } catch (error) { dynamicContext = `runtime failed: ${error.message}`; }
+  // First prompt per tag only: a compaction seed replays recent turns (tags included).
+  if (tag && !runtimeBlocks.has(tag)) runtimeBlocks.set(tag, dynamicContext);
+  return { coreInstructions: "Fixture core", dynamicContext: "", userPrompt: prompt, transcriptPaths: {}, recallMetadata: {} };
+};
+require("./core/turn-observer").createTurnObserver = () => ({ onRecallSurfaced() {}, onToolStart() {}, onTurnSettled() {} });
+
+const stateApi = require("./core/state");
+const router = require("./core/router");
+require("./core/handlers");
+const scheduler = require("./core/scheduler");
+const { conversationKeyFor } = require("./core/identity");
+
+// ── A chat adapter that records everything, with the thread each call carries.
+const events = [];
+let nextMessageId = 1000;
+const adapter = {
+  id: "telegram",
+  type: "telegram",
+  async send(channelId, text, opts = {}) {
+    const id = String(nextMessageId++);
+    events.push({ kind: "send", id, channelId, text: String(text), threadId: opts.threadId || null, at: Date.now() });
+    return id;
+  },
+  async edit(channelId, messageId, text, opts = {}) {
+    events.push({ kind: "edit", id: String(messageId), channelId, text: String(text), streaming: !!opts.streaming, at: Date.now() });
+    return true;
+  },
+  async delete(channelId, messageId) {
+    events.push({ kind: "delete", id: String(messageId), channelId, at: Date.now() });
+    return true;
+  },
+  async typing(channelId, state, opts = {}) {
+    events.push({ kind: "typing", channelId, state: state || "typing", threadId: opts.threadId || null, at: Date.now() });
+  },
+  async typingStop(channelId, opts = {}) {
+    events.push({ kind: "typingStop", channelId, threadId: opts.threadId || null, at: Date.now() });
+  },
+  async downloadMedia() { throw new Error("no media in this fixture"); },
+};
+scheduler.setAdapters([adapter]);
+
+const T = (n) => String(n).repeat(24).slice(0, 24); // a 24-hex Kazee-style root id
+const FORK_THREAD = `3${"2".repeat(23)}`;
+const FRESH_THREAD = `5${"4".repeat(23)}`;
+const MAIN_KEY = conversationKeyFor("telegram", OWNER);
+const keyOf = (threadId) => conversationKeyFor("telegram", OWNER, threadId);
+let inbound = 0;
+function message(text, threadId = null) {
+  inbound += 1;
+  return router.onMessage({
+    adapter,
+    channelId: OWNER,
+    threadId,
+    canonicalUserId: `telegram:${OWNER}`,
+    userId: OWNER,
+    type: "text",
+    text,
+    messageId: `in-${inbound}`,
+    from: { name: "Owner" },
+  });
+}
+
+function runs() {
+  if (!fs.existsSync(runLog)) return [];
+  return fs.readFileSync(runLog, "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
+}
+function runOf(tag) {
+  const all = runs().filter((r) => r.tag === tag);
+  return { start: all.find((r) => r.event === "start"), end: all.find((r) => r.event === "end") };
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function until(predicate, label, timeoutMs = 15000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await sleep(25);
+  }
+  throw new Error(`timed out waiting for ${label}`);
+}
+const state = () => stateApi.getUserState(`telegram:${OWNER}`);
+const lane = (key) => stateApi.peekLane(state(), key);
+const sendsIn = (threadId, since = 0) => events.filter((e) => e.kind === "send" && e.threadId === threadId && e.at >= since);
+async function idle() {
+  await until(() => !stateApi.anyTurnActive(), "every lane to go idle");
+}
+
+async function twoThreadsRunConcurrently() {
+  const [a, b] = [T(1), T(2)];
+  const since = Date.now();
+  await Promise.all([
+    message("[[tag:par-a]] [[delay:1200]] first thread", a),
+    message("[[tag:par-b]] [[delay:1200]] second thread", b),
+  ]);
+  const ra = runOf("par-a");
+  const rb = runOf("par-b");
+  assert.ok(ra.start && ra.end && rb.start && rb.end, "both thread runs ran to the end");
+  assert.ok(rb.start.at < ra.end.at && ra.start.at < rb.end.at, "the two threads' runs overlap in time");
+  assert.strictEqual(ra.start.threadId, a, "the run knows its thread (OC_THREAD_ID)");
+  assert.strictEqual(rb.start.threadId, b);
+  assert.strictEqual(ra.start.project, keyOf(a), "each thread is its own conversation (OC_PROJECT)");
+  assert.strictEqual(rb.start.project, keyOf(b));
+  assert.ok(sendsIn(a, since).some((e) => e.text.includes("fixture answer")), "thread A's answer goes into thread A");
+  assert.ok(sendsIn(b, since).some((e) => e.text.includes("fixture answer")), "thread B's answer goes into thread B");
+  assert.ok(!sendsIn(null, since).some((e) => e.text.includes("fixture answer")), "nothing lands in the main timeline");
+  const sessions = state().activeSessions;
+  assert.ok(sessions[keyOf(a)]?.claude && sessions[keyOf(b)]?.claude, "each thread keeps its own provider session");
+  assert.notStrictEqual(sessions[keyOf(a)].claude, sessions[keyOf(b)].claude);
+  await idle();
+}
+
+async function sameThreadQueuesThenRuns() {
+  const a = T(1);
+  const since = Date.now();
+  const first = message("[[tag:q-1]] [[delay:1000]] long one", a);
+  await until(() => lane(keyOf(a))?.runningProcess, "the first run to spawn");
+  const second = message("[[tag:q-2]] quick follow-up", a);
+  await until(() => sendsIn(a, since).some((e) => e.text === "Queued."), "the queued notice");
+  assert.strictEqual(lane(keyOf(a)).messageQueue.length, 1, "the follow-up waits in its thread's lane");
+  await Promise.all([first, second]);
+  const r1 = runOf("q-1");
+  const r2 = runOf("q-2");
+  assert.ok(r2.start.at >= r1.end.at, "inside one conversation turns run one at a time");
+  assert.strictEqual(r2.start.threadId, a);
+  await idle();
+}
+
+async function mainLaneUnaffectedByThread() {
+  const a = T(3);
+  const since = Date.now();
+  const long = message("[[tag:bg-thread]] [[delay:1500]] busy thread", a);
+  await until(() => lane(keyOf(a))?.runningProcess, "the thread run to spawn");
+  await message("[[tag:bg-main]] quick main question");
+  const main = runOf("bg-main");
+  assert.ok(main.end, "the main timeline answered");
+  assert.ok(!runOf("bg-thread").end, "while the thread was still running");
+  assert.strictEqual(main.start.threadId, null, "a main-timeline run has no thread");
+  assert.strictEqual(main.start.project, MAIN_KEY);
+  assert.ok(!sendsIn(null, since).some((e) => e.text === "Queued."), "the main message never queued behind the thread");
+  await long;
+  await idle();
+}
+
+async function capHoldsAndFifthWaits() {
+  assert.strictEqual(stateApi.maxParallelTurns(), 4, "default cap");
+  const threads = [T(4), T(5), T(6)];
+  const since = Date.now();
+  const running = [
+    message("[[tag:cap-main]] [[delay:1500]] main"),
+    ...threads.map((t, i) => message(`[[tag:cap-${i}]] [[delay:1500]] thread ${i}`, t)),
+  ];
+  await until(() => stateApi.runningLanes(state()).length === 4, "four running lanes");
+  const fifth = T(7);
+  const waiting = message("[[tag:cap-fifth]] fifth conversation", fifth);
+  await until(() => sendsIn(fifth, since).some((e) => e.text.startsWith("Waiting:")), "the waiting notice");
+  const notice = sendsIn(fifth, since).find((e) => e.text.startsWith("Waiting:"));
+  assert.strictEqual(notice.text, "Waiting: 4 conversations are already running; this starts when one finishes.");
+  assert.strictEqual(stateApi.runningLanes(state()).length, 4, "the cap holds");
+  const statusSince = Date.now();
+  await message("/status");
+  const status = sendsIn(null, statusSince).find((e) => e.text.includes("Running conversations:"));
+  assert.ok(status, "/status lists the running conversations");
+  assert.match(status.text, /Running conversations: 4 \(1 waiting for a slot\)/);
+  assert.match(status.text, /\n- main: ".*main"/);
+  assert.match(status.text, /\n- thread …444444: ".*thread 0"/);
+  assert.ok(stateApi.anyTurnActive(), "anyTurnActive while lanes run");
+  await Promise.all([...running, waiting]);
+  const firstEnd = Math.min(...["cap-main", "cap-0", "cap-1", "cap-2"].map((tag) => runOf(tag).end.at));
+  assert.ok(runOf("cap-fifth").start.at >= firstEnd, "the fifth starts only once a slot frees");
+  assert.strictEqual(runOf("cap-fifth").start.threadId, fifth);
+  await idle();
+  assert.strictEqual(stateApi.anyTurnActive(), false, "anyTurnActive is false once every lane is idle");
+}
+
+async function stopInOneThreadSparesTheOther() {
+  const [x, y] = [T(8), T(9)];
+  const since = Date.now();
+  const inX = message("[[tag:stop-x]] [[delay:8000]] long x", x);
+  const inY = message("[[tag:stop-y]] [[delay:1500]] y", y);
+  await until(() => lane(keyOf(x))?.runningProcess && lane(keyOf(y))?.runningProcess, "both runs to spawn");
+  await message("/stop", x);
+  assert.ok(sendsIn(x, since).some((e) => e.text === "Cancelled."), "/stop answers in thread X");
+  await inX;
+  assert.ok(!runOf("stop-x").end, "thread X's run was stopped");
+  await inY;
+  assert.ok(runOf("stop-y").end, "thread Y ran to the end");
+  assert.ok(sendsIn(y, since).some((e) => e.text.includes("fixture answer")), "and delivered its answer");
+  assert.ok(!sendsIn(x, since).some((e) => e.text.includes("fixture answer")), "X delivered nothing after /stop");
+  assert.ok(events.some((e) => e.kind === "typingStop" && e.threadId === x && e.at >= since), "X's typing stopped inside X");
+  await idle();
+}
+
+async function stopAllStopsEveryLane() {
+  const a = T("a");
+  const since = Date.now();
+  const inMain = message("[[tag:all-main]] [[delay:8000]] main");
+  const inThread = message("[[tag:all-thread]] [[delay:8000]] thread", a);
+  await until(() => lane(MAIN_KEY)?.runningProcess && lane(keyOf(a))?.runningProcess, "both runs to spawn");
+  await message("/stop all");
+  assert.ok(sendsIn(null, since).some((e) => e.text === "Cancelled 2 running conversations."), "/stop all reports both");
+  await Promise.all([inMain, inThread]);
+  assert.ok(!runOf("all-main").end && !runOf("all-thread").end, "neither run finished");
+  await idle();
+}
+
+async function wakeupFiresIntoItsThread() {
+  const [x, y] = [T("b"), T("c")];
+  const since = Date.now();
+  const inY = message("[[tag:wake-y]] [[delay:2500]] y keeps running", y);
+  await until(() => lane(keyOf(y))?.runningProcess, "thread Y's run to spawn");
+  const job = scheduler.addJob({
+    kind: "wakeup",
+    adapter: "telegram",
+    adapterType: "telegram",
+    channelId: OWNER,
+    canonicalUserId: `telegram:${OWNER}`,
+    userId: OWNER,
+    provider: "claude",
+    project: keyOf(x),
+    threadId: x,
+    sessionId: null,
+    label: "thread wake",
+    prompt: "[[tag:wake-x]] wake up in x",
+    fireAt: Date.now() + 60 * 60 * 1000,
+  });
+  const fired = await scheduler.fireJob(job.id);
+  assert.strictEqual(fired.ok, true, `the wakeup ran: ${JSON.stringify(fired.error || fired.status)}`);
+  const wake = runOf("wake-x");
+  assert.ok(wake.end, "the wakeup's run answered");
+  assert.ok(!runOf("wake-y").end, "while thread Y was still running");
+  assert.strictEqual(wake.start.threadId, x, "the wakeup's run is in thread X");
+  assert.strictEqual(wake.start.project, keyOf(x));
+  assert.ok(sendsIn(x, since).some((e) => e.text.startsWith("Wakeup: thread wake")), "the wakeup notice lands in thread X");
+  assert.ok(sendsIn(x, since).some((e) => e.text.includes("fixture answer")), "and so does its answer");
+  await inY;
+  await idle();
+}
+
+async function typingAndPreviewCarryTheirThread() {
+  const [p, q] = [T("d"), T("e")];
+  const since = Date.now();
+  await Promise.all([
+    message("[[tag:pv-p]] [[chunkdelay:1100]] preview p", p),
+    message("[[tag:pv-q]] [[chunkdelay:1100]] preview q", q),
+  ]);
+  for (const thread of [p, q]) {
+    assert.ok(events.some((e) => e.kind === "typing" && e.threadId === thread && e.at >= since), `typing goes into thread ${thread}`);
+    const preview = sendsIn(thread, since).find((e) => e.text.includes("⏳ working"));
+    assert.ok(preview, `the live preview of thread ${thread} is posted into it`);
+    // Every edit/delete of that preview message stays with that message.
+    const touches = events.filter((e) => (e.kind === "edit" || e.kind === "delete") && e.id === preview.id);
+    assert.ok(touches.length >= 1, "the preview is settled when the run ends");
+  }
+  const previews = [p, q].map((thread) => sendsIn(thread, since).find((e) => e.text.includes("⏳ working")).id);
+  assert.notStrictEqual(previews[0], previews[1], "each run owns its own preview message");
+  assert.ok(!events.some((e) => e.kind === "typing" && e.threadId === null && e.at >= since), "no typing leaks into the main timeline");
+  await idle();
+}
+
+async function compactionActsOnItsOwnLane() {
+  const [x, y] = [T("f"), T(1)];
+  assert.ok(state().activeSessions[keyOf(y)]?.claude, "thread has a session to compact");
+  const since = Date.now();
+  const inX = message("[[tag:cmp-x]] [[delay:3000]] keep x busy", x);
+  await until(() => lane(keyOf(x))?.runningProcess, "thread X's run to spawn");
+  const before = state().activeSessions[keyOf(y)].claude;
+  await message("/compact", y);
+  const reply = sendsIn(y, since).find((e) => /Compacted into a fresh session|Could not compact|Compaction failed/.test(e.text));
+  assert.ok(reply && reply.text.startsWith("Compacted into a fresh session"), `compaction of thread Y: ${reply?.text}`);
+  assert.ok(!runOf("cmp-x").end, "thread X was still running: compaction never waited for it");
+  assert.notStrictEqual(state().activeSessions[keyOf(y)].claude, before, "thread Y moved to its compacted session");
+  assert.ok(lane(keyOf(x))?.runningProcess, "and X's lane was untouched");
+  await inX;
+  await idle();
+}
+
+async function forkSeedsANewThreadFromMain() {
+  const mainSession = state().activeSessions[MAIN_KEY]?.claude;
+  assert.ok(mainSession, "the main timeline has a session");
+  process.env.OC_THREAD_SEED = "fork";
+  try {
+    await message("[[tag:fork-new]] start a forked thread", FORK_THREAD);
+  } finally {
+    delete process.env.OC_THREAD_SEED;
+  }
+  const fork = runOf("fork-new");
+  assert.strictEqual(fork.start.fork, true, "the first turn of a thread resumes main with --fork-session");
+  assert.strictEqual(fork.start.resume, mainSession, "it resumes (forks) the main session");
+  // …but the turn's own session is not the main one: jobs and approvals made
+  // in it must never carry the main id.
+  assert.notStrictEqual(fork.start.sessionEnv, mainSession, "OC_SESSION_ID is never the main session in a fork turn");
+  assert.notStrictEqual(fork.start.lastSessionEnv, mainSession, "nor is OC_LAST_SESSION_ID");
+  const threadKey = keyOf(FORK_THREAD);
+  const threadSession = state().activeSessions[threadKey]?.claude;
+  assert.ok(threadSession && threadSession !== mainSession, "the thread got a session of its own");
+  assert.strictEqual(state().activeSessions[MAIN_KEY].claude, mainSession, "the main session is untouched");
+  await message("[[tag:fork-again]] second turn", FORK_THREAD);
+  assert.strictEqual(runOf("fork-again").start.fork, false, "later turns resume the thread's own session");
+  await message("[[tag:fresh-default]] default seed", FRESH_THREAD);
+  assert.strictEqual(runOf("fresh-default").start.fork, false, "the default is a fresh thread");
+  await idle();
+
+  // A thread job that stored the MAIN session id (an older build's fork turn)
+  // never resumes it: it resumes the thread's own session, or runs fresh when
+  // the thread has none, and never pins the thread to the main session.
+  const wake = (threadId, tag) => scheduler.addJob({
+    kind: "wakeup", adapter: "telegram", adapterType: "telegram", channelId: OWNER,
+    canonicalUserId: `telegram:${OWNER}`, userId: OWNER, provider: "claude",
+    project: keyOf(threadId), threadId, sessionId: mainSession, label: "main id wake",
+    prompt: `[[tag:${tag}]] wake`, fireAt: Date.now() + 60 * 60 * 1000,
+  });
+  const ownSession = state().activeSessions[threadKey].claude;
+  assert.strictEqual((await scheduler.fireJob(wake(FORK_THREAD, "wake-main-id").id)).ok, true);
+  assert.strictEqual(runOf("wake-main-id").start.resume, ownSession, "the job resumes the thread's own session, not main");
+  const orphan = `7${"6".repeat(23)}`;
+  assert.strictEqual((await scheduler.fireJob(wake(orphan, "wake-orphan").id)).ok, true);
+  assert.strictEqual(runOf("wake-orphan").start.resume, null, "a thread with no session of its own runs fresh");
+  assert.notStrictEqual(state().activeSessions[keyOf(orphan)]?.claude, mainSession, "and is not pinned to the main session");
+  assert.strictEqual(state().activeSessions[MAIN_KEY].claude, mainSession, "the main session is untouched");
+  await idle();
+}
+
+function runtimeStateTellsTheAgent() {
+  const par = runtimeBlocks.get("par-a") || "";
+  assert.match(par, /Thread: this conversation is a Kazee thread \(replies go into the thread\)/);
+  // Whichever of the two threads built its prompt second saw the other running.
+  const parallel = [runtimeBlocks.get("par-a") || "", runtimeBlocks.get("par-b") || ""]
+    .join("\n").match(/- Parallel conversations running now: .*/g) || [];
+  assert.ok(parallel.some((line) => /running now: 1 \(thread …(1{6}|2{6}): (first thread|second thread)\)/.test(line)),
+    `a thread is told the other thread is running: ${parallel.join(" | ")}`);
+  assert.ok(parallel.every((line) => line.endsWith("Do not edit a git checkout another conversation is using; make your own worktree.")));
+  const main = runtimeBlocks.get("bg-main") || "";
+  assert.doesNotMatch(main, /Thread: this conversation/, "the main timeline is not a thread");
+  assert.match(main, /Parallel conversations running now: 1 \(thread …3{6}: busy thread\)/);
+}
+
+async function wiringAndBounds() {
+  const { runInChat } = require("./core/context");
+  const runner = require("./core/runner");
+  const attest = require("./core/speaker-attest");
+
+  // activeSessions keeps at most MAX_THREAD_SESSIONS thread pointers, oldest
+  // written first out; channel keys and busy threads are never evicted.
+  const s = { userId: "growth", activeSessions: { [MAIN_KEY]: { claude: "main" } } };
+  const max = stateApi.MAX_THREAD_SESSIONS;
+  const threadKey = (n) => keyOf(`${String(n).padStart(24, "0")}`);
+  stateApi.laneFor(s, threadKey(0)).runningProcess = { pid: 1 };
+  for (let n = 0; n < max + 5; n += 1) stateApi.setProviderSession(s, "claude", threadKey(n), `t-${n}`);
+  const threadKeys = Object.keys(s.activeSessions).filter((key) => key.includes("#thread:"));
+  assert.strictEqual(threadKeys.length, max, "thread session pointers are bounded");
+  assert.ok(s.activeSessions[MAIN_KEY], "the channel's own session is never evicted");
+  assert.ok(s.activeSessions[threadKey(0)], "a running thread is never evicted");
+  assert.ok(!s.activeSessions[threadKey(1)], "the least recently used idle thread goes first");
+  assert.ok(s.activeSessions[threadKey(max + 4)], "the newest thread stays");
+  s.lanes.clear();
+
+  // usageBySession is partitioned: threads never push channels' usage out.
+  const u = { userId: "usage", usageBySession: {} };
+  for (let n = 0; n < 10; n += 1) stateApi.getUsageForSession(u, `telegram:chan-${n}`, "claude", `s-${n}`);
+  for (let n = 0; n < stateApi.MAX_USAGE_ENTRIES + 20; n += 1) stateApi.getUsageForSession(u, threadKey(n), "claude", `t-${n}`);
+  const usageKeys = Object.keys(u.usageBySession);
+  assert.strictEqual(usageKeys.filter((key) => !key.includes("#thread:")).length, 10, "every channel keeps its usage record");
+  assert.strictEqual(usageKeys.filter((key) => key.includes("#thread:")).length, stateApi.MAX_USAGE_ENTRIES + 20, "threads have a budget of their own");
+
+  // Room settings come from the turn's own context, never from a stamp on the
+  // shared state: one speaker answering in two rooms at once keeps them apart,
+  // and a thread's room is its channel.
+  stateApi.setRoomSetting("telegram:room-a", "backend", "claude");
+  stateApi.setRoomSetting("telegram:room-b", "backend", "codex");
+  const speaker = stateApi.getUserState("telegram:two-rooms");
+  const inRoom = (room, threadId) => runInChat({
+    channelId: room, canonicalUserId: "telegram:two-rooms",
+    conversationKey: conversationKeyFor("telegram", room, threadId), roomKey: conversationKeyFor("telegram", room),
+  }, async () => {
+    stateApi.currentState();
+    await sleep(20);
+    return stateApi.getActiveProvider(speaker);
+  });
+  const [a, b] = await Promise.all([inRoom("room-a"), inRoom("room-b", T(6))]);
+  assert.deepStrictEqual([a, b], ["claude", "codex"], "each concurrent turn resolves its own room");
+  const threadRoom = runInChat({ channelId: "room-b", conversationKey: conversationKeyFor("telegram", "room-b", T(6)) },
+    () => stateApi.activeRoomKey());
+  assert.strictEqual(threadRoom, "telegram:room-b", "a thread without an explicit room resolves to its channel's room");
+  assert.strictEqual(speaker.roomKey, undefined, "nothing is stamped on the state");
+
+  // The run attestation names the thread, and the run's env carries it.
+  const runContext = {
+    runId: "attest-thread-run", purpose: "foreground", provider: "claude", channelId: OWNER, threadId: T(7),
+    canonicalUserId: `telegram:${OWNER}`, project: { name: keyOf(T(7)), dir: workspace },
+    origin: { adapterId: "telegram", transport: "telegram", channelId: OWNER, userId: OWNER, canonicalUserId: `telegram:${OWNER}` },
+  };
+  assert.strictEqual(runner.runPrincipal(runContext).threadId, T(7));
+  const env = runner.decorateForegroundInvocation({ env: {} }, runContext, { transcriptPaths: null }).env;
+  assert.strictEqual(env.OC_THREAD_ID, T(7), "OC_THREAD_ID is set for a thread turn");
+  assert.strictEqual(attest.verifyRun("attest-thread-run", env.OC_RUN_ATTEST).threadId, T(7), "the attested principal carries the thread");
+  attest.endRun("attest-thread-run");
+  const mainEnv = runner.decorateForegroundInvocation({ env: {} }, { ...runContext, runId: "attest-main", threadId: null }, { transcriptPaths: null }).env;
+  assert.ok(!("OC_THREAD_ID" in mainEnv), "no OC_THREAD_ID on the main timeline");
+  assert.strictEqual(attest.verifyRun("attest-main", mainEnv.OC_RUN_ATTEST).threadId, null);
+  attest.endRun("attest-main");
+
+  // The pending-task tree is injected once per CONVERSATION: the main timeline
+  // and a thread each get it once, and switching between them does not make
+  // either one re-inject it.
+  require("./core/tasks").add("telegram", "dedupe-chan", "a pending fixture task");
+  const block = (threadId) => runInChat({
+    adapter: { id: "telegram", type: "telegram" }, channelId: "dedupe-chan",
+    conversationKey: conversationKeyFor("telegram", "dedupe-chan", threadId),
+  }, () => systemPrompt.buildDynamicContextBlock({
+    state: speaker,
+    runContext: {
+      provider: "claude", canonicalUserId: speaker.userId, sessionId: threadId ? "thread-session" : "main-session",
+      laneKey: conversationKeyFor("telegram", "dedupe-chan", threadId),
+      project: { name: conversationKeyFor("telegram", "dedupe-chan", threadId), dir: workspace },
+    },
+  }));
+  const full = (text) => text.includes("## Pending tasks\n");
+  assert.ok(full(block(null)), "main timeline: full tree first");
+  assert.ok(full(block(T(8))), "thread: full tree first");
+  assert.ok(!full(block(null)), "back in the main timeline: only the count (not re-injected)");
+  assert.ok(!full(block(T(8))), "back in the thread: only the count");
+}
+
+(async () => {
+  const deadline = setTimeout(() => { console.error("test-thread-lanes: overall timeout"); process.exit(1); }, 170000);
+  try {
+    await wiringAndBounds();
+    await twoThreadsRunConcurrently();
+    await sameThreadQueuesThenRuns();
+    await mainLaneUnaffectedByThread();
+    await capHoldsAndFifthWaits();
+    await stopInOneThreadSparesTheOther();
+    await stopAllStopsEveryLane();
+    await wakeupFiresIntoItsThread();
+    await typingAndPreviewCarryTheirThread();
+    await compactionActsOnItsOwnLane();
+    await forkSeedsANewThreadFromMain();
+    runtimeStateTellsTheAgent();
+    console.log("thread lanes OK");
+  } finally {
+    clearTimeout(deadline);
+    try { scheduler.stopAll(); } catch (_) {}
+  }
+  process.exit(0);
+})().catch((error) => {
+  console.error(error.stack || error);
+  console.error(JSON.stringify(events.slice(-30), null, 1));
+  process.exit(1);
+});

package/core/queue-drain.js

@@ -1,25 +0,0 @@
-// Pure helpers for origin-aware queue draining. Kept separate from the runner
-// so the grouping logic — which decides where a drained reply is routed under
-// unified identity — is unit-testable without spawning a run.
-
-// A queued message's origin channel, or a sentinel for legacy items that were
-// queued before origin capture existed (those fall back to the finishing turn's
-// context, exactly as before).
-function originKey(item) {
-  return item && item.origin ? `${item.origin.transport}:${item.origin.channelId}` : "__current__";
-}
-
-// Split the leading run of same-origin messages off the front of the queue.
-// Returns { group, rest }: `group` is the contiguous same-origin prefix (to run
-// now, scoped to that origin), `rest` is everything after it (to be requeued so
-// the natural close→drain tail-recursion handles the next origin group). For a
-// non-empty queue, `group` always has at least one item.
-function splitLeadingOriginGroup(queue) {
-  if (!Array.isArray(queue) || queue.length === 0) return { group: [], rest: [] };
-  const firstKey = originKey(queue[0]);
-  let i = 0;
-  while (i < queue.length && originKey(queue[i]) === firstKey) i++;
-  return { group: queue.slice(0, i), rest: queue.slice(i) };
-}
-
-module.exports = { originKey, splitLeadingOriginGroup };

package/test-queue-routing.js

@@ -1,52 +0,0 @@
-// Origin-aware queue draining. Under unified identity the owner's channels
-// share one run-lock and message queue, so a message queued from one channel
-// during a run on another must still be answered on its own channel. These
-// tests lock in the grouping that guarantees that routing.
-
-const assert = require("assert");
-const { originKey, splitLeadingOriginGroup } = require("./core/queue-drain");
-
-const tg = (id) => ({ prompt: `m${id}`, origin: { transport: "telegram", channelId: "6251055967" } });
-const kz = (id) => ({ prompt: `m${id}`, origin: { transport: "kazee", channelId: "abc" } });
-const legacy = (id) => ({ prompt: `m${id}` }); // queued before origin capture
-
-// originKey
-assert.strictEqual(originKey(tg(1)), "telegram:6251055967", "telegram key");
-assert.strictEqual(originKey(kz(1)), "kazee:abc", "kazee key");
-assert.strictEqual(originKey(legacy(1)), "__current__", "legacy → sentinel");
-
-// Empty queue
-assert.deepStrictEqual(splitLeadingOriginGroup([]), { group: [], rest: [] }, "empty");
-
-// All one origin → single group, no remainder (the common case: preserves the
-// prior single-batch behaviour, now scoped to that origin).
-{
-  const q = [tg(1), tg(2), tg(3)];
-  const { group, rest } = splitLeadingOriginGroup(q);
-  assert.strictEqual(group.length, 3, "same-origin: all grouped");
-  assert.strictEqual(rest.length, 0, "same-origin: nothing requeued");
-}
-
-// Mixed origins → only the leading same-origin run comes out; the rest is
-// requeued so the next drain routes it to its own channel.
-{
-  const q = [tg(1), tg(2), kz(3), tg(4)];
-  const { group, rest } = splitLeadingOriginGroup(q);
-  assert.deepStrictEqual(group.map((m) => m.prompt), ["m1", "m2"], "leading telegram group");
-  assert.deepStrictEqual(rest.map((m) => m.prompt), ["m3", "m4"], "kazee + later telegram requeued");
-  // Draining the remainder next peels off the kazee message on its own.
-  const next = splitLeadingOriginGroup(rest);
-  assert.deepStrictEqual(next.group.map((m) => m.prompt), ["m3"], "next drain: kazee alone");
-  assert.deepStrictEqual(next.rest.map((m) => m.prompt), ["m4"], "next drain: trailing telegram requeued");
-}
-
-// Legacy items (no origin) group together under the sentinel and fall back to
-// the finishing turn's context — matching pre-change behaviour.
-{
-  const q = [legacy(1), legacy(2), tg(3)];
-  const { group, rest } = splitLeadingOriginGroup(q);
-  assert.deepStrictEqual(group.map((m) => m.prompt), ["m1", "m2"], "legacy grouped");
-  assert.deepStrictEqual(rest.map((m) => m.prompt), ["m3"], "origin item requeued");
-}
-
-console.log("queue-routing OK");