@inetafrica/open-claudia 3.0.25 → 3.0.27

package/test-agency-deliberate.js

@@ -0,0 +1,119 @@
+// Track B1 — advisory deliberation. Deterministic triage/rank, confidence floor
+// and clear-margin behaviour, the injectable judge (including failure fallback),
+// and best-effort shadow logging. No network, redirected config dir.
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const TMP = fs.mkdtempSync(path.join(os.tmpdir(), "oc-delib-"));
+process.env.OPEN_CLAUDIA_CONFIG_DIR = TMP;
+
+const D = require("./core/agency/deliberate");
+
+const NOW = Date.parse("2026-07-15T12:00:00.000Z");
+const DAY = 86400000;
+
+function entry(o) {
+  return Object.assign(
+    { source: "task", kind: "task", id: "x", title: "t", status: "open",
+      priority: null, due: null, lastTouched: NOW, staleDays: 0, blockedOn: null,
+      overdue: false, meta: {} },
+    o,
+  );
+}
+function ledgerOf(entries) {
+  return { generatedAt: NOW, counts: { total: entries.length }, entries };
+}
+
+// --- triage: notifications never candidates; bare open local task isn't either
+assert.strictEqual(D.isCandidate(entry({ source: "notification", status: "info" }), NOW), false);
+assert.strictEqual(D.isCandidate(entry({ source: "task", status: "open", due: null }), NOW), false);
+assert.strictEqual(D.isCandidate(entry({ source: "task", status: "in_progress" }), NOW), true);
+assert.strictEqual(D.isCandidate(entry({ source: "spaces", staleDays: 3 }), NOW), true);
+
+// --- scoreOf: overdue dominates, signals surface
+const sc = D.scoreOf(entry({ overdue: true, due: NOW - 2 * DAY, priority: "high" }), NOW);
+assert.ok(sc.score > 100, "overdue+high scores high");
+assert.ok(sc.signals.some((s) => s.k === "overdue"));
+assert.ok(sc.signals.some((s) => s.k === "priority"));
+
+(async () => {
+  // --- clear winner: overdue high-priority Spaces task beats an in-progress task
+  const p1 = await D.deliberate(ledgerOf([
+    entry({ source: "spaces", id: "s1", title: "Overdue!", overdue: true, due: NOW - 2 * DAY, priority: "high", staleDays: 2 }),
+    entry({ source: "task", id: "t1", title: "WIP", status: "in_progress", staleDays: 1 }),
+    entry({ source: "notification", id: "n1", status: "info" }),
+  ]), { now: NOW });
+  assert.strictEqual(p1.proposed, true);
+  assert.strictEqual(p1.pick.id, "s1", "overdue item picked");
+  assert.strictEqual(p1.confidence, "high", "clear margin → high confidence");
+  assert.strictEqual(p1.method, "deterministic");
+  assert.strictEqual(p1.actionType, "ask", "overdue Spaces assignment → nudge");
+  assert.ok(p1.why.join(" ").includes("overdue"));
+  assert.ok(D.render(p1).includes("Overdue!"));
+
+  // --- default-silence: lone far-future item scores below the floor
+  const p2 = await D.deliberate(ledgerOf([
+    entry({ source: "spaces", id: "s2", title: "Someday", due: NOW + 20 * DAY, staleDays: 1 }),
+  ]), { now: NOW });
+  assert.strictEqual(p2.proposed, false, "below confidence floor → propose nothing");
+  assert.ok(D.render(p2).includes("Nothing pressing"));
+
+  // --- ambiguous + judge OFF → deterministic, medium confidence
+  const twoWip = ledgerOf([
+    entry({ source: "task", id: "t1", title: "WIP one", status: "in_progress", staleDays: 1 }),
+    entry({ source: "task", id: "t2", title: "WIP two", status: "in_progress", staleDays: 1 }),
+  ]);
+  const p3 = await D.deliberate(twoWip, { now: NOW });
+  assert.strictEqual(p3.proposed, true);
+  assert.strictEqual(p3.method, "deterministic");
+  assert.strictEqual(p3.confidence, "medium", "close margin → medium");
+
+  // --- ambiguous + injected judge overrides the pick + action
+  let judgeSaw = null;
+  const p4 = await D.deliberate(twoWip, {
+    now: NOW, useJudge: true,
+    judge: async (top) => { judgeSaw = top.map((c) => c.id); return { pickId: "t2", actionType: "schedule", why: "second is riper", confidence: "high" }; },
+  });
+  assert.deepStrictEqual(judgeSaw, ["t1", "t2"], "judge sees the top-N");
+  assert.strictEqual(p4.method, "judge");
+  assert.strictEqual(p4.pick.id, "t2", "judge override applied");
+  assert.strictEqual(p4.actionType, "schedule");
+  assert.strictEqual(p4.judgeWhy, "second is riper");
+
+  // --- judge failure falls back to deterministic, never throws
+  const p5 = await D.deliberate(twoWip, { now: NOW, useJudge: true, judge: async () => { throw new Error("boom"); } });
+  assert.strictEqual(p5.method, "deterministic");
+  assert.strictEqual(p5.pick.id, "t1");
+
+  // --- judge NOT called when the winner is clear (margin ≥ CLEAR_MARGIN)
+  let called = false;
+  const p6 = await D.deliberate(ledgerOf([
+    entry({ source: "spaces", id: "s1", title: "Overdue!", overdue: true, due: NOW - 5 * DAY, priority: "high" }),
+    entry({ source: "task", id: "t1", title: "WIP", status: "in_progress" }),
+  ]), { now: NOW, useJudge: true, judge: async () => { called = true; return null; } });
+  assert.strictEqual(called, false, "clear margin skips the judge");
+  assert.strictEqual(p6.pick.id, "s1");
+
+  // --- shadow record: writes a jsonl row; AGENCY_SHADOW=off suppresses it
+  process.env.AGENCY_SHADOW = "on";
+  D.record(p1, { channel: "telegram:123" });
+  assert.ok(fs.existsSync(D.LOG_FILE), "shadow log written");
+  let lines = fs.readFileSync(D.LOG_FILE, "utf8").trim().split("\n");
+  assert.strictEqual(lines.length, 1);
+  const row = JSON.parse(lines[0]);
+  assert.strictEqual(row.pickId, "s1");
+  assert.strictEqual(row.channel, "telegram:123");
+  assert.strictEqual(row.method, "deterministic");
+
+  process.env.AGENCY_SHADOW = "off";
+  D.record(p1, {});
+  lines = fs.readFileSync(D.LOG_FILE, "utf8").trim().split("\n");
+  assert.strictEqual(lines.length, 1, "AGENCY_SHADOW=off suppresses the write");
+  process.env.AGENCY_SHADOW = "on";
+
+  try { fs.rmSync(TMP, { recursive: true, force: true }); } catch (e) {}
+  console.log("test-agency-deliberate: OK");
+})();

