@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/src/shared/run-token-log.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from "bun:test";
+import { runTokenLog } from "./run-token-log";
+
+describe("run token log host usage", () => {
+    test("OpenCode assistant message tokens retain reasoning and cache", () => {
+        const message = {
+            info: {
+                finish: "length",
+                tokens: { input: 10, output: 50, reasoning: 48, cache: { read: 7, write: 0 } },
+            },
+        };
+        expect(runTokenLog(message.info.tokens, 64, message.info.finish)).toEqual({
+            input: 10,
+            output: 50,
+            reasoning: 48,
+            cache_read: 7,
+            cache_write: 0,
+            max_tokens: 64,
+            finish_reason: "length",
+        });
+    });
+
+    test("OpenCode hidden-completion usage preserves omitted reasoning as null", () => {
+        const row = {
+            data: {
+                finish: "stop",
+                tokens: { input: 20, output: 4, cache: { read: 0, write: 3 } },
+            },
+        };
+        expect(runTokenLog(row.data.tokens, undefined, row.data.finish)).toEqual({
+            input: 20,
+            output: 4,
+            reasoning: null,
+            cache_read: 0,
+            cache_write: 3,
+            max_tokens: null,
+            finish_reason: "stop",
+        });
+    });
+
+    test("Pi stdout usage and absent usage remain distinguishable", () => {
+        const message = {
+            stopReason: "length",
+            usage: { input: 3, output: 12, cacheRead: 2, cacheWrite: 0 },
+        };
+        expect(runTokenLog(message.usage, 12, message.stopReason)).toEqual({
+            input: 3,
+            output: 12,
+            reasoning: null,
+            cache_read: 2,
+            cache_write: 0,
+            max_tokens: 12,
+            finish_reason: "length",
+        });
+        expect(runTokenLog(undefined)).toEqual({
+            input: null,
+            output: null,
+            reasoning: null,
+            cache_read: null,
+            cache_write: null,
+            max_tokens: null,
+            finish_reason: null,
+        });
+    });
+});

package/src/shared/run-token-log.ts

