@scira/cli 0.1.4 → 0.1.6

package/dist/storage/jsonl.test.js

@@ -1,38 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { appendJsonl, readJsonl } from "./jsonl.js";
-describe("readJsonl / appendJsonl", () => {
-    let dir;
-    let file;
-    beforeEach(async () => {
-        dir = await mkdtemp(join(tmpdir(), "scira-test-"));
-        file = join(dir, "test.jsonl");
-    });
-    afterEach(async () => {
-        await rm(dir, { recursive: true, force: true });
-    });
-    it("returns [] for a missing file", async () => {
-        expect(await readJsonl(join(dir, "missing.jsonl"))).toEqual([]);
-    });
-    it("round-trips a single object", async () => {
-        await appendJsonl(file, { id: "c1", text: "hello" });
-        expect(await readJsonl(file)).toEqual([{ id: "c1", text: "hello" }]);
-    });
-    it("appends multiple objects sequentially", async () => {
-        await appendJsonl(file, { n: 1 });
-        await appendJsonl(file, { n: 2 });
-        await appendJsonl(file, { n: 3 });
-        expect(await readJsonl(file)).toEqual([{ n: 1 }, { n: 2 }, { n: 3 }]);
-    });
-    it("skips malformed lines without throwing", async () => {
-        await writeFile(file, '{"ok":true}\nNOT_JSON\n{"ok":false}\n');
-        expect(await readJsonl(file)).toEqual([{ ok: true }, { ok: false }]);
-    });
-    it("creates parent directories that do not exist", async () => {
-        const nested = join(dir, "a", "b", "c.jsonl");
-        await appendJsonl(nested, { x: 1 });
-        expect(await readJsonl(nested)).toEqual([{ x: 1 }]);
-    });
-});

package/dist/storage/run-store.test.js

@@ -1,65 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtemp, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { createRun, summarizeRun, setRunTitle, getRunPaths } from "./run-store.js";
-import { SciraConfigSchema } from "../types/index.js";
-import { appendJsonl } from "./jsonl.js";
-const BASE_CONFIG = SciraConfigSchema.parse({});
-describe("createRun / summarizeRun", () => {
-    let tmpRoot;
-    beforeEach(async () => {
-        tmpRoot = await mkdtemp(join(tmpdir(), "scira-runs-"));
-    });
-    afterEach(async () => {
-        await rm(tmpRoot, { recursive: true, force: true });
-    });
-    it("creates all expected files and subdirectories", async () => {
-        const config = { ...BASE_CONFIG, runDirectory: tmpRoot };
-        const state = await createRun("What is the speed of light?", config, "");
-        const paths = getRunPaths(state.path);
-        const { readFile, stat } = await import("node:fs/promises");
-        await expect(readFile(paths.goal, "utf8")).resolves.toContain("speed of light");
-        await expect(stat(paths.artifacts)).resolves.toBeDefined();
-        await expect(stat(paths.snapshots)).resolves.toBeDefined();
-    });
-    it("summarizeRun reflects zero sources and claims on a fresh run", async () => {
-        const config = { ...BASE_CONFIG, runDirectory: tmpRoot };
-        const state = await createRun("Test question", config, "");
-        expect(state.sourceCount).toBe(0);
-        expect(state.claimCount).toBe(0);
-        expect(state.weakCount).toBe(0);
-        expect(state.isFull).toBe(false);
-        expect(state.reportDirty).toBe(true);
-        expect(state.goal).toContain("Test question");
-    });
-    it("setRunTitle persists the title and summarizeRun reads it back", async () => {
-        const config = { ...BASE_CONFIG, runDirectory: tmpRoot };
-        const state = await createRun("Title test", config, "");
-        await setRunTitle(state.path, "My Custom Title");
-        const updated = await summarizeRun(state.path);
-        expect(updated.title).toBe("My Custom Title");
-    });
-    it("isFull becomes true once a source is appended", async () => {
-        const config = { ...BASE_CONFIG, runDirectory: tmpRoot };
-        const state = await createRun("Full test", config, "");
-        const paths = getRunPaths(state.path);
-        await appendJsonl(paths.sources, {
-            id: "s1", title: "Test", url: "https://test.com",
-            kind: "primary", summary: "", createdAt: new Date().toISOString()
-        });
-        const updated = await summarizeRun(state.path);
-        expect(updated.sourceCount).toBe(1);
-        expect(updated.isFull).toBe(true);
-    });
-    it("weakCount reflects weak claims", async () => {
-        const config = { ...BASE_CONFIG, runDirectory: tmpRoot };
-        const state = await createRun("Weak test", config, "");
-        const paths = getRunPaths(state.path);
-        await appendJsonl(paths.claims, { id: "c1", text: "x", confidence: "low", status: "weak", sourceIds: [], reason: "", createdAt: new Date().toISOString() });
-        await appendJsonl(paths.claims, { id: "c2", text: "y", confidence: "high", status: "verified", sourceIds: [], reason: "", createdAt: new Date().toISOString() });
-        const updated = await summarizeRun(state.path);
-        expect(updated.claimCount).toBe(2);
-        expect(updated.weakCount).toBe(1);
-    });
-});

