tokentracker-cli 0.96.2 → 0.96.4

package/src/lib/codex-config.js

@@ -19,6 +19,10 @@ function buildEveryCodeNotifyCmd(notifyPath, options) {
   return [...buildCodexNotifyCmd(notifyPath, options), "--source=every-code"];
 }
 
+function buildAcodeNotifyCmd(notifyPath, options) {
+  return [...buildCodexNotifyCmd(notifyPath, options), "--source=acode"];
+}
+
 // Is this notify command one we wrote? Strict array equality is not a safe
 // test, because the command is not a stable constant across invocations:
 //   - argv[0] on Windows is an absolute `process.execPath` (#361). The desktop
@@ -172,6 +176,39 @@ async function readCodexNotify(codexConfigPath) {
   return readNotify(codexConfigPath);
 }
 
+async function upsertAcodeNotify({
+  acodeConfigPath,
+  notifyCmd,
+  notifyOriginalPath,
+  captureOriginal = true,
+  replaceOriginal = false,
+}) {
+  return upsertNotify({
+    configPath: acodeConfigPath,
+    notifyCmd,
+    notifyOriginalPath,
+    configLabel: "AStudio config",
+    captureOriginal,
+    replaceOriginal,
+  });
+}
+
+async function restoreAcodeNotify({ acodeConfigPath, notifyOriginalPath, notifyCmd }) {
+  return restoreNotify({
+    configPath: acodeConfigPath,
+    notifyOriginalPath,
+    expectedNotify: notifyCmd,
+  });
+}
+
+async function loadAcodeNotifyOriginal(notifyOriginalPath) {
+  return loadNotifyOriginal(notifyOriginalPath);
+}
+
+async function readAcodeNotify(acodeConfigPath) {
+  return readNotify(acodeConfigPath);
+}
+
 async function upsertEveryCodeNotify({
   codeConfigPath,
   notifyCmd,
@@ -536,6 +573,7 @@ function arraysEqual(a, b) {
 
 module.exports = {
   buildCodexNotifyCmd,
+  buildAcodeNotifyCmd,
   buildEveryCodeNotifyCmd,
   isManagedNotifyCmd,
   upsertNotify,
@@ -546,6 +584,10 @@ module.exports = {
   restoreCodexNotify,
   loadCodexNotifyOriginal,
   readCodexNotify,
+  upsertAcodeNotify,
+  restoreAcodeNotify,
+  loadAcodeNotifyOriginal,
+  readAcodeNotify,
   upsertEveryCodeNotify,
   restoreEveryCodeNotify,
   loadEveryCodeNotifyOriginal,

package/src/lib/devin-limits.js

@@ -0,0 +1,249 @@
+// Devin subscription usage limits.
+//
+// Source: the official seat-management RPC the Devin web app calls,
+//   POST https://server.codeium.com/exa.seat_management_pb.SeatManagementService/GetPlanStatus
+// authenticated by `x-auth-token` — the session token the Devin CLI stores in
+// $XDG_DATA_HOME/devin/credentials.toml (~/.local/share/devin/ fallback).
+//
+// Two non-obvious contract points, both verified against the official
+// generated descriptor (docs/devin-limits.md):
+//   - the quota percent/reset fields are proto3 implicit scalars, so the
+//     server omits them at 0: absent percent + live reset = exhausted
+//     (100% used), both absent = no such window;
+//   - a non-default api_server_url is an unsupported configuration, never a
+//     different request destination — the token only ever goes to the fixed
+//     host above.
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const DEVIN_PLAN_STATUS_URL =
+  "https://server.codeium.com/exa.seat_management_pb.SeatManagementService/GetPlanStatus";
+const DEVIN_API_ORIGIN = "https://server.codeium.com";
+
+const DEVIN_DAILY_WINDOW_SECONDS = 24 * 60 * 60;
+const DEVIN_WEEKLY_WINDOW_SECONDS = 7 * 24 * 60 * 60;
+
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// Minimal root-level TOML reader for the CLI-written credentials file: bare
+// `key = value` lines before the first `[section]`, nothing else.
+function parseDevinCredentialsToml(raw) {
+  const fields = {};
+  for (const line of String(raw).split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("[")) break;
+    const match = /^([A-Za-z0-9_]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s#]+))\s*(?:#.*)?$/.exec(
+      trimmed,
+    );
+    if (!match) continue;
+    const [, key, doubleQuoted, singleQuoted, bare] = match;
+    fields[key] = doubleQuoted ?? singleQuoted ?? bare ?? "";
+  }
+  return fields;
+}
+
+// Returns { apiKey } or null when no sign-in exists (no home, or the file is
+// absent — ENOENT only). Any other read failure or a mangled file throws an
+// owned, actionable error with no path or filesystem details, so a broken
+// sign-in can never masquerade as "not configured".
+function readDevinCredentials({ home, env = process.env } = {}) {
+  const xdg = env && typeof env === "object" ? env.XDG_DATA_HOME : null;
+  const dir = isNonEmptyString(xdg)
+    ? xdg.trim()
+    : isNonEmptyString(home)
+      ? home.trim()
+      : isNonEmptyString(env?.HOME)
+        ? env.HOME.trim()
+        : null;
+  if (!dir) return null;
+  const base = isNonEmptyString(xdg)
+    ? path.join(dir, "devin", "credentials.toml")
+    : path.join(dir, ".local", "share", "devin", "credentials.toml");
+  let raw;
+  try {
+    raw = fs.readFileSync(base, "utf8");
+  } catch (error) {
+    if (error && error.code === "ENOENT") return null;
+    throw new Error(
+      "Could not read the Devin CLI credentials file — check its permissions or run `devin auth login` to sign in again.",
+    );
+  }
+  const fields = parseDevinCredentialsToml(raw);
+  const apiKey = isNonEmptyString(fields.windsurf_api_key)
+    ? fields.windsurf_api_key.trim()
+    : null;
+  if (!apiKey) {
+    throw new Error(
+      "Devin credentials file has no sign-in token — run `devin auth login`.",
+    );
+  }
+  const apiServerUrl = isNonEmptyString(fields.api_server_url)
+    ? fields.api_server_url.trim().replace(/\/+$/, "")
+    : null;
+  if (apiServerUrl && apiServerUrl !== DEVIN_API_ORIGIN) {
+    throw new Error(
+      "Devin credentials point at a custom api_server_url, which this quota provider does not support.",
+    );
+  }
+  return { apiKey };
+}
+
+function malformed(field) {
+  return new Error(`Devin quota response has a malformed ${field}.`);
+}
+
+// undefined → proto-default semantics handled by the caller; null/non-numeric
+// → malformed. Percentages are clamped defensively to 0..100.
+function normalizeRemainingPercent(value) {
+  if (value === undefined) return undefined;
+  if (typeof value !== "number" && typeof value !== "string") {
+    throw malformed("quota remaining percent");
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    throw malformed("quota remaining percent");
+  }
+  const n = Number(value);
+  if (!Number.isFinite(n)) throw malformed("quota remaining percent");
+  if (n <= 0) return 0;
+  if (n >= 100) return 100;
+  return n;
+}
+
+// int64 unix seconds (JSON string or number). undefined or proto-default 0 →
+// absent; null/non-numeric/non-positive → malformed. Returns epoch ms.
+function normalizeResetMs(value) {
+  if (value === undefined || value === 0 || value === "0") return null;
+  if (typeof value !== "number" && typeof value !== "string") {
+    throw malformed("quota reset timestamp");
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    throw malformed("quota reset timestamp");
+  }
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) throw malformed("quota reset timestamp");
+  const ms = n * 1000;
+  if (!Number.isFinite(new Date(ms).getTime())) {
+    throw malformed("quota reset timestamp");
+  }
+  return ms;
+}
+
+function normalizeWindow({ remainingPercent, resetUnix, hidden, windowSeconds }) {
+  if (hidden === true) return null;
+  const resetMs = normalizeResetMs(resetUnix);
+  const remaining = normalizeRemainingPercent(remainingPercent);
+  if (remaining === undefined && resetMs === null) return null;
+  return {
+    used_percent: remaining === undefined ? 100 : 100 - remaining,
+    reset_at: resetMs === null ? null : new Date(resetMs).toISOString(),
+    limit_window_seconds: windowSeconds,
+  };
+}
+
+function normalizePlanStatus(body) {
+  const planStatus =
+    body && typeof body === "object" ? body.planStatus : undefined;
+  if (!planStatus || typeof planStatus !== "object") {
+    throw new Error("Devin quota response is missing planStatus.");
+  }
+  const planInfo =
+    planStatus.planInfo && typeof planStatus.planInfo === "object"
+      ? planStatus.planInfo
+      : {};
+  const planLabel = isNonEmptyString(planInfo.planName)
+    ? planInfo.planName.trim()
+    : null;
+
+  // Legacy Windsurf billing fills ACU credit fields instead of the daily /
+  // weekly quota; those strategies have nothing renderable here.
+  const billingStrategy = planInfo.billingStrategy;
+  if (
+    billingStrategy !== undefined &&
+    billingStrategy !== "BILLING_STRATEGY_QUOTA"
+  ) {
+    return { plan_label: planLabel, primary_window: null, secondary_window: null };
+  }
+
+  return {
+    plan_label: planLabel,
+    primary_window: normalizeWindow({
+      remainingPercent: planStatus.dailyQuotaRemainingPercent,
+      resetUnix: planStatus.dailyQuotaResetAtUnix,
+      hidden: planInfo.hideDailyQuota === true,
+      windowSeconds: DEVIN_DAILY_WINDOW_SECONDS,
+    }),
+    secondary_window: normalizeWindow({
+      remainingPercent: planStatus.weeklyQuotaRemainingPercent,
+      resetUnix: planStatus.weeklyQuotaResetAtUnix,
+      hidden: planInfo.hideWeeklyQuota === true,
+      windowSeconds: DEVIN_WEEKLY_WINDOW_SECONDS,
+    }),
+  };
+}
+
+// `{ configured: false }` when the provider is not enabled or no Devin CLI
+// sign-in exists, otherwise the normalized windows. `enabled` is the user's
+// explicit provider selection forwarded from the local API — without it the
+// credentials file is never opened and no request is made. Throws owned
+// errors only — never raw upstream bodies, filesystem paths or token values.
+// `code: "AUTH_EXPIRED"` flags genuine auth failure for the aggregator's
+// auth_action_required path.
+async function fetchDevinLimits({ home, env = process.env, enabled = false, fetchImpl = fetch } = {}) {
+  if (enabled !== true) return { configured: false };
+  const credentials = readDevinCredentials({ home, env });
+  if (!credentials) return { configured: false };
+
+  let response;
+  try {
+    response = await fetchImpl(DEVIN_PLAN_STATUS_URL, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "Connect-Protocol-Version": "1",
+        "x-auth-token": credentials.apiKey,
+      },
+      body: "{}",
+      // The session token must never reach another origin.
+      redirect: "error",
+    });
+  } catch (error) {
+    throw new Error(
+      error && (error.name === "AbortError" || error.name === "TimeoutError")
+        ? "Devin quota request timed out."
+        : "Devin quota request failed.",
+    );
+  }
+  if (response?.status === 401 || response?.status === 403) {
+    const error = new Error(
+      "Devin sign-in expired or was rejected — run `devin auth login` to sign in again.",
+    );
+    error.code = "AUTH_EXPIRED";
+    throw error;
+  }
+  if (!response?.ok) {
+    throw new Error(
+      `Devin quota request was rejected (HTTP ${response?.status ?? "?"}).`,
+    );
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    throw new Error("Devin quota response was not JSON.");
+  }
+  const windows = normalizePlanStatus(body);
+  return {
+    configured: true,
+    error: null,
+    plan_label: windows.plan_label,
+    primary_window: windows.primary_window,
+    secondary_window: windows.secondary_window,
+  };
+}
+
+module.exports = { fetchDevinLimits };

package/src/lib/devin-usage.js

@@ -0,0 +1,212 @@
+"use strict";
+
+// Devin CLI (Cognition — devin.ai) local history projection.
+//
+// Devin persists chat history in a SQLite database at
+// `$XDG_DATA_HOME/devin/cli/sessions.db` (default
+// `~/.local/share/devin/cli/sessions.db`). Token usage lives on assistant
+// message nodes inside the `chat_message` JSON document. The SQL below is a
+// deliberately narrow projection: request identity, generation model, the
+// original generation timestamps, the numeric usage metrics, and the owning
+// session's `working_directory`/`created_at` for canonical ordering and local
+// project attribution. Message bodies, prompt text, node `metadata`,
+// `sessions.cogs_json`, and any credential-bearing state are never selected.
+//
+// Verified against devin CLI 3000.10.21 (611c1cba): replay/fork/compaction
+// produces multiple `message_nodes` rows that share one
+// `metadata.request_id` with identical metrics and original timestamps, so
+// `request_id` — never `row_id` or `(session_id, request_id)` — is the
+// canonical usage identity across the whole local install.
+//
+// Token components are disjoint: the DB's `metrics.input_tokens` already
+// excludes `cache_read_tokens` and `cache_creation_tokens`, so each reported
+// counter is added once and caches are never subtracted from input.
+
+const DEVIN_TABLE_PROBE_SQL =
+  "SELECT name FROM sqlite_master WHERE type='table' AND name IN ('message_nodes','sessions')";
+
+const metricField = (jsonPath, alias) =>
+  `CASE WHEN json_valid(n.chat_message) THEN json_extract(n.chat_message, '${jsonPath}') ELSE NULL END AS ${alias}`;
+
+// `sessions` is LEFT JOINed only for `working_directory` and `created_at`;
+// older databases may not have the table, in which case the projection runs
+// without it (project attribution and session-age ordering degrade to nulls).
+function devinUsageSql({ hasSessionsTable = true } = {}) {
+  const join = hasSessionsTable ? "LEFT JOIN sessions s ON s.id = n.session_id" : "";
+  const sessionCreatedAt = hasSessionsTable ? "s.created_at" : "NULL";
+  const workingDirectory = hasSessionsTable ? "s.working_directory" : "NULL";
+  return `
+    SELECT
+      n.row_id AS row_id,
+      n.session_id AS session_id,
+      ${sessionCreatedAt} AS session_created_at,
+      ${workingDirectory} AS working_directory,
+      ${metricField("$.metadata.request_id", "request_id")},
+      ${metricField("$.metadata.generation_model", "generation_model")},
+      ${metricField("$.metadata.started_generation_at", "started_generation_at")},
+      ${metricField("$.metadata.created_at", "message_created_at")},
+      ${metricField("$.metadata.metrics.input_tokens", "input_tokens")},
+      ${metricField("$.metadata.metrics.output_tokens", "output_tokens")},
+      ${metricField("$.metadata.metrics.cache_read_tokens", "cache_read_tokens")},
+      ${metricField("$.metadata.metrics.cache_creation_tokens", "cache_creation_tokens")}
+    FROM message_nodes n
+    ${join}
+    WHERE json_valid(n.chat_message)
+      AND json_extract(n.chat_message, '$.role') = 'assistant'
+      AND json_extract(n.chat_message, '$.metadata.request_id') IS NOT NULL
+    ORDER BY n.row_id
+  `.trim();
+}
+
+function normalizeText(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+// Strict integer check: usage fields must be finite non-negative safe
+// integers. `null`/`undefined` cache counters are legal (no reported cache
+// contribution) — callers pass them through `optionalCount`; required
+// counters go through `requiredCount`.
+function toSafeCount(value) {
+  const n = Number(value);
+  return Number.isSafeInteger(n) && n >= 0 ? n : null;
+}
+
+function requiredCount(value) {
+  // A missing/NULL required counter is incomplete usage, not zero — pending
+  // assistant records carry no metrics block and must stay uncounted until
+  // the writer finalizes them.
+  if (value === null || value === undefined) return null;
+  return toSafeCount(value);
+}
+
+function optionalCount(value) {
+  if (value === null || value === undefined) return 0;
+  return toSafeCount(value);
+}
+
+// RFC3339 timestamps arrive with both `Z` and `+00:00` spellings; Date.parse
+// normalizes both to the same instant. Returns epoch ms or 0 when missing or
+// unparsable.
+function parseDevinTimestampMs(value) {
+  if (typeof value !== "string" || !value.trim()) return 0;
+  const ms = Date.parse(value.trim());
+  return Number.isFinite(ms) && ms > 0 ? ms : 0;
+}
+
+// session.created_at is Unix seconds; node row ordering uses ms.
+function epochSecondsToMs(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) * 1000 : null;
+}
+
+// Normalize one projected row into a canonical candidate, or null when the
+// record is pending/malformed: missing request identity, missing/invalid
+// numeric usage, or no usable original timestamp. Such rows are re-evaluated
+// on every scan, so a record that gains metrics or a timestamp later is
+// counted then.
+function normalizeDevinUsageRow(row) {
+  const requestId = normalizeText(row?.request_id);
+  if (!requestId) return null;
+
+  const input = requiredCount(row?.input_tokens);
+  const output = requiredCount(row?.output_tokens);
+  const cacheRead = optionalCount(row?.cache_read_tokens);
+  const cacheCreation = optionalCount(row?.cache_creation_tokens);
+  if (input === null || output === null || cacheRead === null || cacheCreation === null) {
+    return null;
+  }
+
+  // The original generation time decides the bucket; the node insertion time
+  // (n.created_at) is clone/replay insertion time and is never a fallback.
+  const tsMs =
+    parseDevinTimestampMs(row?.started_generation_at) ||
+    parseDevinTimestampMs(row?.message_created_at);
+  if (!tsMs) return null;
+
+  return {
+    requestId,
+    sessionId: normalizeText(row?.session_id) || "",
+    rowId: toSafeCount(row?.row_id) ?? 0,
+    sessionCreatedAtMs: epochSecondsToMs(row?.session_created_at),
+    workingDirectory: normalizeText(row?.working_directory),
+    model: normalizeText(row?.generation_model) || "unknown",
+    tsMs,
+    input,
+    output,
+    cacheRead,
+    cacheCreation,
+  };
+}
+
+// Pick the canonical retained record for one request_id. Copies created by
+// replay/fork/compaction carry identical original timestamps and metrics, so
+// the order is: earliest original generation time, then the earliest-created
+// owning session (a fork's copy lives in a younger session), then session id,
+// then newest row first so an in-place correction appended as a fresh node
+// inside the same session wins over the stale sibling.
+function compareCandidates(a, b) {
+  if (a.tsMs !== b.tsMs) return a.tsMs - b.tsMs;
+  const sessionA = a.sessionCreatedAtMs ?? Number.POSITIVE_INFINITY;
+  const sessionB = b.sessionCreatedAtMs ?? Number.POSITIVE_INFINITY;
+  if (sessionA !== sessionB) return sessionA - sessionB;
+  if (a.sessionId !== b.sessionId) return a.sessionId < b.sessionId ? -1 : 1;
+  return b.rowId - a.rowId;
+}
+
+// Build the deduplicated per-request event list. Conversation ownership and
+// session/project attribution are decided by the persisted request ledger in
+// parseDevinIncremental — the projection only reports each request's
+// best-evidence retained record; `conversation_count` stays 0 here and is
+// filled from ledger state at reconcile time.
+function buildDevinUsageEvents(rows) {
+  const byRequest = new Map();
+  let rowsSeen = 0;
+  let rowsSkipped = 0;
+  for (const row of Array.isArray(rows) ? rows : []) {
+    rowsSeen += 1;
+    const candidate = normalizeDevinUsageRow(row);
+    if (!candidate) {
+      rowsSkipped += 1;
+      continue;
+    }
+    const list = byRequest.get(candidate.requestId);
+    if (list) list.push(candidate);
+    else byRequest.set(candidate.requestId, [candidate]);
+  }
+
+  const events = [];
+  for (const [requestId, candidates] of byRequest) {
+    candidates.sort(compareCandidates);
+    const canonical = candidates[0];
+    const total = canonical.input + canonical.output + canonical.cacheRead + canonical.cacheCreation;
+    events.push({
+      requestId,
+      sessionId: canonical.sessionId,
+      workingDirectory: canonical.workingDirectory,
+      model: canonical.model,
+      tsMs: canonical.tsMs,
+      totals: {
+        input_tokens: canonical.input,
+        cached_input_tokens: canonical.cacheRead,
+        cache_creation_input_tokens: canonical.cacheCreation,
+        output_tokens: canonical.output,
+        reasoning_output_tokens: 0,
+        total_tokens: total,
+        billable_total_tokens: total,
+        total_cost_usd: 0,
+        conversation_count: 0,
+      },
+    });
+  }
+  events.sort((a, b) => a.tsMs - b.tsMs || (a.requestId < b.requestId ? -1 : 1));
+
+  return { events, rowsSeen, rowsSkipped };
+}
+
+module.exports = {
+  DEVIN_TABLE_PROBE_SQL,
+  devinUsageSql,
+  buildDevinUsageEvents,
+};

package/src/lib/local-api.js

@@ -3160,6 +3160,11 @@ function createLocalApiHandler({ queuePath }) {
             json(res, { ok: true, skill: await skills.installSkill(body.skill, body.targets || ["claude", "codex"]) });
             return true;
           }
+          if (action === "update_all") {
+            // Partial success is normal, so this reports per-skill rather than failing.
+            json(res, { ok: true, ...(await skills.updateSkills(Array.isArray(body.ids) ? body.ids : [])) });
+            return true;
+          }
           if (action === "uninstall") {
             json(res, { ok: true, ...(skills.uninstallSkill(body.id) || {}) });
             return true;
@@ -3215,6 +3220,19 @@ function createLocalApiHandler({ queuePath }) {
     if (p === "/functions/tokentracker-usage-limits") {
       const { getUsageLimits, resetUsageLimitsCache } = require("./usage-limits");
       try {
+        // Devin quota is opt-in (Settings > Usage & Limits > Providers). An
+        // explicit devin=1 without local authentication is rejected before any
+        // cache reset or provider work — silently downgrading it to a disabled
+        // response would misreport an enabled client as a disabled provider.
+        // Authorization is evaluated unconditionally so the check never depends
+        // on the user-controlled opt-in flag itself.
+        const localAuthorized = isAuthorizedLocalMutation(req);
+        const devinParam = url.searchParams.get("devin");
+        const devinEnabled = devinParam === "1" || devinParam === "true";
+        if (devinEnabled && !localAuthorized) {
+          json(res, { error: "Unauthorized" }, 401);
+          return true;
+        }
         const refreshParam = url.searchParams.get("refresh");
         const forceRefresh = refreshParam === "1" || refreshParam === "true";
         if (forceRefresh) {
@@ -3227,6 +3245,7 @@ function createLocalApiHandler({ queuePath }) {
           // Punches through the Claude disk fresh-cache (but not the 429
           // cooldown) — an explicit user refresh should hit upstream.
           forceRefresh,
+          devinEnabled,
         });
         json(res, data);
       } catch (e) {

package/src/lib/passive-mode.js

@@ -89,7 +89,7 @@ function classifyWritableFailure(filePath) {
  *   every_code, opencode, openclaw, codebuddy, workbuddy, grok }
  * @returns {PassiveProvider[]}
  */
-function detectPassiveProviders({ home, hookStatus }) {
+function detectPassiveProviders({ home, hookStatus, env = process.env }) {
   const out = [];
 
   // Claude Code — logs at ~/.claude/projects/<name>/*.jsonl
@@ -128,6 +128,18 @@ function detectPassiveProviders({ home, hookStatus }) {
     settingsPath: path.join(home, ".codex", "config.toml"),
   }));
 
+  const acodeHome = env.TOKENTRACKER_ACODE_HOME || path.join(home, ".acode");
+  out.push(buildEntry({
+    name: "acode",
+    hookExpected: true,
+    hookInstalled: Boolean(hookStatus?.acode_notify ?? hookStatus?.acode),
+    logsDir: acodeHome,
+    logsPredicate: (_full, name, isDir) =>
+      (isDir && (name === "sessions" || name === "archived_sessions")) ||
+      (!isDir && name.endsWith(".jsonl")),
+    settingsPath: path.join(acodeHome, "config.toml"),
+  }));
+
   // Every Code — same shape as Codex, different home
   out.push(buildEntry({
     name: "every_code",