@@ -0,0 +1,39 @@
+export interface RunTokenLog {
+    input: number | null;
+    output: number | null;
+    reasoning: number | null;
+    cache_read: number | null;
+    cache_write: number | null;
+    max_tokens: number | null;
+    finish_reason: string | null;
+}
+
+function count(value: unknown): number | null {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+/** Keep provider omissions distinct from measured zero in diagnostic logs. */
+export function runTokenLog(tokens: unknown, maxTokens?: number, finish?: unknown): RunTokenLog {
+    const usage = tokens && typeof tokens === "object" ? (tokens as Record<string, unknown>) : {};
+    const cache =
+        usage.cache && typeof usage.cache === "object"
+            ? (usage.cache as Record<string, unknown>)
+            : {};
+    return {
+        input: count(usage.input ?? usage.input_tokens),
+        output: count(usage.output ?? usage.output_tokens),
+        reasoning: count(usage.reasoning ?? usage.reasoning_tokens),
+        cache_read: count(
+            usage.cacheRead ?? usage.cache_read ?? usage.cached_input_tokens ?? cache.read,
+        ),
+        cache_write: count(
+            usage.cacheWrite ?? usage.cache_write ?? usage.cache_write_tokens ?? cache.write,
+        ),
+        max_tokens: count(maxTokens),
+        finish_reason: typeof finish === "string" ? finish : null,
+    };
+}
+
+export function formatRunTokenLog(tokens: RunTokenLog): string {
+    return `tokens=${JSON.stringify(tokens)}`;
+}

package/src/shared/safe-notification-target.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "bun:test";
+import { isDefaultSessionTitle, waitForSafeNotificationTarget } from "./safe-notification-target";
+
+function clientWithTitle(title: string | undefined, calls?: { count: number }) {
+    return {
+        session: {
+            get: async (_input: unknown) => {
+                if (calls) calls.count += 1;
+                return { data: { title } };
+            },
+        },
+    };
+}
+
+describe("isDefaultSessionTitle", () => {
+    it("matches OpenCode default titles for parent and child sessions", () => {
+        expect(isDefaultSessionTitle("New session - 2026-06-10T15:33:11.538Z")).toBe(true);
+        expect(isDefaultSessionTitle("Child session - 2026-01-02T03:04:05.678Z")).toBe(true);
+    });
+
+    it("does not match real titles", () => {
+        expect(isDefaultSessionTitle("Quick test")).toBe(false);
+        expect(isDefaultSessionTitle("New session - notes")).toBe(false);
+        // Prefix alone isn't enough — the timestamp must match exactly,
+        // mirroring OpenCode's Session.isDefaultTitle.
+        expect(isDefaultSessionTitle("New session - 2026-06-10")).toBe(false);
+    });
+});
+
+describe("waitForSafeNotificationTarget", () => {
+    it("returns safe immediately for a titled session", async () => {
+        const calls = { count: 0 };
+        const result = await waitForSafeNotificationTarget(
+            clientWithTitle("Fix tagger collision", calls),
+            "ses-titled",
+            { attempts: 4, delayMs: 1 },
+        );
+        expect(result).toBe("safe");
+        expect(calls.count).toBe(1);
+    });
+
+    it("returns skip after exhausting attempts on a default-titled session", async () => {
+        const calls = { count: 0 };
+        const result = await waitForSafeNotificationTarget(
+            clientWithTitle("New session - 2026-06-10T15:33:11.538Z", calls),
+            "ses-fresh",
+            { attempts: 3, delayMs: 1 },
+        );
+        expect(result).toBe("skip");
+        expect(calls.count).toBe(3);
+    });
+
+    it("returns safe once the title flips to a real one mid-retry", async () => {
+        let call = 0;
+        const client = {
+            session: {
+                get: async () => {
+                    call += 1;
+                    return {
+                        data: {
+                            title: call < 2 ? "New session - 2026-06-10T15:33:11.538Z" : "Greeting",
+                        },
+                    };
+                },
+            },
+        };
+        const result = await waitForSafeNotificationTarget(client, "ses-flip", {
+            attempts: 4,
+            delayMs: 1,
+        });
+        expect(result).toBe("safe");
+        expect(call).toBe(2);
+    });
+
+    it("fails open when the client cannot report a title", async () => {
+        expect(
+            await waitForSafeNotificationTarget({}, "ses-no-api", { attempts: 2, delayMs: 1 }),
+        ).toBe("safe");
+        const throwing = {
+            session: {
+                get: async () => {
+                    throw new Error("transport down");
+                },
+            },
+        };
+        expect(
+            await waitForSafeNotificationTarget(throwing, "ses-throw", { attempts: 2, delayMs: 1 }),
+        ).toBe("safe");
+        // Direct-shape response (no `.data` wrapper) is also recognized.
+        const direct = {
+            session: { get: async () => ({ title: "Real title" }) },
+        };
+        expect(
+            await waitForSafeNotificationTarget(direct, "ses-direct", { attempts: 2, delayMs: 1 }),
+        ).toBe("safe");
+    });
+});

package/src/shared/safe-notification-target.ts

@@ -0,0 +1,102 @@
+import { log } from "./logger";
+
+/**
+ * Guard for ignored-message notification posting: only post into sessions
+ * that already carry a REAL title.
+ *
+ * Why: OpenCode's title generation (SessionPrompt.ensureTitle) silently and
+ * PERMANENTLY skips a session once it contains more than one non-synthetic
+ * user message. Our notification posts (config warnings, conflict warnings,
+ * schema-fence warnings, startup announcements) are `ignored: true` — hidden
+ * from the LLM — but NOT `synthetic: true`, so the title gate counts them as
+ * real user messages. A notification landing in a fresh session before the
+ * user's first prompt therefore suppressed that session's title forever
+ * (issue #129; only repros where the new session is the project's only one,
+ * e.g. fresh non-git directories).
+ *
+ * We deliberately do NOT mark our posts `synthetic: true` instead: the
+ * Desktop renderer (UserMessageDisplay) picks the first NON-synthetic text
+ * part, so synthetic would blank the message on Desktop — the only surface
+ * these posts exist for.
+ *
+ * ensureTitle short-circuits on `!isDefaultTitle(session.title)` before the
+ * message count, so posting into an already-titled session can never affect
+ * titling. Callers must NOT mark a notification as delivered when this guard
+ * returns "skip", so the next startup retries.
+ */
+
+/**
+ * Mirrors OpenCode's Session.isDefaultTitle (session.ts): a default title is
+ * `New session - <ISO>` or `Child session - <ISO>`.
+ */
+const DEFAULT_TITLE_RE =
+    /^(New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+export function isDefaultSessionTitle(title: string): boolean {
+    return DEFAULT_TITLE_RE.test(title);
+}
+
+/**
+ * Read a session's current title via the SDK client. Returns null when the
+ * title cannot be determined (missing API, transport error, unexpected
+ * shape) — callers treat that as "fail open" and post, preserving delivery
+ * on clients/tests that don't expose session.get.
+ */
+async function readSessionTitle(client: unknown, sessionId: string): Promise<string | null> {
+    try {
+        const c = client as {
+            session?: { get?: (input: unknown) => unknown };
+        };
+        if (typeof c.session?.get !== "function") return null;
+        const raw = await Promise.resolve(c.session.get({ path: { id: sessionId } }));
+        // SDK response shapes vary across versions: `{ data: { title } }` or
+        // the session object directly.
+        const obj = raw as { data?: { title?: unknown }; title?: unknown } | null;
+        const title = obj && typeof obj === "object" ? (obj.data?.title ?? obj.title) : undefined;
+        return typeof title === "string" ? title : null;
+    } catch {
+        return null;
+    }
+}
+
+export interface SafeTargetOptions {
+    /** Total title checks before giving up (default 4). */
+    attempts?: number;
+    /** Delay between checks in ms (default 15s). */
+    delayMs?: number;
+}
+
+/**
+ * Resolve whether `sessionId` is safe to receive an ignored-message post.
+ *
+ * - "safe": the session has a real (non-default) title, or the title is
+ *   unreadable (fail-open).
+ * - "skip": the session still has OpenCode's default title after all
+ *   attempts — posting now could permanently suppress its title generation.
+ *   The caller must leave its delivered/seen marker unset so a later
+ *   startup retries.
+ *
+ * The retry window exists for the common startup case: plugin init fires a
+ * few seconds after launch, the user prompts shortly after, and the title
+ * lands within seconds of that first prompt.
+ */
+export async function waitForSafeNotificationTarget(
+    client: unknown,
+    sessionId: string,
+    options?: SafeTargetOptions,
+): Promise<"safe" | "skip"> {
+    const attempts = Math.max(1, options?.attempts ?? 4);
+    const delayMs = options?.delayMs ?? 15_000;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        const title = await readSessionTitle(client, sessionId);
+        if (title === null) return "safe";
+        if (!isDefaultSessionTitle(title)) return "safe";
+        if (attempt < attempts - 1) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    log(
+        `[magic-context] notification skipped: session ${sessionId} still has its default title (would suppress title generation); will retry on a later startup`,
+    );
+    return "skip";
+}

package/src/shared/session-messages-bounded.test.ts

@@ -0,0 +1,112 @@
+/// <reference types="bun-types" />
+
+// Regression guard: every `client.session.messages(...)` call in plugin code
+// must include `limit` in its `query`. Without `limit`, OpenCode's legacy
+// messages endpoint hydrates the ENTIRE session into RAM — catastrophic on
+// huge sessions (10k+ messages) which is exactly when Magic Context shines.
+//
+// Background: the plugin only ever needs the latest assistant message of a
+// helper subagent (historian / dreamer / key-files / user-memory)
+// or a bounded tail of the active session (conflict-warning cleanup). Both
+// fit comfortably in `limit: 50` with massive headroom.
+//
+// If you add a new `session.messages(...)` call, this test fails until you
+// include a `limit` in the query. The test does a static source-text scan
+// so it catches the issue at lint-time without runtime mocking overhead.
+
+import { describe, expect, it } from "bun:test";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+const PLUGIN_SRC = join(__dirname, "..", "..", "src");
+
+/** Recursively walk a directory and return paths of all `.ts` files
+ *  excluding `.test.ts`, `.gen.ts`, and node_modules. */
+function walkSourceFiles(dir: string, out: string[] = []): string[] {
+    for (const entry of readdirSync(dir)) {
+        if (entry === "node_modules" || entry === "dist") continue;
+        const full = join(dir, entry);
+        const s = statSync(full);
+        if (s.isDirectory()) {
+            walkSourceFiles(full, out);
+        } else if (
+            s.isFile() &&
+            entry.endsWith(".ts") &&
+            !entry.endsWith(".test.ts") &&
+            !entry.endsWith(".gen.ts")
+        ) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+
+/** Find call expressions matching `session.messages(...)` and return the
+ *  source text of each call (from "session.messages(" to its matching ")"). */
+function findSessionMessagesCalls(source: string): string[] {
+    const calls: string[] = [];
+    const needle = "session.messages(";
+    let i = 0;
+    while (true) {
+        const idx = source.indexOf(needle, i);
+        if (idx === -1) break;
+        // Skip comments — if the line starts with `*` or `//` we ignore.
+        const lineStart = source.lastIndexOf("\n", idx) + 1;
+        const linePrefix = source.slice(lineStart, idx).trimStart();
+        if (linePrefix.startsWith("//") || linePrefix.startsWith("*")) {
+            i = idx + needle.length;
+            continue;
+        }
+        // Walk forward to find the matching closing paren, respecting
+        // brace/bracket/paren nesting.
+        let depth = 1;
+        let j = idx + needle.length;
+        while (j < source.length && depth > 0) {
+            const ch = source[j];
+            if (ch === "(" || ch === "{" || ch === "[") depth++;
+            else if (ch === ")" || ch === "}" || ch === "]") depth--;
+            j++;
+        }
+        if (depth === 0) {
+            calls.push(source.slice(idx, j));
+        }
+        i = j;
+    }
+    return calls;
+}
+
+describe("session.messages() callsites must include query.limit", () => {
+    const files = walkSourceFiles(PLUGIN_SRC);
+    const violations: Array<{ file: string; callText: string }> = [];
+
+    for (const file of files) {
+        // Skip the regression test itself
+        if (file.endsWith("session-messages-bounded.test.ts")) continue;
+        const source = readFileSync(file, "utf-8");
+        const calls = findSessionMessagesCalls(source);
+        for (const call of calls) {
+            // The call text spans from "session.messages(" to the closing
+            // ")". A correct call must mention `limit` (the SDK key) somewhere
+            // inside that span — typically `query: { ..., limit: N }`.
+            if (!/\blimit\b/.test(call)) {
+                violations.push({ file: file.replace(PLUGIN_SRC, "<plugin>/src"), callText: call });
+            }
+        }
+    }
+
+    it("has no unbounded session.messages() calls in plugin code", () => {
+        if (violations.length > 0) {
+            const report = violations
+                .map(
+                    (v) =>
+                        `\n  in ${v.file}:\n    ${v.callText.replace(/\n/g, "\n    ").slice(0, 300)}`,
+                )
+                .join("\n");
+            throw new Error(
+                `Found ${violations.length} unbounded session.messages() call(s). ` +
+                    `Add \`limit: 50\` (or appropriate bound) to query.${report}`,
+            );
+        }
+        expect(violations).toEqual([]);
+    });
+});

package/src/shared/sqlite-acquisition-fence.test.ts

@@ -0,0 +1,133 @@
+import { expect, test } from "bun:test";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import ts from "typescript";
+
+const root = resolve(import.meta.dir, "../../../..");
+const shared = "packages/plugin/src/shared/sqlite.ts";
+function files(dir: string): string[] {
+    return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) return files(path);
+        return /\.tsx?$/.test(path) && !/\.test\.|test-support|\.d\.ts$/.test(path) ? [path] : [];
+    });
+}
+
+function scan(
+    path: string,
+    text: string,
+): { violations: string[]; transactions: number; literals: number } {
+    const violations: string[] = [];
+    let transactions = 0;
+    let literals = 0;
+    const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true);
+    const visit = (node: ts.Node) => {
+        if (
+            ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            node.expression.name.text === "transaction"
+        )
+            transactions++;
+        if (
+            path !== shared &&
+            ts.isImportDeclaration(node) &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            !node.importClause?.isTypeOnly &&
+            /^(bun:sqlite|node:sqlite|better-sqlite3)$/.test(node.moduleSpecifier.text)
+        ) {
+            violations.push(`${path}: native SQLite import bypasses shared acquisition`);
+        }
+        if (
+            path !== shared &&
+            ts.isExportDeclaration(node) &&
+            !node.isTypeOnly &&
+            node.moduleSpecifier &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            /^(bun:sqlite|node:sqlite|better-sqlite3)$/.test(node.moduleSpecifier.text)
+        ) {
+            violations.push(`${path}: native SQLite re-export bypasses shared acquisition`);
+        }
+        if (
+            path !== shared &&
+            ts.isCallExpression(node) &&
+            (node.expression.kind === ts.SyntaxKind.ImportKeyword ||
+                (ts.isIdentifier(node.expression) && node.expression.text === "require")) &&
+            /(?:bun:sqlite|node:sqlite|better-sqlite3)/.test(
+                node.arguments.map((arg) => arg.getText(source)).join(""),
+            )
+        ) {
+            violations.push(`${path}: dynamic native SQLite import bypasses shared acquisition`);
+        }
+        const sqlText = ts.isStringLiteralLike(node)
+            ? node.text
+            : ts.isTemplateExpression(node)
+              ? node.head.text + node.templateSpans.map((span) => span.literal.text).join("")
+              : undefined;
+        if (
+            sqlText !== undefined &&
+            /\bBEGIN\s+(?:IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*(?:;|$)/i.test(sqlText)
+        ) {
+            literals++;
+            if (path !== shared) {
+                const call = node.parent;
+                const routed =
+                    !ts.isTemplateExpression(node) &&
+                    ts.isCallExpression(call) &&
+                    ts.isPropertyAccessExpression(call.expression) &&
+                    call.expression.name.text === "exec" &&
+                    /^\s*BEGIN\s+(IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*;?\s*$/i.test(sqlText);
+                if (!routed)
+                    violations.push(
+                        `${path}:${source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1}: BEGIN acquisition must be a standalone shared Database.exec call`,
+                    );
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return { violations, transactions, literals };
+}
+
+test("all production transaction acquisition routes through the shared SQLite runtime", () => {
+    // Fork trim: upstream also scans packages/cli/src, deleted here in T-003.
+    const scans = ["packages/plugin/src", "packages/pi-plugin/src"]
+        .flatMap((directory) => files(join(root, directory)))
+        .map((path) => scan(relative(root, path), readFileSync(path, "utf8")));
+    expect(scans.reduce((sum, scan) => sum + scan.transactions, 0)).toBeGreaterThan(50);
+    expect(scans.reduce((sum, scan) => sum + scan.literals, 0)).toBeGreaterThan(20);
+    expect(scans.flatMap((scan) => scan.violations)).toEqual([]);
+});
+
+test("acquisition fence rejects raw native transactions and unrouted BEGIN shapes", () => {
+    expect(
+        scan(
+            "new-writer.ts",
+            'import { Database } from "bun:sqlite"; new Database(":memory:").transaction(() => write())();',
+        ).violations,
+    ).toHaveLength(1);
+    expect(
+        scan(
+            "new-writer.ts",
+            'const { DatabaseSync } = require("node:sqlite"); new DatabaseSync(":memory:").transaction(() => write())();',
+        ).violations,
+    ).toHaveLength(1);
+    expect(scan("new-writer.ts", 'export { Database } from "bun:sqlite";').violations).toHaveLength(
+        1,
+    );
+    expect(scan("new-writer.ts", 'db.prepare("BEGIN IMMEDIATE").run();').violations).toHaveLength(
+        1,
+    );
+    expect(
+        scan("new-writer.ts", 'db.exec("BEGIN IMMEDIATE; INSERT INTO result VALUES (1)");')
+            .violations,
+    ).toHaveLength(1);
+    expect(scan("new-writer.ts", "db.exec(`BEGIN IMMEDIATE; ${extra}`);").violations).toHaveLength(
+        1,
+    );
+    expect(
+        scan(
+            "new-writer.ts",
+            'import { Database } from "./shared/sqlite"; db.exec("BEGIN IMMEDIATE"); db.transaction(() => write()).immediate();',
+        ).violations,
+    ).toEqual([]);
+});