package/dist/tools/bash-policy.test.js

@@ -1,38 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { isReadOnlyBashCommand } from "./agent-tools.js";
-describe("isReadOnlyBashCommand", () => {
-    it("allows common read-only commands", () => {
-        expect(isReadOnlyBashCommand("ls -la")).toBe(true);
-        expect(isReadOnlyBashCommand("cat package.json")).toBe(true);
-        expect(isReadOnlyBashCommand("git status")).toBe(true);
-        expect(isReadOnlyBashCommand("git log --oneline -5")).toBe(true);
-        expect(isReadOnlyBashCommand("git branch")).toBe(false);
-        expect(isReadOnlyBashCommand("git remote -v")).toBe(false);
-    });
-    it("rejects chained or mutating commands", () => {
-        expect(isReadOnlyBashCommand("ls; rm -rf /")).toBe(false);
-        expect(isReadOnlyBashCommand("git commit -m x")).toBe(false);
-        expect(isReadOnlyBashCommand("npm install")).toBe(false);
-    });
-    it("rejects multiline chaining and destructive find", () => {
-        expect(isReadOnlyBashCommand("git status\nrm -rf .")).toBe(false);
-        expect(isReadOnlyBashCommand("git status\nnpm install")).toBe(false);
-        expect(isReadOnlyBashCommand("find . -delete")).toBe(false);
-        expect(isReadOnlyBashCommand("find . -exec rm {} +")).toBe(false);
-        expect(isReadOnlyBashCommand("find . -type f")).toBe(true);
-    });
-    it("rejects path traversal and absolute paths", () => {
-        expect(isReadOnlyBashCommand("cat ../secret")).toBe(false);
-        expect(isReadOnlyBashCommand("grep -r token ..")).toBe(false);
-        expect(isReadOnlyBashCommand("ls /")).toBe(false);
-        expect(isReadOnlyBashCommand("cat .//etc/passwd")).toBe(false);
-        expect(isReadOnlyBashCommand("grep -r secret .//etc")).toBe(false);
-        expect(isReadOnlyBashCommand("cat package.json")).toBe(true);
-        expect(isReadOnlyBashCommand("grep -rn foo .")).toBe(true);
-    });
-    it("rejects privileged flags on allowlisted binaries", () => {
-        expect(isReadOnlyBashCommand("git diff --extcmd=sh")).toBe(false);
-        expect(isReadOnlyBashCommand("rg --pre=bash -- foo .")).toBe(false);
-        expect(isReadOnlyBashCommand("git -c alias.status=!rm status")).toBe(false);
-    });
-});