package/test-agency-ledger.js

@@ -0,0 +1,114 @@
+// Track B0 — agency ledger aggregator. Exercises the pure build()/normalizers/
+// render, plus collect() with an injected Spaces fetch (no subprocess) and a
+// redirected config dir so no real task/connector files are touched.
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const TMP = fs.mkdtempSync(path.join(os.tmpdir(), "oc-ledger-"));
+process.env.OPEN_CLAUDIA_CONFIG_DIR = TMP;
+
+const ledger = require("./core/agency/ledger");
+
+const NOW = Date.parse("2026-07-15T12:00:00.000Z");
+const DAY = 86400000;
+
+// --- normalizeTask: local task, never overdue, no due date ---
+const t1 = ledger.normalizeTask(
+  { id: "a", content: "Ship X", status: "in_progress", updatedAt: NOW - 3600000 },
+  NOW,
+);
+assert.strictEqual(t1.source, "task");
+assert.strictEqual(t1.status, "in_progress");
+assert.strictEqual(t1.overdue, false);
+assert.strictEqual(t1.due, null);
+
+// --- normalizeSpacesTask: overdue + status + space name + priority ---
+const s1 = ledger.normalizeSpacesTask(
+  {
+    id: "s1", title: "Leave page", status: "open", priority: "high",
+    dueDate: "2026-07-14T00:00:00.000Z", updatedAt: NOW - 2 * DAY,
+    spaceId: { name: "HR + Product" }, subtaskCount: 2, subtaskCompletedCount: 1,
+  },
+  NOW,
+);
+assert.strictEqual(s1.source, "spaces");
+assert.strictEqual(s1.overdue, true, "past dueDate + not done → overdue");
+assert.strictEqual(s1.meta.space, "HR + Product");
+assert.strictEqual(s1.priority, "high");
+
+// a completed Spaces task is done and never overdue, even past its due date
+const s2 = ledger.normalizeSpacesTask(
+  { id: "s2", title: "done", status: "completed", dueDate: "2026-07-01T00:00:00.000Z" },
+  NOW,
+);
+assert.strictEqual(s2.status, "done");
+assert.strictEqual(s2.overdue, false);
+
+// --- normalizeInbox: actor + task title fold into a readable line ---
+const n1 = ledger.normalizeInbox(
+  { id: "n1", type: "comment", actorName: "Jane", taskTitle: "Fix bug", createdAt: NOW - 1800000 },
+  NOW,
+);
+assert.strictEqual(n1.source, "notification");
+assert.ok(n1.title.includes("Jane") && n1.title.includes("Fix bug"));
+assert.strictEqual(n1.status, "info");
+
+// --- build: drops completed, ranks overdue first, counts by source/stale ---
+const l = ledger.build({
+  tasks: [
+    { id: "a", content: "In progress task", status: "in_progress", updatedAt: NOW - 3600000 },
+    { id: "b", content: "Done task", status: "completed", updatedAt: NOW - DAY },
+    { id: "c", content: "Stale open", status: "pending", updatedAt: NOW - 30 * DAY },
+  ],
+  spacesMine: [
+    { id: "s1", title: "Overdue!", status: "open", dueDate: "2026-07-13T00:00:00.000Z", updatedAt: NOW - 5 * DAY },
+  ],
+  inboxes: [
+    { id: "n1", type: "comment", actorName: "Jane", taskTitle: "T", createdAt: NOW - 1800000 },
+  ],
+  now: NOW,
+});
+assert.strictEqual(l.counts.total, 4, "1 completed dropped from 5 inputs");
+assert.strictEqual(l.counts.overdue, 1);
+assert.strictEqual(l.entries[0].id, "s1", "overdue entry ranked first");
+assert.strictEqual(l.counts.stale, 1, "30d-untouched task is stale");
+assert.strictEqual(l.counts.bySource.task, 2);
+assert.strictEqual(l.counts.bySource.spaces, 1);
+assert.strictEqual(l.counts.bySource.notification, 1);
+
+// --- render: summary line + per-source sections ---
+const text = ledger.render(l, { now: NOW });
+assert.ok(text.includes("Agenda"));
+assert.ok(text.includes("4 open"));
+assert.ok(text.includes("1 overdue"));
+assert.ok(text.includes("Spaces (assigned to me)"));
+assert.ok(text.includes("Overdue!"));
+
+// empty ledger renders the all-clear
+const empty = ledger.render(ledger.build({ now: NOW }), { now: NOW });
+assert.ok(empty.includes("Nothing on your plate"));
+
+// --- collect: injected Spaces fetch, no adapter (no task files), no subprocess ---
+(async () => {
+  const r = await ledger.collect({
+    now: NOW,
+    fetchSpacesMine: async () => [{ id: "s9", title: "Injected", status: "open" }],
+  });
+  assert.ok(r.entries.some((e) => e.id === "s9"), "injected spaces task present");
+  assert.strictEqual(typeof r.counts.total, "number");
+
+  // includeSpaces:false skips the fetch entirely
+  let called = false;
+  const r2 = await ledger.collect({
+    now: NOW, includeSpaces: false,
+    fetchSpacesMine: async () => { called = true; return [{ id: "nope" }]; },
+  });
+  assert.strictEqual(called, false, "includeSpaces:false skips the Spaces fetch");
+  assert.ok(!r2.entries.some((e) => e.id === "nope"));
+
+  try { fs.rmSync(TMP, { recursive: true, force: true }); } catch (e) {}
+  console.log("test-agency-ledger: OK");
+})();

