@inetafrica/open-claudia 2.15.0 → 3.0.1

package/test-fixtures/migrations/dual-provider/sessions.json

@@ -0,0 +1,7 @@
+{
+  "owner@example.test": {
+    "parity": [
+      { "id": "claude-session-parity", "title": "Parity", "created": "2026-02-01T00:00:00.000Z", "lastUsed": "2026-02-02T00:00:00.000Z" }
+    ]
+  }
+}

package/test-fixtures/migrations/dual-provider/state.json

@@ -0,0 +1,10 @@
+{
+  "users": {
+    "owner@example.test": {
+      "currentSession": { "name": "parity", "dir": "/workspace/parity" },
+      "lastSessionId": "claude-session-parity",
+      "codexSessionId": "codex-thread-parity",
+      "settings": { "backend": "codex", "model": "gpt-fixture" }
+    }
+  }
+}

package/test-fixtures/migrations/malformed-partial/jobs.json

@@ -0,0 +1 @@
+[{"id":"partial-job","kind":"wakeup","project":null

package/test-fixtures/migrations/malformed-partial/sessions.json

@@ -0,0 +1 @@
+{"fallback":[{"id":"truncated-session"

package/test-fixtures/migrations/malformed-partial/sessions.json.bak

@@ -0,0 +1,3 @@
+{
+  "fallback": [{ "id": "fallback-session", "title": "Fallback" }]
+}

package/test-fixtures/migrations/malformed-partial/state.json

@@ -0,0 +1 @@
+{"users":{"broken":{"currentSession":

package/test-fixtures/migrations/malformed-partial/state.json.bak

@@ -0,0 +1,5 @@
+{
+  "currentSession": { "name": "fallback", "dir": "/workspace/fallback" },
+  "lastSessionId": "fallback-session",
+  "settings": { "backend": "claude" }
+}

package/test-fixtures/migrations/missing-project/jobs.json

@@ -0,0 +1,3 @@
+[
+  { "id": "orphan-job", "kind": "wakeup", "project": null, "sessionKey": "lastSessionId", "sessionId": "orphan-session", "prompt": "unresolved project" }
+]

package/test-fixtures/migrations/missing-project/sessions.json

@@ -0,0 +1,3 @@
+{
+  "unknown-project": [{ "id": "orphan-session", "title": "Missing project selection" }]
+}

package/test-fixtures/migrations/missing-project/state.json

@@ -0,0 +1,4 @@
+{
+  "lastSessionId": "orphan-session",
+  "settings": { "backend": "claude" }
+}

package/test-fixtures/migrations/multi-user/jobs.json

@@ -0,0 +1,4 @@
+[
+  { "id": "job-one", "kind": "wakeup", "canonicalUserId": "telegram:100", "project": "one", "sessionKey": "lastSessionId", "sessionId": "session-one", "prompt": "one" },
+  { "id": "job-two", "kind": "cron", "canonicalUserId": "person@example.test", "project": "two", "sessionKey": "codexSessionId", "sessionId": "thread-two", "prompt": "two" }
+]

package/test-fixtures/migrations/multi-user/sessions.json

@@ -0,0 +1,4 @@
+{
+  "telegram:100": { "one": [{ "id": "session-one", "title": "One" }] },
+  "person@example.test": { "two": [{ "id": "provider-ambiguous-two", "title": "Two" }] }
+}

package/test-fixtures/migrations/multi-user/state.json

@@ -0,0 +1,6 @@
+{
+  "users": {
+    "telegram:100": { "currentSession": { "name": "one", "dir": "/workspace/one" }, "lastSessionId": "session-one", "settings": { "backend": "claude" } },
+    "person@example.test": { "currentSession": { "name": "two", "dir": "/workspace/two" }, "codexSessionId": "thread-two", "settings": { "backend": "codex" } }
+  }
+}

package/test-fixtures/provider-event-samples.json

@@ -0,0 +1,17 @@
+{
+  "claude": {
+    "session": { "type": "system", "subtype": "init", "session_id": "claude-session-1" },
+    "delta": { "type": "stream_event", "event": { "type": "content_block_delta", "delta": { "type": "text_delta", "text": "Hello " } }, "session_id": "claude-session-1" },
+    "assistant": { "type": "assistant", "message": { "role": "assistant", "content": [{ "type": "text", "text": "world" }], "usage": { "input_tokens": 12, "output_tokens": 3 } }, "session_id": "claude-session-1" },
+    "toolUse": { "type": "assistant", "message": { "role": "assistant", "content": [{ "type": "tool_use", "id": "tool-1", "name": "Read", "input": { "file_path": "fixture.txt" } }] }, "session_id": "claude-session-1" },
+    "toolResult": { "type": "user", "message": { "role": "user", "content": [{ "type": "tool_result", "tool_use_id": "tool-1", "content": "fixture output", "is_error": false }] }, "session_id": "claude-session-1" },
+    "result": { "type": "result", "subtype": "success", "is_error": false, "session_id": "claude-session-1", "result": "Hello world", "usage": { "input_tokens": 12, "output_tokens": 3 }, "total_cost_usd": 0 }
+  },
+  "codex": {
+    "session": { "type": "thread.started", "thread_id": "codex-thread-1" },
+    "toolStart": { "type": "item.started", "item": { "id": "item-1", "type": "command_execution", "command": "printf fixture", "status": "in_progress" } },
+    "toolEnd": { "type": "item.completed", "item": { "id": "item-1", "type": "command_execution", "command": "printf fixture", "aggregated_output": "fixture", "exit_code": 0, "status": "completed" } },
+    "assistant": { "type": "item.completed", "item": { "id": "item-final", "type": "agent_message", "text": "Hello from Codex" } },
+    "result": { "type": "turn.completed", "usage": { "input_tokens": 20, "cached_input_tokens": 5, "output_tokens": 4 } }
+  }
+}

package/test-learning-e2e.js

@@ -73,6 +73,11 @@ if (haveFts) {
 const transferred = packs.recordCoUse(["pack:mobile-app-deploy", "pack:chat-mobile"]);
 assert.deepStrictEqual(transferred.map((t) => t.project), ["chat-mobile"], "Stage 4: reuse recorded from real use");
 assert.deepStrictEqual(packs.readPack("mobile-app-deploy").applied_on, ["spaces", "chat-mobile"], "Stage 4: applied_on grew");
+const learnedAbilityFile = path.join(process.env.PACKS_DIR, "mobile-app-deploy", "PACK.md");
+assert.ok(fs.existsSync(`${learnedAbilityFile}.bak`), "learning updates retain a last-good pack backup");
+assert.strictEqual(fs.statSync(learnedAbilityFile).mode & 0o777, 0o600, "learning files stay owner-only");
+assert.deepStrictEqual(fs.readdirSync(path.dirname(learnedAbilityFile)).filter((name) => name.endsWith(".tmp")), [],
+  "atomic learning writes leave no partial temporary file");
 if (haveGraph) {
   graph.syncFromCorpus(packs, entStub);
   const fromChat = graph.expand([{ id: "pack:chat-mobile", score: 4 }], {});

package/test-memory-mutation-queue.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const root = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-memory-queue-"));
+process.env.OPEN_CLAUDIA_TEST = "1";
+process.env.OPEN_CLAUDIA_CONFIG_DIR = path.join(root, "config");
+fs.mkdirSync(process.env.OPEN_CLAUDIA_CONFIG_DIR, { recursive: true });
+
+const {
+  MemoryMutationQueue,
+  MutationQueueError,
+} = require("./core/memory-mutation-queue");
+const { atomicWriteFileSync } = require("./core/fsutil");
+
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+  return { promise, resolve, reject };
+}
+
+function wait(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+
+async function main() {
+  const lockDir = path.join(root, "shared.lock");
+  const journalFile = path.join(root, "mutation-journal.jsonl");
+  const firstQueue = new MemoryMutationQueue({ lockDir, journalFile, maxPending: 5, lockPollMs: 5 });
+  const secondQueue = new MemoryMutationQueue({ lockDir, journalFile, maxPending: 5, lockPollMs: 5 });
+  const gate = deferred();
+  const events = [];
+
+  const first = firstQueue.enqueue("review", async () => {
+    events.push("review:start");
+    await gate.promise;
+    events.push("review:end");
+    return "reviewed";
+  }, { provider: "codex", model: "fixture" });
+  while (!events.includes("review:start")) await wait(5);
+  const second = secondQueue.enqueue("dream", async () => {
+    events.push("dream:start");
+    await wait(5);
+    events.push("dream:end");
+    return "dreamed";
+  });
+  await wait(30);
+  assert.deepStrictEqual(events, ["review:start"], "independent queue instances serialize through the shared lock");
+  gate.resolve();
+  assert.deepStrictEqual(await Promise.all([first, second]), ["reviewed", "dreamed"]);
+  assert.deepStrictEqual(events, ["review:start", "review:end", "dream:start", "dream:end"]);
+  assert.ok(!fs.existsSync(lockDir), "shared lock is removed after every mutation");
+
+  const liveLockDir = path.join(root, "live-stale.lock");
+  const liveGate = deferred();
+  const liveOwner = new MemoryMutationQueue({
+    lockDir: liveLockDir,
+    journalFile,
+    maxPending: 2,
+    lockPollMs: 5,
+    staleLockMs: 10,
+  });
+  const liveContender = new MemoryMutationQueue({
+    lockDir: liveLockDir,
+    journalFile,
+    maxPending: 2,
+    lockPollMs: 5,
+    staleLockMs: 10,
+    lockTimeoutMs: 50,
+  });
+  const liveMutation = liveOwner.enqueue("long-dream", async () => liveGate.promise);
+  while (!fs.existsSync(path.join(liveLockDir, "owner.json"))) await wait(5);
+  await wait(20);
+  await assert.rejects(
+    liveContender.enqueue("must-not-steal", async () => "stolen"),
+    (error) => error.code === "MEMORY_MUTATION_LOCK_TIMEOUT",
+    "an old lock owned by a live process cannot be stolen from a long dream mutation",
+  );
+  liveGate.resolve("complete");
+  assert.strictEqual(await liveMutation, "complete");
+
+  const deadLockDir = path.join(root, "dead-stale.lock");
+  fs.mkdirSync(deadLockDir);
+  fs.writeFileSync(path.join(deadLockDir, "owner.json"), JSON.stringify({ token: "dead", pid: 2147483647 }));
+  const old = new Date(Date.now() - 10_000);
+  fs.utimesSync(deadLockDir, old, old);
+  const deadRecovery = new MemoryMutationQueue({
+    lockDir: deadLockDir,
+    journalFile,
+    lockPollMs: 5,
+    staleLockMs: 10,
+    lockTimeoutMs: 200,
+  });
+  assert.strictEqual(await deadRecovery.enqueue("recover-dead-lock", async () => "recovered"), "recovered");
+
+  const failureQueue = new MemoryMutationQueue({
+    lockDir: path.join(root, "failure.lock"),
+    journalFile,
+    maxPending: 3,
+    lockPollMs: 5,
+  });
+  await assert.rejects(
+    failureQueue.enqueue("broken-review", async () => { throw new Error("write fixture failed"); }),
+    /write fixture failed/,
+  );
+  assert.strictEqual(await failureQueue.enqueue("after-failure", async () => "still runs"), "still runs",
+    "one failed mutation never poisons the serial chain");
+
+  const boundedGate = deferred();
+  const bounded = new MemoryMutationQueue({
+    lockDir: path.join(root, "bounded.lock"),
+    journalFile,
+    maxPending: 1,
+    lockPollMs: 5,
+  });
+  const held = bounded.enqueue("held", async () => boundedGate.promise);
+  await wait(10);
+  await assert.rejects(
+    bounded.enqueue("overflow", async () => {}),
+    (error) => error instanceof MutationQueueError && error.code === "MEMORY_MUTATION_QUEUE_FULL",
+  );
+  boundedGate.resolve("released");
+  assert.strictEqual(await held, "released");
+
+  const shutdownGate = deferred();
+  const shutdownQueue = new MemoryMutationQueue({
+    lockDir: path.join(root, "shutdown.lock"),
+    journalFile,
+    maxPending: 3,
+    lockPollMs: 5,
+  });
+  const pending = shutdownQueue.enqueue("pending-review", async () => shutdownGate.promise, { provider: "claude" });
+  await wait(10);
+  shutdownQueue.stopAdmission("test shutdown");
+  await assert.rejects(
+    shutdownQueue.enqueue("late-review", async () => {}),
+    (error) => error.code === "MEMORY_MUTATION_QUEUE_CLOSED",
+  );
+  const timedDrain = await shutdownQueue.drain({ timeoutMs: 25 });
+  assert.strictEqual(timedDrain.drained, false);
+  assert.strictEqual(timedDrain.pending.length, 1);
+  assert.strictEqual(timedDrain.pending[0].label, "pending-review");
+  const journalBeforeRelease = fs.readFileSync(journalFile, "utf8");
+  assert.match(journalBeforeRelease, /"status":"pending_on_shutdown"/);
+  assert.ok(!journalBeforeRelease.includes("provider prompt"), "queue journal stores metadata only, never prompts");
+  shutdownGate.resolve("done");
+  assert.strictEqual(await pending, "done");
+  const finalDrain = await shutdownQueue.drain({ timeoutMs: 100 });
+  assert.strictEqual(finalDrain.drained, true);
+  assert.deepStrictEqual(finalDrain.pending, []);
+
+  const atomicFile = path.join(root, "atomic", "memory.md");
+  atomicWriteFileSync(atomicFile, "old complete memory\n", { mode: 0o600, backup: true });
+  const originalRename = fs.renameSync;
+  fs.renameSync = () => { throw new Error("rename fault fixture"); };
+  try {
+    assert.throws(
+      () => atomicWriteFileSync(atomicFile, "new incomplete memory\n", { mode: 0o600, backup: true }),
+      /rename fault fixture/,
+    );
+  } finally {
+    fs.renameSync = originalRename;
+  }
+  assert.strictEqual(fs.readFileSync(atomicFile, "utf8"), "old complete memory\n",
+    "failed atomic replacement preserves the complete previous file");
+  assert.deepStrictEqual(
+    fs.readdirSync(path.dirname(atomicFile)).filter((name) => name.endsWith(".tmp")),
+    [],
+    "failed atomic replacement cleans its temporary file",
+  );
+  atomicWriteFileSync(atomicFile, "new complete memory\n", { mode: 0o600, backup: true });
+  assert.strictEqual(fs.readFileSync(atomicFile, "utf8"), "new complete memory\n");
+  assert.strictEqual(fs.readFileSync(`${atomicFile}.bak`, "utf8"), "old complete memory\n");
+  assert.strictEqual(fs.statSync(atomicFile).mode & 0o777, 0o600);
+
+  const journal = fs.readFileSync(journalFile, "utf8").trim().split("\n").map(JSON.parse);
+  assert.ok(journal.some((entry) => entry.label === "broken-review" && entry.status === "failed"));
+  assert.ok(journal.some((entry) => entry.label === "after-failure" && entry.status === "completed"));
+  assert.ok(journal.every((entry) => !Object.prototype.hasOwnProperty.call(entry, "payload")));
+
+  console.log("memory mutation queue OK");
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+}).finally(() => fs.rmSync(root, { recursive: true, force: true }));