@inetafrica/open-claudia 3.5.1 → 3.5.7

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");
 }