context-mode 1.0.168 → 2.0.0-next.5

package/hooks/posttooluse.mjs

@@ -1,187 +0,0 @@
-#!/usr/bin/env node
-/**
- * PostToolUse hook for context-mode session continuity.
- *
- * Captures session events from tool calls (13 categories) and stores
- * them in the per-project SessionDB for later resume snapshot building.
- *
- * Must be fast (<20ms). No network, no LLM, just SQLite writes.
- *
- * Crash-resilience: wrapped via runHook (#414).
- */
-
-import { runHook } from "./run-hook.mjs";
-
-await runHook(async () => {
-  const {
-    readStdin,
-    parseStdin,
-    getSessionId,
-    getSessionDBPath,
-    getInputProjectDir,
-  } = await import("./session-helpers.mjs");
-  const { createSessionLoaders, attributeAndInsertEvents } = await import("./session-loaders.mjs");
-  const { dirname, resolve } = await import("node:path");
-  const { fileURLToPath } = await import("node:url");
-  const { readFileSync, unlinkSync } = await import("node:fs");
-  const { tmpdir } = await import("node:os");
-
-  // Resolve absolute path for imports — relative dynamic imports can fail
-  // when Claude Code invokes hooks from a different working directory.
-  const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
-  const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
-
-  try {
-    const raw = await readStdin();
-    const input = parseStdin(raw);
-    const projectDir = getInputProjectDir(input);
-
-    const { extractEvents } = await loadExtract();
-    const { resolveProjectAttributions } = await loadProjectAttribution();
-    const { SessionDB } = await loadSessionDB();
-
-    const dbPath = getSessionDBPath();
-    const db = new SessionDB({ dbPath });
-    const sessionId = getSessionId(input);
-
-    // Ensure session meta exists
-    db.ensureSession(sessionId, projectDir);
-
-    // Extract and store events
-    const events = extractEvents({
-      tool_name: input.tool_name,
-      tool_input: input.tool_input ?? {},
-      tool_response: typeof input.tool_response === "string"
-        ? input.tool_response
-        : JSON.stringify(input.tool_response ?? ""),
-      tool_output: input.tool_output,
-    });
-
-    attributeAndInsertEvents(db, sessionId, events, input, projectDir, "PostToolUse", resolveProjectAttributions);
-
-    // ─── Category 18: Rejected-approach — read PreToolUse marker ───
-    try {
-      const rejectedPath = resolve(tmpdir(), `context-mode-rejected-${sessionId}.txt`);
-      let rejectedData;
-      try {
-        rejectedData = readFileSync(rejectedPath, "utf-8").trim();
-        unlinkSync(rejectedPath);
-      } catch { /* no marker */ }
-      if (rejectedData) {
-        const colonIdx = rejectedData.indexOf(":");
-        const rejTool = colonIdx > 0 ? rejectedData.slice(0, colonIdx) : rejectedData;
-        const rejReason = colonIdx > 0 ? rejectedData.slice(colonIdx + 1) : "denied";
-        // v1.0.160: route through attributeAndInsertEvents so the bridge wire
-        // receives this event too. db.insertEvent only writes locally — the
-        // dashboard's rejection-rate widget needs the platform row.
-        attributeAndInsertEvents(
-          db,
-          sessionId,
-          [{
-            type: "rejected",
-            category: "rejected-approach",
-            data: `${rejTool}: ${rejReason}`,
-            priority: 2,
-          }],
-          input,
-          projectDir,
-          "PreToolUse",
-          resolveProjectAttributions,
-        );
-      }
-    } catch { /* best-effort */ }
-
-    // ─── D2 PRD Phase 3/4: redirect marker — emit byte-accounting event ───
-    // PreToolUse wrote `context-mode-redirect-${sessionId}.txt` for tools whose
-    // output we kept out of the model's context window (curl/wget, WebFetch,
-    // large Read). Format: `tool:type:bytesAvoided:commandSummary` (Override C).
-    try {
-      const redirectPath = resolve(tmpdir(), `context-mode-redirect-${sessionId}.txt`);
-      let redirectData;
-      try {
-        redirectData = readFileSync(redirectPath, "utf-8").trim();
-        // Slice 3.3: unlink so the next PostToolUse for an unrelated tool call
-        // does NOT re-emit the same event (no double-accounting).
-        unlinkSync(redirectPath);
-      } catch { /* no marker — Slice 3.4: phantom-event guard */ }
-
-      if (redirectData) {
-        // Parse first 3 colons; the rest (commandSummary) may itself contain
-        // colons (URLs do — `https://`). Avoid `split(":", 4)` which would
-        // truncate the summary at any embedded colon.
-        const i1 = redirectData.indexOf(":");
-        const i2 = i1 >= 0 ? redirectData.indexOf(":", i1 + 1) : -1;
-        const i3 = i2 >= 0 ? redirectData.indexOf(":", i2 + 1) : -1;
-        if (i1 > 0 && i2 > i1 && i3 > i2) {
-          const tool = redirectData.slice(0, i1);
-          const type = redirectData.slice(i1 + 1, i2);
-          const bytesRaw = redirectData.slice(i2 + 1, i3);
-          const summary = redirectData.slice(i3 + 1);
-          const bytesAvoided = Number.parseInt(bytesRaw, 10);
-          if (Number.isFinite(bytesAvoided) && bytesAvoided > 0) {
-            // v1.0.160: route through wire — context-saving (byte-accounting)
-            // widget on the platform reads category='redirect' rows. event
-            // carries bytes_avoided so the bytesList branch in
-            // attributeAndInsertEvents stamps the column.
-            attributeAndInsertEvents(
-              db,
-              sessionId,
-              [{
-                type,
-                category: "redirect",
-                data: `${tool}: ${summary}`,
-                priority: 2,
-                bytes_avoided: bytesAvoided,
-              }],
-              input,
-              projectDir,
-              "PreToolUse",
-              resolveProjectAttributions,
-            );
-          }
-        }
-      }
-    } catch { /* best-effort — never block hook */ }
-
-    // ─── Category 27: Latency — read cross-hook marker and emit event if slow ───
-    try {
-      const toolName = input.tool_name ?? "";
-      if (toolName) {
-        const markerPath = resolve(tmpdir(), `context-mode-latency-${sessionId}-${toolName}.txt`);
-        let startTime;
-        try {
-          startTime = parseInt(readFileSync(markerPath, "utf-8").trim(), 10);
-          unlinkSync(markerPath);
-        } catch {
-          // No marker — pretooluse didn't write one or already consumed
-        }
-        if (startTime && !isNaN(startTime)) {
-          const duration = Date.now() - startTime;
-          if (duration > 5000) {
-            // v1.0.160: route through wire — slow-tool insights need this row.
-            attributeAndInsertEvents(
-              db,
-              sessionId,
-              [{
-                type: "tool_latency",
-                category: "latency",
-                data: `${toolName}: ${duration}ms`,
-                priority: 3,
-              }],
-              input,
-              projectDir,
-              "PostToolUse",
-              resolveProjectAttributions,
-            );
-          }
-        }
-      }
-    } catch { /* latency tracking is best-effort */ }
-
-    db.close();
-  } catch {
-    // PostToolUse must never block the session — silent fallback
-  }
-
-  // PostToolUse hooks don't need hookSpecificOutput
-});