package/dist/tools/search-web.test.js

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { SciraConfigSchema } from "../types/index.js";
-import { multiSearchWeb } from "./search-web.js";
-const BASE_CONFIG = SciraConfigSchema.parse({});
-describe("multiSearchWeb", () => {
-    it("reports provider errors instead of silently returning empty results", async () => {
-        const origExa = process.env.EXA_API_KEY;
-        const origFc = process.env.FIRECRAWL_API_KEY;
-        process.env.EXA_API_KEY = "invalid";
-        process.env.FIRECRAWL_API_KEY = "invalid";
-        const config = { ...BASE_CONFIG, search: { ...BASE_CONFIG.search, provider: "exa" } };
-        const results = await multiSearchWeb(["test query"], [{}], config);
-        expect(results[0]?.results).toEqual([]);
-        expect(results[0]?.error).toMatch(/invalid|unauthorized|api key/i);
-        if (origExa)
-            process.env.EXA_API_KEY = origExa;
-        else
-            delete process.env.EXA_API_KEY;
-        if (origFc)
-            process.env.FIRECRAWL_API_KEY = origFc;
-        else
-            delete process.env.FIRECRAWL_API_KEY;
-    });
-});

package/dist/tools/workspace.test.js

@@ -1,75 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { harnessBasename, isRunArtifactPath, resolveInsideRun, resolveProjectRoot, resolveToolPath } from "./workspace.js";
-const RUN = "/tmp/scira-test-run";
-const PROJECT = "/Users/me/my-app";
-const RUN_UNDER_SCIRA = `${PROJECT}/.scira/runs/2024-test-abc`;
-describe("resolveInsideRun", () => {
-    it("resolves a relative path inside the run dir", () => {
-        expect(resolveInsideRun(RUN, "notes.md")).toBe(`${RUN}/notes.md`);
-    });
-    it("resolves a nested relative path inside the run dir", () => {
-        expect(resolveInsideRun(RUN, "artifacts/output.txt")).toBe(`${RUN}/artifacts/output.txt`);
-    });
-    it("resolves an absolute path that is inside the run dir", () => {
-        expect(resolveInsideRun(RUN, `${RUN}/plan.md`)).toBe(`${RUN}/plan.md`);
-    });
-    it("throws for a path that escapes with ../", () => {
-        expect(() => resolveInsideRun(RUN, "../outside.txt")).toThrow("outside the run directory");
-    });
-    it("throws for a deep escape path", () => {
-        expect(() => resolveInsideRun(RUN, "a/../../outside.txt")).toThrow("outside the run directory");
-    });
-    it("throws for an absolute path outside the run dir", () => {
-        expect(() => resolveInsideRun(RUN, "/etc/passwd")).toThrow("outside the run directory");
-    });
-    it("throws for a home-dir escape", () => {
-        const home = `${process.env.HOME ?? "/root"}/evil.sh`;
-        expect(() => resolveInsideRun(RUN, home)).toThrow("outside the run directory");
-    });
-});
-describe("resolveProjectRoot", () => {
-    it("returns parent of .scira when run is under .scira/runs", () => {
-        expect(resolveProjectRoot(RUN_UNDER_SCIRA)).toBe(PROJECT);
-    });
-});
-describe("harnessBasename", () => {
-    it("strips run: and ./ prefixes", () => {
-        expect(harnessBasename("run:report.md")).toBe("report.md");
-        expect(harnessBasename("./plan.md")).toBe("plan.md");
-        expect(harnessBasename("notes.md")).toBe("notes.md");
-    });
-});
-describe("isRunArtifactPath", () => {
-    it("treats bare harness filenames as run artifacts", () => {
-        expect(isRunArtifactPath("plan.md")).toBe(true);
-        expect(isRunArtifactPath("notes.md")).toBe(true);
-        expect(isRunArtifactPath("src/foo.ts")).toBe(false);
-    });
-    it("does not treat nested paths as run artifacts by basename", () => {
-        expect(isRunArtifactPath("docs/notes.md")).toBe(false);
-        expect(isRunArtifactPath("src/plan.md")).toBe(false);
-    });
-    it("treats run: prefix as run artifact", () => {
-        expect(isRunArtifactPath("run:custom.md")).toBe(true);
-    });
-});
-describe("resolveToolPath", () => {
-    it("routes source paths to workspace", () => {
-        const resolved = resolveToolPath(RUN_UNDER_SCIRA, PROJECT, "src/index.ts");
-        expect(resolved.scope).toBe("workspace");
-        expect(resolved.abs).toBe(`${PROJECT}/src/index.ts`);
-    });
-    it("routes plan.md to run directory", () => {
-        const resolved = resolveToolPath(RUN_UNDER_SCIRA, PROJECT, "plan.md");
-        expect(resolved.scope).toBe("run");
-        expect(resolved.abs).toBe(`${RUN_UNDER_SCIRA}/plan.md`);
-    });
-    it("routes nested notes.md to workspace not run", () => {
-        const resolved = resolveToolPath(RUN_UNDER_SCIRA, PROJECT, "docs/notes.md");
-        expect(resolved.scope).toBe("workspace");
-        expect(resolved.abs).toBe(`${PROJECT}/docs/notes.md`);
-    });
-    it("blocks writes into .scira from workspace paths", () => {
-        expect(() => resolveToolPath(RUN_UNDER_SCIRA, PROJECT, ".scira/config.json")).toThrow("inside .scira");
-    });
-});