package/test-guardrail.js

@@ -0,0 +1,126 @@
+// Track C — dynamic owner-guardrail capture. Deterministic detection tiers,
+// the hard owner gate, C0 detect+confirm (Y/N pending), C1 auto-capture with
+// undo, and dedupe against existing lessons. No network, redirected config dir.
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const TMP = fs.mkdtempSync(path.join(os.tmpdir(), "oc-guard-"));
+process.env.OPEN_CLAUDIA_CONFIG_DIR = TMP;
+process.env.GUARDRAIL_CAPTURE = "on";
+
+const G = require("./core/guardrail");
+const lessons = require("./core/lessons");
+
+const OWNER = { isOwner: true, channelId: "telegram:1" };
+const EXTERNAL = { isOwner: false, channelId: "telegram:9" };
+
+function resetLessons() {
+  try { fs.rmSync(lessons.LESSONS_FILE, { force: true }); } catch (e) {}
+  try { fs.rmSync(lessons.LESSONS_META_FILE, { force: true }); } catch (e) {}
+  try { fs.rmSync(G.PENDING_FILE, { force: true }); } catch (e) {}
+}
+
+// ── detection tiers ─────────────────────────────────────────────────
+
+// high: explicit durable marker → clean imperative, marker stripped
+let d = G.detect("From now on, always send the deep link after posting a Spaces comment.");
+assert.strictEqual(d.isRule, true);
+assert.strictEqual(d.confidence, "high");
+assert.strictEqual(d.trigger, "marker");
+assert.ok(/send the deep link/i.test(d.rule));
+assert.ok(!/from now on/i.test(d.rule), "leading marker stripped");
+
+// high: bare negative directive (never / stop-gerund)
+assert.strictEqual(G.detect("Never send voice notes by default.").confidence, "high");
+assert.strictEqual(G.detect("Stop summarizing every response.").confidence, "high");
+assert.strictEqual(G.detect("Don't ever deploy on Fridays.").confidence, "high");
+
+// medium: softer imperative → ask first
+const dm = G.detect("Always double-check the staging config before a deploy.");
+assert.strictEqual(dm.confidence, "medium");
+assert.strictEqual(G.detect("Please don't touch prod without asking me first.").confidence, "medium");
+
+// silence: questions, past-tense "never", one-off "stop <noun>", junk
+assert.strictEqual(G.detect("What colour are the fish?").isRule, false);
+assert.strictEqual(G.detect("I never got the email from Emmanuel.").isRule, false);
+assert.strictEqual(G.detect("Stop the server.").isRule, false, "stop + non-gerund is a one-off action");
+assert.strictEqual(G.detect("Never mind.").isRule, false, "below the word floor");
+assert.strictEqual(G.detect("Make it a rule?").isRule, false, "a question is not a directive");
+
+// ── owner gate (hard) ───────────────────────────────────────────────
+(async () => {
+  resetLessons();
+  const ext = await G.consider({ text: "From now on always run the linter first.", speaker: EXTERNAL, announce: null });
+  assert.strictEqual(ext.action, "external-skip", "external speaker never captures");
+  assert.strictEqual(lessons.readLessons().length, 0, "nothing written for an external");
+
+  // ── C1: high-confidence auto-capture + announce with Undo button ──
+  resetLessons();
+  const calls = [];
+  const announce = (text, opts) => { calls.push({ text, opts }); };
+  const hi = await G.consider({ text: "From now on, always send the deep link after posting a comment.", speaker: OWNER, announce });
+  assert.strictEqual(hi.action, "captured");
+  assert.strictEqual(calls.length, 1, "announced once");
+  assert.ok(calls[0].text.includes("standing rule"));
+  const undoBtn = calls[0].opts.keyboard.inline_keyboard[0][0];
+  assert.strictEqual(undoBtn.callback_data, `grd:undo:${hi.id}`, "undo button carries the lesson id");
+  const stored = lessons.readLessons();
+  assert.strictEqual(stored.length, 1, "one lesson written");
+  assert.ok(/send the deep link/i.test(stored[0].text));
+  // provenance: origin recorded as guardrail
+  assert.strictEqual((lessons.readMeta()[hi.id] || {}).origin, "guardrail");
+
+  // one-tap undo removes it
+  const un = G.undo(hi.id);
+  assert.strictEqual(un.ok, true);
+  assert.strictEqual(lessons.readLessons().length, 0, "undo removed the rule");
+
+  // ── dedupe: same rule twice reinforces, never duplicates ──
+  resetLessons();
+  const a = await G.consider({ text: "Never commit the .env file.", speaker: OWNER, announce: null });
+  assert.strictEqual(a.action, "captured");
+  const b = await G.consider({ text: "Never commit the .env file.", speaker: OWNER, announce: null });
+  assert.strictEqual(b.action, "reinforced", "second identical rule reinforces");
+  assert.strictEqual(lessons.readLessons().length, 1, "no duplicate lesson");
+
+  // ── C0: medium-confidence asks first (pending), then confirm captures ──
+  resetLessons();
+  const calls2 = [];
+  const announce2 = (text, opts) => { calls2.push({ text, opts }); };
+  const med = await G.consider({ text: "Always run the full test suite before pushing.", speaker: OWNER, announce: announce2 });
+  assert.strictEqual(med.action, "asked");
+  assert.ok(med.token, "a pending token is issued");
+  assert.strictEqual(lessons.readLessons().length, 0, "nothing captured until confirmed");
+  const kb = calls2[0].opts.keyboard.inline_keyboard[0];
+  assert.strictEqual(kb[0].callback_data, `grd:save:${med.token}`);
+  assert.strictEqual(kb[1].callback_data, `grd:no:${med.token}`);
+
+  // confirm → capture; token is one-shot (second confirm expired)
+  const ok = G.confirmPending(med.token);
+  assert.strictEqual(ok.ok, true);
+  assert.strictEqual(ok.added, true);
+  assert.strictEqual(lessons.readLessons().length, 1, "confirm captured the rule");
+  assert.strictEqual(G.confirmPending(med.token).ok, false, "token is single-use");
+
+  // drop → discards the pending without capturing
+  resetLessons();
+  const med2 = await G.consider({ text: "Prefer GitOps over direct kubectl for cluster changes.", speaker: OWNER, announce: null });
+  assert.strictEqual(med2.action, "asked");
+  assert.strictEqual(G.dropPending(med2.token).ok, true);
+  assert.strictEqual(lessons.readLessons().length, 0, "drop captured nothing");
+  assert.strictEqual(G.confirmPending(med2.token).ok, false, "dropped token is gone");
+
+  // ── enabled gate ──
+  resetLessons();
+  process.env.GUARDRAIL_CAPTURE = "off";
+  const off = await G.consider({ text: "From now on always foo the bar.", speaker: OWNER, announce: null });
+  assert.strictEqual(off.action, "disabled");
+  assert.strictEqual(lessons.readLessons().length, 0, "disabled captures nothing");
+  process.env.GUARDRAIL_CAPTURE = "on";
+
+  try { fs.rmSync(TMP, { recursive: true, force: true }); } catch (e) {}
+  console.log("test-guardrail: OK");
+})();