package/hooks/precompact.mjs

@@ -1,100 +0,0 @@
-#!/usr/bin/env node
-/**
- * PreCompact hook for context-mode session continuity.
- *
- * Triggered when Claude Code is about to compact the conversation.
- * Reads all captured session events, builds a priority-sorted resume
- * snapshot (<2KB XML), and stores it for injection after compact.
- *
- * Crash-resilience: wrapped via runHook (#414).
- */
-
-import { runHook } from "./run-hook.mjs";
-
-await runHook(async () => {
-  const {
-    readStdin,
-    parseStdin,
-    getSessionId,
-    getSessionDBPath,
-    getInputProjectDir,
-    resolveConfigDir,
-  } = await import("./session-helpers.mjs");
-  const { createSessionLoaders, attributeAndInsertEvents } = await import("./session-loaders.mjs");
-  const { appendFileSync } = await import("node:fs");
-  const { join, dirname } = await import("node:path");
-  const { fileURLToPath } = await import("node:url");
-
-  // Resolve absolute path for imports
-  const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
-  const { loadSessionDB, loadSnapshot, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
-  const DEBUG_LOG = join(resolveConfigDir(), "context-mode", "precompact-debug.log");
-
-  try {
-    const raw = await readStdin();
-    const input = parseStdin(raw);
-
-    const { buildResumeSnapshot } = await loadSnapshot();
-    const { SessionDB } = await loadSessionDB();
-
-    const dbPath = getSessionDBPath();
-    const db = new SessionDB({ dbPath });
-    const sessionId = getSessionId(input);
-
-    // Get all events for this session
-    const events = db.getEvents(sessionId);
-
-    if (events.length > 0) {
-      const stats = db.getSessionStats(sessionId);
-      const snapshot = buildResumeSnapshot(events, {
-        compactCount: (stats?.compact_count ?? 0) + 1,
-      });
-
-      db.upsertResume(sessionId, snapshot, events.length);
-      db.incrementCompactCount(sessionId);
-
-      // v1.0.160: route compaction lifecycle events through wire so
-      // dashboard's compact widget gets per-compaction rows (the engine
-      // joins on category='compaction' to compute snapshot insights).
-      try {
-        const fileEvents = events.filter(e => e.category === "file");
-        const projectDirCompact = getInputProjectDir(input);
-        const { resolveProjectAttributions } = await loadProjectAttribution();
-        attributeAndInsertEvents(
-          db,
-          sessionId,
-          [
-            {
-              type: "compaction_summary",
-              category: "compaction",
-              data: `Session compacted. ${events.length} events, ${fileEvents.length} files touched.`,
-              priority: 1,
-            },
-            {
-              type: "snapshot-built",
-              category: "compaction",
-              data: `Snapshot built. ${snapshot.length} bytes for ${events.length} events.`,
-              priority: 1,
-              bytes_avoided: snapshot.length,
-            },
-          ],
-          input,
-          projectDirCompact,
-          "PreCompact",
-          resolveProjectAttributions,
-        );
-      } catch { /* best-effort — never block PreCompact */ }
-    }
-
-    db.close();
-  } catch (err) {
-    try {
-      appendFileSync(DEBUG_LOG, `[${new Date().toISOString()}] ${err.message}\n`);
-    } catch {
-      // Silent fallback
-    }
-  }
-
-  // PreCompact doesn't need hookSpecificOutput
-  console.log(JSON.stringify({}));
-});

package/hooks/pretooluse.mjs

@@ -1,227 +0,0 @@
-#!/usr/bin/env node
-/**
- * Unified PreToolUse hook for context-mode (Claude Code)
- * Redirects data-fetching tools to context-mode MCP tools
- *
- * Cross-platform (Windows/macOS/Linux) — no bash/jq dependency.
- *
- * Routing is delegated to core/routing.mjs (shared across platforms).
- * This file retains the Claude Code-specific self-heal block and
- * uses core/formatters.mjs for Claude Code output format.
- *
- * Crash-resilience: wrapped via runHook (#414) — module loads happen
- * dynamically inside the wrapper.
- *
- * #415: the destructive settings.json mutation block (which removed
- * context-mode hook entries when hooks.json was present) was deleted.
- * It deleted user-written hook configs without consent and was the
- * documented cause of the regression.
- */
-
-import { runHook } from "./run-hook.mjs";
-
-await runHook(async () => {
-  const { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync, readdirSync } = await import("node:fs");
-  const { resolve, dirname, basename } = await import("node:path");
-  const { fileURLToPath } = await import("node:url");
-  const { tmpdir } = await import("node:os");
-  const { readStdin } = await import("./core/stdin.mjs");
-  const { routePreToolUse, initSecurity } = await import("./core/routing.mjs");
-  const { formatDecision } = await import("./core/formatters.mjs");
-  const { parseStdin, getInputProjectDir, getSessionId, resolveConfigDir } = await import("./session-helpers.mjs");
-
-  // ─── Manual recursive copy (avoids cpSync libuv crash on non-ASCII paths, Windows + Node 24) ───
-  function copyDirSync(src, dest) {
-    mkdirSync(dest, { recursive: true });
-    for (const entry of readdirSync(src, { withFileTypes: true })) {
-      const srcPath = resolve(src, entry.name);
-      const destPath = resolve(dest, entry.name);
-      if (entry.isDirectory()) copyDirSync(srcPath, destPath);
-      else copyFileSync(srcPath, destPath);
-    }
-  }
-
-  // ─── Self-heal: rename dir to correct version, fix registry + hooks ───
-  try {
-    const hookDir = dirname(fileURLToPath(import.meta.url));
-    const myRoot = resolve(hookDir, "..");
-    const myPkg = JSON.parse(readFileSync(resolve(myRoot, "package.json"), "utf-8"));
-    const myVersion = myPkg.version ?? "unknown";
-    const myDirName = basename(myRoot);
-    const cacheParent = dirname(myRoot);
-    const marker = resolve(tmpdir(), `context-mode-healed-${myVersion}`);
-
-    // Only self-heal inside plugin cache dirs — skip in dev/CI environments
-    const isInPluginCache = myRoot.includes("/plugins/cache/") || myRoot.includes("\\plugins\\cache\\");
-    if (myVersion !== "unknown" && isInPluginCache && !existsSync(marker)) {
-      // 1. If dir name doesn't match version (e.g. "0.7.0" but code is "0.9.12"),
-      //    create correct dir, copy files, update registry + hooks
-      const correctDir = resolve(cacheParent, myVersion);
-      if (myDirName !== myVersion && !existsSync(correctDir)) {
-        copyDirSync(myRoot, correctDir);
-
-        // Create start.mjs in new dir if missing
-        const startMjs = resolve(correctDir, "start.mjs");
-        if (!existsSync(startMjs)) {
-          writeFileSync(startMjs, [
-            '#!/usr/bin/env node',
-            'import { existsSync } from "node:fs";',
-            'import { dirname, resolve } from "node:path";',
-            'import { fileURLToPath } from "node:url";',
-            'const __dirname = dirname(fileURLToPath(import.meta.url));',
-            'process.chdir(__dirname);',
-            'if (!process.env.CLAUDE_PROJECT_DIR) process.env.CLAUDE_PROJECT_DIR = process.cwd();',
-            'if (existsSync(resolve(__dirname, "server.bundle.mjs"))) {',
-            '  await import("./server.bundle.mjs");',
-            '} else if (existsSync(resolve(__dirname, "build", "server.js"))) {',
-            '  await import("./build/server.js");',
-            '}',
-          ].join("\n"), "utf-8");
-        }
-      }
-
-      const targetDir = existsSync(correctDir) ? correctDir : myRoot;
-
-      // 2. Update installed_plugins.json → point to correct version dir
-      //    Skip if not present (e.g. CI / non-Claude-Code environments)
-      const ipPath = resolve(resolveConfigDir(), "plugins", "installed_plugins.json");
-      if (existsSync(ipPath)) {
-        const ip = JSON.parse(readFileSync(ipPath, "utf-8"));
-        for (const [key, entries] of Object.entries(ip.plugins || {})) {
-          if (!key.toLowerCase().includes("context-mode")) continue;
-          for (const entry of entries) {
-            entry.installPath = targetDir;
-            entry.version = myVersion;
-            entry.lastUpdated = new Date().toISOString();
-          }
-        }
-        writeFileSync(ipPath, JSON.stringify(ip, null, 2) + "\n", "utf-8");
-      }
-
-      // 3. Legacy: hooks.json absent — rewrite stale paths in settings.json to current version dir.
-      //    The previous "if hooks.json present, delete settings.json entries" block was REMOVED (#415):
-      //    it destroyed user-written hook configs without consent. Plugin-system + settings.json
-      //    coexistence is now Claude Code's responsibility, not ours.
-      const settingsPath = resolve(resolveConfigDir(), "settings.json");
-      try {
-        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-        const allHooks = settings.hooks || {};
-        let changed = false;
-
-        const hooksJsonPath = resolve(myRoot, "hooks", "hooks.json");
-        if (!existsSync(hooksJsonPath)) {
-          // Legacy: hooks.json absent — rewrite stale paths to current version dir.
-          for (const hookType of Object.keys(allHooks)) {
-            const entries = allHooks[hookType];
-            if (!Array.isArray(entries)) continue;
-
-            for (const entry of entries) {
-              // Fix deprecated Task-only matcher (PreToolUse only)
-              if (hookType === "PreToolUse" && entry.matcher?.includes("Task") && !entry.matcher.includes("Agent")) {
-                entry.matcher = entry.matcher.replace("Task", "Agent|Task");
-                changed = true;
-              }
-              // Rewrite stale context-mode hook paths to point to current version
-              for (const h of (entry.hooks || [])) {
-                if (h.command && h.command.includes(".mjs") && h.command.includes("context-mode") && !h.command.includes(targetDir)) {
-                  // Extract the script filename (e.g., sessionstart.mjs, pretooluse.mjs)
-                  const scriptMatch = h.command.match(/([a-z]+\.mjs)\s*"?\s*$/);
-                  if (scriptMatch) {
-                    // Issue #636: quote the script path so spaces in targetDir
-                    // (e.g. Dropbox/iCloud display names like "Lucas Werneck",
-                    // or CLAUDE_CONFIG_DIR pointed at a synced spaced folder)
-                    // don't break /bin/sh's word-splitting at hook-spawn time.
-                    // JSON.stringify is sufficient on Unix and safe on Windows
-                    // (backslashes get escaped — Claude Code's hook layer
-                    //  normalizes to POSIX on Windows anyway via toHookPath).
-                    const scriptPath = resolve(targetDir, "hooks", scriptMatch[1]);
-                    h.command = `node ${JSON.stringify(scriptPath)}`;
-                    changed = true;
-                  }
-                }
-              }
-            }
-          }
-        }
-
-        if (changed) writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-      } catch { /* skip settings update */ }
-
-      // Old version dirs are cleaned lazily by sessionstart.mjs (age-gated >1h)
-      // to avoid breaking active sessions that still reference them (#181).
-
-      writeFileSync(marker, Date.now().toString(), "utf-8");
-    }
-  } catch { /* best effort — don't block hook */ }
-
-  // ─── Init security from compiled build ───
-  const __hookDir = dirname(fileURLToPath(import.meta.url));
-  await initSecurity(resolve(__hookDir, "..", "build"));
-
-  // ─── Read stdin ───
-  const raw = await readStdin();
-  const input = parseStdin(raw);
-  const tool = input.tool_name ?? "";
-  const toolInput = input.tool_input ?? {};
-  const projectDir = getInputProjectDir(input);
-  const isSubagentContext = input.agent_id != null || input.agent_type != null;
-
-  // ─── Route and format response ───
-  const decision = routePreToolUse(tool, toolInput, projectDir, "claude-code", getSessionId(input), {
-    mcpToolsAvailable: !isSubagentContext,
-  });
-  const response = formatDecision("claude-code", decision);
-
-  // ─── Write latency marker for cross-hook timing (Category 27) ───
-  // Marker writes MUST happen before stdout write — stdout is the last action
-  // so the process can exit immediately after, avoiding CI test timeouts.
-  try {
-    const sessionId = getSessionId(input);
-    if (tool) {
-      const markerPath = resolve(tmpdir(), `context-mode-latency-${sessionId}-${tool}.txt`);
-      writeFileSync(markerPath, String(Date.now()), "utf-8");
-    }
-  } catch { /* latency tracking is best-effort — never block hook */ }
-
-  // ─── Write rejected-approach marker for PostToolUse to pick up ───
-  // PreToolUse cannot safely load SessionDB (native module loading breaks hook stdout).
-  // Write a marker file instead; PostToolUse reads it and writes the event.
-  if (decision && (decision.action === "deny" || decision.action === "modify")) {
-    try {
-      const sessionId = getSessionId(input);
-      const reason = decision.action === "deny"
-        ? (decision.reason || "denied")
-        : "Redirected to context-mode sandbox";
-      const markerPath = resolve(tmpdir(), `context-mode-rejected-${sessionId}.txt`);
-      writeFileSync(markerPath, `${tool}:${reason}`, "utf-8");
-    } catch { /* best-effort — never block hook */ }
-  }
-
-  // ─── D2 PRD Phase 3/4: redirect marker for byte-accounting events ───
-  // routing.mjs attaches `redirectMeta` to decisions for tools whose output we
-  // kept out of the model's context window (curl/wget, WebFetch, large Read).
-  // PostToolUse reads this marker to emit a `category=redirect` event with the
-  // estimated `bytes_avoided`. PreToolUse cannot load SessionDB safely (native
-  // module load breaks hook stdout), hence the marker indirection.
-  if (decision && decision.redirectMeta) {
-    try {
-      const sessionId = getSessionId(input);
-      const meta = decision.redirectMeta;
-      const summary = String(meta.commandSummary ?? "").slice(0, 200);
-      const markerPath = resolve(tmpdir(), `context-mode-redirect-${sessionId}.txt`);
-      // Format: tool:type:bytesAvoided:commandSummary (matches Override C).
-      // commandSummary may legitimately contain `:` (URLs) — don't quote it,
-      // PostToolUse parses only the first 3 colons and treats the rest as data.
-      writeFileSync(
-        markerPath,
-        `${meta.tool}:${meta.type}:${meta.bytesAvoided}:${summary}`,
-        "utf-8",
-      );
-    } catch { /* best-effort — never block hook */ }
-  }
-
-  // ─── stdout write is the LAST action — process exits immediately after ───
-  if (response !== null) {
-    process.stdout.write(JSON.stringify(response) + "\n");
-  }
-});

package/hooks/qwen-code/platform.mjs

@@ -1 +0,0 @@
-process.env.CONTEXT_MODE_PLATFORM = "qwen-code";

package/hooks/qwen-code/stop.mjs

@@ -1,168 +0,0 @@
-#!/usr/bin/env node
-import "./platform.mjs";
-import "../suppress-stderr.mjs";
-import "../ensure-deps.mjs";
-/**
- * Qwen Code Stop hook — record turn-end state + capture per-turn token cost.
- *
- * Stop fires at the end of an assistant turn, not at true session shutdown, so
- * we record a `turn_end` marker (session_end stays reserved for a genuine
- * terminal lifecycle event) and tail the session JSONL for new usage.
- *
- * COST CAPTURE: qwen-code's hook stdin carries tool I/O ONLY — token usage is
- * unreachable through the hook stream (matrix §4). The single live capture path
- * is a cursor-gated tail of the session record file at
- *   ~/.qwen/tmp/<project_id>/chats/<sessionId>.jsonl
- * where <project_id> = sha256(projectRoot) hex
- * (refs chatRecordingService.ts:451 + storage.ts:316-320 getProjectTempDir;
- * paths.ts:262 getProjectHash). The extractor lives in
- * src/adapters/qwen-code/usage.ts and is re-exported through the
- * session-extract bundle (src/session/extract.ts), reachable here via
- * loadExtract() — exactly the kimi wire.jsonl pattern.
- */
-
-import { readStdin, parseStdin, getSessionId, getSessionDBPath, getInputProjectDir } from "../session-helpers.mjs";
-import { createSessionLoaders, attributeAndInsertEvents } from "../session-loaders.mjs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { homedir, platform } from "node:os";
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-
-const HOOK_DIR = dirname(fileURLToPath(import.meta.url));
-const { loadSessionDB, loadExtract, loadProjectAttribution } = createSessionLoaders(HOOK_DIR);
-
-// Qwen Code session options. Mirrors the QwenCodeAdapter config (index.ts):
-// config dir ~/.qwen, project dir via QWEN_PROJECT_DIR (no config-dir env var,
-// no session-id env var — session_id arrives on the hook stdin). Kept local
-// because session-helpers.mjs ships no QWEN_OPTS export.
-const QWEN_OPTS = {
-  configDir: ".qwen",
-  configDirEnv: undefined,
-  projectDirEnv: "QWEN_PROJECT_DIR",
-  sessionIdEnv: undefined,
-};
-
-/**
- * Resolve the qwen config dir (~/.qwen). Qwen Code exposes no documented
- * config-dir override env var (unlike CODEX_HOME / KIMI_CODE_HOME), so this is
- * a fixed home-rooted path. NO regex.
- */
-function resolveQwenHome() {
-  return resolve(homedir(), ".qwen");
-}
-
-/**
- * EXACT port of qwen's getProjectHash (paths.ts:262): sha256 hex of the project
- * root, lowercased first on win32 for case-insensitive FS parity. The TS twin
- * is `qwenProjectHash` in src/adapters/qwen-code/usage.ts (unit-tested); the
- * hook cannot import that TS at runtime, so the logic is duplicated here — same
- * precedent as kimi's resolveKimiConfigDir. NO regex.
- */
-function qwenProjectHash(projectRoot) {
-  const normalized = platform() === "win32" ? String(projectRoot).toLowerCase() : String(projectRoot);
-  return createHash("sha256").update(normalized).digest("hex");
-}
-
-/**
- * Resolve <qwenHome>/tmp/<sha256(projectRoot)>/chats/<sessionId>.jsonl.
- *
- * Primary path is fully deterministic from the hashing scheme above. Should the
- * hash diverge (e.g. an upstream qwen normalization we did not pin), we fall
- * back to a glob of every <qwenHome>/tmp/<*>/chats dir for <sessionId>.jsonl —
- * a pure directory walk + filename equality test, NO regex. Best-effort:
- * returns null on any failure so cost capture never blocks the turn.
- */
-function resolveQwenChatJsonlPath(projectDir, sessionId) {
-  if (typeof sessionId !== "string" || sessionId.length === 0) return null;
-  const qwenHome = resolveQwenHome();
-  const fileName = `${sessionId}.jsonl`;
-
-  // 1) Canonical hashed path.
-  try {
-    if (typeof projectDir === "string" && projectDir.length > 0) {
-      const direct = join(qwenHome, "tmp", qwenProjectHash(projectDir), "chats", fileName);
-      if (existsSync(direct)) return direct;
-    }
-  } catch { /* fall through to glob */ }
-
-  // 2) Glob fallback — scan every tmp/<hash>/chats for this session file.
-  try {
-    const tmpRoot = join(qwenHome, "tmp");
-    if (!existsSync(tmpRoot)) return null;
-    let projectDirs;
-    try { projectDirs = readdirSync(tmpRoot, { withFileTypes: true }); } catch { return null; }
-    for (const entry of projectDirs) {
-      if (!entry.isDirectory()) continue;
-      const candidate = join(tmpRoot, entry.name, "chats", fileName);
-      try { if (existsSync(candidate)) return candidate; } catch { /* try next */ }
-    }
-  } catch { /* best-effort */ }
-
-  return null;
-}
-
-try {
-  const raw = await readStdin();
-  const input = parseStdin(raw);
-  const projectDir = getInputProjectDir(input, QWEN_OPTS);
-
-  const { SessionDB } = await loadSessionDB();
-  const dbPath = getSessionDBPath(QWEN_OPTS, projectDir);
-  const db = new SessionDB({ dbPath });
-  const sessionId = getSessionId(input, QWEN_OPTS);
-
-  db.ensureSession(sessionId, projectDir);
-  // SessionEvent contract requires {type, category, data, priority}. insertEvent
-  // hashes `data` for the dedup key, so encode the turn snapshot into `data`.
-  const payload = {
-    stop_hook_active: input.stop_hook_active ?? false,
-    last_assistant_message: typeof input.last_assistant_message === "string"
-      ? input.last_assistant_message.slice(0, 2000)
-      : null,
-  };
-  db.insertEvent(sessionId, {
-    type: "turn_end",
-    category: "session",
-    data: JSON.stringify(payload),
-    priority: 1,
-  }, "Stop");
-
-  // ─── qwen-code per-turn cost capture (cursor-gated, no double-count) ───
-  // Usage lives ONLY on the session chats JSONL ChatRecords, never in hook
-  // stdin. Tail the file, sum NEW usage records since a per-session high-water
-  // cursor, and forward. Best-effort — a missing file or read/extract failure
-  // must never block the turn_end write or the session, so the whole block is
-  // wrapped and swallowed.
-  try {
-    const jsonlPath = resolveQwenChatJsonlPath(projectDir, sessionId);
-    if (jsonlPath) {
-      let jsonlText = null;
-      try {
-        jsonlText = readFileSync(jsonlPath, "utf-8");
-      } catch {
-        // unreadable/missing chats JSONL — skip capture this turn.
-      }
-      if (jsonlText) {
-        const { extractQwenUsageSince } = await loadExtract();
-        const { resolveProjectAttributions } = await loadProjectAttribution();
-        const cursor = db.getUsageCursor(sessionId);
-        const { events, cursor: next } = extractQwenUsageSince(jsonlText, cursor);
-        if (events.length > 0) {
-          // attributeAndInsertEvents both INSERTS locally and FORWARDS to the
-          // platform (gated on ~/.context-mode/platform.json).
-          attributeAndInsertEvents(db, sessionId, events, input, projectDir, "Stop", resolveProjectAttributions);
-        }
-        if (next) db.setUsageCursor(sessionId, next);
-      }
-    }
-  } catch {
-    // Best-effort cost capture — never block the session on failure.
-  }
-
-  db.close();
-} catch {
-  // Qwen Code hooks must not block the session.
-}
-
-process.stdout.write("{}\n");