package/dist/types/schema.test.js

@@ -1,61 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ClaimSchema, SourceSchema, SciraConfigSchema } from "./index.js";
-describe("ClaimSchema", () => {
-    it("parses a valid claim with defaults", () => {
-        const result = ClaimSchema.parse({
-            id: "c1",
-            text: "The sky is blue.",
-            createdAt: new Date().toISOString(),
-        });
-        expect(result.confidence).toBe("medium");
-        expect(result.status).toBe("draft");
-        expect(result.sourceIds).toEqual([]);
-        expect(result.reason).toBe("");
-    });
-    it("rejects an invalid confidence value", () => {
-        expect(() => ClaimSchema.parse({ id: "c1", text: "x", confidence: "very_high", createdAt: "" })).toThrow();
-    });
-    it("rejects an invalid status value", () => {
-        expect(() => ClaimSchema.parse({ id: "c1", text: "x", status: "maybe", createdAt: "" })).toThrow();
-    });
-    it("preserves all fields when fully specified", () => {
-        const input = {
-            id: "c2",
-            text: "Claim text.",
-            confidence: "high",
-            status: "verified",
-            sourceIds: ["s1", "s2"],
-            reason: "Verified by primary source.",
-            createdAt: "2026-01-01T00:00:00.000Z",
-        };
-        expect(ClaimSchema.parse(input)).toEqual(input);
-    });
-});
-describe("SourceSchema", () => {
-    it("parses a valid source with defaults", () => {
-        const result = SourceSchema.parse({
-            id: "s1",
-            title: "Example",
-            url: "https://example.com",
-            createdAt: new Date().toISOString(),
-        });
-        expect(result.kind).toBe("unknown");
-        expect(result.summary).toBe("");
-    });
-    it("rejects an invalid kind value", () => {
-        expect(() => SourceSchema.parse({ id: "s1", title: "t", url: "u", kind: "blog", createdAt: "" })).toThrow();
-    });
-});
-describe("SciraConfigSchema", () => {
-    it("parses an empty object using all defaults", () => {
-        const config = SciraConfigSchema.parse({});
-        expect(config.llmProvider).toBe("gateway");
-        expect(config.approvalMode).toBe("suggest");
-        expect(config.alwaysAllowLinks).toBe(false);
-        expect(config.runDirectory).toBe(".scira/runs");
-        expect(config.maxSources).toBe(20);
-    });
-    it("rejects an invalid approvalMode", () => {
-        expect(() => SciraConfigSchema.parse({ approvalMode: "yolo" })).toThrow();
-    });
-});

