@mxalbert/context-mode 2.0.0

package/build/adapters/qwen-code/hooks.d.ts

@@ -0,0 +1,26 @@
+/**
+ * adapters/qwen-code/hooks — Qwen Code hook definitions.
+ *
+ * Qwen Code is a Gemini CLI fork (packages/core/src/tools/tool-names.ts —
+ * shares native names like `run_shell_command`, `read_file`). The hook wire
+ * protocol is JSON stdin / stdout, identical to Claude Code and Gemini CLI.
+ *
+ * Config: ~/.qwen/settings.json under "hooks" key.
+ */
+/**
+ * Negative-lookahead matcher for external MCP tool namespaces on Qwen Code (#529).
+ *
+ * Qwen Code MCP wire shape: `mcp__<server>__<tool>` (shared with Gemini CLI
+ * upstream). Own context-mode MCP surfaces as both
+ * `mcp__plugin_context-mode_context-mode__ctx_*` (Claude shim path when users
+ * install via the Claude marketplace) and `mcp__context-mode__ctx_*` (Qwen
+ * canonical — see hooks/core/tool-naming.mjs). The negative lookahead
+ * `(?!.*context-mode)` excludes both variants from the external-MCP routing
+ * branch so context-mode's own tools (already wired by the explicit entries
+ * above this catch-all) are not double-routed.
+ *
+ * Without this matcher, large payloads from slack / telegram / gdrive / notion
+ * MCPs bypass the routing nudge and flood the model's context window —
+ * PostToolUse runs too late to keep the raw data out.
+ */
+export declare const EXTERNAL_MCP_MATCHER_PATTERN = "mcp__(?!.*context-mode)";

package/build/adapters/qwen-code/hooks.js

@@ -0,0 +1,29 @@
+/**
+ * adapters/qwen-code/hooks — Qwen Code hook definitions.
+ *
+ * Qwen Code is a Gemini CLI fork (packages/core/src/tools/tool-names.ts —
+ * shares native names like `run_shell_command`, `read_file`). The hook wire
+ * protocol is JSON stdin / stdout, identical to Claude Code and Gemini CLI.
+ *
+ * Config: ~/.qwen/settings.json under "hooks" key.
+ */
+// ─────────────────────────────────────────────────────────
+// External MCP routing matcher (#529)
+// ─────────────────────────────────────────────────────────
+/**
+ * Negative-lookahead matcher for external MCP tool namespaces on Qwen Code (#529).
+ *
+ * Qwen Code MCP wire shape: `mcp__<server>__<tool>` (shared with Gemini CLI
+ * upstream). Own context-mode MCP surfaces as both
+ * `mcp__plugin_context-mode_context-mode__ctx_*` (Claude shim path when users
+ * install via the Claude marketplace) and `mcp__context-mode__ctx_*` (Qwen
+ * canonical — see hooks/core/tool-naming.mjs). The negative lookahead
+ * `(?!.*context-mode)` excludes both variants from the external-MCP routing
+ * branch so context-mode's own tools (already wired by the explicit entries
+ * above this catch-all) are not double-routed.
+ *
+ * Without this matcher, large payloads from slack / telegram / gdrive / notion
+ * MCPs bypass the routing nudge and flood the model's context window —
+ * PostToolUse runs too late to keep the raw data out.
+ */
+export const EXTERNAL_MCP_MATCHER_PATTERN = "mcp__(?!.*context-mode)";

