@inetafrica/open-claudia 3.5.18 → 3.5.19

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 3.5.19
+
+The memory duplicate-check fix as its own release (Sumeet, 8 Oct 13:08 EAT: "I'd rather just push out another release now rather than waiting for another day or so"). Everything in 3.5.18 below comes with it.
+
+- **The memory duplicate check works.** Before a reviewer's journal fact is stored, the dedup judge (3.2.0) checks it against similar stored lines: store, skip, update or merge. Its reply format was a bare JSON array, and Claude Code turns the format into a tool whose input the API requires to be an object, so every call from 3.2.2 on got "API Error: 400 tools.8.custom.input_schema.type: Input should be 'object'" and the fact was stored as proposed (1,459 times on the owner's bot, after 248 "Unknown utility purpose: dedup" on 3.2.0). The reply is now `{"verdicts": [...]}` (a bare array is still read), and each judgement logs one line with its verdicts (`[dedup-adjudicator] judged 2 facts: 1 store, 1 skip`). Exact repeats were already skipped without the judge.
+- **The classic recall filter works on Claude.** The relevance filter had the same bare-array format, so with `/engine classic` every Claude-run filter call failed and recall kept every keyword match. Its reply is now `{"relevant": [...]}`. Live calls still skip the filter.
+- **A reply format without an object root is refused before any model runs** (`INVALID_UTILITY_SCHEMA`), so the next one fails in tests instead of quietly on every call.
+- **Tests:** `test-dedup-adjudicator.js` (the judge through the real utility agent and the fake Claude and Codex CLIs; the object reply and a bare array), `test-provider-recall.js` (the filter's object schema reaches Claude Code, and Codex enforces it), `test-utility-provider-policy.js` (array, untyped and non-object roots refused before any spawn), `test-codex-output-schema.js` (every `*_OUTPUT_SCHEMA` in core/ has an object root).
+
 ## 3.5.18
 
 Usage limits (Sumeet, 7 Oct 15:00 EAT: "track usage and notify the user that they are going to hit their limit, if the limit is hit can the bot auto schedule to continue when the limit replenishes"; 15:14 EAT: "if the user sends it a message it cancels and if the session limit message comes up again it will just rearm").

package/core/dedup-adjudicator.js

@@ -17,23 +17,32 @@ const GATE_MIN_SCORE = Number(process.env.PACK_DEDUP_GATE_SCORE || 25);
 const ADJUDICATOR_TIMEOUT_MS = Number(process.env.PACK_DEDUP_TIMEOUT_MS || 45000);
 const MAX_CANDIDATES_PER_FACT = 3;
 
+// The root must be an object: Claude Code turns the schema into a tool whose
+// input_schema the API requires to be an object. The bare array this used to
+// be got a 400 on every call from 3.2.2 to 3.5.18, so dedup failed open.
 const ADJUDICATOR_OUTPUT_SCHEMA = Object.freeze({
-  type: "array",
-  items: {
-    type: "object",
-    required: ["id", "verdict"],
-    properties: {
-      id: { type: "string" },
-      verdict: { type: "string", enum: ["store", "update", "merge", "skip"] },
-      target: { type: "string" },
-      merged: { type: "string" },
+  type: "object",
+  required: ["verdicts"],
+  properties: {
+    verdicts: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["id", "verdict"],
+        properties: {
+          id: { type: "string" },
+          verdict: { type: "string", enum: ["store", "update", "merge", "skip"] },
+          target: { type: "string" },
+          merged: { type: "string" },
+        },
+      },
     },
   },
 });
 
 const ADJUDICATOR_SYSTEM_PROMPT = [
   "You are a dedup judge for an assistant's long-term memory.",
-  "Reply with ONLY a JSON array of verdicts — no prose, no markdown fences.",
+  'Reply with ONLY a JSON object {"verdicts": [...]} — no prose, no markdown fences.',
 ].join("\n");
 
 function enabled() {
@@ -113,20 +122,29 @@ function buildAdjudicationPrompt(pairs) {
     "",
     ...blocks,
     "",
-    `Reply with ONLY a JSON array like [{"id":"f1","verdict":"store"}] covering every FACT id.`,
+    `Reply with ONLY a JSON object like {"verdicts":[{"id":"f1","verdict":"store"}]} covering every FACT id.`,
   ].join("\n");
 }
 
+// The reply is {"verdicts": [...]}; a bare array is still read.
+function verdictList(value) {
+  if (Array.isArray(value)) return value;
+  return value && typeof value === "object" && Array.isArray(value.verdicts) ? value.verdicts : null;
+}
+
 function parseVerdicts(result) {
-  if (Array.isArray(result?.json)) return result.json;
-  const match = String(result?.text || "").match(/\[[\s\S]*\]/);
-  if (!match) return null;
-  try {
-    const parsed = JSON.parse(match[0]);
-    return Array.isArray(parsed) ? parsed : null;
-  } catch (_) {
-    return null;
+  const fromJson = verdictList(result?.json);
+  if (fromJson) return fromJson;
+  const text = String(result?.text || "");
+  for (const pattern of [/\{[\s\S]*\}/, /\[[\s\S]*\]/]) {
+    const match = text.match(pattern);
+    if (!match) continue;
+    try {
+      const list = verdictList(JSON.parse(match[0]));
+      if (list) return list;
+    } catch (_) { /* try the other shape */ }
   }
+  return null;
 }
 
 // Phase 3 — turn raw verdicts into a transformed decision plus replacement
@@ -220,6 +238,11 @@ function createDedupAdjudicator(dependencies = {}) {
         });
         rawVerdicts = parseVerdicts(result) || [];
         llmUsed = true;
+        // One line per judgement, so its verdicts can be checked in the log
+        // (before 3.5.19 it logged only failures, and failed on every call).
+        const counts = {};
+        for (const v of rawVerdicts) if (v && typeof v.verdict === "string") counts[v.verdict] = (counts[v.verdict] || 0) + 1;
+        console.log(`[dedup-adjudicator] judged ${pairs.length} fact${pairs.length === 1 ? "" : "s"}: ${Object.entries(counts).map(([verdict, n]) => `${n} ${verdict}`).join(", ") || "no verdicts"}`);
       } catch (error) {
         console.warn(`[dedup-adjudicator] failed open: ${error.message}`);
         rawVerdicts = [];

package/core/recall-filter.js

@@ -7,9 +7,15 @@
 const FILTER_TIMEOUT_MS = Number(process.env.RECALL_FILTER_TIMEOUT_MS || 20000);
 const MESSAGE_CLIP_CHARS = 1500;
 const CONTEXT_CLIP_CHARS = 3500;
+// The root must be an object: Claude Code turns the schema into a tool whose
+// input_schema the API requires to be an object, so the bare array this used
+// to be got a 400 on every Claude call and the filter failed open.
 const FILTER_OUTPUT_SCHEMA = Object.freeze({
-  type: "array",
-  items: { type: "string" },
+  type: "object",
+  required: ["relevant"],
+  properties: {
+    relevant: { type: "array", items: { type: "string" } },
+  },
 });
 
 function enabled() {
@@ -18,15 +24,28 @@ function enabled() {
 
 const FILTER_SYSTEM_PROMPT = [
   "You are a relevance judge for an assistant's memory recall.",
-  "Reply with ONLY a JSON array of candidate ids — no prose, no markdown fences.",
+  'Reply with ONLY a JSON object {"relevant": [candidate ids]} — no prose, no markdown fences.',
 ].join("\n");
 
+// The reply is {"relevant": [...]}; a bare array is still read.
+function idList(value) {
+  if (Array.isArray(value)) return value;
+  return value && typeof value === "object" && Array.isArray(value.relevant) ? value.relevant : null;
+}
+
 function parseIds(result) {
-  if (Array.isArray(result?.json)) return result.json;
-  const match = String(result?.text || "").match(/\[[\s\S]*?\]/);
-  if (!match) return null;
-  const parsed = JSON.parse(match[0]);
-  return Array.isArray(parsed) ? parsed : null;
+  const fromJson = idList(result?.json);
+  if (fromJson) return fromJson;
+  const text = String(result?.text || "");
+  for (const pattern of [/\{[\s\S]*\}/, /\[[\s\S]*?\]/]) {
+    const match = text.match(pattern);
+    if (!match) continue;
+    try {
+      const ids = idList(JSON.parse(match[0]));
+      if (ids) return ids;
+    } catch (_) { /* try the other shape */ }
+  }
+  return null;
 }
 
 function createRecallFilter(dependencies = {}) {
@@ -62,7 +81,7 @@ function createRecallFilter(dependencies = {}) {
       "Candidates:",
       ...lines,
       "",
-      `Reply with ONLY a JSON array of the relevant ids, e.g. ["${candidates[0].id}"]. Use [] if none are relevant.`,
+      `Reply with ONLY a JSON object of the relevant ids, e.g. {"relevant": ["${candidates[0].id}"]}. Use {"relevant": []} if none are relevant.`,
     ].join("\n");
     try {
       const result = await runUtility(prompt, {

package/core/utility-agent.js

@@ -123,6 +123,13 @@ function validateSchema(value, schema, location = "$", depth = 0) {
 
 function prepareSchemaFile(schema) {
   if (!schema) return null;
+  // Claude Code turns the schema into a tool whose input_schema the API
+  // requires to be an object, and OpenAI strict mode wants an object root too.
+  // Any other root is refused on every call, which a fail-open caller shows
+  // only as a warning (the dedup adjudicator's array root, 3.2.2 to 3.5.18).
+  if (typeof schema !== "object" || Array.isArray(schema) || schema.type !== "object") {
+    throw new UtilityAgentError("INVALID_UTILITY_SCHEMA", 'outputSchema must have top-level type "object"');
+  }
   let serialized;
   try { serialized = JSON.stringify(schema); }
   catch (_) { throw new UtilityAgentError("INVALID_UTILITY_SCHEMA", "outputSchema must be JSON-serializable"); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.5.18",
+  "version": "3.5.19",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {

package/test-provider-language.js

@@ -586,7 +586,12 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // step without tools, the same cap for scheduled jobs' own conversations,
 // and usage-limit pick-ups with 80/95% warnings. This Mac bot first, then the
 // fleet once it is stable here.
-assert.strictEqual(pkg.version, "3.5.18", "release version must remain unchanged without explicit approval");
+// 3.5.19 approved by Sumeet 2026-10-08 13:08 EAT ("I'd rather just push out
+// another release now rather than waiting for another day or so"): the memory
+// dedup judge and the classic recall filter reply in an object (the API
+// refused their bare-array formats on every Claude call), and the utility
+// agent refuses any reply format without an object root. This Mac bot first.
+assert.strictEqual(pkg.version, "3.5.19", "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-recall.js

@@ -20,7 +20,7 @@ const { createClaudeProvider } = require("./core/providers/claude");
 const { createCodexProvider } = require("./core/providers/codex");
 const { createUtilityPolicy } = require("./core/providers/utility-policy");
 const { createUtilityAgentService } = require("./core/utility-agent");
-const { createRecallFilter } = require("./core/recall-filter");
+const { createRecallFilter, FILTER_OUTPUT_SCHEMA } = require("./core/recall-filter");
 const discoverer = require("./core/recall/discoverer");
 const metrics = require("./core/recall/metrics");
 const warmWalker = require("./core/recall/warm-walker");
@@ -89,15 +89,25 @@ async function main() {
     const capture = path.join(root, `${kind}-filter.json`);
     const h = harness(kind, {
       FAKE_AGENT_CAPTURE: capture,
-      FAKE_AGENT_TEXT: '["pack:keep"]',
+      FAKE_AGENT_TEXT: '{"relevant":["pack:keep"]}',
     });
     const filter = createRecallFilter({ spawnUtilityAgent: h.utility.spawnUtilityAgent });
     const kept = await filter.judgeRelevance("keep this project", [
       { id: "pack:keep", name: "Keep", description: "relevant" },
       { id: "pack:drop", name: "Drop", description: "unrelated" },
     ], { provider: kind, context: "same project" });
-    assert.deepStrictEqual([...kept], ["pack:keep"]);
     const record = JSON.parse(fs.readFileSync(capture, "utf8"));
+    if (kind === "claude") {
+      // Claude Code turns the schema into a tool whose input_schema must be an
+      // object; the bare array the filter's schema was got a 400 on every call.
+      assert.ok(record.argv.includes("--json-schema"), "Claude Code is handed the filter's schema");
+      assert.strictEqual(JSON.parse(record.argv[record.argv.indexOf("--json-schema") + 1]).type, "object",
+        "Claude Code gets an object-root schema: the API refuses any other tool input_schema");
+    } else {
+      assert.ok(record.argv.includes("--output-schema"), "the filter's schema passes strict mode, so Codex enforces it");
+    }
+    assert.ok(kept, `${kind}: the relevance judgement is read (not failed open)`);
+    assert.deepStrictEqual([...kept], ["pack:keep"]);
     assert.strictEqual(record.stdin.present, true);
     assert.ok(!record.argv.some((arg) => /keep this project/.test(arg)), "recall candidates stay out of argv");
     if (kind === "claude") {
@@ -108,6 +118,29 @@ async function main() {
     }
   }
 
+  // The filter's schema has an object root and the reply is {"relevant": [...]};
+  // the prompts ask for that object, and a bare array is still read.
+  assert.strictEqual(FILTER_OUTPUT_SCHEMA.type, "object", "the recall filter schema's top-level type is object");
+  assert.deepStrictEqual(FILTER_OUTPUT_SCHEMA.required, ["relevant"]);
+  assert.strictEqual(FILTER_OUTPUT_SCHEMA.properties.relevant.type, "array");
+  for (const [shape, reply] of [
+    ["wrapped JSON", { json: { relevant: ["pack:a"] } }],
+    ["wrapped text", { text: 'Kept: {"relevant": ["pack:a"]}' }],
+    ["bare array JSON", { json: ["pack:a"] }],
+    ["bare array text", { text: '["pack:a"]' }],
+  ]) {
+    let asked = null;
+    const kept = await createRecallFilter({
+      spawnUtilityAgent: async (prompt, request) => { asked = { prompt, request }; return reply; },
+    }).judgeRelevance("alpha question", [{ id: "pack:a", name: "A" }, { id: "pack:b", name: "B" }]);
+    assert.ok(kept, `${shape}: the ids are read`);
+    assert.deepStrictEqual([...kept], ["pack:a"], `${shape}: only the kept candidate`);
+    assert.strictEqual(asked.request.outputSchema, FILTER_OUTPUT_SCHEMA);
+    assert.match(asked.request.systemPrompt, /\{"relevant"/, "the system prompt asks for the object");
+    assert.match(asked.prompt, /\{"relevant": \["pack:a"\]\}/, "the task prompt asks for the object");
+    assert.doesNotMatch(`${asked.request.systemPrompt}\n${asked.prompt}`, /JSON array/, "nothing asks for a bare array any more");
+  }
+
   const failedFilter = createRecallFilter({
     spawnUtilityAgent: async () => { throw new Error("fixture unavailable"); },
   });
@@ -120,7 +153,7 @@ async function main() {
   const legacyClaudeCapture = path.join(root, "legacy-claude-filter.json");
   const legacyClaude = harness("claude", {
     FAKE_AGENT_CAPTURE: legacyClaudeCapture,
-    FAKE_AGENT_TEXT: '["pack:a"]',
+    FAKE_AGENT_TEXT: '{"relevant":["pack:a"]}',
   }, { RECALL_FILTER_MODEL: "legacy-claude-filter" });
   await createRecallFilter({ spawnUtilityAgent: legacyClaude.utility.spawnUtilityAgent })
     .judgeRelevance("query", [{ id: "pack:a", name: "A" }], { provider: "claude" });
@@ -135,7 +168,7 @@ async function main() {
   const codexExactCapture = path.join(root, "exact-codex-filter.json");
   const codexExact = harness("codex", {
     FAKE_AGENT_CAPTURE: codexExactCapture,
-    FAKE_AGENT_TEXT: '["pack:a"]',
+    FAKE_AGENT_TEXT: '{"relevant":["pack:a"]}',
   }, {
     RECALL_FILTER_MODEL: "legacy-must-not-cross",
     RECALL_FILTER_MODEL_CODEX: "codex-filter-exact",

package/test-utility-provider-policy.js

@@ -386,6 +386,33 @@ async function main() {
     cwd: root,
   }), "UTILITY_SCHEMA_INVALID");
 
+  // A schema whose root is not an object never reaches a provider. Claude Code
+  // turns it into a tool whose input_schema must be an object (OpenAI strict
+  // mode wants one too): the dedup adjudicator's array root got "400 ...
+  // input_schema.type: Input should be 'object'" at the API on every call and
+  // showed only as a fail-open warning. It fails here, before any spawn.
+  const arrayRootCapture = path.join(root, "array-root-capture.json");
+  const arrayRootService = createUtilityAgentService({
+    registry: registry(providers({ claude: { FAKE_AGENT_CAPTURE: arrayRootCapture, FAKE_AGENT_TEXT: "[]" } })),
+    env: { UTILITY_PROVIDER: "claude" },
+  });
+  for (const outputSchema of [
+    { type: "array", items: { type: "string" } },
+    { items: { type: "object" } },
+    [{ type: "object" }],
+  ]) {
+    await assert.rejects(arrayRootService.spawnUtilityAgent("judge", {
+      purpose: "dedup", tier: "low", systemPrompt: "judge", readOnly: true, outputSchema, cwd: root,
+    }), (error) => {
+      assert.ok(error instanceof UtilityAgentError);
+      assert.strictEqual(error.code, "INVALID_UTILITY_SCHEMA");
+      assert.match(error.message, /top-level type "object"/);
+      return true;
+    }, `${JSON.stringify(outputSchema)} is refused`);
+  }
+  assert.strictEqual(fs.existsSync(arrayRootCapture), false, "no provider ran for a schema it would refuse");
+  assert.deepStrictEqual(arrayRootService.stats(), { activeGlobal: 0, activeByPurpose: {} }, "the refused calls released their slots");
+
   const truncService = createUtilityAgentService({
     registry: registry(providers({ claude: { FAKE_AGENT_TEXT: "0123456789abcdefghijklmnopqrstuvwxyz" } })),
     env: { UTILITY_PROVIDER: "claude" },