package/dist/ui/ink/hooks/use-feed-lines.test.js

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { computeGroups } from "./use-feed-lines.js";
-describe("computeGroups", () => {
-    it("lists thinking and tools in step order", () => {
-        const feed = [
-            { kind: "reasoning", text: "plan", durationMs: 100 },
-            { kind: "tool", name: "webSearch", summary: "q", status: "done" },
-            { kind: "reasoning", text: "read", durationMs: 50 },
-            { kind: "tool", name: "readUrl", summary: "url", status: "done" },
-        ];
-        const { groups } = computeGroups(feed);
-        const g = groups.get(0);
-        expect(g?.stepLabels).toEqual(["thinking", "webSearch", "thinking", "readUrl"]);
-        expect(g?.itemCount).toBe(4);
-    });
-});

package/dist/ui/ink/lib/tool-result.test.js

@@ -1,60 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DARK_THEME } from "../theme.js";
-import { formatToolResultLines, formatToolResultPreview, isToolItemCollapsed, defaultCollapsedToolName, } from "./tool-result.js";
-function textOf(lines) {
-    return lines.map((row) => row.map((s) => s.text).join("")).join("\n");
-}
-describe("formatToolResultLines", () => {
-    it("shows queries then a flat sources list", () => {
-        const result = JSON.stringify([
-            {
-                query: "ai news",
-                results: [
-                    { title: "Alpha", url: "https://a.com", snippet: "First hit snippet." },
-                    { title: "Beta", url: "https://b.com", snippet: "Second hit snippet." },
-                ],
-            },
-            {
-                query: "ai frameworks",
-                results: [
-                    { title: "Alpha", url: "https://a.com", snippet: "Duplicate should drop." },
-                    { title: "Gamma", url: "https://c.com", snippet: "Third hit snippet." },
-                ],
-            },
-        ]);
-        const out = textOf(formatToolResultLines("webSearch", "ai news · ai frameworks", result, "done", 80, DARK_THEME));
-        expect(out.indexOf("Queries")).toBeLessThan(out.indexOf("Sources"));
-        expect(out).toContain("ai news");
-        expect(out).toContain("ai frameworks");
-        expect(out).toContain("Sources (3)");
-        expect(out).toContain("Alpha");
-        expect(out).toContain("First hit snippet.");
-        expect(out).toContain("Gamma");
-        expect(out).not.toContain("Duplicate should drop");
-    });
-    it("shows shell command and full output", () => {
-        const out = textOf(formatToolResultLines("bash", "ls -la", "total 0\nfile.txt", "done", 80, DARK_THEME));
-        expect(out).toContain("$ ls -la");
-        expect(out).toContain("total 0");
-        expect(out).toContain("file.txt");
-    });
-    it("shows readUrl title and body when expanded", () => {
-        const result = "# Example\n(snapshot saved to snapshots/example.md)\n\nBody paragraph here.";
-        const out = textOf(formatToolResultLines("readUrl", "https://example.com", result, "done", 80, DARK_THEME, true));
-        expect(out).toContain("Example");
-        expect(out).toContain("snapshots/example.md");
-        expect(out).toContain("Body paragraph here.");
-    });
-    it("hides readUrl body when collapsed", () => {
-        const result = "# Example\n(snapshot saved to snapshots/example.md)\n\nBody paragraph here.";
-        expect(formatToolResultLines("readUrl", "https://example.com", result, "done", 80, DARK_THEME, false)).toEqual([]);
-        expect(formatToolResultPreview("readUrl", "https://example.com", result, "done")).toContain("Example");
-    });
-    it("defaults readUrl and webSearch collapsed", () => {
-        expect(defaultCollapsedToolName("readUrl")).toBe(true);
-        expect(defaultCollapsedToolName("webSearch")).toBe(true);
-        expect(isToolItemCollapsed("id", "readUrl", "done", new Map())).toBe(true);
-        expect(isToolItemCollapsed("id", "webSearch", "done", new Map())).toBe(true);
-        expect(isToolItemCollapsed("id", "readUrl", "done", new Map([["id", true]]))).toBe(false);
-    });
-});