package/test-prompt-budget.js

@@ -0,0 +1,78 @@
+// Track X0 — always-on prompt budget instrumentation.
+// Verifies the measure/record/summary contract without touching the real
+// config dir (redirected to a temp OPEN_CLAUDIA_CONFIG_DIR before require).
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const TMP = fs.mkdtempSync(path.join(os.tmpdir(), "oc-budget-"));
+process.env.OPEN_CLAUDIA_CONFIG_DIR = TMP;
+process.env.PROMPT_BUDGET = "on";
+
+const budget = require("./core/prompt-budget");
+budget._resetForTest();
+
+// --- estimateTokens: ~chars/4, never negative, tolerant of non-strings ---
+assert.strictEqual(budget.estimateTokens(""), 0);
+assert.strictEqual(budget.estimateTokens("abcd"), 1);
+assert.strictEqual(budget.estimateTokens("abcde"), 2); // ceil(5/4)
+assert.strictEqual(budget.estimateTokens(null), 0);
+assert.strictEqual(budget.estimateTokens(undefined), 0);
+
+// --- measure: always-on vs recall vs userPrompt split ---
+const m = budget.measure({
+  core: "x".repeat(400),      // 100 tok, always-on
+  runtime: "y".repeat(40),    // 10 tok, always-on
+  speaker: "z".repeat(40),    // 10 tok, always-on
+  recall: "r".repeat(200),    // 50 tok, VARIABLE
+  transcript: "t".repeat(40), // 10 tok, VARIABLE
+  userPrompt: "u".repeat(20), // 5 tok, user
+});
+assert.strictEqual(m.alwaysOn.tokens, 120, "always-on = core+runtime+speaker");
+assert.strictEqual(m.recall.tokens, 50, "recall isolated");
+assert.strictEqual(m.variable.tokens, 60, "variable = recall + transcript");
+assert.strictEqual(m.userPrompt.tokens, 5);
+assert.strictEqual(m.total.tokens, 120 + 60 + 5, "total = alwaysOn + variable + userPrompt");
+assert.strictEqual(m.components.core.tokens, 100);
+
+// recall must NOT be counted in the always-on floor
+const m2 = budget.measure({ core: "a".repeat(4), recall: "b".repeat(4000) });
+assert.strictEqual(m2.alwaysOn.tokens, 1, "recall excluded from always-on floor");
+assert.strictEqual(m2.recall.tokens, 1000);
+
+// --- record + summary: rolling averages, max, latest snapshot ---
+budget.record(budget.measure({ core: "x".repeat(400) }), { provider: "claude", runId: "r1" }); // 100
+budget.record(budget.measure({ core: "x".repeat(800) }), { provider: "claude", runId: "r2" }); // 200
+const s = budget.summary();
+assert.strictEqual(s.turns, 2);
+assert.strictEqual(s.avgAlwaysOnTokens, 150, "avg of 100 & 200");
+assert.strictEqual(s.maxAlwaysOnTokens, 200);
+assert.ok(s.latest && s.latest.alwaysOnTokens === 200, "latest snapshot is the last record");
+assert.strictEqual(s.componentAvgTokens.core, 150);
+
+// jsonl written with one line per record
+assert.ok(fs.existsSync(budget.LOG_FILE), "jsonl log written");
+const lines = fs.readFileSync(budget.LOG_FILE, "utf8").trim().split("\n");
+assert.strictEqual(lines.length, 2);
+const first = JSON.parse(lines[0]);
+assert.strictEqual(first.alwaysOnTokens, 100);
+assert.strictEqual(first.provider, "claude");
+
+// --- record is best-effort: junk input never throws, never records ---
+const before = budget.summary().turns;
+budget.record(null);
+budget.record({});
+budget.record({ total: null });
+assert.strictEqual(budget.summary().turns, before, "invalid measurements are ignored");
+
+// --- disabled gate ---
+budget._resetForTest();
+process.env.PROMPT_BUDGET = "off";
+budget.record(budget.measure({ core: "x".repeat(400) }), { provider: "claude" });
+assert.strictEqual(budget.summary().turns, 0, "PROMPT_BUDGET=off disables recording");
+process.env.PROMPT_BUDGET = "on";
+
+try { fs.rmSync(TMP, { recursive: true, force: true }); } catch (e) {}
+console.log("test-prompt-budget: OK");