package/build/adapters/qwen-code/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * adapters/qwen-code — Qwen Code platform adapter.
+ *
+ * Extends ClaudeCodeBaseAdapter (shared wire-protocol parse/format methods)
+ * with Qwen Code-specific configuration, diagnostics, and session ID logic.
+ *
+ * Differences from Claude Code:
+ *   - Config dir: ~/.qwen/ (not ~/.claude/)
+ *   - Env vars: QWEN_PROJECT_DIR, QWEN_SESSION_ID (not CLAUDE_*)
+ *   - Session ID priority: session_id field first (Claude: transcript_path first)
+ *   - No plugin registry (Qwen uses settings.json directly)
+ *   - MCP clientInfo: qwen-cli-mcp-client-* (pattern)
+ *   - 12 hook events (superset of Claude's 5, but context-mode uses the shared 5)
+ */
+import { ClaudeCodeBaseAdapter, type ClaudeCodeWireInput } from "../claude-code-base.js";
+import { type HookAdapter, type HookParadigm, type PlatformCapabilities, type DiagnosticResult, type HookRegistration } from "../types.js";
+export declare class QwenCodeAdapter extends ClaudeCodeBaseAdapter implements HookAdapter {
+    constructor();
+    readonly name = "Qwen Code";
+    readonly paradigm: HookParadigm;
+    protected readonly projectDirEnvVar = "QWEN_PROJECT_DIR";
+    readonly capabilities: PlatformCapabilities;
+    getSettingsPath(): string;
+    getInstructionFiles(): string[];
+    generateHookConfig(pluginRoot: string): HookRegistration;
+    readSettings(): Record<string, unknown> | null;
+    writeSettings(settings: Record<string, unknown>): void;
+    validateHooks(_pluginRoot: string): DiagnosticResult[];
+    checkPluginRegistration(): DiagnosticResult;
+    getInstalledVersion(): string;
+    configureAllHooks(pluginRoot: string): string[];
+    setHookPermissions(_pluginRoot: string): string[];
+    updatePluginRegistry(_pluginRoot: string, _version: string): void;
+    getRoutingInstructionsConfig(): {
+        instructionsPath: string;
+        targetPath: string;
+        platformName: string;
+    };
+    protected extractSessionId(input: ClaudeCodeWireInput): string;
+}

package/build/adapters/qwen-code/index.js

@@ -0,0 +1,361 @@
+/**
+ * adapters/qwen-code — Qwen Code platform adapter.
+ *
+ * Extends ClaudeCodeBaseAdapter (shared wire-protocol parse/format methods)
+ * with Qwen Code-specific configuration, diagnostics, and session ID logic.
+ *
+ * Differences from Claude Code:
+ *   - Config dir: ~/.qwen/ (not ~/.claude/)
+ *   - Env vars: QWEN_PROJECT_DIR, QWEN_SESSION_ID (not CLAUDE_*)
+ *   - Session ID priority: session_id field first (Claude: transcript_path first)
+ *   - No plugin registry (Qwen uses settings.json directly)
+ *   - MCP clientInfo: qwen-cli-mcp-client-* (pattern)
+ *   - 12 hook events (superset of Claude's 5, but context-mode uses the shared 5)
+ */
+import { readFileSync, writeFileSync, existsSync, } from "node:fs";
+import { resolve, join } from "node:path";
+import { homedir } from "node:os";
+import { ClaudeCodeBaseAdapter } from "../claude-code-base.js";
+import { EXTERNAL_MCP_MATCHER_PATTERN } from "./hooks.js";
+import { buildHookRuntimeCommand, } from "../types.js";
+// ─────────────────────────────────────────────────────────
+// Adapter implementation
+// ─────────────────────────────────────────────────────────
+export class QwenCodeAdapter extends ClaudeCodeBaseAdapter {
+    constructor() {
+        super([".qwen"]);
+    }
+    name = "Qwen Code";
+    paradigm = "json-stdio";
+    projectDirEnvVar = "QWEN_PROJECT_DIR";
+    capabilities = {
+        preToolUse: true,
+        postToolUse: true,
+        preCompact: true,
+        sessionStart: true,
+        canModifyArgs: true,
+        canModifyOutput: true,
+        canInjectSessionContext: true,
+    };
+    // ── Configuration (differs from Claude Code) ───────────
+    getSettingsPath() {
+        return resolve(homedir(), ".qwen", "settings.json");
+    }
+    getInstructionFiles() {
+        return ["QWEN.md"];
+    }
+    generateHookConfig(pluginRoot) {
+        // Qwen Code passes native tool names in hook stdin (verified from
+        // packages/core/src/tools/tool-names.ts). Claude-style names (Bash, Read)
+        // are only accepted in permission configs, NOT in hook tool_name payloads.
+        const preToolUseMatcher = [
+            // Qwen-native names (canonical tool_name in hook stdin)
+            "run_shell_command", "read_file", "read_many_files", "grep_search",
+            "web_fetch", "agent",
+            // MCP tools (same naming convention as Claude Code)
+            "mcp__plugin_context-mode_context-mode__ctx_execute",
+            "mcp__plugin_context-mode_context-mode__ctx_execute_file",
+            "mcp__plugin_context-mode_context-mode__ctx_batch_execute",
+            // External MCP catch-all (#529). Negative-lookahead excludes context-mode's
+            // own server segments so the explicit entries above are not double-routed.
+            EXTERNAL_MCP_MATCHER_PATTERN,
+        ].join("|");
+        return {
+            PreToolUse: [
+                {
+                    matcher: preToolUseMatcher,
+                    hooks: [
+                        { type: "command", command: buildHookRuntimeCommand(`${pluginRoot}/hooks/pretooluse.mjs`) },
+                    ],
+                },
+            ],
+            PostToolUse: [
+                {
+                    matcher: "run_shell_command|read_file|write_file|edit|glob|grep_search|todo_write|agent|ask_user_question|mcp__",
+                    hooks: [
+                        { type: "command", command: buildHookRuntimeCommand(`${pluginRoot}/hooks/posttooluse.mjs`) },
+                    ],
+                },
+            ],
+            SessionStart: [
+                {
+                    matcher: "",
+                    hooks: [
+                        { type: "command", command: buildHookRuntimeCommand(`${pluginRoot}/hooks/sessionstart.mjs`) },
+                    ],
+                },
+            ],
+            PreCompact: [
+                {
+                    matcher: "",
+                    hooks: [
+                        { type: "command", command: buildHookRuntimeCommand(`${pluginRoot}/hooks/precompact.mjs`) },
+                    ],
+                },
+            ],
+            UserPromptSubmit: [
+                {
+                    matcher: "",
+                    hooks: [
+                        { type: "command", command: buildHookRuntimeCommand(`${pluginRoot}/hooks/userpromptsubmit.mjs`) },
+                    ],
+                },
+            ],
+            // Stop fires at end-of-turn. The qwen-specific stop hook records a
+            // turn_end marker AND captures per-turn token cost by tailing the session
+            // chats JSONL (~/.qwen/tmp/<hash>/chats/<sessionId>.jsonl) — usage is not
+            // reachable through hook stdin (usage.ts matrix §4). Points at the
+            // qwen-code/ hook dir (not the shared root) so it sets the qwen platform.
+            Stop: [
+                {
+                    matcher: "",
+                    hooks: [
+                        { type: "command", command: buildHookRuntimeCommand(`${pluginRoot}/hooks/qwen-code/stop.mjs`) },
+                    ],
+                },
+            ],
+        };
+    }
+    // ── Settings read/write ────────────────────────────────
+    readSettings() {
+        try {
+            const raw = readFileSync(this.getSettingsPath(), "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    writeSettings(settings) {
+        // Issue #511: use top-level static import (line 18) — never inline
+        // `require("node:fs")` in ESM-bundled sources. esbuild rewrites them to
+        // a `__require` shim that throws `Dynamic require of "node:fs" is not
+        // supported` under Node ESM/Bun (this adapter is pulled into both
+        // server.bundle.mjs and cli.bundle.mjs via adapter detect).
+        writeFileSync(this.getSettingsPath(), JSON.stringify(settings, null, 2));
+    }
+    // ── Diagnostics (doctor) ───────────────────────────────
+    validateHooks(_pluginRoot) {
+        const results = [];
+        const settings = this.readSettings();
+        const hooks = (settings?.hooks ?? {});
+        for (const hookName of ["PreToolUse", "PostToolUse", "SessionStart", "PreCompact", "UserPromptSubmit", "Stop"]) {
+            const configured = Array.isArray(hooks[hookName]) && hooks[hookName].length > 0;
+            results.push({
+                check: `${hookName} hook`,
+                status: configured ? "pass" : "fail",
+                message: configured
+                    ? `${hookName} hook configured in ~/.qwen/settings.json`
+                    : `${hookName} hook not found in ~/.qwen/settings.json`,
+                ...(configured ? {} : { fix: `Add ${hookName} hook to ~/.qwen/settings.json` }),
+            });
+        }
+        return results;
+    }
+    checkPluginRegistration() {
+        // Qwen Code has no plugin registry — check for MCP config instead
+        try {
+            const settings = this.readSettings();
+            if (settings?.mcpServers && typeof settings.mcpServers === "object") {
+                const servers = settings.mcpServers;
+                if (Object.keys(servers).some(k => k.includes("context-mode"))) {
+                    return {
+                        check: "Plugin registration",
+                        status: "pass",
+                        message: "context-mode found in mcpServers",
+                    };
+                }
+                return {
+                    check: "Plugin registration",
+                    status: "fail",
+                    message: "mcpServers exists but context-mode not found",
+                    fix: "Add context-mode to mcpServers in ~/.qwen/settings.json",
+                };
+            }
+            return {
+                check: "Plugin registration",
+                status: "warn",
+                message: "No mcpServers in ~/.qwen/settings.json",
+            };
+        }
+        catch {
+            return {
+                check: "Plugin registration",
+                status: "warn",
+                message: "Could not read ~/.qwen/settings.json",
+            };
+        }
+    }
+    getInstalledVersion() {
+        const settings = this.readSettings();
+        if (!settings)
+            return "not installed";
+        const hooks = settings.hooks;
+        if (!hooks)
+            return "not installed";
+        // Check if any hook type has context-mode scripts configured
+        const contextModeScripts = [
+            "pretooluse.mjs",
+            "posttooluse.mjs",
+            "precompact.mjs",
+            "sessionstart.mjs",
+            "userpromptsubmit.mjs",
+        ];
+        for (const [, entries] of Object.entries(hooks)) {
+            if (!Array.isArray(entries))
+                continue;
+            for (const entry of entries) {
+                const e = entry;
+                if (e.hooks?.some((h) => h.command && contextModeScripts.some((s) => h.command.includes(s)))) {
+                    return "installed (hooks configured)";
+                }
+            }
+        }
+        return "not installed";
+    }
+    configureAllHooks(pluginRoot) {
+        const settings = this.readSettings() ?? {};
+        const hooks = (settings.hooks ?? {});
+        const changes = [];
+        // ── Phase 1: Clean stale context-mode hooks ──────────
+        // After an upgrade, settings.json may contain hardcoded paths
+        // pointing to deleted version directories. Remove those.
+        for (const hookType of Object.keys(hooks)) {
+            const entries = hooks[hookType];
+            if (!Array.isArray(entries))
+                continue;
+            const filtered = entries.filter((entry) => {
+                const e = entry;
+                const commands = e.hooks ?? [];
+                // Preserve entries that are not context-mode hooks
+                const isContextMode = commands.some((h) => h.command && /context-mode|pretooluse|posttooluse|precompact|sessionstart|userpromptsubmit/i.test(h.command));
+                if (!isContextMode)
+                    return true;
+                // For context-mode hooks, check if referenced script files exist
+                return commands.every((h) => {
+                    if (!h.command)
+                        return true;
+                    // Extract path from both new ("nodePath" "scriptPath.mjs") and legacy (node .../script.mjs) formats
+                    const newFmt = h.command.match(/"[^"]+"\s+"([^"]+\.mjs)"/);
+                    const legacyFmt = h.command.match(/node\s+"?([^"]+\.mjs)"?/);
+                    const scriptMatch = newFmt || legacyFmt;
+                    if (!scriptMatch)
+                        return true; // CLI dispatcher format, always valid
+                    return existsSync(scriptMatch[1]);
+                });
+            });
+            const removed = entries.length - filtered.length;
+            if (removed > 0) {
+                hooks[hookType] = filtered;
+                changes.push(`Removed ${removed} stale ${hookType} hook(s)`);
+            }
+        }
+        // ── Phase 2: Register fresh hooks ────────────────────
+        // All 5 hooks must be wired (z6 — capabilities declare 5 events but
+        // configureAllHooks previously only wrote 2). Qwen Code's hook stdin shape
+        // is wire-identical to Claude Code, so we reuse top-level hook scripts.
+        const hookTypes = [
+            {
+                name: "PreToolUse",
+                script: "pretooluse.mjs",
+                matcher: [
+                    "run_shell_command", "read_file", "read_many_files", "grep_search",
+                    "web_fetch", "agent",
+                    "mcp__plugin_context-mode_context-mode__ctx_execute",
+                    "mcp__plugin_context-mode_context-mode__ctx_execute_file",
+                    "mcp__plugin_context-mode_context-mode__ctx_batch_execute",
+                    // External MCP catch-all (#529) — keep in sync with generateHookConfig above.
+                    EXTERNAL_MCP_MATCHER_PATTERN,
+                ].join("|"),
+            },
+            {
+                name: "PostToolUse",
+                script: "posttooluse.mjs",
+                matcher: "run_shell_command|read_file|write_file|edit|glob|grep_search|todo_write|agent|ask_user_question|mcp__",
+            },
+            {
+                name: "SessionStart",
+                script: "sessionstart.mjs",
+                matcher: "",
+            },
+            {
+                name: "PreCompact",
+                script: "precompact.mjs",
+                matcher: "",
+            },
+            {
+                name: "UserPromptSubmit",
+                script: "userpromptsubmit.mjs",
+                matcher: "",
+            },
+            {
+                // Stop captures per-turn token cost by tailing the session chats JSONL
+                // (usage is unreachable through hook stdin). Routes to the qwen-code/
+                // hook dir so it sets the qwen platform — keep in sync with
+                // generateHookConfig above.
+                name: "Stop",
+                script: "qwen-code/stop.mjs",
+                matcher: "",
+            },
+        ];
+        for (const { name, script, matcher } of hookTypes) {
+            const entry = {
+                matcher,
+                hooks: [{ type: "command", command: buildHookRuntimeCommand(`${pluginRoot}/hooks/${script}`) }],
+            };
+            const existing = hooks[name];
+            if (existing && Array.isArray(existing)) {
+                // Replace existing context-mode entry or append
+                const idx = existing.findIndex((e) => {
+                    const typed = e;
+                    return typed.hooks?.some((h) => h.command?.includes(script)) ?? false;
+                });
+                if (idx >= 0) {
+                    existing[idx] = entry;
+                    changes.push(`Updated ${name} hook`);
+                }
+                else {
+                    existing.push(entry);
+                    changes.push(`Added ${name} hook`);
+                }
+                hooks[name] = existing;
+            }
+            else {
+                hooks[name] = [entry];
+                changes.push(`Created ${name} hooks`);
+            }
+        }
+        settings.hooks = hooks;
+        this.writeSettings(settings);
+        return changes;
+    }
+    setHookPermissions(_pluginRoot) {
+        return [];
+    }
+    updatePluginRegistry(_pluginRoot, _version) {
+        // No plugin registry in Qwen Code
+    }
+    getRoutingInstructionsConfig() {
+        const instructionsPath = resolve(join(homedir(), ".qwen", "QWEN.md"));
+        return {
+            instructionsPath,
+            targetPath: "QWEN.md",
+            platformName: "Qwen Code",
+        };
+    }
+    // ── Session ID extraction (differs from Claude Code) ───
+    // Qwen Code prioritizes session_id field, then QWEN_SESSION_ID env var.
+    // Claude Code prioritizes transcript_path UUID first.
+    extractSessionId(input) {
+        if (input.session_id)
+            return input.session_id;
+        if (input.transcript_path) {
+            const match = input.transcript_path.match(/([a-f0-9-]{36})\.jsonl$/);
+            if (match)
+                return match[1];
+        }
+        if (process.env.QWEN_SESSION_ID)
+            return process.env.QWEN_SESSION_ID;
+        return `pid-${process.ppid}`;
+    }
+}

package/build/adapters/qwen-code/usage.d.ts

@@ -0,0 +1,90 @@
+/**
+ * adapters/qwen-code/usage — per-turn token capture from the session JSONL.
+ *
+ * Qwen Code is a Gemini-CLI fork and normalizes EVERY backend (Gemini-native,
+ * OpenAI-compat/DashScope, Anthropic) to the same canonical token shape:
+ * `GenerateContentResponseUsageMetadata` { promptTokenCount, candidatesTokenCount,
+ * cachedContentTokenCount, thoughtsTokenCount, totalTokenCount }
+ * (matrix §1: turn.ts:96,417 + converter.ts:1145-1148). That metadata is
+ * persisted, per API call, into the session record file as a `ChatRecord`
+ * carrying `.usageMetadata` + `.model`
+ * (refs: packages/core/src/services/chatRecordingService.ts:259,261,919 file at
+ * ~/.qwen/tmp/<project_id>/chats/<sessionId>.jsonl — :451 location comment,
+ * :600,628-629 path build).
+ *
+ * CRITICAL (matrix §4): qwen-code's hook payloads carry tool I/O ONLY — token
+ * usage is unreachable through the hook stream (grep of hookEventHandler.ts /
+ * hookSystem.ts / toolHookTriggers.ts for token|usageMetadata|usage → zero
+ * matches). The ONLY live capture path is a tail of the session JSONL. This
+ * module is therefore the JSONL-tail counterpart to claude-code's
+ * `extractTranscriptUsageSince` (src/session/extract.ts) — same cursor-gated,
+ * char-algorithmic, NO-regex parse, same `buildAgentUsageEvent` emission path.
+ *
+ * Per matrix §3 each ChatRecord.usageMetadata is INCREMENTAL per API call
+ * (cumulative session totals are derived downstream via += in
+ * uiTelemetry.ts:237-241), so summing the NEW records since the cursor yields
+ * the exact billed delta with no double-count.
+ *
+ * No native USD — cost_usd is derived from the pricing catalog inside
+ * buildAgentUsageEvent (native_cost_usd omitted). Pure, null-safe, NO regex.
+ */
+import { type AgentUsageCounts, type SessionEvent } from "../../session/extract.js";
+/**
+ * Parse ONE qwen `ChatRecord` into the `buildAgentUsageEvent` input shape, or
+ * null when the record carries no usage / sums to zero.
+ *
+ * Mapping → builder shape (AgentUsageCounts):
+ *   promptTokenCount        → input_tokens
+ *   candidatesTokenCount    → output_tokens
+ *   thoughtsTokenCount      → ADDED into output_tokens (Gemini-lineage bills
+ *                             reasoning/thoughts as output — same fold as
+ *                             parseGeminiUsage in src/session/extract.ts)
+ *   cachedContentTokenCount → cache_read_tokens (when present)
+ *   model_id                → ChatRecord.model
+ *
+ * No native cost — native_cost_usd omitted (catalog-derived). NO regex.
+ */
+export declare function parseQwenUsage(record: unknown): AgentUsageCounts | null;
+/**
+ * Cursor-aware tail of the qwen session JSONL. Emits one priced `agent_usage`
+ * event PER distinct model across the records NEW since `cursor`, so re-reading
+ * the (append-only, ever-growing) JSONL each Stop never double-counts.
+ *
+ *   - cursor null/empty            → process ALL records.
+ *   - cursor found                 → process records STRICTLY AFTER it.
+ *   - cursor set but NOT found     → compaction/rotation dropped it: bounded
+ *     fallback processes ONLY THE LAST record (never re-emit full history).
+ *
+ * `cursor` returns the id of the LAST id-bearing record seen (whether or not it
+ * carried usage), so the next call resumes exactly past it. When no record
+ * carries an id, the input cursor is returned unchanged.
+ *
+ * One linear walk, JSON.parse per line, NO regex — mirrors
+ * extractTranscriptUsageSince's structure exactly.
+ */
+export declare function extractQwenUsageSince(jsonlText: string, cursor: string | null): {
+    events: SessionEvent[];
+    cursor: string | null;
+};
+/**
+ * Hash a project root into qwen-code's `<project_id>` directory segment.
+ *
+ * EXACT port of qwen's `getProjectHash`
+ * (refs/platforms/qwen-code/packages/core/src/utils/paths.ts:262 —
+ * `crypto.createHash('sha256').update(normalizedPath).digest('hex')`). On
+ * Windows qwen lowercases the path first (case-insensitive FS); we mirror that
+ * so a hook running on win32 resolves the same tmp dir qwen itself wrote.
+ * Pure, deterministic, NO regex.
+ */
+export declare function qwenProjectHash(projectRoot: string): string;
+/**
+ * Build the canonical session JSONL path qwen-code writes its ChatRecords to:
+ *   <qwenHome>/tmp/<sha256(projectRoot)>/chats/<sessionId>.jsonl
+ * (refs chatRecordingService.ts:451 location + storage.ts:316-320
+ * getProjectTempDir → getGlobalTempDir(<qwenHome>/tmp) + getProjectHash).
+ *
+ * `qwenHome` is normally `<homedir>/.qwen`. Pure path join — does NOT touch the
+ * FS, so it is fully unit-testable; existence probing + the glob fallback live
+ * in the Stop hook (which cannot import this TS at runtime). NO regex.
+ */
+export declare function qwenChatJsonlPath(qwenHome: string, projectRoot: string, sessionId: string): string;