package/dist/ui/ink/lib/utils.test.js

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { summarizeToolInput, summarizeToolOutput, ansiHyperlink, computeLineLinks, linkAtMouseColumn } from "./utils.js";
-describe("hyperlink helpers", () => {
-    it("wraps OSC 8 around styled link text", () => {
-        const out = ansiHyperlink("docs", "https://example.com", { color: "#FFE0C2", underline: true });
-        expect(out).toContain("\x1b]8;;https://example.com\x1b\\");
-        expect(out).toContain("docs");
-        expect(out).toContain("\x1b]8;;\x1b\\");
-    });
-    it("maps mouse column to link url", () => {
-        const links = computeLineLinks([
-            { text: "see " },
-            { text: "docs", url: "https://example.com" },
-        ], 2);
-        expect(links).toEqual([{ start: 6, end: 9, url: "https://example.com" }]);
-        expect(linkAtMouseColumn(links, 7)).toBe("https://example.com");
-        expect(linkAtMouseColumn(links, 3)).toBeUndefined();
-    });
-});
-describe("summarizeToolInput", () => {
-    it("formats webSearch queries", () => {
-        expect(summarizeToolInput("webSearch", { queries: ["a", "b", "c"] })).toBe("a · b +1");
-    });
-    it("formats readUrl url", () => {
-        expect(summarizeToolInput("readUrl", { url: "https://example.com" })).toBe("https://example.com");
-    });
-});
-describe("summarizeToolOutput", () => {
-    it("summarizes webSearch json results", () => {
-        const output = JSON.stringify([
-            { query: "q1", results: [{ title: "Alpha" }, { title: "Beta" }] },
-            { query: "q2", results: [{ title: "Gamma" }] },
-        ]);
-        expect(summarizeToolOutput("webSearch", output)).toBe("3 results · Alpha · Beta · Gamma");
-    });
-    it("extracts readUrl page title", () => {
-        const output = "# Example Page\n(snapshot saved to snapshots/example.md)\n\nBody text";
-        expect(summarizeToolOutput("readUrl", output)).toBe("Example Page");
-    });
-    it("summarizes listSkills output", () => {
-        const output = "plan: Write a research plan\nsources: Gather sources";
-        expect(summarizeToolOutput("listSkills", output)).toBe("2 skills · plan, sources");
-    });
-    it("passes through predetermined string results", () => {
-        expect(summarizeToolOutput("requestFullResearch", "Approved. Stop now and do not call more tools."))
-            .toBe("Approved. Stop now and do not call more tools.");
-    });
-});

package/dist/ui/ink/session-manager.test.js

@@ -1,31 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { mergeFeedToolResults } from "./session-manager.js";
-describe("mergeFeedToolResults", () => {
-    it("replaces truncated tool results with full buffer copies", () => {
-        const feed = [
-            {
-                kind: "tool",
-                name: "webSearch",
-                toolCallId: "call-1",
-                summary: "query a",
-                status: "done",
-                result: "truncated…",
-            },
-        ];
-        const buffer = [
-            {
-                kind: "tool",
-                name: "webSearch",
-                toolCallId: "call-1",
-                summary: "query a",
-                status: "done",
-                result: "x".repeat(5000),
-            },
-        ];
-        const merged = mergeFeedToolResults(feed, buffer);
-        expect(merged[0].kind).toBe("tool");
-        if (merged[0].kind === "tool") {
-            expect(merged[0].result).toHaveLength(5000);
-        }
-    });
-});

package/dist/ui/ink/terminal-probe.test.js

