@inetafrica/open-claudia 2.6.15 → 2.6.21

package/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## v2.6.20
+- **AgentSpace pod durability.** `/upgrade` and password-change callbacks now preserve the `/api` base path expected by AgentSpace, CLI paths are resolved to concrete executables at startup, and runs repair a stale/missing session workspace before spawning Claude, Cursor, or Codex. This prevents misleading `spawn ... ENOENT` failures when the saved session cwd no longer exists.
+
 ## v2.6.15
 - **Tokenomics guardrails.** The Usage dashboard now shows the latest context-token count, recent baseline, current rate multiplier, and active alert policy above the existing per-version/token trend charts. Completed turns already logged to `~/.open-claudia/usage-history.jsonl`; the dashboard now uses that history to make regressions visible immediately after `/upgrade`.
 - **Hard memory recall budget.** Auto-recalled packs/entities now share a total `MEMORY_RECALL_MAX_CHARS` budget (default `9000`) after relevance filtering. Matched memory beyond the budget is omitted with a short pointer to inspect packs/entities manually, so long-term memory remains available without silently bloating every turn.

package/bot-agent.js

@@ -150,6 +150,7 @@ bot.on("polling_error", (err) => {
 
 // ── Update checker (every 5 mins) ──────────────────────────────────
 const CURRENT_VERSION = require(path.join(__dirname, "package.json")).version;
+const { isNewerVersion } = require("./core/version");
 let lastNotifiedVersion = null;
 
 function checkForUpdates() {
@@ -159,7 +160,7 @@ function checkForUpdates() {
     res.on("end", () => {
       try {
         const latest = JSON.parse(data).version;
-        if (latest && latest !== CURRENT_VERSION && latest !== lastNotifiedVersion) {
+        if (isNewerVersion(latest, CURRENT_VERSION) && latest !== lastNotifiedVersion) {
           lastNotifiedVersion = latest;
           bot.sendMessage(CHAT_ID, `Hey! A new version is available (v${latest}). You're on v${CURRENT_VERSION}.\n\nSend /upgrade to update — I'll be back in a few seconds.`);
         }
@@ -1585,12 +1586,13 @@ bot.onText(/\/upgrade$/, async (msg) => {
   if (!isOwner(msg)) return;
   try { process.chdir(process.env.HOME || require("os").homedir()); } catch (e) { /* already gone */ }
   // Check if there's actually a newer version
+  let latest = null;
   try {
-    const latest = execSync("npm view @inetafrica/open-claudia version", {
+    latest = execSync("npm view @inetafrica/open-claudia version", {
       encoding: "utf-8", timeout: 15000,
       env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() },
     }).trim();
-    if (latest === CURRENT_VERSION) {
+    if (!isNewerVersion(latest, CURRENT_VERSION)) {
       await send(`Already on the latest version (v${CURRENT_VERSION}).`);
       return;
     }

package/bot.js

@@ -16,6 +16,7 @@ const { isOnboarded } = require("./core/onboarding");
 const { initScheduler, stopAll: stopScheduler } = require("./core/scheduler");
 const { onMessage, onAction } = require("./core/router");
 const { publicCommands } = require("./core/commands");
+const { isNewerVersion } = require("./core/version");
 const registry = require("./core/adapter-registry");
 const loopback = require("./core/loopback");
 require("./core/handlers"); // side-effect: register slash commands
@@ -102,7 +103,7 @@ function checkForUpdates() {
     res.on("end", () => {
       try {
         const latest = JSON.parse(data).version;
-        if (latest && latest !== CURRENT_VERSION && latest !== lastNotifiedVersion) {
+        if (isNewerVersion(latest, CURRENT_VERSION) && latest !== lastNotifiedVersion) {
           lastNotifiedVersion = latest;
           // Notify owner via the first telegram adapter (the historical home).
           const tg = adapters.find((a) => a.type === "telegram");

package/core/config.js

@@ -3,7 +3,7 @@
 
 const fs = require("fs");
 const path = require("path");
-const { execSync } = require("child_process");
+const { execFileSync } = require("child_process");
 const CONFIG_DIR = require("../config-dir");
 const { truthy: configTruthy } = require("../project-transcripts");
 
@@ -12,11 +12,12 @@ const ENV_PATH = path.join(CONFIG_DIR, ".env");
 
 function loadEnv() {
   if (!fs.existsSync(ENV_PATH)) {
+    if (process.env.OPEN_CLAUDIA_TEST === "1") return { ...process.env };
     console.error("No .env file found. Run: node setup.js");
     process.exit(1);
   }
   const lines = fs.readFileSync(ENV_PATH, "utf-8").split("\n");
-  const env = {};
+  const env = { ...process.env };
   for (const line of lines) {
     const idx = line.indexOf("=");
     if (idx > 0) env[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
@@ -38,13 +39,55 @@ function saveEnvKey(key, value) {
 
 const config = loadEnv();
 
+function hasPathSeparator(value) {
+  return value.includes("/") || value.includes("\\");
+}
+
+function which(command) {
+  const lookup = process.platform === "win32" ? "where" : "which";
+  return execFileSync(lookup, [command], { encoding: "utf-8" })
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)[0] || null;
+}
+
+function resolveExecutablePath(configured, fallbackCommand, label, opts = {}) {
+  const raw = (configured || fallbackCommand || "").trim();
+  if (!raw) {
+    if (opts.required) {
+      console.error(`${label} not set`);
+      process.exit(1);
+    }
+    return null;
+  }
+
+  if (path.isAbsolute(raw) || hasPathSeparator(raw)) {
+    if (fs.existsSync(raw)) return raw;
+    if (opts.required) {
+      console.error(`${label} not found at: ${raw}`);
+      process.exit(1);
+    }
+    return null;
+  }
+
+  try {
+    return which(raw);
+  } catch (e) {
+    if (opts.required) {
+      console.error(`${label} not found on PATH: ${raw}`);
+      process.exit(1);
+    }
+    return null;
+  }
+}
+
 // Telegram (kept for backwards compat — channels list defaults to telegram)
 const TOKEN = config.TELEGRAM_BOT_TOKEN;
 const CHAT_IDS = (config.TELEGRAM_CHAT_ID || "").split(",").map((s) => s.trim()).filter(Boolean);
 const CHAT_ID = CHAT_IDS[0];
 
 const WORKSPACE = config.WORKSPACE;
-const CLAUDE_PATH = config.CLAUDE_PATH;
+const CLAUDE_PATH = resolveExecutablePath(config.CLAUDE_PATH, null, "Claude CLI", { required: true });
 const CURSOR_PATH = config.CURSOR_PATH || null;
 const CODEX_PATH = config.CODEX_PATH || null;
 const DEFAULT_CLAUDE_MODEL = config.CLAUDE_MODEL || process.env.CLAUDE_MODEL || "claude-fable-5";
@@ -78,7 +121,6 @@ const MAX_PROCESS_TIMEOUT = 360 * 60 * 1000;
 const COMPACT_SUMMARY_TIMEOUT = 10 * 60 * 1000;
 
 if (!WORKSPACE) { console.error("WORKSPACE not set"); process.exit(1); }
-if (!CLAUDE_PATH) { console.error("CLAUDE_PATH not set"); process.exit(1); }
 
 if (!fs.existsSync(WORKSPACE)) {
   try {
@@ -90,27 +132,10 @@ if (!fs.existsSync(WORKSPACE)) {
   }
 }
 
-if (!fs.existsSync(CLAUDE_PATH)) {
-  try {
-    execSync(`which "${CLAUDE_PATH}" 2>/dev/null || where "${CLAUDE_PATH}" 2>nul`, { encoding: "utf-8" });
-  } catch (e) {
-    console.error(`Claude CLI not found at: ${CLAUDE_PATH}`);
-    process.exit(1);
-  }
-}
-
-let resolvedCursorPath = CURSOR_PATH;
-if (!resolvedCursorPath) {
-  try { resolvedCursorPath = execSync("which agent 2>/dev/null", { encoding: "utf-8" }).trim() || null; }
-  catch (e) { resolvedCursorPath = null; }
-}
+let resolvedCursorPath = resolveExecutablePath(CURSOR_PATH, "agent", "Cursor Agent CLI");
 if (resolvedCursorPath) console.error(`Cursor Agent CLI: ${resolvedCursorPath}`);
 
-let resolvedCodexPath = CODEX_PATH;
-if (!resolvedCodexPath) {
-  try { resolvedCodexPath = execSync("which codex 2>/dev/null", { encoding: "utf-8" }).trim() || null; }
-  catch (e) { resolvedCodexPath = null; }
-}
+let resolvedCodexPath = resolveExecutablePath(CODEX_PATH, "codex", "Codex CLI");
 if (resolvedCodexPath) console.error(`Codex CLI: ${resolvedCodexPath}`);
 
 if (!fs.existsSync(TEMP_DIR)) fs.mkdirSync(TEMP_DIR, { recursive: true });

package/core/handlers.js

@@ -21,6 +21,7 @@ const { listProjects, findProject, projectKeyboard, workspacePath } = require(".
 const { vault } = require("./vault-store");
 const { redactSensitive } = require("./redact");
 const { runDoctorChecks, formatDoctorReport } = require("./doctor");
+const { isNewerVersion } = require("./version");
 const jobs = require("./jobs");
 const scheduler = require("./scheduler");
 const skillsLib = require("./skills");
@@ -338,7 +339,10 @@ async function requestAgentSpaceUpgrade() {
   const apiUrl = process.env.AGENTSPACE_API_URL;
   const token = process.env.AGENTSPACE_POD_TOKEN;
   if (!apiUrl || !token) return null;
-  const u = new URL("/pods/self/upgrade", apiUrl);
+  const base = new URL(apiUrl);
+  if (base.pathname === "/") base.pathname = "/api/";
+  if (!base.pathname.endsWith("/")) base.pathname += "/";
+  const u = new URL("pods/self/upgrade", base);
   const lib = u.protocol === "https:" ? require("https") : require("http");
   return new Promise((resolve) => {
     const req = lib.request({
@@ -434,7 +438,7 @@ register({
         await send(`Upgrade failed: could not query npm registry (${(e.message || String(e)).slice(0, 200)}).`);
         return;
       }
-      if (latest === CURRENT_VERSION) {
+      if (!isNewerVersion(latest, CURRENT_VERSION)) {
         await send(`Already on the latest version (v${CURRENT_VERSION}).`);
         return;
       }
@@ -474,7 +478,7 @@ register({
         encoding: "utf-8", timeout: 15000,
         env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() },
       }).trim();
-      if (latest === CURRENT_VERSION) {
+      if (!isNewerVersion(latest, CURRENT_VERSION)) {
         await send(`Already on the latest version (v${CURRENT_VERSION}).`);
         return;
       }
@@ -594,6 +598,7 @@ register({
     if (resolvedCodexPath) {
       rows.push([{ text: "── Codex ──", callback_data: "noop" }]);
       rows.push([
+        { text: "GPT-5.5", callback_data: "mb:codex:gpt-5.5" },
         { text: "gpt-5", callback_data: "mb:codex:gpt-5" },
         { text: "gpt-5-codex", callback_data: "mb:codex:gpt-5-codex" },
       ]);

package/core/runner.js

@@ -9,9 +9,9 @@ const { spawn, execFileSync } = require("child_process");
 const {
   CLAUDE_PATH, DEFAULT_CLAUDE_MODEL, resolvedCursorPath, resolvedCodexPath,
   AUTO_COMPACT_TOKENS, MIN_COMPACT_INTERVAL_MS, MAX_PROCESS_TIMEOUT, COMPACT_SUMMARY_TIMEOUT, botSubprocessEnv,
-  CONFIG_DIR, config,
+  CONFIG_DIR, WORKSPACE, config,
 } = require("./config");
-const { currentState, saveState, recordSession, userOwnsClaudeSession } = require("./state");
+const { currentState, saveState, recordSession, userOwnsClaudeSession, resetSessionUsage } = require("./state");
 const { chatContext, currentChannelId, currentAdapter } = require("./context");
 const { buildSystemPrompt, promptWithDynamicContext } = require("./system-prompt");
 const { redactSensitive } = require("./redact");
@@ -20,7 +20,7 @@ const { textToVoice, TTS_CMD } = require("./media");
 const { killProcessTree } = require("./process-tree");
 const {
   appendProjectTranscript, transcriptProjectInfo,
-  promptWithTranscriptPointer, stripTranscriptPointerForStorage,
+  stripTranscriptPointerForStorage,
 } = require("./transcripts");
 const { getClaudeOAuthToken, claudeAuthRecoveryMessage, isClaudeAuthErrorText, claudeUsageLimitMessage, isClaudeUsageLimitText, runClaudeAuthStatusDiagnostic, claudeSubprocessEnv } = require("./auth-flow");
 const loopback = require("./loopback");
@@ -45,13 +45,91 @@ function fmtTokens(n) {
   return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
 }
 
-function logTurnUsage(state, usage, costUsd, announce) {
+function usageNumber(usage, ...keys) {
+  for (const key of keys) {
+    const value = usage?.[key];
+    if (Number.isFinite(value)) return value;
+  }
+  return 0;
+}
+
+function usageParts(usage, backend = "claude") {
+  const input = usageNumber(usage, "input_tokens");
+  const cacheRead = backend === "codex"
+    ? usageNumber(usage, "cached_input_tokens", "cache_read_input_tokens")
+    : usageNumber(usage, "cache_read_input_tokens", "cached_input_tokens");
+  const cacheCreation = usageNumber(usage, "cache_creation_input_tokens");
+  const output = usageNumber(usage, "output_tokens");
+  return {
+    input,
+    cacheRead,
+    cacheCreation,
+    output,
+    // Codex/OpenAI reports cached input as part of input_tokens. Keep the
+    // cache-read field for attribution, but do not add it again to context.
+    context: backend === "codex" ? input : input + cacheRead + cacheCreation,
+  };
+}
+
+function clampUsageDelta(current, previous) {
+  if (!previous) return current;
+  return {
+    input_tokens: Math.max(0, usageNumber(current, "input_tokens") - usageNumber(previous, "input_tokens")),
+    cached_input_tokens: Math.max(0, usageNumber(current, "cached_input_tokens") - usageNumber(previous, "cached_input_tokens")),
+    cache_read_input_tokens: Math.max(0, usageNumber(current, "cache_read_input_tokens") - usageNumber(previous, "cache_read_input_tokens")),
+    cache_creation_input_tokens: Math.max(0, usageNumber(current, "cache_creation_input_tokens") - usageNumber(previous, "cache_creation_input_tokens")),
+    output_tokens: Math.max(0, usageNumber(current, "output_tokens") - usageNumber(previous, "output_tokens")),
+  };
+}
+
+function snapshotCodexUsage(state, sessionId, usage) {
+  if (!state || !sessionId || !usage) return null;
+  const snapshots = state.codexUsageSnapshots && typeof state.codexUsageSnapshots === "object"
+    ? state.codexUsageSnapshots
+    : {};
+  const previous = snapshots[sessionId] || null;
+  snapshots[sessionId] = {
+    input_tokens: usageNumber(usage, "input_tokens"),
+    cached_input_tokens: usageNumber(usage, "cached_input_tokens"),
+    output_tokens: usageNumber(usage, "output_tokens"),
+  };
+  const keys = Object.keys(snapshots);
+  if (keys.length > 20) {
+    for (const key of keys.slice(0, keys.length - 20)) delete snapshots[key];
+  }
+  state.codexUsageSnapshots = snapshots;
+  return previous;
+}
+
+function normalizeCodexUsage(state, sessionId, usage) {
+  const previous = snapshotCodexUsage(state, sessionId, usage);
+  if (!previous) return { usage, usageScope: "session_total", rawUsage: usage };
+  return { usage: clampUsageDelta(usage, previous), usageScope: "turn_delta", rawUsage: usage };
+}
+
+function applyUsageToState(state, usage, costUsd, opts = {}) {
+  if (!usage) return null;
+  const backend = state.settings?.backend || "claude";
+  const parts = usageParts(usage, backend);
+  const u = state.sessionUsage;
+  u.turns += 1;
+  u.inputTokens += parts.input;
+  u.outputTokens += parts.output;
+  u.cacheReadTokens += parts.cacheRead;
+  u.cacheCreationTokens += parts.cacheCreation;
+  u.lastInputTokens = parts.context;
+  u.lastUsageScope = opts.usageScope || "turn_delta";
+  if (Number.isFinite(opts.liveContextTokens)) u.liveContextTokens = opts.liveContextTokens;
+  else u.liveContextTokens = parts.context;
+  if (typeof costUsd === "number") u.costUsd += costUsd;
+  return parts;
+}
+
+function logTurnUsage(state, usage, costUsd, announce, opts = {}) {
   if (!usage) return null;
   const backend = state.settings?.backend || "claude";
-  const input = usage.input_tokens || 0;
-  const cacheRead = usage.cache_read_input_tokens || usage.cached_input_tokens || 0;
-  const cacheCreation = usage.cache_creation_input_tokens || 0;
-  const output = usage.output_tokens || 0;
+  const parts = usageParts(usage, backend);
+  const usageScope = opts.usageScope || "turn_delta";
   const record = {
     ts: new Date().toISOString(),
     version: PKG_VERSION,
@@ -59,13 +137,21 @@ function logTurnUsage(state, usage, costUsd, announce) {
     model: state.settings?.model || (backend === "claude" ? DEFAULT_CLAUDE_MODEL : null),
     userId: state.userId || null,
     sessionId: state[getActiveSessionKey(state)] || null,
-    inputTokens: input,
-    outputTokens: output,
-    cacheReadTokens: cacheRead,
-    cacheCreationTokens: cacheCreation,
-    contextTokens: input + cacheRead + cacheCreation,
+    usageScope,
+    inputTokens: parts.input,
+    outputTokens: parts.output,
+    cacheReadTokens: parts.cacheRead,
+    cacheCreationTokens: parts.cacheCreation,
+    contextTokens: parts.context,
     costUsd: typeof costUsd === "number" ? costUsd : 0,
   };
+  if (opts.rawUsage && opts.rawUsage !== usage) {
+    const raw = usageParts(opts.rawUsage, backend);
+    record.rawInputTokens = raw.input;
+    record.rawOutputTokens = raw.output;
+    record.rawCacheReadTokens = raw.cacheRead;
+    record.rawContextTokens = raw.context;
+  }
   const previousRecords = loadUsageHistory();
   appendUsageRecord(record);
 
@@ -77,9 +163,10 @@ function logTurnUsage(state, usage, costUsd, announce) {
     if (announce) {
       const baseline = result.trend?.baselineAvgContextTokens || 0;
       const rate = result.trend?.latestRate || 0;
+      const contextLabel = usageScope === "turn_delta" ? "Context this turn" : "Session context total";
       announce([
         "Token usage alert:",
-        `Context this turn: ${fmtTokens(record.contextTokens)}`,
+        `${contextLabel}: ${fmtTokens(record.contextTokens)}`,
         baseline ? `Recent baseline: ${fmtTokens(baseline)} (${rate.toFixed(2)}x)` : null,
         `Version/model: v${record.version} / ${record.model || record.backend}`,
         `Reason: ${result.reasons.join("; ")}`,
@@ -154,6 +241,26 @@ function getActiveSessionKey(state = currentState()) {
   return "lastSessionId";
 }
 
+function resolveRunCwd(cwd) {
+  const state = currentState();
+  const requested = cwd || state.currentSession?.dir || WORKSPACE || process.cwd();
+  if (requested && fs.existsSync(requested)) return requested;
+
+  const fallback = WORKSPACE && fs.existsSync(WORKSPACE) ? WORKSPACE : process.cwd();
+  if (state.currentSession && state.currentSession.dir === requested) {
+    console.warn(`[session-guard] repairing missing session dir ${requested} -> ${fallback}`);
+    state.currentSession = { ...state.currentSession, dir: fallback };
+    state.lastSessionId = null;
+    state.cursorSessionId = null;
+    state.codexSessionId = null;
+    resetSessionUsage(state);
+    saveState();
+  } else {
+    console.warn(`[session-guard] missing run cwd ${requested}; using ${fallback}`);
+  }
+  return fallback;
+}
+
 function effectiveCompactThreshold(state = currentState()) {
   const override = state.settings?.compactWindow;
   if (override === 0) return 0;
@@ -166,9 +273,11 @@ function shouldAutoCompact(state = currentState(), opts = {}) {
   if (!state[getActiveSessionKey(state)]) return false;
   const threshold = effectiveCompactThreshold(state);
   if (threshold === 0) return false;
-  if ((state.sessionUsage?.lastInputTokens || 0) < threshold) return false;
+  const contextTokens = state.sessionUsage?.liveContextTokens || state.sessionUsage?.lastInputTokens || 0;
+  if (contextTokens < threshold) return false;
   const minInterval = Number.isFinite(MIN_COMPACT_INTERVAL_MS) ? MIN_COMPACT_INTERVAL_MS : 1800000;
-  if (state.lastCompactedAt && (Date.now() - state.lastCompactedAt) < minInterval) return false;
+  const farOverThreshold = contextTokens >= threshold * 2;
+  if (!farOverThreshold && state.lastCompactedAt && (Date.now() - state.lastCompactedAt) < minInterval) return false;
   return true;
 }
 
@@ -219,7 +328,7 @@ function buildCursorArgs(prompt, opts = {}) {
   return args;
 }
 
-function buildCodexArgs(prompt, opts = {}) {
+async function buildCodexArgs(prompt, opts = {}) {
   const state = currentState();
   const { settings, codexSessionId } = state;
   const args = [];
@@ -231,7 +340,7 @@ function buildCodexArgs(prompt, opts = {}) {
   if (settings.permissionMode === "plan") args.push("--sandbox", "read-only");
   else args.push("--dangerously-bypass-approvals-and-sandbox");
   if (settings.model) args.push("--model", settings.model);
-  args.push(promptWithTranscriptPointer(prompt, state));
+  args.push(await promptWithDynamicContext(prompt, { includeTranscriptPointer: true }));
   return args;
 }
 
@@ -504,6 +613,7 @@ async function runClaudeCapture(prompt, cwd, opts = {}) {
   if (state.runningProcess) throw new Error("Another task is already running.");
   const authPreflight = preflightClaudeAuthMessage();
   if (authPreflight) throw new Error(authPreflight);
+  cwd = resolveRunCwd(cwd);
 
   const args = await buildClaudeArgs(prompt, { ...opts, skipAutoCompact: true });
   return new Promise((resolve, reject) => {
@@ -556,15 +666,7 @@ async function runClaudeCapture(prompt, cwd, opts = {}) {
           else state.lastSessionId = evt.session_id;
           sessionId = evt.session_id;
           if (evt.usage) {
-            const u = state.sessionUsage;
-            u.turns += 1;
-            u.inputTokens += evt.usage.input_tokens || 0;
-            u.outputTokens += evt.usage.output_tokens || 0;
-            u.cacheReadTokens += evt.usage.cache_read_input_tokens || 0;
-            u.cacheCreationTokens += evt.usage.cache_creation_input_tokens || 0;
-            u.lastInputTokens = (evt.usage.input_tokens || 0) +
-              (evt.usage.cache_read_input_tokens || 0) +
-              (evt.usage.cache_creation_input_tokens || 0);
+            applyUsageToState(state, evt.usage, 0, { usageScope: "turn_delta" });
           }
           if (typeof evt.total_cost_usd === "number") state.sessionUsage.costUsd += evt.total_cost_usd;
           saveState();
@@ -630,7 +732,8 @@ async function compactActiveSession(cwd, opts = {}) {
   state[sessionKey] = newSessionId;
   state.isFirstMessage = false;
   state.lastCompactedAt = Date.now();
-  state.sessionUsage = { turns: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0, lastInputTokens: 0 };
+  state.sessionUsage = { turns: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0, lastInputTokens: 0, liveContextTokens: 0, lastUsageScope: "turn_delta" };
+  state.codexUsageSnapshots = {};
   saveState();
 
   if (newSessionId && state.currentSession) {
@@ -646,6 +749,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   const channelId = currentChannelId();
   const adapter = currentAdapter();
   const { settings } = state;
+  cwd = resolveRunCwd(cwd);
 
   if (state.runningProcess) {
     state.messageQueue.push({ prompt, replyToMsgId, opts, queuedAt: Date.now() });
@@ -659,6 +763,14 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     return;
   }
 
+  if (state.currentSession && shouldAutoCompact(state, opts)) {
+    try {
+      await compactActiveSession(state.currentSession.dir, { notify: true, message: "Context is getting large, compacting before I handle this…" });
+    } catch (e) {
+      console.warn(`[preflight-compact] failed: ${redactSensitive(e.message)}`);
+    }
+  }
+
   appendProjectTranscript("user", prompt, {
     sourceMessageId: replyToMsgId || null,
     fresh: !!opts.fresh,
@@ -868,37 +980,26 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         }
       }
       if (evt.type === "turn.completed" && evt.usage && settings.backend === "codex") {
-        const u = state.sessionUsage;
-        u.turns += 1;
-        const input = evt.usage.input_tokens || 0;
-        const cached = evt.usage.cached_input_tokens || 0;
-        const output = evt.usage.output_tokens || 0;
-        u.inputTokens += input;
-        u.outputTokens += output;
-        u.cacheReadTokens += cached;
-        u.lastInputTokens = input + cached;
-        logTurnUsage(state, evt.usage, 0, (text) => chatContext.run(store, () => send(text)));
+        const session = state.codexSessionId || evt.thread_id || getActiveSessionId();
+        const normalized = normalizeCodexUsage(state, session, evt.usage);
+        const rawParts = usageParts(evt.usage, "codex");
+        applyUsageToState(state, normalized.usage, 0, {
+          usageScope: normalized.usageScope,
+          liveContextTokens: rawParts.context,
+        });
+        logTurnUsage(state, normalized.usage, 0, (text) => chatContext.run(store, () => send(text)), normalized);
         saveState();
       }
       if (evt.type === "result" && evt.session_id) {
         if (settings.backend === "cursor") { state.cursorSessionId = evt.session_id; }
         else { state.lastSessionId = evt.session_id; }
-        if (evt.usage) {
-          const u = state.sessionUsage;
-          u.turns += 1;
-          u.inputTokens += evt.usage.input_tokens || 0;
-          u.outputTokens += evt.usage.output_tokens || 0;
-          u.cacheReadTokens += evt.usage.cache_read_input_tokens || 0;
-          u.cacheCreationTokens += evt.usage.cache_creation_input_tokens || 0;
-          u.lastInputTokens = (evt.usage.input_tokens || 0) +
-            (evt.usage.cache_read_input_tokens || 0) +
-            (evt.usage.cache_creation_input_tokens || 0);
-          // Codex already logged this turn at turn.completed — don't double-count.
-          if (settings.backend !== "codex") {
-            logTurnUsage(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0, (text) => chatContext.run(store, () => send(text)));
-          }
+        // Codex already reports usage at turn.completed. A result usage block,
+        // if present, is the same cumulative total and must not be counted again.
+        if (evt.usage && settings.backend !== "codex") {
+          applyUsageToState(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0, { usageScope: "turn_delta" });
+          logTurnUsage(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0, (text) => chatContext.run(store, () => send(text)), { usageScope: "turn_delta" });
         }
-        if (typeof evt.total_cost_usd === "number") state.sessionUsage.costUsd += evt.total_cost_usd;
+        if (typeof evt.total_cost_usd === "number" && settings.backend === "codex") state.sessionUsage.costUsd += evt.total_cost_usd;
         saveState();
       }
       // Fallback only: evt.result is just the final text segment, and assigning
@@ -1068,6 +1169,10 @@ module.exports = {
   getActiveSessionKey,
   shouldAutoCompact,
   effectiveCompactThreshold,
+  usageParts,
+  clampUsageDelta,
+  normalizeCodexUsage,
+  applyUsageToState,
   compactSeedPrompt,
   splitCompactionBrief,
   archiveCompactionBrief,

package/core/state.js

@@ -47,7 +47,7 @@ function freshSettings() {
 }
 
 function freshUsage() {
-  return { turns: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0, lastInputTokens: 0 };
+  return { turns: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0, lastInputTokens: 0, liveContextTokens: 0, lastUsageScope: "turn_delta" };
 }
 
 function createUserState(userId) {
@@ -65,6 +65,7 @@ function createUserState(userId) {
     lastSessionId: saved.lastSessionId || null,
     cursorSessionId: saved.cursorSessionId || null,
     codexSessionId: saved.codexSessionId || null,
+    codexUsageSnapshots: saved.codexUsageSnapshots || {},
     messageQueue: [],
     isFirstMessage: !saved.lastSessionId,
     lastInputWasVoice: false,
@@ -97,6 +98,7 @@ function currentState() {
 
 function resetSessionUsage(state = currentState()) {
   state.sessionUsage = freshUsage();
+  state.codexUsageSnapshots = {};
 }
 
 function resetSettings(state = currentState()) {
@@ -111,6 +113,7 @@ function saveState() {
       lastSessionId: s.lastSessionId,
       cursorSessionId: s.cursorSessionId,
       codexSessionId: s.codexSessionId,
+      codexUsageSnapshots: s.codexUsageSnapshots || {},
       settings: s.settings,
       sessionUsage: s.sessionUsage,
       lastCompactedAt: s.lastCompactedAt || 0,

package/core/system-prompt.js

@@ -118,6 +118,11 @@ ${buildPersonaBlock()}
 - Voice notes: ${hasVoice ? "enabled" : "disabled"}
 - Vault status, session state, and any pending tasks arrive in a "Runtime state" block at the top of each user message, not here.
 
+## Open Claudia Skills
+Open Claudia learned skills are stored as context packs under ${path.join(CONFIG_DIR, "packs")}. Older \`~/.claude/skills/<name>/SKILL.md\` skills may have been migrated into packs; their reusable instructions live in the pack's Procedure section.
+
+If the user asks for a skill by name, do not rely only on the backend harness's native "Available skills" list. First use any Active context pack injected into the current request as the requested Open Claudia skill. If no matching pack was injected, inspect with \`open-claudia pack list\` / \`open-claudia pack show <dir>\` and legacy \`/skills\` paths before saying the skill does not exist.
+
 ## Stable Local Paths
 - Bot code: ${path.join(BOT_DIR, "bot.js")}
 - Soul file (identity + hard rules): ${SOUL_FILE}
@@ -379,7 +384,7 @@ function buildPackBlock(matches, budget) {
     }
     if (used.length > 0) setImmediate(() => { try { packsLib.touchUsed(used); } catch (e) {} });
     if (blocks.length === 0) return "";
-    return `\n\n## Active context packs\nLong-term topic context auto-matched to this message. Source files live under ${packsLib.PACKS_DIR}/<dir>/PACK.md — read or edit them directly when deeper context or a correction is needed.\n\n${blocks.join("\n\n---\n\n")}`;
+    return `\n\n## Active Open Claudia skills / context packs\nLong-term topic context auto-matched to this message. If the user asked for a skill by name, treat the matching pack's Procedure section as that Open Claudia skill. Source files live under ${packsLib.PACKS_DIR}/<dir>/PACK.md — read or edit them directly when deeper context or a correction is needed.\n\n${blocks.join("\n\n---\n\n")}`;
   } catch (e) {
     return "";
   }
@@ -518,7 +523,7 @@ function logRecall(msg, candPacks, candEntities, keptPacks, keptEntities) {
   } catch (e) {}
 }
 
-async function promptWithDynamicContext(prompt) {
+async function promptWithDynamicContext(prompt, opts = {}) {
   lastInjected = { packs: [], entities: [] };
   try {
     const { userText, contextText } = recallMatchParts(prompt);
@@ -557,7 +562,8 @@ async function promptWithDynamicContext(prompt) {
     const budgetNote = budget.omitted > 0
       ? `\n\n## Memory budget\n${budget.omitted} matched memory item${budget.omitted === 1 ? " was" : "s were"} omitted to keep this turn under the recall budget (${budget.maxChars} chars). Use \`open-claudia pack show <dir>\`, \`entity show <slug>\`, or transcript search if deeper context is needed.`
       : "";
-    return `${buildDynamicContextBlock()}${packBlock}${entityBlock}${budgetNote}\n\nCurrent user request:\n${prompt}`;
+    const transcriptPointer = opts.includeTranscriptPointer ? `${transcriptPointerNote(state)}\n\n` : "";
+    return `${transcriptPointer}${buildDynamicContextBlock()}${packBlock}${entityBlock}${budgetNote}\n\nCurrent user request:\n${prompt}`;
   } catch (e) {
     return prompt;
   }

package/core/version.js

@@ -0,0 +1,22 @@
+function parseVersion(version) {
+  const match = String(version || "").trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+  if (!match) return null;
+  return match.slice(1).map((part) => Number.parseInt(part, 10));
+}
+
+function compareVersions(left, right) {
+  const a = parseVersion(left);
+  const b = parseVersion(right);
+  if (!a || !b) return 0;
+  for (let i = 0; i < 3; i += 1) {
+    if (a[i] > b[i]) return 1;
+    if (a[i] < b[i]) return -1;
+  }
+  return 0;
+}
+
+function isNewerVersion(candidate, current) {
+  return compareVersions(candidate, current) > 0;
+}
+
+module.exports = { compareVersions, isNewerVersion };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.15",
+  "version": "2.6.21",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {
@@ -9,7 +9,7 @@
   "scripts": {
     "setup": "node setup.js",
     "start": "node bot.js",
-    "test": "node -e \"require('./vault'); console.log('OK')\""
+    "test": "OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node -e \"require('./vault'); console.log('OK')\" && OPEN_CLAUDIA_TEST=1 WORKSPACE=/tmp/open-claudia-test CLAUDE_PATH=node node test-usage-accounting.js"
   },
   "files": [
     "bot.js",
@@ -29,7 +29,8 @@
     ".dockerignore",
     ".env.example",
     "README.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "test-usage-accounting.js"
   ],
   "keywords": [
     "claude",

package/test-usage-accounting.js

@@ -0,0 +1,84 @@
+const assert = require("assert");
+const {
+  usageParts,
+  normalizeCodexUsage,
+  applyUsageToState,
+  shouldAutoCompact,
+} = require("./core/runner");
+
+function state(overrides = {}) {
+  return {
+    settings: { backend: "codex", compactWindow: 100 },
+    codexSessionId: "codex-session-1",
+    codexUsageSnapshots: {},
+    sessionUsage: {
+      turns: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+      costUsd: 0,
+      lastInputTokens: 0,
+      liveContextTokens: 0,
+      lastUsageScope: "turn_delta",
+    },
+    ...overrides,
+  };
+}
+
+assert.deepStrictEqual(
+  usageParts({ input_tokens: 100, cached_input_tokens: 60, output_tokens: 10 }, "codex"),
+  { input: 100, cacheRead: 60, cacheCreation: 0, output: 10, context: 100 },
+);
+
+assert.deepStrictEqual(
+  usageParts({ input_tokens: 100, cache_read_input_tokens: 60, cache_creation_input_tokens: 20, output_tokens: 10 }, "claude"),
+  { input: 100, cacheRead: 60, cacheCreation: 20, output: 10, context: 180 },
+);
+
+const s = state();
+const first = normalizeCodexUsage(s, "codex-session-1", {
+  input_tokens: 1000,
+  cached_input_tokens: 700,
+  output_tokens: 50,
+});
+assert.strictEqual(first.usageScope, "session_total");
+assert.strictEqual(usageParts(first.usage, "codex").context, 1000);
+
+const second = normalizeCodexUsage(s, "codex-session-1", {
+  input_tokens: 1250,
+  cached_input_tokens: 800,
+  output_tokens: 80,
+});
+assert.strictEqual(second.usageScope, "turn_delta");
+assert.deepStrictEqual(second.usage, {
+  input_tokens: 250,
+  cached_input_tokens: 100,
+  cache_read_input_tokens: 0,
+  cache_creation_input_tokens: 0,
+  output_tokens: 30,
+});
+
+applyUsageToState(s, second.usage, 0, {
+  usageScope: second.usageScope,
+  liveContextTokens: usageParts(second.rawUsage, "codex").context,
+});
+assert.strictEqual(s.sessionUsage.turns, 1);
+assert.strictEqual(s.sessionUsage.inputTokens, 250);
+assert.strictEqual(s.sessionUsage.cacheReadTokens, 100);
+assert.strictEqual(s.sessionUsage.lastInputTokens, 250);
+assert.strictEqual(s.sessionUsage.liveContextTokens, 1250);
+
+assert.strictEqual(shouldAutoCompact(state({
+  sessionUsage: { liveContextTokens: 99, lastInputTokens: 99 },
+})), false);
+assert.strictEqual(shouldAutoCompact(state({
+  sessionUsage: { liveContextTokens: 150, lastInputTokens: 150 },
+  lastCompactedAt: Date.now(),
+})), false);
+assert.strictEqual(shouldAutoCompact(state({
+  sessionUsage: { liveContextTokens: 250, lastInputTokens: 250 },
+  lastCompactedAt: Date.now(),
+})), true);
+
+console.log("usage accounting OK");

package/web.js

@@ -70,7 +70,14 @@ function notifyAgentSpacePasswordChanged() {
     const token = process.env.AGENTSPACE_POD_TOKEN;
     if (!apiUrl || !token) return resolve({ ok: false, reason: "missing-env" });
     let u;
-    try { u = new URL("/pods/self/password-changed", apiUrl); } catch (e) { return resolve({ ok: false, reason: "bad-url" }); }
+    try {
+      const base = new URL(apiUrl);
+      if (base.pathname === "/") base.pathname = "/api/";
+      if (!base.pathname.endsWith("/")) base.pathname += "/";
+      u = new URL("pods/self/password-changed", base);
+    } catch (e) {
+      return resolve({ ok: false, reason: "bad-url" });
+    }
     const lib = u.protocol === "https:" ? require("https") : require("http");
     const req = lib.request({
       method: "POST",
@@ -935,7 +942,11 @@ init();
 
 // ── Server ─────────────────────────────────────────────────────────
 
+let webServer = null;
+
 function startWebServer() {
+  if (webServer) return webServer;
+
   const server = http.createServer(async (req, res) => {
     // CORS for local dev
     res.setHeader("Access-Control-Allow-Origin", "*");
@@ -977,6 +988,7 @@ function startWebServer() {
     reconcileGrandfatheredPasswordChange();
   });
 
+  webServer = server;
   return server;
 }