@inetafrica/open-claudia 3.0.26 → 3.0.27

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,16 +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.26 approved by Sumeet 2026-07-15: fix Spaces reply posting. (1) An engaged
-// reply no longer 400s — send() only threads under an explicit "comment:"-prefixed
-// id (the triggering reply/comment-mention) and otherwise posts a top-level task
-// comment, with a top-level retry if a stale parent 400s. (2) The bot threads its
-// reply under the exact triggering comment when the notification names one
-// (replyId / comment-target). (3) The transient "Queued." ack is suppressed on
-// Spaces — a stacked turn stays silent and just posts the real reply when it runs,
-// instead of dropping a throwaway "Queued." comment on the task. Builds on 3.0.25's
-// comment:typing emit.
-assert.strictEqual(pkg.version, "3.0.26", "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);