@@ -1,12 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { luminance, parseOscBackgroundColor, themeFromLuminance } from "./terminal-probe.js";
-describe("terminal-probe", () => {
-    it("parses rgb OSC background colors", () => {
-        expect(parseOscBackgroundColor("rgb:1e1e/1e1e/1e1e")).toEqual({ r: 30, g: 30, b: 30 });
-        expect(parseOscBackgroundColor("#f0f0f0")).toEqual({ r: 240, g: 240, b: 240 });
-    });
-    it("classifies luminance into light and dark", () => {
-        expect(themeFromLuminance(luminance({ r: 30, g: 30, b: 30 }))).toBe("dark");
-        expect(themeFromLuminance(luminance({ r: 240, g: 240, b: 240 }))).toBe("light");
-    });
-});

package/dist/ui/ink/theme.test.js

@@ -1,68 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { detectTerminalTheme, getTheme, inputForegroundForAppearance, resolveRenderingAppearance, watchAutoThemeChanges, } from "./theme.js";
-const env = process.env;
-afterEach(() => {
-    process.env = { ...env };
-});
-describe("detectTerminalTheme", () => {
-    it("uses COLORFGBG when present", () => {
-        process.env.COLORFGBG = "15;0";
-        expect(detectTerminalTheme()).toBe("dark");
-        process.env.COLORFGBG = "0;15";
-        expect(detectTerminalTheme()).toBe("light");
-    });
-    it("prefers COLORFGBG over terminal profile hints", () => {
-        process.env.COLORFGBG = "0;15";
-        process.env.TERM_PROFILE = "Dark";
-        expect(detectTerminalTheme()).toBe("light");
-    });
-    it("resolves auto theme colors from detected appearance", () => {
-        process.env.COLORFGBG = "0;15";
-        expect(getTheme("auto").text).toBe("ansi256(0)");
-        expect(getTheme("auto").inputText).toBe("ansi256(0)");
-        expect(getTheme("auto").userBandBackground).toBe("#f0f0f0");
-        process.env.COLORFGBG = "15;0";
-        expect(getTheme("auto").text).toBe("ansi256(15)");
-        expect(getTheme("auto").inputText).toBe("ansi256(15)");
-        expect(getTheme("auto").userBandBackground).toBe("ansi256(238)");
-    });
-    it("detects Warp and Apple Terminal as dark when unset", () => {
-        delete process.env.COLORFGBG;
-        delete process.env.TERM_PROFILE;
-        delete process.env.ITERM_PROFILE;
-        process.env.TERM_PROGRAM = "WarpTerminal";
-        expect(detectTerminalTheme()).toBe("dark");
-        process.env.TERM_PROGRAM = "Apple_Terminal";
-        expect(detectTerminalTheme()).toBe("dark");
-    });
-    it("defaults to dark when no signals are present", () => {
-        delete process.env.COLORFGBG;
-        delete process.env.TERM_PROFILE;
-        delete process.env.ITERM_PROFILE;
-        delete process.env.TERM_PROGRAM;
-        delete process.env.TERM_PROGRAM;
-        expect(detectTerminalTheme()).toBe("dark");
-    });
-    it("maps terminal appearance to ansi256 input foreground", () => {
-        expect(inputForegroundForAppearance("dark")).toBe("ansi256(15)");
-        expect(inputForegroundForAppearance("light")).toBe("ansi256(0)");
-    });
-    it("overrides a mismatched locked theme to match the terminal", () => {
-        expect(resolveRenderingAppearance("light", "dark")).toBe("dark");
-        expect(resolveRenderingAppearance("dark", "light")).toBe("light");
-        expect(resolveRenderingAppearance("dark", "dark")).toBe("dark");
-        expect(resolveRenderingAppearance("auto", "dark")).toBe("dark");
-    });
-    it("watchAutoThemeChanges fires immediately and on interval", () => {
-        vi.useFakeTimers();
-        const onChange = vi.fn();
-        const stop = watchAutoThemeChanges(onChange);
-        expect(onChange).toHaveBeenCalledTimes(1);
-        vi.advanceTimersByTime(1500);
-        expect(onChange).toHaveBeenCalledTimes(2);
-        stop();
-        vi.advanceTimersByTime(1500);
-        expect(onChange).toHaveBeenCalledTimes(2);
-        vi.useRealTimers();
-    });
-});