claude-mem 13.9.1 → 13.9.3

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem",
-  "version": "13.9.1",
+  "version": "13.9.3",
   "description": "Memory compression system for Claude Code - persist context across sessions",
   "author": {
     "name": "Alex Newman",

package/dist/index.js

@@ -363,6 +363,29 @@ CREATE INDEX IF NOT EXISTS idx_observation_jobs_event ON observation_generation_
 CREATE INDEX IF NOT EXISTS idx_observation_jobs_source ON observation_generation_jobs(source_type, source_id);
 CREATE INDEX IF NOT EXISTS idx_observation_job_events_job_created ON observation_generation_job_events(generation_job_id, created_at);
 CREATE INDEX IF NOT EXISTS idx_audit_log_scope_created ON audit_log(project_id, team_id, created_at);
+
+-- Usage metering: append-only per-team usage, aggregated for quotas + billing.
+-- kind is open-ended ('request', 'tokens_in', 'tokens_out', 'observation', ...).
+CREATE TABLE IF NOT EXISTS usage_events (
+  id TEXT PRIMARY KEY,
+  team_id TEXT NOT NULL REFERENCES teams(id) ON DELETE CASCADE,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  kind TEXT NOT NULL,
+  quantity BIGINT NOT NULL DEFAULT 1,
+  metadata JSONB NOT NULL DEFAULT '{}'::jsonb,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+CREATE INDEX IF NOT EXISTS idx_usage_events_team_created ON usage_events(team_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_usage_events_team_kind_created ON usage_events(team_id, kind, created_at);
+
+-- Fixed-window rate-limit counters. subject_id is the api key id (per-key limit).
+CREATE TABLE IF NOT EXISTS rate_limit_counters (
+  subject_id TEXT NOT NULL,
+  window_start TIMESTAMPTZ NOT NULL,
+  count BIGINT NOT NULL DEFAULT 0,
+  PRIMARY KEY (subject_id, window_start)
+);
+CREATE INDEX IF NOT EXISTS idx_rate_limit_counters_window ON rate_limit_counters(window_start);
 `;
 
 // src/storage/postgres/utils.ts
@@ -1586,6 +1609,77 @@ function mapTeamMemberRow(row) {
   };
 }
 
+// src/storage/postgres/usage.ts
+var PostgresUsageRepository = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async record(input) {
+    await this.client.query(
+      `INSERT INTO usage_events (id, team_id, project_id, kind, quantity, metadata)
+       VALUES ($1, $2, $3, $4, $5, $6::jsonb)`,
+      [
+        newId(),
+        input.teamId,
+        input.projectId ?? null,
+        input.kind,
+        Math.max(0, Math.trunc(input.quantity ?? 1)),
+        JSON.stringify(input.metadata ?? {})
+      ]
+    );
+  }
+  /** Total quantity of one `kind` for a team since `since` — the quota read. */
+  async total(input) {
+    const res = await this.client.query(
+      `SELECT COALESCE(SUM(quantity), 0)::bigint AS total
+         FROM usage_events
+        WHERE team_id = $1 AND kind = $2 AND created_at >= $3`,
+      [input.teamId, input.kind, input.since]
+    );
+    return Number(res.rows[0]?.total ?? 0);
+  }
+  /** Per-kind totals for a team since `since` — the /v1/usage read. */
+  async summarize(input) {
+    const res = await this.client.query(
+      `SELECT kind, SUM(quantity)::bigint AS total
+         FROM usage_events
+        WHERE team_id = $1 AND created_at >= $2
+        GROUP BY kind`,
+      [input.teamId, input.since]
+    );
+    const out = {};
+    for (const row of res.rows) out[row.kind] = Number(row.total);
+    return out;
+  }
+};
+
+// src/storage/postgres/rate-limit.ts
+var PostgresRateLimitRepository = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Atomically increment the current window's counter for `subjectId` and
+   * report whether it is still within `limit`.
+   */
+  async hit(input) {
+    const res = await this.client.query(
+      `INSERT INTO rate_limit_counters (subject_id, window_start, count)
+       VALUES ($1, $2, 1)
+       ON CONFLICT (subject_id, window_start)
+       DO UPDATE SET count = rate_limit_counters.count + 1
+       RETURNING count`,
+      [input.subjectId, input.windowStart]
+    );
+    const count = Number(res.rows[0]?.count ?? 0);
+    return { allowed: count <= input.limit, count, limit: input.limit, windowStart: input.windowStart };
+  }
+  /** Best-effort cleanup of expired windows. Call off the hot path. */
+  async prune(before) {
+    await this.client.query(`DELETE FROM rate_limit_counters WHERE window_start < $1`, [before]);
+  }
+};
+
 // src/storage/postgres/index.ts
 function createPostgresStorageRepositories(client) {
   return {
@@ -1597,7 +1691,9 @@ function createPostgresStorageRepositories(client) {
     observations: new PostgresObservationRepository(client),
     observationSources: new PostgresObservationSourcesRepository(client),
     observationGenerationJobs: new PostgresObservationGenerationJobRepository(client),
-    observationGenerationJobEvents: new PostgresObservationGenerationJobEventsRepository(client)
+    observationGenerationJobEvents: new PostgresObservationGenerationJobEventsRepository(client),
+    usage: new PostgresUsageRepository(client),
+    rateLimits: new PostgresRateLimitRepository(client)
   };
 }
 
@@ -1994,10 +2090,6 @@ var SettingsDefaultsManager = class {
     // Default Gemini model (highest free tier RPM)
     CLAUDE_MEM_GEMINI_RATE_LIMITING_ENABLED: "true",
     // Rate limiting ON by default for free tier users
-    CLAUDE_MEM_GEMINI_MAX_CONTEXT_MESSAGES: "20",
-    // Max messages in Gemini context window
-    CLAUDE_MEM_GEMINI_MAX_TOKENS: "100000",
-    // Max estimated tokens (~100k safety limit)
     CLAUDE_MEM_OPENROUTER_API_KEY: "",
     // Empty by default, can be set via UI or env
     CLAUDE_MEM_OPENROUTER_MODEL: "xiaomi/mimo-v2-flash:free",
@@ -2008,10 +2100,6 @@ var SettingsDefaultsManager = class {
     // Optional: for OpenRouter analytics
     CLAUDE_MEM_OPENROUTER_APP_NAME: "claude-mem",
     // App name for OpenRouter analytics
-    CLAUDE_MEM_OPENROUTER_MAX_CONTEXT_MESSAGES: "20",
-    // Max messages in context window
-    CLAUDE_MEM_OPENROUTER_MAX_TOKENS: "100000",
-    // Max estimated tokens (~100k safety limit)
     CLAUDE_MEM_DATA_DIR: join3(homedir2(), ".claude-mem"),
     CLAUDE_MEM_LOG_LEVEL: "INFO",
     CLAUDE_MEM_PYTHON_VERSION: "3.13",
@@ -6066,7 +6154,7 @@ async function processGeneratedResponse(input) {
   const observationsToWrite = parsed.observations ?? [];
   const skipped = parsed.summary?.skipped === true;
   const privateContentDetected = skipped || observationsToWrite.length === 0;
-  return await withPostgresTransaction(input.pool, async (client) => {
+  const outcome = await withPostgresTransaction(input.pool, async (client) => {
     const obsRepo = new PostgresObservationRepository(client);
     const sourcesRepo = new PostgresObservationSourcesRepository(client);
     const jobsRepo = new PostgresObservationGenerationJobRepository(client);
@@ -6226,6 +6314,35 @@ async function processGeneratedResponse(input) {
       privateContentDetected
     };
   });
+  if (outcome.kind === "completed" && process.env.CLAUDE_MEM_USAGE_METERING === "1") {
+    try {
+      const usageRepo = new PostgresUsageRepository(input.pool);
+      if (input.tokensUsed && input.tokensUsed > 0) {
+        await usageRepo.record({
+          teamId: input.job.teamId,
+          projectId: input.job.projectId,
+          kind: "tokens",
+          quantity: input.tokensUsed,
+          metadata: { jobId: input.job.id, provider: input.providerLabel, model: input.modelId ?? null }
+        });
+      }
+      if (outcome.observations.length > 0) {
+        await usageRepo.record({
+          teamId: input.job.teamId,
+          projectId: input.job.projectId,
+          kind: "observation",
+          quantity: outcome.observations.length,
+          metadata: { jobId: input.job.id }
+        });
+      }
+    } catch (usageError) {
+      logger.warn("SYSTEM", "usage metering record failed (post-commit)", {
+        jobId: input.job.id,
+        error: usageError instanceof Error ? usageError.message : String(usageError)
+      });
+    }
+  }
+  return outcome;
 }
 function renderObservationContent(observation) {
   const parts = [];