package/test-provider-language.js

@@ -32,15 +32,18 @@ assert.doesNotMatch(setup, /Your Claude Code bot is connected|Description=Claude
 
 const pkg = JSON.parse(read("package.json"));
 assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
-// 3.0.25 approved by Sumeet 2026-07-15 ("Ship it"): the bot now emits its own
-// comment:typing on a Spaces task thread. Core's typing heartbeat drives the
-// SpacesAdapter typing()/typingStop() (previously no-op stubs), which re-emit the
-// same ephemeral event a human client sends, so teammates watching a task see
-// "Open Claudia is typing…" while it composes a reply. Part 4 of the cross-repo
-// typing-indicator work (backend/web/mobile shipped in prior deploys); the
-// backend stamps identity from the authenticated socket and re-broadcasts to the
-// space room, so the adapter only sends targetId + spaceId + isTyping.
-assert.strictEqual(pkg.version, "3.0.25", "release version must remain unchanged without explicit approval");
+// 3.0.27 approved by Sumeet 2026-07-15 ("work through till it's done and push it
+// out"): the non-gated architecture batch. (1) X0 — always-on prompt-budget
+// instrumentation: measure the fixed floor vs per-turn recall payload, telemetry
+// only (no prompt change, no trim). (2) B0 — /agenda read-only work ledger
+// (tasks + Spaces + notifications). (3) B1 — /next advisory deliberation that
+// proposes a pick and acts on nothing. (4) C0/C1 — owner-guardrail capture:
+// "from now on / never / stop" statements become always-loaded lessons (asked or
+// auto-captured with announce + one-tap undo), owner-only, never from externals.
+// (5) Turn-aware reboot: the Telegram 10-min poll-wedge backstop defers its
+// self-exit while any turn is running/queued so a restart never interrupts
+// in-flight work. B2+ autonomy and Track A stay gated.
+assert.strictEqual(pkg.version, "3.0.27", "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-telegram-poll-recovery.js

@@ -1,6 +1,16 @@
 "use strict";
 
 const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+// Redirect config before loading the adapter so the idle wedge-exit test's
+// recordExitReason writes to a throwaway dir, never the real
+// ~/.open-claudia/last-exit.json (which would make the next real boot report a
+// phantom "polling wedged" restart reason).
+process.env.OPEN_CLAUDIA_CONFIG_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "oc-poll-"));
+
 const { TelegramAdapter } = require("./channels/telegram/adapter");
 
 async function testStartDoesNotWaitForFirstLongPollAndArmsStallWatchdog() {
@@ -165,11 +175,82 @@ async function test409ConflictSeversGhostSocketAndRestartsIdle() {
   }
 }
 
