@inetafrica/open-claudia 3.4.23 → 3.5.0

package/test-approval-cards.js

@@ -176,6 +176,46 @@ const lastSend = () => sends[sends.length - 1]?.text || "";
   assert.ok(rows.includes(`grl:${ruled.id}:channel`), "channel scope offered");
   assert.ok(rows.includes(`grl:${ruled.id}:global`), "global scope offered");
 
+  // ── grn: standing grants from a card ("Always — here / everywhere") ──
+  const grants = require("./core/grants");
+  const pair = { speakerId: "user-lucy", room: "kazee:ext-channel" };
+
+  // Destructive is never standing: the tap is refused and nothing is written.
+  const destructive = approvals.create({ ...base, ...pair, kind: "action", tier: "destructive", command: "open-claudia tool run infra delete-vm vm-1" });
+  await handleAction(envelopeFor(`grn:${destructive.id}:all`));
+  assert.ok(/^Destructive actions always ask; no standing permission/.test(lastSend()), "owner is told destructive always asks");
+  await handleAction(envelopeFor(`grn:${destructive.id}:room`));
+  assert.ok(/^Destructive actions always ask/.test(lastSend()));
+  assert.strictEqual(grants.list().length, 0, "no grant written from a destructive card");
+
+  // Anonymous or unverifiable principals are refused at the button.
+  const anon = approvals.create({
+    ...base, adapter: "telegram", targetAdapter: "telegram", channelId: "-100555", targetChannel: "-100555",
+    kind: "action", tier: "write", command: "open-claudia tool run kticket create",
+    speakerId: "1087968824", room: "telegram:-100555",
+  });
+  await handleAction(envelopeFor(`grn:${anon.id}:room`));
+  assert.ok(/^No standing permission for an anonymous group admin.*Use Approve once/.test(lastSend()), "anonymous admin refused at the button");
+  const roomAsSender = approvals.create({ ...base, kind: "reply", tier: "reply", payloadText: "Hi.", speakerId: "ext-channel", room: "kazee:ext-channel" });
+  await handleAction(envelopeFor(`grn:${roomAsSender.id}:all`));
+  assert.ok(/^No standing permission for the room itself/.test(lastSend()), "a sender that is really the room is refused");
+  assert.strictEqual(grants.list().length, 0, "no grant written for an unverifiable principal");
+
+  // Only an owner can grant.
+  const write = approvals.create({ ...base, ...pair, kind: "action", tier: "write", command: "open-claudia tool run kticket create" });
+  await handleAction(envelopeFor(`grn:${write.id}:room`, { channelId: "intruder-chat" }));
+  assert.ok(/Owner only/.test(lastSend()));
+  assert.strictEqual(grants.list().length, 0);
+
+  // A write card from one identifiable person grants `act` for that pair.
+  await handleAction(envelopeFor(`grn:${write.id}:room`));
+  assert.ok(/Granted Lucy `act`/.test(lastSend()), "write card grants act");
+  const issued = grants.list();
+  assert.strictEqual(issued.length, 1);
+  assert.strictEqual(issued[0].capability, "act");
+  assert.strictEqual(issued[0].principal.channelId, "user-lucy");
+  assert.strictEqual(issued[0].room, "kazee:ext-channel");
+
   // ── expired card: nothing to decide ──
   await handleAction(envelopeFor("apr:apr_0000_dead:ok"));
   assert.ok(/expired|cleaned up/.test(lastEdit()), "stale card gets a clear ack");

package/test-provider-compaction.js

@@ -289,6 +289,98 @@ async function codexRestrictionProbe() {
   assert.deepStrictEqual(claudeInvocation.args.slice(claudeInvocation.args.indexOf("--permission-mode"), claudeInvocation.args.indexOf("--permission-mode") + 2), ["--permission-mode", "plan"]);
 }
 
