@inetafrica/open-claudia 3.4.22 → 3.4.24

package/test-provider-language.js

@@ -494,7 +494,19 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // removing those would push recall, pack review and the enforcer onto opus.
 // Removal is cosmetic by design: /model accepts a typed name without checking
 // the list, so `/model claude-opus-4-8` remains a working rollback.
-assert.strictEqual(pkg.version, "3.4.22", "release version must remain unchanged without explicit approval");
+// 3.4.23 approved by Sumeet 2026-09-24 ("push", answering "Shall I install
+// 3.4.23 once that is done?" after "can you fix this in open claudia"): watch and
+// wakeup turns stream like chat turns; /stop keeps the room busy until the
+// 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.
+// 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.
+assert.strictEqual(pkg.version, "3.4.24", "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);