+// The 10-min wedge backstop must NEVER reboot mid-turn: a restart there kills
+// in-flight work and breaks the seamless resume. While a turn is active the heal
+// defers the exit and falls through to in-place recovery (stop/destroy/start)
+// instead — which may itself clear the wedge with no restart at all.
+async function testWedgeExitDefersWhileTurnInFlight() {
+  const calls = [];
+  let exited = false;
+  const adapter = Object.create(TelegramAdapter.prototype);
+  adapter._healTimer = null;
+  adapter._healthyTimer = null;
+  adapter._conflictSince = 0;
+  adapter._wedgedSince = Date.now() - 11 * 60 * 1000; // wedged >10min
+  adapter._deferredExitLogAt = 0;
+  adapter._healBackoff = 0;
+  adapter._anyTurnActive = () => true; // a turn is running/queued
+  adapter._agent = { destroy() { calls.push("destroy"); } };
+  adapter.bot = {
+    async stopPolling() { calls.push("stop"); },
+    async startPolling() { calls.push("start"); },
+  };
+
+  const realExit = process.exit;
+  process.exit = () => { exited = true; throw new Error("process.exit must not be called mid-turn"); };
+  const realSetTimeout = global.setTimeout;
+  const realClearTimeout = global.clearTimeout;
+  global.setTimeout = (fn, ms) => { if (ms === 500) fn(); return { ms }; };
+  global.clearTimeout = () => {};
+
+  try {
+    await adapter._heal();
+  } finally {
+    process.exit = realExit;
+    global.setTimeout = realSetTimeout;
+    global.clearTimeout = realClearTimeout;
+  }
+
+  assert.strictEqual(exited, false, "a wedge backstop must NOT exit while a turn is in flight");
+  assert.deepStrictEqual(calls, ["stop", "destroy", "start"],
+    "a deferred wedge must still attempt in-place recovery instead of rebooting");
+  assert.ok(adapter._deferredExitLogAt > 0, "the deferral must be logged (throttle stamp set)");
+}
+
+// Once the process is idle (no turn running/queued), the same backstop exits for
+// a clean restart exactly as before — the deferral only postpones, never cancels.
+async function testWedgeExitFiresWhenIdle() {
+  let exitCode;
+  const adapter = Object.create(TelegramAdapter.prototype);
+  adapter._healTimer = null;
+  adapter._conflictSince = 0;
+  adapter._wedgedSince = Date.now() - 11 * 60 * 1000; // wedged >10min
+  adapter._deferredExitLogAt = 0;
+  adapter._anyTurnActive = () => false; // idle
+  adapter._agent = { destroy() {} };
+  adapter.bot = { async stopPolling() {}, async startPolling() {} };
+
+  const realExit = process.exit;
+  process.exit = (code) => { exitCode = code; throw new Error("__exit__"); };
+  try {
+    await adapter._heal();
+    assert.fail("the idle wedge backstop must exit");
+  } catch (e) {
+    if (e.message !== "__exit__") throw e;
+  } finally {
+    process.exit = realExit;
+  }
+
+  assert.strictEqual(exitCode, 1, "the idle wedge backstop must exit(1) for a clean restart");
+}
+
 (async () => {
   await testStartDoesNotWaitForFirstLongPollAndArmsStallWatchdog();
   await testHealStopsPlainlyDestroysAgentAndRestartsIdle();
   await testStopPollingCleanDoesNotHangOnAWedgedStop();
   await test409ConflictSeversGhostSocketAndRestartsIdle();
+  await testWedgeExitDefersWhileTurnInFlight();
+  await testWedgeExitFiresWhenIdle();
   console.log("telegram poll recovery OK");
 })().catch((err) => {
   console.error(err.stack || err);