+// 21 Sep (task 76ecr7): a watch passed while a long turn ran, the turn ended in
+// a compaction, and the alarm looked lost. The queued delivery waits out the
+// turn and the compaction, then runs once at the next idle moment on the
+// compacted session; after a later session switch it still runs, on its own
+// branch, without taking over the live session.
+async function deferredWatchAcrossCompactionProbe() {
+  const { createSchedulerService } = require("./core/scheduler");
+  for (const switchAfter of [false, true]) {
+    resetFixture("claude");
+    const records = new Map([["watch-long-turn", {
+      id: "watch-long-turn",
+      kind: "cron",
+      schedule: "* * * * *",
+      check: "fixture-check",
+      repeat: false,
+      expiresAt: Date.now() + 60 * 60 * 1000,
+      adapter: "telegram-fixture",
+      adapterType: "telegram",
+      channelId: "fixture",
+      canonicalUserId: state.userId,
+      provider: "claude",
+      providerSettings: {},
+      project: "alpha",
+      projectDir: alphaDir,
+      sessionId: "old-claude",
+      prompt: "the SDK tag pipeline finished",
+      label: "SDK pipeline",
+      occurrenceId: "occ-long-turn",
+      status: "pending",
+      attemptCount: 0,
+      maxAttempts: 3,
+      disabled: false,
+    }]]);
+    const jobsStore = {
+      get: (id) => (records.has(id) ? structuredClone(records.get(id)) : null),
+      update(id, patch) {
+        if (!records.has(id)) return null;
+        records.set(id, { ...records.get(id), ...structuredClone(patch) });
+        return structuredClone(records.get(id));
+      },
+      remove(id) { const value = records.get(id) || null; records.delete(id); return value; },
+      listAll: () => [...records.values()].map((job) => structuredClone(job)),
+    };
+    const timers = [];
+    const runs = [];
+    const scheduler = createSchedulerService({
+      jobsStore,
+      adapters: [{ id: "telegram-fixture", type: "telegram" }],
+      workspace,
+      getUserState: () => state,
+      runInChat: async (_chat, fn) => fn(),
+      send: async () => ({ ok: true }),
+      setTimer: (fn, delay) => { timers.push({ fn, delay }); return timers.length; },
+      clearTimer: () => {},
+      scheduleCron: () => ({ stop() {} }),
+      providerStatus: () => ({ availability: { state: "available" }, auth: { state: "authenticated" } }),
+      fallbackProviders: [],
+      runWatchCheck: async () => ({ code: 0 }),
+      admitRunContext: (_prompt, cwd, _replyTo, opts) => ({ cwd, ...opts }),
+      runAgent: async (_prompt, _cwd, _replyTo, opts) => {
+        runs.push(opts);
+        return { ok: true, status: "succeeded", persistence: { transcript: { ok: true } }, delivery: { ok: true } };
+      },
+    });
+
+    state.runningProcess = { pid: 4242 };
+    assert.strictEqual((await scheduler.fireJob("watch-long-turn")).deferred, true, "a watch that passes mid-turn is queued");
+    for (let i = 0; i < 3; i++) await timers.at(-1).fn();
+    state.runningProcess = null;
+    let calls = 0;
+    const compaction = serviceWith(async () => {
+      calls += 1;
+      if (calls === 1) {
+        assert.strictEqual(state.isCompacting, true);
+        assert.strictEqual((await timers.at(-1).fn()).deferred, true, "the delivery waits out the compaction");
+        return result({ sessionId: "old-claude" });
+      }
+      return result({ sessionId: "compacted-claude" });
+    });
+    assert.strictEqual((await compaction.compact(alphaDir, { operationId: `compact-watch-${switchAfter}` })).compacted, true);
+    assert.strictEqual(runs.length, 0);
+    assert.ok(records.get("watch-long-turn"), "the queued delivery survives the compaction");
+    if (switchAfter) stateApi.setProviderSession(state, "claude", "alpha", "fresh-claude-after-new");
+
+    assert.strictEqual((await timers.at(-1).fn()).ok, true, "the next idle moment delivers it");
+    assert.strictEqual(runs.length, 1, "exactly once");
+    assert.strictEqual(runs[0].resumeSessionId, "compacted-claude", "it resumes the compacted session, not the pre-compaction one");
+    assert.strictEqual(runs[0].attachSession, !switchAfter, "it never takes over a session the user switched to");
+    assert.strictEqual(records.has("watch-long-turn"), false, "a delivered one-shot watch is consumed, not left listed");
+  }
+}
+
 function duplicateCommitProbe() {
   resetFixture("claude");
   const transaction = {
@@ -364,6 +456,7 @@ function restartRecoveryProbe() {
     await immutableSuccessProbe();
     await failureProbe();
     await codexRestrictionProbe();
+    await deferredWatchAcrossCompactionProbe();
     duplicateCommitProbe();
     restartRecoveryProbe();
     console.log("provider compaction OK");

package/test-provider-language.js

@@ -500,7 +500,21 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // stopped run unwinds and its flag names that run, so it no longer cancels the
 // next messages; "Queued." names what it waits on; a watch alarm stuck 15 min
 // behind a busy room posts one line.
-assert.strictEqual(pkg.version, "3.4.23", "release version must remain unchanged without explicit approval");
+// 3.4.24 approved by Sumeet 2026-09-24 20:30 EAT ("If there's fixes needed for open
+// Claudia proceed."): a repeating watch keeps polling while its delivery waits or
+// retries, and new hits fold into it; 3 check timeouts in a row alarm once; far
+// wakeups sleep in chunks instead of firing at once; a failed jobs-store write
+// keeps the retry armed; listings say where a fired job stands; loopback says
+// which step failed; the pack-review release gate no longer flakes on 30 s.
+// 3.5.0 approved by Sumeet 2026-09-25 14:43 EAT ("yes work through it end to end",
+// the permission redesign, phase 0 security fixes first): the bot decides who a
+// process acts for (run attestation, whoami); staff tool writes are decided and
+// escalated in the bot; undeclared verbs refused; approvals carry their tier;
+// tool/note/keyring/sub-agent changes owner-only; staff follow-ups run at the
+// setter's level; notes/tasks owner-only and search stays in the room; reads
+// screened and the hook fails closed on staff turns; no standing destructive
+// or anonymous grants; canary release tags. Shipped first as canary-v3.5.0.
+assert.strictEqual(pkg.version, "3.5.0", "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-provider-pack-review.js

@@ -404,21 +404,43 @@ async function lifecycleProbe() {
   return { serialized: true, staleProtected: true, failureRecorded: true, shutdownDrained: true };
 }
 
+// A loaded CI runner has taken over 30 s for one probe child; the kill then
+// read as "failed (null)" and failed the release gate (v3.4.19, job 43703).
+const CHILD_TIMEOUT_MS = 120000;
+
+// Why a child did not exit 0: killed by the timeout, killed by a signal, never
+// started, or a real non-zero exit.
+function childFailure(child, timeoutMs = CHILD_TIMEOUT_MS) {
+  if (child.error?.code === "ETIMEDOUT") return `timed out after ${timeoutMs / 1000} s (killed with ${child.signal || "SIGTERM"})`;
+  if (child.signal) return `was killed by ${child.signal}`;
+  if (child.error) return `could not start (${child.error.code || child.error.message})`;
+  return `failed (exit ${child.status})`;
+}
+
 function runChild(args) {
   const child = spawnSync(process.execPath, [__filename, ...args], {
     cwd: __dirname,
     env: { ...process.env },
     encoding: "utf8",
-    timeout: 30000,
+    timeout: CHILD_TIMEOUT_MS,
   });
   if (child.status !== 0) {
-    throw new Error(`child ${args.join(" ")} failed (${child.status})\n${child.stdout}\n${child.stderr}`);
+    throw new Error(`child ${args.join(" ")} ${childFailure(child)}\n${child.stdout}\n${child.stderr}`);
   }
   const line = child.stdout.split("\n").find((entry) => entry.startsWith(RESULT_PREFIX));
   if (!line) throw new Error(`child ${args.join(" ")} returned no result\n${child.stdout}\n${child.stderr}`);
   return JSON.parse(line.slice(RESULT_PREFIX.length));
 }
 
+function childFailureProbe() {
+  const hung = spawnSync(process.execPath, ["-e", "setTimeout(() => {}, 10000)"], { encoding: "utf8", timeout: 200 });
+  assert.strictEqual(childFailure(hung, 200), "timed out after 0.2 s (killed with SIGTERM)", "a timeout reads as a timeout");
+  const failing = spawnSync(process.execPath, ["-e", "process.exit(3)"], { encoding: "utf8", timeout: 10000 });
+  assert.strictEqual(childFailure(failing), "failed (exit 3)", "a failing probe keeps its exit code");
+  const killed = spawnSync(process.execPath, ["-e", "process.kill(process.pid, 'SIGKILL')"], { encoding: "utf8", timeout: 10000 });
+  assert.strictEqual(childFailure(killed), "was killed by SIGKILL");
+}
+
 async function main() {
   if (process.argv[2] === "--provider-probe") {
     const result = await providerProbe(process.argv[3]);
@@ -431,6 +453,7 @@ async function main() {
     return;
   }
 
+  childFailureProbe();
   const claude = runChild(["--provider-probe", "claude"]);
   const codex = runChild(["--provider-probe", "codex"]);
   assert.deepStrictEqual(codex.mutations, claude.mutations, "identical fixture decisions produce identical memory mutations under Claude and Codex");

package/test-provider-parity-e2e.js

@@ -21,7 +21,9 @@ const SUPPORT_SUITES = Object.freeze({
   scheduler: ["test-provider-scheduler.js", "provider scheduler OK"],
   sideChat: ["test-provider-side-chat.js", "provider side chat OK"],
   recall: ["test-provider-recall.js", "provider recall OK"],
-  review: ["test-provider-pack-review.js", "provider pack review OK"],
+  // Three probe children, each allowed 120 s under a loaded runner; the suite
+  // cap must not undercut them (a 90 s cap would move the v3.4.19 flake here).
+  review: ["test-provider-pack-review.js", "provider pack review OK", 8 * 60 * 1000],
   mutationQueue: ["test-memory-mutation-queue.js", "memory mutation queue OK"],
   dream: ["test-provider-dream.js", "provider dream OK"],
   subagent: ["test-provider-subagent.js", "provider subagent OK"],
@@ -457,7 +459,7 @@ function runProviderChild(kind) {
 function runSupportSuites(provider) {
   assert.ok(["claude", "codex"].includes(provider));
   const passed = new Set();
-  for (const [key, [script, marker]] of Object.entries(SUPPORT_SUITES)) {
+  for (const [key, [script, marker, suiteTimeoutMs = 90000]] of Object.entries(SUPPORT_SUITES)) {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), `open-claudia-parity-suite-${key}-`));
     try {
       fs.mkdirSync(path.join(root, "home"));
@@ -466,7 +468,7 @@ function runSupportSuites(provider) {
         cwd: repoRoot,
         env: isolatedEnv(root, provider),
         encoding: "utf8",
-        timeout: 90000,
+        timeout: suiteTimeoutMs,
         maxBuffer: 8 * 1024 * 1024,
       });
       assert.ifError(result.error);