@inetafrica/open-claudia 3.0.26 → 3.0.28

package/core/prompt-budget.js

@@ -0,0 +1,165 @@
+// Always-on prompt budget instrumentation (Track X0). One JSONL line per real
+// user turn plus a rolling summary, so we can baseline the fixed prompt floor
+// (soul + lessons + runtime state + slash-command list + tool headlines +
+// relationship/mandate) and watch it grow as new systems are bolted on. This
+// is read-only telemetry: it never changes what is sent to the model, it only
+// measures it. Mirrors the storage shape of core/recall/metrics.js.
+
+const fs = require("fs");
+const path = require("path");
+const CONFIG_DIR = require("../config-dir");
+
+const LOG_FILE = path.join(CONFIG_DIR, "prompt-budget.jsonl");
+const SUMMARY_FILE = path.join(CONFIG_DIR, "prompt-budget-summary.json");
+let VERSION = "";
+try { VERSION = require("../package.json").version || ""; } catch (e) {}
+
+const MAX_LOG_BYTES = 2 * 1024 * 1024; // truncate the jsonl past ~2MB so telemetry never eats disk
+
+function enabled() {
+  return String(process.env.PROMPT_BUDGET || "on").toLowerCase() !== "off";
+}
+
+// Local, network-free token estimate. Markdown/English averages ~4 chars per
+// token; this is deliberately an ESTIMATE — consistency across turns matters
+// more than matching a specific tokenizer, since X0 tracks growth over time.
+function estimateTokens(str) {
+  const chars = typeof str === "string" ? str.length : 0;
+  return Math.ceil(chars / 4);
+}
+
+function part(str) {
+  const chars = typeof str === "string" ? str.length : 0;
+  return { chars, tokens: estimateTokens(str) };
+}
+
+function addSize(a, b) {
+  return { chars: a.chars + b.chars, tokens: a.tokens + b.tokens };
+}
+
+// Which named prompt components form the fixed "always-on floor" vs the
+// variable, on-demand recall payload and the turn's own user input.
+const ALWAYS_ON_KEYS = [
+  "core",           // soul + persona + lessons + skill index + tool index + fixed boilerplate
+  "runtime",        // runtime state block
+  "speaker",        // speaker + team roster + slash-command list
+  "speakerPersona",
+  "provider",       // provider-native tools note
+  "voice",
+  "relationship",   // external-mode / mandate
+  "spacesMode",
+];
+const VARIABLE_KEYS = ["transcript", "recall"];
+
+// Break an assembled turn's named parts into sizes. `parts` keys mirror the
+// components of buildTurnPrompt(); any subset is tolerated.
+function measure(parts = {}) {
+  const components = {};
+  for (const [k, v] of Object.entries(parts)) components[k] = part(v);
+
+  let alwaysOn = { chars: 0, tokens: 0 };
+  for (const k of ALWAYS_ON_KEYS) if (components[k]) alwaysOn = addSize(alwaysOn, components[k]);
+
+  let variable = { chars: 0, tokens: 0 };
+  for (const k of VARIABLE_KEYS) if (components[k]) variable = addSize(variable, components[k]);
+
+  const recall = components.recall || { chars: 0, tokens: 0 };
+  const userPrompt = components.userPrompt || { chars: 0, tokens: 0 };
+  const total = addSize(addSize(alwaysOn, variable), userPrompt);
+
+  return { components, alwaysOn, recall, variable, userPrompt, total };
+}
+
+function readSummary() {
+  try { return JSON.parse(fs.readFileSync(SUMMARY_FILE, "utf8")) || {}; } catch (e) { return {}; }
+}
+function writeSummary(s) {
+  try { fs.writeFileSync(SUMMARY_FILE, JSON.stringify(s, null, 2)); } catch (e) {}
+}
+
+function bumpSummary(m, meta) {
+  const s = readSummary();
+  s.turns = (s.turns || 0) + 1;
+  s.alwaysOnTokensTotal = (s.alwaysOnTokensTotal || 0) + m.alwaysOn.tokens;
+  s.recallTokensTotal = (s.recallTokensTotal || 0) + m.recall.tokens;
+  s.totalTokensTotal = (s.totalTokensTotal || 0) + m.total.tokens;
+  s.alwaysOnTokensMax = Math.max(s.alwaysOnTokensMax || 0, m.alwaysOn.tokens);
+  s.componentTokensTotal = s.componentTokensTotal || {};
+  for (const [k, v] of Object.entries(m.components)) {
+    s.componentTokensTotal[k] = (s.componentTokensTotal[k] || 0) + v.tokens;
+  }
+  // Latest snapshot — the current per-component breakdown ("what is the floor
+  // right now"), distinct from the rolling averages above.
+  s.latest = {
+    ts: new Date().toISOString(),
+    v: VERSION,
+    provider: meta.provider || "",
+    alwaysOnTokens: m.alwaysOn.tokens,
+    recallTokens: m.recall.tokens,
+    totalTokens: m.total.tokens,
+    components: Object.fromEntries(Object.entries(m.components).map(([k, v]) => [k, v.tokens])),
+  };
+  s.updatedAt = new Date().toISOString();
+  writeSummary(s);
+}
+
+function appendLog(rec) {
+  try {
+    try {
+      const st = fs.statSync(LOG_FILE);
+      if (st.size > MAX_LOG_BYTES) fs.rmSync(LOG_FILE, { force: true });
+    } catch (e) {}
+    fs.appendFileSync(LOG_FILE, JSON.stringify(rec) + "\n");
+  } catch (e) {}
+}
+
+// Record one real turn's prompt budget. Best-effort; never throws.
+function record(measurement, meta = {}) {
+  if (!enabled()) return;
+  try {
+    const m = measurement && measurement.total ? measurement : null;
+    if (!m) return;
+    const rec = {
+      ts: new Date().toISOString(),
+      v: VERSION,
+      provider: meta.provider || "",
+      runId: meta.runId || null,
+      alwaysOnTokens: m.alwaysOn.tokens,
+      recallTokens: m.recall.tokens,
+      totalTokens: m.total.tokens,
+      components: Object.fromEntries(Object.entries(m.components).map(([k, v]) => [k, v.tokens])),
+    };
+    appendLog(rec);
+    bumpSummary(m, meta);
+  } catch (e) {}
+}
+
+// Human-readable rolling view (rendered by `open-claudia prompt-budget`).
+function summary() {
+  const s = readSummary();
+  const turns = s.turns || 0;
+  const avg = (total) => (turns ? Math.round((total || 0) / turns) : 0);
+  const componentAvg = {};
+  for (const [k, v] of Object.entries(s.componentTokensTotal || {})) componentAvg[k] = avg(v);
+  return {
+    turns,
+    avgAlwaysOnTokens: avg(s.alwaysOnTokensTotal),
+    maxAlwaysOnTokens: s.alwaysOnTokensMax || 0,
+    avgRecallTokens: avg(s.recallTokensTotal),
+    avgTotalTokens: avg(s.totalTokensTotal),
+    componentAvgTokens: componentAvg,
+    latest: s.latest || null,
+    updatedAt: s.updatedAt || "",
+  };
+}
+
+function _resetForTest() {
+  try { fs.rmSync(LOG_FILE, { force: true }); } catch (e) {}
+  try { fs.rmSync(SUMMARY_FILE, { force: true }); } catch (e) {}
+}
+
+module.exports = {
+  LOG_FILE, SUMMARY_FILE, VERSION, enabled,
+  ALWAYS_ON_KEYS, VARIABLE_KEYS,
+  estimateTokens, measure, record, summary, _resetForTest,
+};

