switchroom 0.14.91 → 0.14.93

package/telegram-plugin/gateway/turn-active-marker.ts

@@ -174,3 +174,25 @@ export function sweepStaleTurnActiveMarker(
     return false;
   }
 }
+
+/**
+ * Age (ms) of the turn-active marker's mtime, or null if the marker is
+ * absent/unstattable. The marker is touched on every foreground tool_use AND
+ * (via the subagent-watcher, #501) on foreground sub-agent JSONL growth — so a
+ * SMALL age means the agent, or an orphaned/extended-autonomous foreground
+ * sub-agent that outlived its turn (#2240), is actively working RIGHT NOW, even
+ * though the turn-in-flight machine has gone idle. A large age (or null) means
+ * the work stopped or the marker leaked. Used by the obligation sweep to avoid a
+ * false "did I miss this? re-send" escalation while genuine post-turn work is in
+ * flight. Pure read; clock injectable for tests. Never throws — a stat failure
+ * is reported as null (treated as "not working").
+ */
+export function readTurnActiveMarkerAgeMs(stateDir: string, now?: number): number | null {
+  const path = join(stateDir, TURN_ACTIVE_MARKER_FILE);
+  try {
+    const st = statSync(path);
+    return (now ?? Date.now()) - st.mtimeMs;
+  } catch {
+    return null; // ENOENT / unstattable → not working
+  }
+}

package/telegram-plugin/tests/cron-session.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest'
+import {
+  CRON_IDENTITY_SUFFIX,
+  baseAgent,
+  cronIdentity,
+  isCronIdentity,
+  resolveInjectTarget,
+} from '../gateway/cron-session.js'
+
+describe('cron-session identity helpers', () => {
+  it('derives and detects the cron identity', () => {
+    expect(cronIdentity('clerk')).toBe(`clerk${CRON_IDENTITY_SUFFIX}`)
+    expect(isCronIdentity('clerk-cron')).toBe(true)
+    expect(isCronIdentity('clerk')).toBe(false)
+    expect(isCronIdentity(null)).toBe(false)
+    expect(isCronIdentity(undefined)).toBe(false)
+  })
+
+  it('round-trips base agent', () => {
+    expect(baseAgent(cronIdentity('marko'))).toBe('marko')
+    expect(baseAgent('marko')).toBe('marko')
+  })
+
+  it('resolveInjectTarget routes only meta.session=cron to the cron bridge', () => {
+    expect(resolveInjectTarget('clerk', { session: 'cron', source: 'cron' })).toBe('clerk-cron')
+    expect(resolveInjectTarget('clerk', { session: 'main', source: 'cron' })).toBe('clerk')
+    expect(resolveInjectTarget('clerk', { source: 'cron' })).toBe('clerk')
+    expect(resolveInjectTarget('clerk', undefined)).toBe('clerk')
+    // back-compat: every legacy caller (no session) is unchanged.
+    expect(resolveInjectTarget('clerk', { source: 'telegram' })).toBe('clerk')
+  })
+})

package/telegram-plugin/tests/obligation-determinism.test.ts

@@ -89,7 +89,13 @@ interface Sim {
   steps: number;
 }
 
