sidekick-shared 0.27.6 → 0.28.0

package/dist/sessionPromptSignals.js

@@ -12,6 +12,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SIGNAL_TEXT_CHARS = void 0;
 exports.createSessionRecordExtractor = createSessionRecordExtractor;
+const mcpToolName_1 = require("./parsers/mcpToolName");
+const toolCategory_1 = require("./toolCategory");
 /** Error text kept on a signal; tool output can be arbitrarily long. */
 exports.SIGNAL_TEXT_CHARS = 1024;
 const CLAUDE_REJECTED_PREFIX = "The user doesn't want to proceed with this tool use";
@@ -64,6 +66,13 @@ class RecordExtractor {
         const signal = { kind, timestamp, afterOrdinal: ordinal };
         if (detail.tool)
             signal.tool = detail.tool;
+        if (detail.tool || detail.mcp) {
+            const mcpServer = detail.mcpServer || (detail.tool ? (0, mcpToolName_1.parseMcpToolName)(detail.tool)?.serverName : undefined);
+            signal.toolCategory =
+                detail.mcp || !detail.tool ? 'mcp' : (0, toolCategory_1.classifyTool)(detail.tool, { mcpServer });
+            if (mcpServer)
+                signal.mcpServer = mcpServer;
+        }
         if (detail.fullText) {
             signal.text = detail.fullText;
         }
@@ -234,6 +243,8 @@ class CodexRecordExtractor extends RecordExtractor {
                 if (failure !== null) {
                     this.signal('toolError', timestamp, ordinal, {
                         tool: invocation ? stringValue(invocation.tool) : undefined,
+                        mcp: true,
+                        mcpServer: invocation ? stringValue(invocation.server) : undefined,
                         text: failure,
                     });
                 }
@@ -273,6 +284,8 @@ class CodexRecordExtractor extends RecordExtractor {
                 if (failed) {
                     this.signal('toolError', timestamp, ordinal, {
                         tool: stringValue(row.tool),
+                        mcp: true,
+                        mcpServer: stringValue(row.server),
                         text: row.error !== undefined && row.error !== null
                             ? errorText(row.error)
                             : (mcpFailure(row.result) ?? undefined),

package/dist/testing/credentialGuard.d.ts

@@ -0,0 +1,23 @@
+export interface CredentialGuard {
+    /** The developer's real home, from the passwd entry. */
+    readonly realHome: string;
+    /** The temp directory `HOME` now points at. */
+    readonly testHome: string;
+    /** Violations recorded since the last `take()`. */
+    readonly violations: string[];
+    /** Drain and return the recorded violations. */
+    take(): string[];
+    /** Throw when anything reached real credentials or homes since the last check. */
+    assertNoViolations(): void;
+}
+export interface CredentialGuardOptions {
+    /** Binaries no child process may run (default `security`, `claude`, `codex`). */
+    blockedBinaries?: string[];
+    /** Extra real paths to protect, besides the Claude, Codex, and Sidekick homes. */
+    protectedPaths?: string[];
+}
+/**
+ * Installs the guard once per process and returns it; later calls return the
+ * same guard and ignore their options.
+ */
+export declare function installCredentialGuard(options?: CredentialGuardOptions): CredentialGuard;

package/dist/testing/credentialGuard.js

@@ -0,0 +1,233 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installCredentialGuard = installCredentialGuard;
+/**
+ * Credential guard for test runners, published as `sidekick-shared/testing`.
+ *
+ * No test may reach the real macOS `security` binary, the real `claude` /
+ * `codex` CLIs, or the developer's real Claude, Codex, or Sidekick homes: a
+ * stray keychain write copies a live refresh token, and Claude Code rotates
+ * that token on every refresh, so a second copy is a login waiting to die.
+ *
+ * Three layers:
+ * - `HOME` (and the Windows equivalents) point at a per-process temp dir,
+ *   removed on exit, and the home overrides (`CLAUDE_CONFIG_DIR`,
+ *   `CLAUDE_SECURESTORAGE_CONFIG_DIR`, `CODEX_HOME`, `SIDEKICK_CONFIG_DIR`)
+ *   are unset, so every `os.homedir()`-derived path is isolated structurally;
+ * - the real `child_process` module object is patched, which reaches both ESM
+ *   named imports (after `syncBuiltinESMExports`) and CommonJS code loaded
+ *   through native `require`; per-file `vi.mock('child_process')` factories
+ *   replace the module and never get here;
+ * - the real `fs` module refuses writes under the real homes and records reads.
+ *
+ * Production code swallows most errors, so violations are also recorded;
+ * call `assertNoViolations()` after each test (see `credentialGuard.setup.ts`
+ * for a vitest wiring). Framework-free; the real modules come from
+ * `process.getBuiltinModule` (Node 20.16+), or `require` in CommonJS.
+ *
+ * @module testing/credentialGuard
+ */
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const GUARD_KEY = '__sidekickCredentialGuard';
+const DEFAULT_BLOCKED_BINARIES = ['security', 'claude', 'codex'];
+const CHILD_PROCESS_FUNCTIONS = [
+    'spawn',
+    'spawnSync',
+    'execFile',
+    'execFileSync',
+    'exec',
+    'execSync',
+];
+const FS_WRITE_FUNCTIONS = [
+    'writeFileSync',
+    'appendFileSync',
+    'mkdirSync',
+    'rmSync',
+    'rmdirSync',
+    'unlinkSync',
+    'renameSync',
+    'copyFileSync',
+    'cpSync',
+    'chmodSync',
+    'symlinkSync',
+];
+const FS_READ_FUNCTIONS = [
+    'readFileSync',
+    'existsSync',
+    'statSync',
+    'lstatSync',
+    'readdirSync',
+    'openSync',
+    'watch',
+];
+/**
+ * Installs the guard once per process and returns it; later calls return the
+ * same guard and ignore their options.
+ */
+function installCredentialGuard(options = {}) {
+    const existing = globalThis[GUARD_KEY];
+    if (existing)
+        return existing;
+    const childProcess = builtin('node:child_process');
+    const realFs = builtin('node:fs');
+    const fs = realFs;
+    const { syncBuiltinESMExports } = builtin('node:module');
+    const blockedBinaries = new Set((options.blockedBinaries ?? DEFAULT_BLOCKED_BINARIES).map((name) => name.toLowerCase()));
+    // os.userInfo() reads the passwd entry, so it still names the real home
+    // after HOME is redirected below.
+    const realHome = os.userInfo().homedir;
+    const testHome = realFs.mkdtempSync(path.join(os.tmpdir(), 'sidekick-test-home-'));
+    const removeTestHome = realFs.rmSync.bind(realFs);
+    process.once('exit', () => {
+        try {
+            removeTestHome(testHome, { recursive: true, force: true });
+        }
+        catch {
+            /* best effort */
+        }
+    });
+    const state = {
+        realHome,
+        testHome,
+        violations: [],
+        take() {
+            return state.violations.splice(0, state.violations.length);
+        },
+        assertNoViolations() {
+            const violations = state.take();
+            if (violations.length > 0) {
+                throw new Error(`Credential guard: this test reached real credentials or homes:\n- ${violations.join('\n- ')}`);
+            }
+        },
+    };
+    process.env.HOME = testHome;
+    process.env.USERPROFILE = testHome;
+    process.env.APPDATA = path.join(testHome, 'AppData', 'Roaming');
+    process.env.LOCALAPPDATA = path.join(testHome, 'AppData', 'Local');
+    delete process.env.CLAUDE_CONFIG_DIR;
+    delete process.env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
+    delete process.env.CODEX_HOME;
+    delete process.env.SIDEKICK_CONFIG_DIR;
+    const protectedRoots = path.resolve(realHome) === path.resolve(testHome)
+        ? []
+        : [
+            path.join(realHome, '.claude'),
+            path.join(realHome, '.claude.json'),
+            path.join(realHome, '.codex'),
+            path.join(realHome, '.config', 'sidekick'),
+            ...(options.protectedPaths ?? []),
+        ];
+    const isProtected = (target) => {
+        let candidate = null;
+        if (typeof target === 'string')
+            candidate = target;
+        else if (target instanceof URL && target.protocol === 'file:')
+            candidate = target.pathname;
+        if (!candidate)
+            return null;
+        const resolved = path.resolve(candidate);
+        return protectedRoots.some((root) => resolved === root || resolved.startsWith(root + path.sep))
+            ? resolved
+            : null;
+    };
+    const binaryName = (command) => {
+        if (typeof command !== 'string')
+            return '';
+        const first = command.trim().split(/\s+/)[0] ?? '';
+        return path
+            .basename(first.replace(/^["']|["']$/g, ''))
+            .replace(/\.(exe|cmd|bat)$/i, '')
+            .toLowerCase();
+    };
+    const record = (message) => {
+        state.violations.push(message);
+        throw new Error(`[credential guard] ${message}`);
+    };
+    for (const name of CHILD_PROCESS_FUNCTIONS) {
+        const original = childProcess[name];
+        if (typeof original !== 'function')
+            continue;
+        childProcess[name] = function guarded(...args) {
+            const binary = binaryName(args[0]);
+            if (blockedBinaries.has(binary)) {
+                record(`child_process.${name}('${binary}') reached the real binary; mock child_process or inject a runner`);
+            }
+            return original.apply(this, args);
+        };
+    }
+    for (const name of FS_WRITE_FUNCTIONS) {
+        const original = fs[name];
+        if (typeof original !== 'function')
+            continue;
+        fs[name] = function guarded(...args) {
+            for (const arg of args.slice(0, 2)) {
+                const hit = isProtected(arg);
+                if (hit)
+                    record(`fs.${name}(${hit}) would write inside the real home`);
+            }
+            return original.apply(this, args);
+        };
+    }
+    for (const name of FS_READ_FUNCTIONS) {
+        const original = fs[name];
+        if (typeof original !== 'function')
+            continue;
+        fs[name] = function guarded(...args) {
+            const hit = isProtected(args[0]);
+            // Reads are recorded rather than thrown so existsSync keeps its
+            // never-throws contract; the afterEach below still fails the test.
+            if (hit)
+                state.violations.push(`fs.${name}(${hit}) read the real home`);
+            return original.apply(this, args);
+        };
+    }
+    syncBuiltinESMExports();
+    globalThis[GUARD_KEY] = state;
+    return state;
+}
+/**
+ * The real module object of a Node built-in: `process.getBuiltinModule`
+ * (Node 20.16+), or `require` in CommonJS on older Node.
+ */
+function builtin(id) {
+    if (typeof process.getBuiltinModule === 'function')
+        return process.getBuiltinModule(id);
+    // eslint-disable-next-line @typescript-eslint/no-require-imports -- CommonJS fallback for Node < 20.16
+    if (typeof require === 'function')
+        return require(id);
+    throw new Error('installCredentialGuard() needs Node 20.16+ outside CommonJS.');
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Testing entry (`sidekick-shared/testing`): helpers for test suites that
+ * exercise sidekick-shared against Claude Code and Codex session data.
+ *
+ * - `installCredentialGuard()` keeps tests away from the real `security`,
+ *   `claude`, and `codex` binaries and the real Claude, Codex, and Sidekick
+ *   homes.
+ * - The session-log builders write Claude Code and Codex logs in the shapes
+ *   the readers parse.
+ */
+export { installCredentialGuard } from './credentialGuard';
+export type { CredentialGuard, CredentialGuardOptions } from './credentialGuard';
+export { appendJsonl, claudeFiller, codexFiller, createSessionLogFixtures, ts, writeJsonl, } from './sessionLogFixtures';
+export type { Row, SessionLogFixtureContext } from './sessionLogFixtures';

package/dist/testing/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeJsonl = exports.ts = exports.createSessionLogFixtures = exports.codexFiller = exports.claudeFiller = exports.appendJsonl = exports.installCredentialGuard = void 0;
+/**
+ * Testing entry (`sidekick-shared/testing`): helpers for test suites that
+ * exercise sidekick-shared against Claude Code and Codex session data.
+ *
+ * - `installCredentialGuard()` keeps tests away from the real `security`,
+ *   `claude`, and `codex` binaries and the real Claude, Codex, and Sidekick
+ *   homes.
+ * - The session-log builders write Claude Code and Codex logs in the shapes
+ *   the readers parse.
+ */
+var credentialGuard_1 = require("./credentialGuard");
+Object.defineProperty(exports, "installCredentialGuard", { enumerable: true, get: function () { return credentialGuard_1.installCredentialGuard; } });
+var sessionLogFixtures_1 = require("./sessionLogFixtures");
+Object.defineProperty(exports, "appendJsonl", { enumerable: true, get: function () { return sessionLogFixtures_1.appendJsonl; } });
+Object.defineProperty(exports, "claudeFiller", { enumerable: true, get: function () { return sessionLogFixtures_1.claudeFiller; } });
+Object.defineProperty(exports, "codexFiller", { enumerable: true, get: function () { return sessionLogFixtures_1.codexFiller; } });
+Object.defineProperty(exports, "createSessionLogFixtures", { enumerable: true, get: function () { return sessionLogFixtures_1.createSessionLogFixtures; } });
+Object.defineProperty(exports, "ts", { enumerable: true, get: function () { return sessionLogFixtures_1.ts; } });
+Object.defineProperty(exports, "writeJsonl", { enumerable: true, get: function () { return sessionLogFixtures_1.writeJsonl; } });

package/dist/testing/sessionLogFixtures.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Claude Code and Codex session-log builders shared by the prompt-history
+ * tests, published through `sidekick-shared/testing`.
+ */
+export type Row = Record<string, unknown>;
+export declare function ts(second: number): string;
+export declare function writeJsonl(file: string, rows: Row[]): void;
+export declare function appendJsonl(file: string, rows: Row[]): void;
+/** A Claude Code line with no message: read and ignored, like progress records. */
+export declare function claudeFiller(bytes: number, second: number): Row;
+/** A Codex line that is neither a prompt nor usage. */
+export declare function codexFiller(bytes: number, second: number): Row;
+export interface SessionLogFixtureContext {
+    /** The mocked home directory holding `.claude/` and `.codex/`. */
+    home: string;
+    /** Default working directory recorded on Claude lines. */
+    repo: string;
+}
+/** Builders that read the per-test home and repo lazily from `context`. */
+export declare function createSessionLogFixtures(context: () => SessionLogFixtureContext): {
+    claudeFile: (workspace: string, sessionId: string) => string;
+    claudeUser: (content: unknown, second: number, extra?: Row) => Row;
+    claudeAssistant: (id: string, second: number, extra?: Row, message?: Row) => Row;
+    codexFile: () => string;
+    codexMeta: (cwd: string | undefined, source?: unknown, extra?: Row) => Row;
+    codexUser: (texts: string[], second: number) => Row;
+    codexTokenCount: (second: number) => Row;
+};

package/dist/testing/sessionLogFixtures.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Claude Code and Codex session-log builders shared by the prompt-history
+ * tests, published through `sidekick-shared/testing`.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ts = ts;
+exports.writeJsonl = writeJsonl;
+exports.appendJsonl = appendJsonl;
+exports.claudeFiller = claudeFiller;
+exports.codexFiller = codexFiller;
+exports.createSessionLogFixtures = createSessionLogFixtures;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sessionPathResolver_1 = require("../parsers/sessionPathResolver");
+function ts(second) {
+    return new Date(Date.UTC(2026, 8, 1, 10, 0, second)).toISOString();
+}
+function writeJsonl(file, rows) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, rows.map((row) => JSON.stringify(row)).join('\n') + '\n');
+}
+function appendJsonl(file, rows) {
+    fs.appendFileSync(file, rows.map((row) => JSON.stringify(row)).join('\n') + '\n');
+}
+/** A Claude Code line with no message: read and ignored, like progress records. */
+function claudeFiller(bytes, second) {
+    return { type: 'system', subtype: 'filler', timestamp: ts(second), content: 'f'.repeat(bytes) };
+}
+/** A Codex line that is neither a prompt nor usage. */
+function codexFiller(bytes, second) {
+    return {
+        timestamp: ts(second),
+        type: 'event_msg',
+        payload: { type: 'agent_message', message: 'f'.repeat(bytes) },
+    };
+}
+/** Builders that read the per-test home and repo lazily from `context`. */
+function createSessionLogFixtures(context) {
+    let codexCounter = 0;
+    function claudeFile(workspace, sessionId) {
+        return path.join(context().home, '.claude', 'projects', (0, sessionPathResolver_1.encodeWorkspacePath)(workspace), `${sessionId}.jsonl`);
+    }
+    function claudeUser(content, second, extra = {}) {
+        return {
+            type: 'user',
+            entrypoint: 'cli',
+            cwd: context().repo,
+            gitBranch: 'main',
+            timestamp: ts(second),
+            message: { role: 'user', content },
+            ...extra,
+        };
+    }
+    /** One Claude Code assistant record; `message` fields are merged over the defaults. */
+    function claudeAssistant(id, second, extra = {}, message = {}) {
+        return {
+            type: 'assistant',
+            entrypoint: 'cli',
+            cwd: context().repo,
+            timestamp: ts(second),
+            message: {
+                id,
+                role: 'assistant',
+                model: 'claude-opus-5',
+                content: [{ type: 'text', text: 'ok' }],
+                stop_reason: 'end_turn',
+                usage: {
+                    input_tokens: 10,
+                    output_tokens: 20,
+                    cache_read_input_tokens: 30,
+                    cache_creation_input_tokens: 40,
+                },
+                ...message,
+            },
+            ...extra,
+        };
+    }
+    function codexFile() {
+        codexCounter++;
+        const id = `019d86b0-b20c-7b02-a3b2-${String(codexCounter).padStart(12, '0')}`;
+        return path.join(context().home, '.codex', 'sessions', '2026', '09', '01', `rollout-2026-09-01T10-00-${String(codexCounter).padStart(2, '0')}-${id}.jsonl`);
+    }
+    function codexMeta(cwd, source = 'cli', extra = {}) {
+        return {
+            timestamp: ts(0),
+            type: 'session_meta',
+            payload: {
+                id: 'meta',
+                timestamp: ts(0),
+                ...(cwd !== undefined ? { cwd } : {}),
+                originator: 'codex-tui',
+                source,
+                git: { branch: 'feature/x' },
+                ...extra,
+            },
+        };
+    }
+    function codexUser(texts, second) {
+        return {
+            timestamp: ts(second),
+            type: 'response_item',
+            payload: {
+                type: 'message',
+                role: 'user',
+                content: texts.map((text) => ({ type: 'input_text', text })),
+            },
+        };
+    }
+    function codexTokenCount(second) {
+        return {
+            timestamp: ts(second),
+            type: 'event_msg',
+            payload: {
+                type: 'token_count',
+                info: {
+                    last_token_usage: {
+                        input_tokens: 100,
+                        cached_input_tokens: 60,
+                        output_tokens: 7,
+                        cache_write_input_tokens: 5,
+                    },
+                },
+            },
+        };
+    }
+    return {
+        claudeFile,
+        claudeUser,
+        claudeAssistant,
+        codexFile,
+        codexMeta,
+        codexUser,
+        codexTokenCount,
+    };
+}

package/dist/tokenEstimation.d.ts

@@ -13,6 +13,8 @@ export interface TokenEstimate {
     confidence: TokenEstimationConfidence;
     provenance: string;
 }
+/** Latin/source-code characters per token in the fallback estimate. */
+export declare const ASCII_CHARS_PER_TOKEN = 3.5;
 /**
  * Estimate tokens without bundling a tokenizer.
  *

package/dist/tokenEstimation.js

@@ -1,7 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASCII_CHARS_PER_TOKEN = void 0;
 exports.estimateTextTokens = estimateTextTokens;
 exports.estimateSerializedTokens = estimateSerializedTokens;
+/** Latin/source-code characters per token in the fallback estimate. */
+exports.ASCII_CHARS_PER_TOKEN = 3.5;
 const CJK = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
 const EMOJI = /\p{Extended_Pictographic}/u;
 /**
@@ -30,19 +33,26 @@ function estimateTextTokens(text, options = {}) {
             provenance: options.model ?? 'injected-counter',
         };
     }
-    let asciiChars = 0;
+    // ASCII is never CJK or pictographic, so the leading ASCII run is counted
+    // without the per-code-point regex tests; most source text is all ASCII.
+    let firstNonAscii = 0;
+    while (firstNonAscii < text.length && text.charCodeAt(firstNonAscii) <= 127)
+        firstNonAscii++;
+    let asciiChars = firstNonAscii;
     let conservativeTokens = 0;
-    for (const codePoint of text) {
-        if (EMOJI.test(codePoint))
-            conservativeTokens += 2;
-        else if (CJK.test(codePoint))
-            conservativeTokens += 1;
-        else if ((codePoint.codePointAt(0) ?? 128) <= 127)
-            asciiChars += codePoint.length;
-        else
-            conservativeTokens += 1;
+    if (firstNonAscii < text.length) {
+        for (const codePoint of text.slice(firstNonAscii)) {
+            if (EMOJI.test(codePoint))
+                conservativeTokens += 2;
+            else if (CJK.test(codePoint))
+                conservativeTokens += 1;
+            else if ((codePoint.codePointAt(0) ?? 128) <= 127)
+                asciiChars += codePoint.length;
+            else
+                conservativeTokens += 1;
+        }
     }
-    const count = Math.ceil(asciiChars / 3.5) + conservativeTokens;
+    const count = Math.ceil(asciiChars / exports.ASCII_CHARS_PER_TOKEN) + conservativeTokens;
     return {
         count: Number.isFinite(count) && count >= 0 ? count : 0,
         method: 'sidekick-fallback-v1',

package/dist/toolCategory.d.ts

@@ -0,0 +1,18 @@
+/**
+ * One vocabulary for what a tool call does, across Claude Code, Codex, and
+ * OpenCode tool names. Browser-safe: no Node imports.
+ *
+ * @module toolCategory
+ */
+export declare const TOOL_CATEGORIES: readonly ["shell", "file_read", "file_edit", "search", "web", "subagent", "planning", "mcp", "other"];
+export type ToolCategory = (typeof TOOL_CATEGORIES)[number];
+export interface ClassifyToolOptions {
+    /** The MCP server the call went to, when the log records it separately (Codex). */
+    mcpServer?: string;
+}
+/**
+ * Classifies a tool name from any supported provider. `mcp__<server>__<tool>`
+ * names and calls with a known `mcpServer` are `mcp`; unknown names are
+ * `other`.
+ */
+export declare function classifyTool(name: string, options?: ClassifyToolOptions): ToolCategory;