package/core/runner.js

@@ -761,7 +761,7 @@ function createRunnerService(dependencies = {}) {
     let bundle;
     let invocation;
     try {
-      bundle = await promptBuilder(prompt, { runContext, provider });
+      bundle = await promptBuilder(prompt, { runContext, provider, recordBudget: !capture });
       invocation = invocationBuilder(provider, invocationContextForRun(runContext, bundle, provider));
       if (dependencies.decorateInvocation) {
         invocation = dependencies.decorateInvocation(invocation, runContext, bundle, provider);
@@ -1860,6 +1860,23 @@ async function handoffMemoryReview(result, runContext, store, state) {
   });
 }
 
+// Track C — owner-guardrail capture. After a foreground turn, a deterministic
+// detector spots durable-rule statements ("from now on / never / stop") in the
+// owner's message and captures them into lessons.md (or asks first). Owner-only
+// and best-effort: it never blocks or breaks a turn.
+async function considerGuardrail(result, runContext, store) {
+  try {
+    if (!result.ok || runContext.purpose !== "foreground") return;
+    const guardrail = require("./guardrail");
+    if (!guardrail.enabled()) return;
+    const relationship = require("./relationship");
+    const speaker = relationship.speakerFor(store?.adapter?.type, store?.channelId, store?.userId);
+    if (relationship.guardActive(speaker)) return; // external speakers never capture
+    const announce = (text, opts) => chatContext.run(store, () => send(text, opts));
+    await guardrail.consider({ text: runContext.userPrompt, speaker, announce });
+  } catch (e) { /* best-effort — a guardrail miss must never break a turn */ }
+}
+
 function deferredRunResult() {
   let resolve;
   let reject;
@@ -1920,6 +1937,7 @@ async function executeAdmittedRun(runContext, state, store, capture, ownsAdmissi
     try { service.turnObserver.onTurnSettled(!!result.ok); } catch (e) { /* best-effort */ }
   }
   if (!internalCapture) await handoffMemoryReview(result, runContext, store, state);
+  if (!internalCapture) await considerGuardrail(result, runContext, store);
   if (!internalCapture && state.settings?.backend === runContext.provider && state.settings.budget) {
     state.settings.budget = null;
     try { saveState({ strict: true }); }

package/core/state.js

@@ -652,6 +652,21 @@ function acquireRunLock(state = currentState()) {
   return true;
 }
 
+// True when ANY user has a turn running, admitted-and-preparing, compacting, or
+// waiting in its queue. Same busy predicate as acquireRunLock, but across every
+// user state rather than one — the Telegram poll-wedge backstop consults this
+// before a self-exit so a reboot never interrupts in-flight work. It fires on a
+// timer outside any channel context (no "current" user) and a reboot kills the
+// whole process, so it must scan all states, not just currentState().
+function anyTurnActive() {
+  for (const s of userStates.values()) {
+    if (!s) continue;
+    if (s.runningProcess || s.preparingRun || s.isCompacting) return true;
+    if (Array.isArray(s.messageQueue) && s.messageQueue.length) return true;
+  }
+  return false;
+}
+
 function migrationSources() {
   return defaultMigrationSources({
     configDir: CONFIG_DIR,
@@ -1363,6 +1378,7 @@ module.exports = {
   resetSessionUsage,
   resetSettings,
   acquireRunLock,
+  anyTurnActive,
   saveState,
   loadSessions,
   loadSessionsDocument,

package/core/system-prompt.js

@@ -15,6 +15,7 @@ const {
 const tasksStore = require("./tasks");
 const people = require("./people");
 const commandsRegistry = require("./commands");
+const promptBudget = require("./prompt-budget");
 
 function loadSoul() {
   const soul = fs.readFileSync(SOUL_FILE, "utf-8");
@@ -1068,12 +1069,40 @@ function createPromptBuilder(dependencies = {}) {
         spacesTaskMode,
       ].filter((part) => typeof part === "string" && part.trim()).join("\n\n");
 
+      // Track X0: measure the fixed always-on floor vs the variable recall
+      // payload for this turn. Pure measurement — attached to the bundle for
+      // any caller; only recorded to telemetry when the caller opts in
+      // (real user turns, never sub-agent/capture builds).
+      let budget = null;
+      try {
+        budget = promptBudget.measure({
+          core: coreInstructions,
+          transcript: transcriptContext,
+          runtime: runtimeContext,
+          speaker: speakerContext,
+          speakerPersona,
+          provider: providerContext,
+          recall: recallResult.dynamicContext,
+          voice: voiceContext,
+          relationship: relationshipContext,
+          spacesMode: spacesTaskMode,
+          userPrompt,
+        });
+        if (opts.recordBudget) {
+          promptBudget.record(budget, {
+            provider: opts.provider?.id,
+            runId: opts.runContext?.runId,
+          });
+        }
+      } catch (_) { budget = null; }
+
       return {
         coreInstructions,
         dynamicContext,
         userPrompt,
         transcriptPaths,
         recallMetadata: recallResult.metadata,
+        promptBudget: budget,
       };
     },
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.0.26",
+  "version": "3.0.28",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {
@@ -9,7 +9,7 @@
   "scripts": {
     "setup": "node setup.js",
     "start": "node bot.js",
-    "pretest": "node test-provider-fixture.js && node test-provider-core-prompt.js && node test-provider-prompt-parity.js && node test-provider-env-isolation.js && node test-provider-resume-parity.js && node test-provider-bootstrap.js && node test-provider-registry.js && node test-provider-stream-decoder.js && node test-provider-events.js && node test-provider-claude.js && node test-provider-codex.js && node test-provider-runner.js && node test-provider-run-lifecycle.js && node test-provider-gateway.js && node test-provider-side-chat.js && node test-single-runtime.js && node test-provider-migration-backup.js && node test-provider-state-migration.js && node test-provider-session-history.js && node test-provider-session-commands.js && node test-provider-compaction.js && node test-provider-scheduler.js && node test-cursor-removal.js && node test-utility-provider-policy.js && node test-provider-subagent.js && node test-provider-recall.js && node test-provider-pack-review.js && node test-memory-mutation-queue.js && node test-provider-dream.js && node test-provider-enforcer.js && node test-provider-tool-hooks.js && node test-provider-boot-matrix.js && node test-provider-capabilities.js && node test-provider-language.js && node test-provider-coupling-audit.js && node test-provider-parity-e2e.js && node test-kazee-channel-health.js",
+    "pretest": "node test-provider-fixture.js && node test-provider-core-prompt.js && node test-provider-prompt-parity.js && node test-provider-env-isolation.js && node test-provider-resume-parity.js && node test-provider-bootstrap.js && node test-provider-registry.js && node test-provider-stream-decoder.js && node test-provider-events.js && node test-provider-claude.js && node test-provider-codex.js && node test-provider-runner.js && node test-provider-run-lifecycle.js && node test-provider-gateway.js && node test-provider-side-chat.js && node test-single-runtime.js && node test-provider-migration-backup.js && node test-provider-state-migration.js && node test-provider-session-history.js && node test-provider-session-commands.js && node test-provider-compaction.js && node test-provider-scheduler.js && node test-cursor-removal.js && node test-utility-provider-policy.js && node test-provider-subagent.js && node test-provider-recall.js && node test-provider-pack-review.js && node test-memory-mutation-queue.js && node test-provider-dream.js && node test-provider-enforcer.js && node test-provider-tool-hooks.js && node test-provider-boot-matrix.js && node test-provider-capabilities.js && node test-provider-language.js && node test-provider-coupling-audit.js && node test-provider-parity-e2e.js && node test-kazee-channel-health.js && node test-prompt-budget.js && node test-agency-ledger.js && node test-agency-deliberate.js && node test-guardrail.js",
     "test": "OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node -e \"require('./vault'); console.log('OK')\" && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-runner-watchdog-static.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-usage-accounting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-engine.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-discoverer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-project-transcripts-smoke.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-abilities.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-extraction.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-couse.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-transfer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-tiers.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-ability-merge-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-learning-e2e.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-pack-nesting.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-journal-dedupe.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-read-signal.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tools.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-graph.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tooling-mode.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-tool-manifest.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-evolution.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-approval-async.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-unified-identity.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-queue-routing.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-persona-packs.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-speaker-persona.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-persona-pipeline.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-recall-relationship-gate.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-relationship.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-enforcer.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-identity-prune.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-kazee-message-id.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-delivery-contract.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-run-lock.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-web-sessions.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-telegram-poll-recovery.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-telegram-409-grace.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-telegram-conflict-heal-guard.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-single-instance.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-streaming-split.js && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=./test-fixtures/fake-agent-cli.js FAKE_AGENT_KIND=claude AGENT_ENV_PASSTHROUGH=FAKE_AGENT_KIND node test-spaces-autoenable.js"
   },
   "files": [
@@ -66,6 +66,10 @@
     "test-identity-prune.js",
     "test-kazee-message-id.js",
     "test-kazee-channel-health.js",
+    "test-prompt-budget.js",
+    "test-agency-ledger.js",
+    "test-agency-deliberate.js",
+    "test-guardrail.js",
     "test-delivery-contract.js",
     "test-run-lock.js",
     "test-web-sessions.js",

package/test-agency-deliberate.js

@@ -0,0 +1,119 @@
+// Track B1 — advisory deliberation. Deterministic triage/rank, confidence floor
+// and clear-margin behaviour, the injectable judge (including failure fallback),
+// and best-effort shadow logging. 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-delib-"));
+process.env.OPEN_CLAUDIA_CONFIG_DIR = TMP;
+
+const D = require("./core/agency/deliberate");
+
+const NOW = Date.parse("2026-07-15T12:00:00.000Z");
+const DAY = 86400000;
+
+function entry(o) {
+  return Object.assign(
+    { source: "task", kind: "task", id: "x", title: "t", status: "open",
+      priority: null, due: null, lastTouched: NOW, staleDays: 0, blockedOn: null,
+      overdue: false, meta: {} },
+    o,
+  );
+}
+function ledgerOf(entries) {
+  return { generatedAt: NOW, counts: { total: entries.length }, entries };
+}
+
+// --- triage: notifications never candidates; bare open local task isn't either
+assert.strictEqual(D.isCandidate(entry({ source: "notification", status: "info" }), NOW), false);
+assert.strictEqual(D.isCandidate(entry({ source: "task", status: "open", due: null }), NOW), false);
+assert.strictEqual(D.isCandidate(entry({ source: "task", status: "in_progress" }), NOW), true);
+assert.strictEqual(D.isCandidate(entry({ source: "spaces", staleDays: 3 }), NOW), true);
+
+// --- scoreOf: overdue dominates, signals surface
+const sc = D.scoreOf(entry({ overdue: true, due: NOW - 2 * DAY, priority: "high" }), NOW);
+assert.ok(sc.score > 100, "overdue+high scores high");
+assert.ok(sc.signals.some((s) => s.k === "overdue"));
+assert.ok(sc.signals.some((s) => s.k === "priority"));
+
+(async () => {
+  // --- clear winner: overdue high-priority Spaces task beats an in-progress task
+  const p1 = await D.deliberate(ledgerOf([
+    entry({ source: "spaces", id: "s1", title: "Overdue!", overdue: true, due: NOW - 2 * DAY, priority: "high", staleDays: 2 }),
+    entry({ source: "task", id: "t1", title: "WIP", status: "in_progress", staleDays: 1 }),
+    entry({ source: "notification", id: "n1", status: "info" }),
+  ]), { now: NOW });
+  assert.strictEqual(p1.proposed, true);
+  assert.strictEqual(p1.pick.id, "s1", "overdue item picked");
+  assert.strictEqual(p1.confidence, "high", "clear margin → high confidence");
+  assert.strictEqual(p1.method, "deterministic");
+  assert.strictEqual(p1.actionType, "ask", "overdue Spaces assignment → nudge");
+  assert.ok(p1.why.join(" ").includes("overdue"));
+  assert.ok(D.render(p1).includes("Overdue!"));
+
+  // --- default-silence: lone far-future item scores below the floor
+  const p2 = await D.deliberate(ledgerOf([
+    entry({ source: "spaces", id: "s2", title: "Someday", due: NOW + 20 * DAY, staleDays: 1 }),
+  ]), { now: NOW });
+  assert.strictEqual(p2.proposed, false, "below confidence floor → propose nothing");
+  assert.ok(D.render(p2).includes("Nothing pressing"));
+
+  // --- ambiguous + judge OFF → deterministic, medium confidence
+  const twoWip = ledgerOf([
+    entry({ source: "task", id: "t1", title: "WIP one", status: "in_progress", staleDays: 1 }),
+    entry({ source: "task", id: "t2", title: "WIP two", status: "in_progress", staleDays: 1 }),
+  ]);
+  const p3 = await D.deliberate(twoWip, { now: NOW });
+  assert.strictEqual(p3.proposed, true);
+  assert.strictEqual(p3.method, "deterministic");
+  assert.strictEqual(p3.confidence, "medium", "close margin → medium");
+
+  // --- ambiguous + injected judge overrides the pick + action
+  let judgeSaw = null;
+  const p4 = await D.deliberate(twoWip, {
+    now: NOW, useJudge: true,
+    judge: async (top) => { judgeSaw = top.map((c) => c.id); return { pickId: "t2", actionType: "schedule", why: "second is riper", confidence: "high" }; },
+  });
+  assert.deepStrictEqual(judgeSaw, ["t1", "t2"], "judge sees the top-N");
+  assert.strictEqual(p4.method, "judge");
+  assert.strictEqual(p4.pick.id, "t2", "judge override applied");
+  assert.strictEqual(p4.actionType, "schedule");
+  assert.strictEqual(p4.judgeWhy, "second is riper");
+
+  // --- judge failure falls back to deterministic, never throws
+  const p5 = await D.deliberate(twoWip, { now: NOW, useJudge: true, judge: async () => { throw new Error("boom"); } });
+  assert.strictEqual(p5.method, "deterministic");
+  assert.strictEqual(p5.pick.id, "t1");
+
+  // --- judge NOT called when the winner is clear (margin ≥ CLEAR_MARGIN)
+  let called = false;
+  const p6 = await D.deliberate(ledgerOf([
+    entry({ source: "spaces", id: "s1", title: "Overdue!", overdue: true, due: NOW - 5 * DAY, priority: "high" }),
+    entry({ source: "task", id: "t1", title: "WIP", status: "in_progress" }),
+  ]), { now: NOW, useJudge: true, judge: async () => { called = true; return null; } });
+  assert.strictEqual(called, false, "clear margin skips the judge");
+  assert.strictEqual(p6.pick.id, "s1");
+
+  // --- shadow record: writes a jsonl row; AGENCY_SHADOW=off suppresses it
+  process.env.AGENCY_SHADOW = "on";
+  D.record(p1, { channel: "telegram:123" });
+  assert.ok(fs.existsSync(D.LOG_FILE), "shadow log written");
+  let lines = fs.readFileSync(D.LOG_FILE, "utf8").trim().split("\n");
+  assert.strictEqual(lines.length, 1);
+  const row = JSON.parse(lines[0]);
+  assert.strictEqual(row.pickId, "s1");
+  assert.strictEqual(row.channel, "telegram:123");
+  assert.strictEqual(row.method, "deterministic");
+
+  process.env.AGENCY_SHADOW = "off";
+  D.record(p1, {});
+  lines = fs.readFileSync(D.LOG_FILE, "utf8").trim().split("\n");
+  assert.strictEqual(lines.length, 1, "AGENCY_SHADOW=off suppresses the write");
+  process.env.AGENCY_SHADOW = "on";
+
+  try { fs.rmSync(TMP, { recursive: true, force: true }); } catch (e) {}
+  console.log("test-agency-deliberate: OK");
+})();

package/test-agency-ledger.js

@@ -0,0 +1,114 @@
+// Track B0 — agency ledger aggregator. Exercises the pure build()/normalizers/
+// render, plus collect() with an injected Spaces fetch (no subprocess) and a
+// redirected config dir so no real task/connector files are touched.
+
+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-ledger-"));
+process.env.OPEN_CLAUDIA_CONFIG_DIR = TMP;
+
+const ledger = require("./core/agency/ledger");
+
+const NOW = Date.parse("2026-07-15T12:00:00.000Z");
+const DAY = 86400000;
+
+// --- normalizeTask: local task, never overdue, no due date ---
+const t1 = ledger.normalizeTask(
+  { id: "a", content: "Ship X", status: "in_progress", updatedAt: NOW - 3600000 },
+  NOW,
+);
+assert.strictEqual(t1.source, "task");
+assert.strictEqual(t1.status, "in_progress");
+assert.strictEqual(t1.overdue, false);
+assert.strictEqual(t1.due, null);
+
+// --- normalizeSpacesTask: overdue + status + space name + priority ---
+const s1 = ledger.normalizeSpacesTask(
+  {
+    id: "s1", title: "Leave page", status: "open", priority: "high",
+    dueDate: "2026-07-14T00:00:00.000Z", updatedAt: NOW - 2 * DAY,
+    spaceId: { name: "HR + Product" }, subtaskCount: 2, subtaskCompletedCount: 1,
+  },
+  NOW,
+);
+assert.strictEqual(s1.source, "spaces");
+assert.strictEqual(s1.overdue, true, "past dueDate + not done → overdue");
+assert.strictEqual(s1.meta.space, "HR + Product");
+assert.strictEqual(s1.priority, "high");
+
+// a completed Spaces task is done and never overdue, even past its due date
+const s2 = ledger.normalizeSpacesTask(
+  { id: "s2", title: "done", status: "completed", dueDate: "2026-07-01T00:00:00.000Z" },
+  NOW,
+);
+assert.strictEqual(s2.status, "done");
+assert.strictEqual(s2.overdue, false);
+
+// --- normalizeInbox: actor + task title fold into a readable line ---
+const n1 = ledger.normalizeInbox(
+  { id: "n1", type: "comment", actorName: "Jane", taskTitle: "Fix bug", createdAt: NOW - 1800000 },
+  NOW,
+);
+assert.strictEqual(n1.source, "notification");
+assert.ok(n1.title.includes("Jane") && n1.title.includes("Fix bug"));
+assert.strictEqual(n1.status, "info");
+
+// --- build: drops completed, ranks overdue first, counts by source/stale ---
+const l = ledger.build({
+  tasks: [
+    { id: "a", content: "In progress task", status: "in_progress", updatedAt: NOW - 3600000 },
+    { id: "b", content: "Done task", status: "completed", updatedAt: NOW - DAY },
+    { id: "c", content: "Stale open", status: "pending", updatedAt: NOW - 30 * DAY },
+  ],
+  spacesMine: [
+    { id: "s1", title: "Overdue!", status: "open", dueDate: "2026-07-13T00:00:00.000Z", updatedAt: NOW - 5 * DAY },
+  ],
+  inboxes: [
+    { id: "n1", type: "comment", actorName: "Jane", taskTitle: "T", createdAt: NOW - 1800000 },
+  ],
+  now: NOW,
+});
+assert.strictEqual(l.counts.total, 4, "1 completed dropped from 5 inputs");
+assert.strictEqual(l.counts.overdue, 1);
+assert.strictEqual(l.entries[0].id, "s1", "overdue entry ranked first");
+assert.strictEqual(l.counts.stale, 1, "30d-untouched task is stale");
+assert.strictEqual(l.counts.bySource.task, 2);
+assert.strictEqual(l.counts.bySource.spaces, 1);
+assert.strictEqual(l.counts.bySource.notification, 1);
+
+// --- render: summary line + per-source sections ---
+const text = ledger.render(l, { now: NOW });
+assert.ok(text.includes("Agenda"));
+assert.ok(text.includes("4 open"));
+assert.ok(text.includes("1 overdue"));
+assert.ok(text.includes("Spaces (assigned to me)"));
+assert.ok(text.includes("Overdue!"));
+
+// empty ledger renders the all-clear
+const empty = ledger.render(ledger.build({ now: NOW }), { now: NOW });
+assert.ok(empty.includes("Nothing on your plate"));
+
+// --- collect: injected Spaces fetch, no adapter (no task files), no subprocess ---
+(async () => {
+  const r = await ledger.collect({
+    now: NOW,
+    fetchSpacesMine: async () => [{ id: "s9", title: "Injected", status: "open" }],
+  });
+  assert.ok(r.entries.some((e) => e.id === "s9"), "injected spaces task present");
+  assert.strictEqual(typeof r.counts.total, "number");
+
+  // includeSpaces:false skips the fetch entirely
+  let called = false;
+  const r2 = await ledger.collect({
+    now: NOW, includeSpaces: false,
+    fetchSpacesMine: async () => { called = true; return [{ id: "nope" }]; },
+  });
+  assert.strictEqual(called, false, "includeSpaces:false skips the Spaces fetch");
+  assert.ok(!r2.entries.some((e) => e.id === "nope"));
+
+  try { fs.rmSync(TMP, { recursive: true, force: true }); } catch (e) {}
+  console.log("test-agency-ledger: OK");
+})();