-function runSchedule(msgs: Msg[], seed: number, graceMs = 0): Sim {
+function runSchedule(
+  msgs: Msg[],
+  seed: number,
+  graceMs = 0,
+  bgGraceMs = 0,
+  bgAlwaysActive = false,
+): Sim {
   const PATH = "/state/agent/telegram/obligations.json";
   const store = memStore();
   let ledger = new ObligationLedger(MAX_REPRESENTS, {
@@ -148,12 +154,23 @@ function runSchedule(msgs: Msg[], seed: number, graceMs = 0): Sim {
         threadId: 3,
         messageId: m.msgId,
         text: `msg ${m.id}`,
-        openedAt: 1000 + steps,
+        // When the background-work ceiling is exercised it is measured from
+        // openedAt against `clock`, so openedAt must live on the same virtual
+        // clock (the legacy proofs keep the tiny 1000+steps value — they never
+        // read openedAt against `now`).
+        openedAt: bgGraceMs > 0 ? clock : 1000 + steps,
       });
       deliverTurn(m.id); // original turn (attempt 0)
     } else if (open) {
       const decision =
-        graceMs > 0 ? ledger.decideAtIdle({ now: clock, graceMs }) : ledger.decideAtIdle();
+        graceMs > 0 || bgGraceMs > 0
+          ? ledger.decideAtIdle({
+              now: clock,
+              graceMs,
+              backgroundWorkActive: bgGraceMs > 0 && bgAlwaysActive,
+              backgroundGraceMs: bgGraceMs,
+            })
+          : ledger.decideAtIdle();
       if (decision.action === "none") {
         // Every open obligation is within its grace window — the sweep waits.
         // Advance the clock so grace deterministically expires; no livelock.
@@ -280,6 +297,49 @@ describe("obligation determinism — every inbound reaches a terminal, no silent
     }
   });
 
+  it("holds across 3000 schedules WITH background-work grace PERPETUALLY active (ceiling forces a terminal, never prevents one)", () => {
+    // The hardest case for the new bound: the agent appears to be doing
+    // autonomous sub-agent work for the ENTIRE run (backgroundWorkActive never
+    // clears). The ledger must still drive every obligation to its correct
+    // terminal — proving the OBLIGATION_BACKGROUND_WORK_GRACE_MS ceiling makes
+    // the suppression bounded BY CONSTRUCTION (no livelock, no silent loss), and
+    // that, like the trailing-answer grace, it only DELAYS: the terminal each
+    // message reaches is IDENTICAL to the no-grace run. If always-on terminates
+    // correctly, every intermittent work pattern does too (strictly less
+    // suppression).
+    const ANSWER = [0, 1, 2, 3, 99];
+    const ESCFAIL = [0, 1, 2, 3, 5];
+    const GRACE_MS = 45_000;
+    const BG_CEIL_MS = 20 * 60_000; // mirrors OBLIGATION_BACKGROUND_WORK_GRACE_MS default
+    for (let seed = 1; seed <= 3000; seed++) {
+      const r = rng(seed * 7919);
+      const n = 1 + Math.floor(r() * 5);
+      const msgs: Msg[] = [];
+      for (let i = 0; i < n; i++) {
+        const msgId = seed * 100 + i;
+        msgs.push({
+          id: `c:3#${msgId}`,
+          msgId,
+          answerOnAttempt: pick(ANSWER, r),
+          escalateFailsFor: pick(ESCFAIL, r),
+        });
+      }
+      const { terminals, steps } = runSchedule(msgs, seed * 104729, GRACE_MS, BG_CEIL_MS, true);
+      expect(steps).toBeLessThan(10_000); // ceiling forces progress — no bg-grace livelock
+      for (const m of msgs) {
+        const t = terminals.get(m.id);
+        expect(t, `bg seed=${seed} msg=${m.id} answer=${m.answerOnAttempt} escFail=${m.escalateFailsFor}`).toBeDefined();
+        if (m.answerOnAttempt <= MAX_REPRESENTS) {
+          expect(t).toBe("answered");
+        } else if (m.escalateFailsFor < ESCALATE_MAX) {
+          expect(t).toBe("escalation-delivered");
+        } else {
+          expect(t).toBe("escalation-give-up");
+        }
+      }
+    }
+  });
+
   it("a delivered-but-unanswered obligation survives a restart and is escalated, not lost", () => {
     // Deterministic single case: model NEVER answers, escalation succeeds first try,
     // with a restart forced mid-life via a seed that triggers the 0.15 branch.

package/telegram-plugin/tests/obligation-ledger.test.ts

@@ -326,3 +326,88 @@ describe("ObligationLedger — escalate-grace window (over-escalation fix)", ()
     expect(L.decideAtIdle({ now: 142000, graceMs: 45000 }).action).toBe("escalate");
   });
 });
+
+describe("ObligationLedger — background-work grace (extended-autonomous fix, gymbro 2026-06-10)", () => {
+  function input(id: string, openedAt: number) {
+    return { originTurnId: id, chatId: "-100123", threadId: 3, messageId: Number(id.split("#").pop() ?? 0), text: "research liven", openedAt };
+  }
+  // 20-min ceiling, mirroring OBLIGATION_BACKGROUND_WORK_GRACE_MS default.
+  const CEIL = 20 * 60_000;
+
+  it("skips an obligation younger than the ceiling while background work is active", () => {
+    const L = new ObligationLedger();
+    L.openIfAbsent(input("c:3#1", 1000)); // opened at t=1000
+    // 5 min later, a worker is running → genuine work in flight → wait.
+    expect(
+      L.decideAtIdle({ now: 1000 + 5 * 60_000, graceMs: 45000, backgroundWorkActive: true, backgroundGraceMs: CEIL }).action,
+    ).toBe("none");
+  });
+
+  it("acts once the obligation crosses the ceiling EVEN IF work is still active (bounded — no silent drop)", () => {
+    const L = new ObligationLedger();
+    L.openIfAbsent(input("c:3#1", 1000));
+    // 20m + 1s after openedAt, still flagged active → ceiling wins → act.
+    expect(
+      L.decideAtIdle({ now: 1000 + CEIL + 1000, graceMs: 45000, backgroundWorkActive: true, backgroundGraceMs: CEIL }).action,
+    ).toBe("represent");
+  });
+
+  it("backgroundWorkActive=false → no extra grace (pre-fix behaviour on this axis)", () => {
+    const L = new ObligationLedger();
+    L.openIfAbsent(input("c:3#1", 1000)); // still-queued, no turn end
+    expect(
+      L.decideAtIdle({ now: 2000, graceMs: 45000, backgroundWorkActive: false, backgroundGraceMs: CEIL }).action,
+    ).toBe("represent");
+  });
+
+  it("backgroundGraceMs=0 (kill switch) → work signal ignored, acts immediately", () => {
+    const L = new ObligationLedger();
+    L.openIfAbsent(input("c:3#1", 1000));
+    expect(
+      L.decideAtIdle({ now: 2000, graceMs: 45000, backgroundWorkActive: true, backgroundGraceMs: 0 }).action,
+    ).toBe("represent");
+  });
+
+  it("composes with the trailing-answer grace: both must clear before acting", () => {
+    const L = new ObligationLedger();
+    L.openIfAbsent(input("c:3#1", 1000));
+    L.noteTurnEnded("c:3#1", 5000);
+    // turn-end grace cleared (60s later) but within bg ceiling + work active → still wait.
+    expect(
+      L.decideAtIdle({ now: 65000, graceMs: 45000, backgroundWorkActive: true, backgroundGraceMs: CEIL }).action,
+    ).toBe("none");
+    // same instant, work no longer active → trailing grace already clear → act.
+    expect(
+      L.decideAtIdle({ now: 65000, graceMs: 45000, backgroundWorkActive: false, backgroundGraceMs: CEIL }).action,
+    ).toBe("represent");
+  });
+
+  it("picks the oldest ELIGIBLE: a young in-work obligation does not block an ancient one past the ceiling", () => {
+    const L = new ObligationLedger();
+    L.openIfAbsent(input("c:3#old", 1000)); // ancient
+    L.openIfAbsent(input("c:3#new", 1000 + CEIL)); // opened CEIL later
+    const now = 1000 + CEIL + 5000; // old is past ceiling; new is only 5s old
+    const d = L.decideAtIdle({ now, graceMs: 45000, backgroundWorkActive: true, backgroundGraceMs: CEIL });
+    expect(d.action).toBe("represent");
+    expect(d.obligation?.originTurnId).toBe("c:3#old");
+  });
+
+  it("represent budget is preserved across the work window → resumes (not escalates) after a restart-kill", () => {
+    // Models the gymbro case: while the worker runs, the sweep must NOT burn the
+    // represent ladder. So after a restart kills the work (work now inactive),
+    // a never-represented obligation re-presents (resume) rather than escalates.
+    const L = new ObligationLedger(2);
+    L.openIfAbsent(input("c:3#1", 1000));
+    // During the work window, every sweep is a no-op (no markRepresented called).
+    for (const t of [60_000, 120_000, 300_000]) {
+      expect(
+        L.decideAtIdle({ now: t, graceMs: 45000, backgroundWorkActive: true, backgroundGraceMs: CEIL }).action,
+      ).toBe("none");
+    }
+    expect(L.list()[0].representCount).toBe(0); // budget intact
+    // Restart kills the work; obligation hydrated with representCount 0 → resume.
+    expect(
+      L.decideAtIdle({ now: 360_000, graceMs: 45000, backgroundWorkActive: false, backgroundGraceMs: CEIL }).action,
+    ).toBe("represent");
+  });
+});

package/telegram-plugin/tests/turn-active-marker.test.ts

@@ -14,6 +14,7 @@ import {
   touchTurnActiveMarker,
   removeTurnActiveMarker,
   sweepStaleTurnActiveMarker,
+  readTurnActiveMarkerAgeMs,
 } from '../gateway/turn-active-marker.js'
 
 describe('turn-active-marker (#412)', () => {
@@ -192,4 +193,31 @@ describe('turn-active-marker (#412)', () => {
     const mode = statSync(path).mode & 0o777
     expect(mode).toBe(0o600)
   })
+
+  // readTurnActiveMarkerAgeMs — the orphaned-foreground "agent still working"
+  // signal for the obligation sweep (#2240 / gymbro 2026-06-10).
+  it('readTurnActiveMarkerAgeMs returns null when the marker is absent', () => {
+    expect(readTurnActiveMarkerAgeMs(tmp)).toBeNull()
+  })
+
+  it('readTurnActiveMarkerAgeMs returns a small age for a fresh marker', () => {
+    writeTurnActiveMarker(tmp, { turnKey: 'k', chatId: 'c', threadId: null, startedAt: 1 })
+    const age = readTurnActiveMarkerAgeMs(tmp)
+    expect(age).not.toBeNull()
+    // |age| is tiny for a just-written marker. It can be a hair negative when the
+    // filesystem mtime resolves slightly ahead of Date.now() — that's fine; what
+    // matters for the freshness signal is the small magnitude.
+    expect(Math.abs(age!)).toBeLessThan(5_000)
+  })
+
+  it('readTurnActiveMarkerAgeMs reflects a stale (back-dated) mtime against an injected clock', () => {
+    const path = join(tmp, TURN_ACTIVE_MARKER_FILE)
+    writeTurnActiveMarker(tmp, { turnKey: 'k', chatId: 'c', threadId: null, startedAt: 1 })
+    const tenMinAgo = new Date(Date.now() - 10 * 60_000)
+    utimesSync(path, tenMinAgo, tenMinAgo)
+    const now = tenMinAgo.getTime() + 10 * 60_000
+    const age = readTurnActiveMarkerAgeMs(tmp, now)
+    expect(age).not.toBeNull()
+    expect(Math.abs(age! - 10 * 60_000)).toBeLessThan(50) // ~10 min old
+  })
 })