micode 0.9.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "micode",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "OpenCode plugin with Brainstorm-Research-Plan-Implement workflow",
   "module": "dist/index.js",
   "main": "dist/index.js",
@@ -42,6 +42,7 @@
   "dependencies": {
     "@opencode-ai/plugin": "1.1.23",
     "bun-pty": "^0.4.5",
+    "jsonc-parser": "^3.3.1",
     "valibot": "^1.2.0",
     "yaml": "^2.8.2"
   },

package/src/agents/brainstormer.ts

@@ -135,7 +135,7 @@ The redesigned artifact system treats artifacts as first‑class records stored
 
 <phase name="finalizing" trigger="after presenting design">
   <action>Write validated design to thoughts/shared/designs/YYYY-MM-DD-{topic}-design.md</action>
-  <action>Commit the design document to git</action>
+  <action>Commit the design document to git (if git add fails because the file is gitignored, skip the commit — NEVER force-add ignored files)</action>
   <action>IMMEDIATELY spawn planner - do NOT ask "Ready for planner?"</action>
   <spawn>
     Task(

package/src/agents/commander.ts

@@ -128,6 +128,7 @@ Not everything needs brainstorm → plan → execute.
 <rule>Commit message format: type(scope): description</rule>
 <rule>Types: feat, fix, refactor, docs, test, chore</rule>
 <rule>Reference plan file in commit body</rule>
+<rule>NEVER use git add -f or --force. If a file is gitignored, respect it and skip it.</rule>
 </phase>
 
 <phase name="ledger" trigger="context getting full or session ending">
@@ -250,7 +251,7 @@ export const primaryAgent: AgentConfig = {
   temperature: 0.2,
   thinking: {
     type: "enabled",
-    budgetTokens: 32000,
+    budgetTokens: 64000,
   },
   maxTokens: 64000,
   tools: {

package/src/agents/index.ts

@@ -1,5 +1,6 @@
 import type { AgentConfig } from "@opencode-ai/sdk";
 
+import { DEFAULT_MODEL } from "../utils/config";
 import { artifactSearcherAgent } from "./artifact-searcher";
 import { bootstrapperAgent } from "./bootstrapper";
 import { brainstormerAgent } from "./brainstormer";
@@ -30,34 +31,34 @@ import { projectInitializerAgent } from "./project-initializer";
 import { reviewerAgent } from "./reviewer";
 
 export const agents: Record<string, AgentConfig> = {
-  [PRIMARY_AGENT_NAME]: { ...primaryAgent, model: "openai/gpt-5.2-codex" },
-  brainstormer: { ...brainstormerAgent, model: "openai/gpt-5.2-codex" },
-  bootstrapper: { ...bootstrapperAgent, model: "openai/gpt-5.2-codex" },
-  "codebase-locator": { ...codebaseLocatorAgent, model: "openai/gpt-5.2-codex" },
-  "codebase-analyzer": { ...codebaseAnalyzerAgent, model: "openai/gpt-5.2-codex" },
-  "pattern-finder": { ...patternFinderAgent, model: "openai/gpt-5.2-codex" },
-  planner: { ...plannerAgent, model: "openai/gpt-5.2-codex" },
-  implementer: { ...implementerAgent, model: "openai/gpt-5.2-codex" },
-  reviewer: { ...reviewerAgent, model: "openai/gpt-5.2-codex" },
-  executor: { ...executorAgent, model: "openai/gpt-5.2-codex" },
-  "ledger-creator": { ...ledgerCreatorAgent, model: "openai/gpt-5.2-codex" },
-  "artifact-searcher": { ...artifactSearcherAgent, model: "openai/gpt-5.2-codex" },
-  "project-initializer": { ...projectInitializerAgent, model: "openai/gpt-5.2-codex" },
-  octto: { ...octtoAgent, model: "openai/gpt-5.2-codex" },
-  probe: { ...probeAgent, model: "openai/gpt-5.2-codex" },
+  [PRIMARY_AGENT_NAME]: { ...primaryAgent, model: DEFAULT_MODEL },
+  brainstormer: { ...brainstormerAgent, model: DEFAULT_MODEL },
+  bootstrapper: { ...bootstrapperAgent, model: DEFAULT_MODEL },
+  "codebase-locator": { ...codebaseLocatorAgent, model: DEFAULT_MODEL },
+  "codebase-analyzer": { ...codebaseAnalyzerAgent, model: DEFAULT_MODEL },
+  "pattern-finder": { ...patternFinderAgent, model: DEFAULT_MODEL },
+  planner: { ...plannerAgent, model: DEFAULT_MODEL },
+  implementer: { ...implementerAgent, model: DEFAULT_MODEL },
+  reviewer: { ...reviewerAgent, model: DEFAULT_MODEL },
+  executor: { ...executorAgent, model: DEFAULT_MODEL },
+  "ledger-creator": { ...ledgerCreatorAgent, model: DEFAULT_MODEL },
+  "artifact-searcher": { ...artifactSearcherAgent, model: DEFAULT_MODEL },
+  "project-initializer": { ...projectInitializerAgent, model: DEFAULT_MODEL },
+  octto: { ...octtoAgent, model: DEFAULT_MODEL },
+  probe: { ...probeAgent, model: DEFAULT_MODEL },
   // Mindmodel generation agents
-  "mm-stack-detector": { ...stackDetectorAgent, model: "openai/gpt-5.2-codex" },
-  "mm-pattern-discoverer": { ...mindmodelPatternDiscovererAgent, model: "openai/gpt-5.2-codex" },
-  "mm-example-extractor": { ...exampleExtractorAgent, model: "openai/gpt-5.2-codex" },
-  "mm-orchestrator": { ...mindmodelOrchestratorAgent, model: "openai/gpt-5.2-codex" },
+  "mm-stack-detector": { ...stackDetectorAgent, model: DEFAULT_MODEL },
+  "mm-pattern-discoverer": { ...mindmodelPatternDiscovererAgent, model: DEFAULT_MODEL },
+  "mm-example-extractor": { ...exampleExtractorAgent, model: DEFAULT_MODEL },
+  "mm-orchestrator": { ...mindmodelOrchestratorAgent, model: DEFAULT_MODEL },
   // Mindmodel v2 analysis agents
-  "mm-dependency-mapper": { ...dependencyMapperAgent, model: "openai/gpt-5.2-codex" },
-  "mm-convention-extractor": { ...conventionExtractorAgent, model: "openai/gpt-5.2-codex" },
-  "mm-domain-extractor": { ...domainExtractorAgent, model: "openai/gpt-5.2-codex" },
-  "mm-code-clusterer": { ...codeClustererAgent, model: "openai/gpt-5.2-codex" },
-  "mm-anti-pattern-detector": { ...antiPatternDetectorAgent, model: "openai/gpt-5.2-codex" },
-  "mm-constraint-writer": { ...constraintWriterAgent, model: "openai/gpt-5.2-codex" },
-  "mm-constraint-reviewer": { ...constraintReviewerAgent, model: "openai/gpt-5.2-codex" },
+  "mm-dependency-mapper": { ...dependencyMapperAgent, model: DEFAULT_MODEL },
+  "mm-convention-extractor": { ...conventionExtractorAgent, model: DEFAULT_MODEL },
+  "mm-domain-extractor": { ...domainExtractorAgent, model: DEFAULT_MODEL },
+  "mm-code-clusterer": { ...codeClustererAgent, model: DEFAULT_MODEL },
+  "mm-anti-pattern-detector": { ...antiPatternDetectorAgent, model: DEFAULT_MODEL },
+  "mm-constraint-writer": { ...constraintWriterAgent, model: DEFAULT_MODEL },
+  "mm-constraint-reviewer": { ...constraintReviewerAgent, model: DEFAULT_MODEL },
 };
 
 export {

package/src/config-loader.test.ts

@@ -1,7 +1,10 @@
 // src/config-loader.test.ts
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-import { type MicodeConfig, type ProviderInfo, validateAgentModels } from "./config-loader";
+import { loadMicodeConfig, type MicodeConfig, type ProviderInfo, validateAgentModels } from "./config-loader";
 
 // Helper to create a minimal ProviderInfo for testing
 function createProvider(id: string, modelIds: string[]): ProviderInfo {
@@ -224,3 +227,51 @@ describe("validateAgentModels", () => {
     expect(result).toEqual({ agents: {} });
   });
 });
+
+describe("JSONC parsing via loadMicodeConfig", () => {
+  let testConfigDir: string;
+
+  beforeEach(() => {
+    testConfigDir = join(tmpdir(), `micode-jsonc-unit-test-${Date.now()}`);
+    mkdirSync(testConfigDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(testConfigDir, { recursive: true, force: true });
+  });
+
+  test("parses .jsonc file with comments and trailing commas", async () => {
+    writeFileSync(
+      join(testConfigDir, "micode.jsonc"),
+      `{
+  // Agent configuration
+  "agents": {
+    "commander": {
+      "model": "openai/gpt-4o", // use GPT-4o
+      "temperature": 0.2,
+    },
+  },
+}`,
+    );
+
+    const config = await loadMicodeConfig(testConfigDir);
+
+    expect(config).not.toBeNull();
+    expect(config?.agents?.commander?.model).toBe("openai/gpt-4o");
+    expect(config?.agents?.commander?.temperature).toBe(0.2);
+  });
+
+  test("still parses plain .json files (backward compatibility)", async () => {
+    writeFileSync(
+      join(testConfigDir, "micode.json"),
+      JSON.stringify({
+        agents: { commander: { model: "openai/gpt-4o" } },
+      }),
+    );
+
+    const config = await loadMicodeConfig(testConfigDir);
+
+    expect(config).not.toBeNull();
+    expect(config?.agents?.commander?.model).toBe("openai/gpt-4o");
+  });
+});

package/src/config-loader.ts

@@ -1,10 +1,11 @@
 // src/config-loader.ts
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
 import type { AgentConfig } from "@opencode-ai/sdk";
+import { type ParseError, parse as parseJsonc } from "jsonc-parser";
 
 // Minimal type for provider validation - only what we need
 export interface ProviderInfo {
@@ -21,23 +22,75 @@ interface OpencodeConfig {
 }
 
 /**
- * Load opencode.json config file (synchronous)
+ * Parse a JSON or JSONC string, supporting comments and trailing commas.
+ * Uses the same options as OpenCode's own parser.
+ */
+function parseConfigJson(content: string): unknown {
+  const errors: ParseError[] = [];
+  const result = parseJsonc(content, errors, { allowTrailingComma: true });
+  if (errors.length > 0) {
+    throw new Error(`Invalid JSON/JSONC: ${errors.length} parse error(s)`);
+  }
+  return result;
+}
+
+/**
+ * Resolve a config file path, preferring .jsonc over .json (synchronous).
+ * Returns the path to the first file found, or null if neither exists.
+ */
+function resolveConfigFileSync(baseDir: string, baseName: string): string | null {
+  const jsoncPath = join(baseDir, `${baseName}.jsonc`);
+  if (existsSync(jsoncPath)) {
+    return jsoncPath;
+  }
+
+  const jsonPath = join(baseDir, `${baseName}.json`);
+  if (existsSync(jsonPath)) {
+    return jsonPath;
+  }
+
+  return null;
+}
+
+/**
+ * Read a config file, preferring .jsonc over .json (async).
+ * Returns the file content string, or null if neither file exists.
+ */
+async function readConfigFileAsync(baseDir: string, baseName: string): Promise<string | null> {
+  // Try .jsonc first
+  try {
+    return await readFile(join(baseDir, `${baseName}.jsonc`), "utf-8");
+  } catch {
+    // .jsonc not found, try .json
+  }
+
+  try {
+    return await readFile(join(baseDir, `${baseName}.json`), "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load opencode.json/opencode.jsonc config file (synchronous)
  * Returns the parsed config or null if unavailable
  */
 function loadOpencodeConfig(configDir?: string): OpencodeConfig | null {
   const baseDir = configDir ?? join(homedir(), ".config", "opencode");
 
   try {
-    const configPath = join(baseDir, "opencode.json");
+    const configPath = resolveConfigFileSync(baseDir, "opencode");
+    if (!configPath) return null;
+
     const content = readFileSync(configPath, "utf-8");
-    return JSON.parse(content) as OpencodeConfig;
+    return parseConfigJson(content) as OpencodeConfig;
   } catch {
     return null;
   }
 }
 
 /**
- * Load available models from opencode.json config file (synchronous)
+ * Load available models from opencode.json/opencode.jsonc config file (synchronous)
  * Returns a Set of "provider/model" strings
  */
 export function loadAvailableModels(configDir?: string): Set<string> {
@@ -58,7 +111,7 @@ export function loadAvailableModels(configDir?: string): Set<string> {
 }
 
 /**
- * Load the default model from opencode.json config file (synchronous)
+ * Load the default model from opencode.json/opencode.jsonc config file (synchronous)
  * Returns the model string in "provider/model" format or null if not set
  */
 export function loadDefaultModel(configDir?: string): string | null {
@@ -67,7 +120,7 @@ export function loadDefaultModel(configDir?: string): string | null {
 }
 
 // Safe properties that users can override
-const SAFE_AGENT_PROPERTIES = ["model", "temperature", "maxTokens"] as const;
+const SAFE_AGENT_PROPERTIES = ["model", "temperature", "maxTokens", "thinking"] as const;
 
 // Built-in OpenCode models that don't require validation (always available)
 const BUILTIN_MODELS = new Set(["opencode/big-pickle"]);
@@ -76,6 +129,10 @@ export interface AgentOverride {
   model?: string;
   temperature?: number;
   maxTokens?: number;
+  thinking?: {
+    type: string;
+    budgetTokens: number;
+  };
 }
 
 export interface MicodeFeatures {
@@ -90,17 +147,18 @@ export interface MicodeConfig {
 }
 
 /**
- * Load micode.json from ~/.config/opencode/micode.json
- * Returns null if file doesn't exist or is invalid JSON
+ * Load micode.json/micode.jsonc from ~/.config/opencode/
+ * Returns null if file doesn't exist or is invalid
  * @param configDir - Optional override for config directory (for testing)
  */
 export async function loadMicodeConfig(configDir?: string): Promise<MicodeConfig | null> {
   const baseDir = configDir ?? join(homedir(), ".config", "opencode");
-  const configPath = join(baseDir, "micode.json");
 
   try {
-    const content = await readFile(configPath, "utf-8");
-    const parsed = JSON.parse(content) as Record<string, unknown>;
+    const content = await readConfigFileAsync(baseDir, "micode");
+    if (!content) return null;
+
+    const parsed = parseConfigJson(content) as Record<string, unknown>;
 
     const result: MicodeConfig = {};
 
@@ -166,7 +224,7 @@ export async function loadMicodeConfig(configDir?: string): Promise<MicodeConfig
 }
 
 /**
- * Load model context limits from opencode.json
+ * Load model context limits from opencode.json/opencode.jsonc
  * Returns a Map of "provider/model" -> context limit (tokens)
  */
 export function loadModelContextLimits(configDir?: string): Map<string, number> {
@@ -174,9 +232,11 @@ export function loadModelContextLimits(configDir?: string): Map<string, number>
   const baseDir = configDir ?? join(homedir(), ".config", "opencode");
 
   try {
-    const configPath = join(baseDir, "opencode.json");
+    const configPath = resolveConfigFileSync(baseDir, "opencode");
+    if (!configPath) return limits;
+
     const content = readFileSync(configPath, "utf-8");
-    const config = JSON.parse(content) as {
+    const config = parseConfigJson(content) as {
       provider?: Record<string, { models?: Record<string, { limit?: { context?: number } }> }>;
     };
 
@@ -207,7 +267,7 @@ export function loadModelContextLimits(configDir?: string): Map<string, number>
  * Model resolution priority:
  * 1. Per-agent override in micode.json (highest)
  * 2. Default model from opencode.json "model" field
- * 3. Plugin default (hardcoded in agent definitions)
+ * 3. DEFAULT_MODEL from config (plugin fallback)
  */
 export function mergeAgentConfigs(
   pluginAgents: Record<string, AgentConfig>,
@@ -247,8 +307,9 @@ export function mergeAgentConfigs(
           finalConfig = { ...finalConfig, ...userOverride };
         } else {
           // Model is invalid - log warning and apply other overrides only
+          const fallbackModel = finalConfig.model || "DEFAULT_MODEL";
           console.warn(
-            `[micode] Model "${userOverride.model}" for agent "${name}" is not available. Using opencode default.`,
+            `[micode] Model "${userOverride.model}" for agent "${name}" is not available. Using ${fallbackModel}.`,
           );
           const { model: _ignored, ...safeOverrides } = userOverride;
           finalConfig = { ...finalConfig, ...safeOverrides };

package/src/hooks/fetch-tracker.ts

@@ -0,0 +1,233 @@
+// src/hooks/fetch-tracker.ts
+import type { PluginInput } from "@opencode-ai/plugin";
+
+import { config } from "../utils/config";
+import { log } from "../utils/logger";
+
+// --- Tracked tools ---
+
+export const FETCH_TOOLS = new Set(["webfetch", "context7_query-docs", "context7_resolve-library-id", "btca_ask"]);
+
+// --- LRU Cache (same pattern as mindmodel-injector.ts) ---
+
+interface CacheEntry {
+  content: string;
+  timestamp: number;
+}
+
+class LRUCache<V> {
+  private cache = new Map<string, V>();
+  constructor(private maxSize: number) {}
+
+  get(key: string): V | undefined {
+    const value = this.cache.get(key);
+    if (value !== undefined) {
+      // Move to end (most recently used)
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+
+  set(key: string, value: V): void {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      // Delete oldest (first) entry
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== undefined) this.cache.delete(firstKey);
+    }
+    this.cache.set(key, value);
+  }
+
+  delete(key: string): void {
+    this.cache.delete(key);
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+}
+
+// --- Per-session state ---
+
+// Call counts: sessionID -> (normalizedKey -> count)
+const sessionCallCounts = new Map<string, Map<string, number>>();
+
+// Cache: sessionID -> LRUCache of fetch results
+const sessionCaches = new Map<string, LRUCache<CacheEntry>>();
+
+// --- Key normalization ---
+
+/**
+ * Normalize a tool call into a cache/tracking key.
+ * Returns null if the tool is not tracked or args are missing/malformed.
+ */
+export function normalizeKey(tool: string, args: Record<string, unknown> | undefined): string | null {
+  if (!FETCH_TOOLS.has(tool) || !args) return null;
+
+  try {
+    switch (tool) {
+      case "webfetch": {
+        const rawUrl = args.url as string | undefined;
+        if (!rawUrl) return null;
+        try {
+          const parsed = new URL(rawUrl);
+          // Sort query params for consistent keys
+          parsed.searchParams.sort();
+          return `webfetch|${parsed.toString()}`;
+        } catch {
+          // Malformed URL — use raw string as fallback
+          return `webfetch|${rawUrl}`;
+        }
+      }
+      case "context7_query-docs": {
+        const libraryId = args.libraryId as string | undefined;
+        const query = args.query as string | undefined;
+        if (!libraryId || !query) return null;
+        return `context7_query-docs|${libraryId}|${query}`;
+      }
+      case "context7_resolve-library-id": {
+        const libraryName = args.libraryName as string | undefined;
+        const query = args.query as string | undefined;
+        if (!libraryName || !query) return null;
+        return `context7_resolve-library-id|${libraryName}|${query}`;
+      }
+      case "btca_ask": {
+        const tech = args.tech as string | undefined;
+        const question = args.question as string | undefined;
+        if (!tech || !question) return null;
+        return `btca_ask|${tech}|${question}`;
+      }
+      default:
+        return null;
+    }
+  } catch (error) {
+    log.warn("hooks.fetch-tracker", `Key normalization failed: ${error instanceof Error ? error.message : "unknown"}`);
+    return null;
+  }
+}
+
+// --- Public accessors (for testing and external use) ---
+
+export function getCallCount(sessionID: string, normalizedKey: string): number {
+  return sessionCallCounts.get(sessionID)?.get(normalizedKey) ?? 0;
+}
+
+export function getCacheEntry(sessionID: string, normalizedKey: string): CacheEntry | undefined {
+  return sessionCaches.get(sessionID)?.get(normalizedKey);
+}
+
+export function clearSession(sessionID: string): void {
+  sessionCallCounts.delete(sessionID);
+  sessionCaches.delete(sessionID);
+}
+
+// --- Internal helpers ---
+
+function getOrCreateCounts(sessionID: string): Map<string, number> {
+  let counts = sessionCallCounts.get(sessionID);
+  if (!counts) {
+    counts = new Map();
+    sessionCallCounts.set(sessionID, counts);
+  }
+  return counts;
+}
+
+function getOrCreateCache(sessionID: string): LRUCache<CacheEntry> {
+  let cache = sessionCaches.get(sessionID);
+  if (!cache) {
+    cache = new LRUCache<CacheEntry>(config.fetch.cacheMaxEntries);
+    sessionCaches.set(sessionID, cache);
+  }
+  return cache;
+}
+
+function incrementCount(sessionID: string, key: string): number {
+  const counts = getOrCreateCounts(sessionID);
+  const current = counts.get(key) ?? 0;
+  const next = current + 1;
+  counts.set(key, next);
+  return next;
+}
+
+function isCacheExpired(entry: CacheEntry): boolean {
+  return Date.now() - entry.timestamp > config.fetch.cacheTtlMs;
+}
+
+// --- Hook factory ---
+
+export function createFetchTrackerHook(_ctx: PluginInput) {
+  return {
+    /**
+     * After hook: track fetch calls, cache results, inject warnings/blocks.
+     *
+     * On first call: stores result in cache, increments count.
+     * On repeated calls: replaces output with cached content + warning.
+     * After maxCallsPerResource: replaces output with block message.
+     *
+     * Note: We use tool.execute.after (not before) because the plugin SDK's
+     * before hook only exposes { args } for modification, not { output }.
+     * The after hook can mutate output.output to replace the tool's result.
+     */
+    "tool.execute.after": async (
+      input: { tool: string; sessionID: string; args?: Record<string, unknown> },
+      output: { output?: string },
+    ) => {
+      try {
+        if (!FETCH_TOOLS.has(input.tool)) return;
+
+        const key = normalizeKey(input.tool, input.args);
+        if (!key) return;
+
+        // Increment call count
+        const count = incrementCount(input.sessionID, key);
+
+        // Hard block: exceeded max calls — unconditional, independent of cache state
+        if (count > config.fetch.maxCallsPerResource) {
+          output.output = `<fetch-blocked>This resource has been fetched ${count} times this session. The content is already available in the conversation above. Use the information already available instead of re-fetching.</fetch-blocked>`;
+          return;
+        }
+
+        // Check for cached content from a previous call
+        const cache = getOrCreateCache(input.sessionID);
+        const cached = cache.get(key);
+
+        if (count > 1 && cached && !isCacheExpired(cached)) {
+          // Repeated call with valid cache — replace output with cached content
+          let cachedOutput = `<from-cache>Returning cached result (fetched ${count} time${count !== 1 ? "s" : ""} previously).</from-cache>\n\n${cached.content}`;
+
+          // Add warning if at or above warn threshold
+          if (count >= config.fetch.warnThreshold) {
+            cachedOutput += `\n\n<fetch-warning>You have fetched this resource ${count} times. The content is cached and identical. Consider using the information you already have instead of re-fetching.</fetch-warning>`;
+          }
+
+          output.output = cachedOutput;
+        } else {
+          // First call or cache expired — store fresh result
+          if (output.output) {
+            cache.set(key, { content: output.output, timestamp: Date.now() });
+          }
+        }
+      } catch (error) {
+        log.warn("hooks.fetch-tracker", `After hook error: ${error instanceof Error ? error.message : "unknown"}`);
+      }
+    },
+
+    /**
+     * Event handler: clean up on session deletion.
+     * Same pattern as file-ops-tracker.
+     */
+    event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
+      if (event.type === "session.deleted") {
+        const props = event.properties as { info?: { id?: string } } | undefined;
+        if (props?.info?.id) {
+          clearSession(props.info.id);
+        }
+      }
+    },
+
+    /** Direct cleanup function (used by index.ts for explicit cleanup) */
+    cleanupSession: clearSession,
+  };
+}