carthagent 1.0.7 → 1.1.0-beta.2

package/plugins/carthagent/tests/commands.test.ts

@@ -0,0 +1,107 @@
+import { strict as assert } from "node:assert";
+import { test } from "node:test";
+import { COMMANDS, matchCommand, NATIVE_COMMAND_COLLISIONS, resolveCommand } from "../src/ui/commands.js";
+import { readFile } from "node:fs/promises";
+import { parseThemeDocument } from "@opencode/theme/tui";
+import { cliConfigDirectory, cliConfigPath, readCliConfig, writeNativeTheme } from "../src/ui/host-state.js";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { provisionNativeThemes } from "../src/ui/theme-provision.mjs";
+
+test("Carthagent command manifest resolves visible CTG commands", () => {
+  assert.equal(resolveCommand("/help")?.id, "help");
+  assert.equal(resolveCommand("/ctg-help")?.id, "help");
+  assert.deepEqual(COMMANDS.find((item) => item.id === "help")?.aliases, ["ctg-help"]);
+  assert.equal(COMMANDS.find((item) => item.id === "help")?.submitSlash, true);
+  assert.equal(resolveCommand("/review")?.id, "review");
+  assert.equal(resolveCommand("/review-mode")?.id, "review");
+  for (const name of ["workflow", "architecture", "evidence"]) assert.equal(resolveCommand(name)?.hidden, undefined);
+  for (const name of ["model", "compact", "autocompact", "abort", "clear"]) assert.equal(resolveCommand(name)?.id, name);
+  assert.deepEqual(matchCommand("/arch").map((item) => item.name), ["architecture", "archive"]);
+  assert.deepEqual(matchCommand("/rev status"), []);
+  for (const name of ["login", "account", "usage", "billing", "logout-cloud", "archive", "demo", "voyages", "quests"]) {
+    assert.ok(resolveCommand(`/${name}`), `/${name} must resolve to a registered handler`);
+  }
+  assert.equal(resolveCommand("/cloud")?.id, "account");
+  assert.equal(resolveCommand("/auth")?.id, "login");
+  assert.match(resolveCommand("/voyages")!.description, /daily quests/);
+  assert.match(resolveCommand("/quests")!.description, /separate explicit consent/);
+});
+
+test("manifest prevents collisions with native OpenCode slash commands", () => {
+  for (const name of NATIVE_COMMAND_COLLISIONS) assert.equal(COMMANDS.some((item) => item.name === name || item.aliases?.includes(name)), false, name);
+  assert.equal(NATIVE_COMMAND_COLLISIONS.includes("help" as typeof NATIVE_COMMAND_COLLISIONS[number]), false);
+  assert.deepEqual(COMMANDS.filter((item) => ["model", "compact", "abort", "resume"].includes(item.name)).map((item) => item.name).sort(), ["abort", "compact", "model", "resume"]);
+});
+
+test("theme provisioning installs the startup default through its launcher-facing export", async () => {
+  const { provisionDefaultNativeTheme } = await import("../src/ui/theme-provision.mjs");
+  const directory = await mkdtemp(join(tmpdir(), "ctg-default-theme-"));
+  try {
+    const result = await provisionDefaultNativeTheme(directory);
+    assert.ok(result.installed.includes("carthage"));
+    const theme = parseThemeDocument(JSON.parse(await readFile(join(result.directory, "carthage.json"), "utf8")), "carthage");
+    assert.equal(theme.dark.hue.yellow[400], "#d5af66");
+  } finally { await rm(directory, { recursive: true, force: true }); }
+});
+
+test("startup theme provisioning covers compatibility themes and preserves host/user themes", async () => {
+  const { provisionDefaultNativeTheme } = await import("../src/ui/theme-provision.mjs");
+  const directory = await mkdtemp(join(tmpdir(), "ctg-startup-themes-"));
+  try {
+    await mkdir(join(directory, "themes"), { recursive: true });
+    await writeFile(join(directory, "themes", "forest.json"), '{"userOwned":true}');
+    const result = await provisionDefaultNativeTheme(directory);
+    assert.ok(result.installed.includes("carthage"));
+    assert.ok(result.installed.includes("forest") === false);
+    assert.ok(result.conflicts.includes("forest"));
+    assert.ok(result.installed.includes("opencode") === false);
+    assert.ok(result.installed.includes("tokyonight") === false);
+    assert.deepEqual(JSON.parse(await readFile(join(directory, "themes", "forest.json"), "utf8")), { userOwned: true });
+  } finally { await rm(directory, { recursive: true, force: true }); }
+});
+
+test("Carthage theme validates against the OpenCode V2 theme schema and resolver", async () => {
+  const raw = JSON.parse(await readFile(new URL("../themes/carthage.json", import.meta.url), "utf8"));
+  const resolved = parseThemeDocument(raw, "carthage");
+  assert.ok(resolved.dark?.hue.yellow);
+  assert.equal(resolved.base.categorical?.length, 5);
+});
+
+test("native CLI theme write preserves unrelated cli.json settings", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "ctg-cli-config-"));
+  const path = join(directory, "cli.json");
+  try {
+    await writeFile(path, JSON.stringify({ theme: { name: "opencode", mode: "dark" }, session: { thinking: "show" }, custom: true }));
+    await writeNativeTheme(path, "carthage");
+    const config = await readCliConfig(path);
+    assert.deepEqual(config.theme, { name: "carthage", mode: "dark" });
+    assert.deepEqual(config.session, { thinking: "show" });
+    assert.equal(config.custom, true);
+    assert.equal(cliConfigPath({ XDG_CONFIG_HOME: "/tmp/profile" }, "/home/test"), join("/tmp/profile", "opencode", "cli.json"));
+    assert.equal(cliConfigDirectory({ OPENCODE_CONFIG_DIR: "/tmp/opencode-profile" }), "/tmp/opencode-profile");
+    assert.equal(cliConfigDirectory({ XDG_CONFIG_HOME: "/tmp/profile" }, "/home/test"), join("/tmp/profile", "opencode"));
+  } finally { await rm(directory, { recursive: true, force: true }); }
+});
+
+test("native theme provisioning converts legacy palettes inside the selected OpenCode profile", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "ctg-native-themes-"));
+  const themeDirectory = join(directory, "themes");
+  try {
+    await mkdir(themeDirectory, { recursive: true });
+    await writeFile(join(themeDirectory, "user-theme.json"), '{"custom":true}');
+    const result = await provisionNativeThemes(directory, ["carthage", "nebula"]);
+    assert.deepEqual(result.installed.sort(), ["carthage", "nebula"]);
+    assert.deepEqual(JSON.parse(await readFile(join(themeDirectory, "user-theme.json"), "utf8")), { custom: true });
+    const carthage = parseThemeDocument(JSON.parse(await readFile(join(themeDirectory, "carthage.json"), "utf8")), "carthage");
+    const nebula = parseThemeDocument(JSON.parse(await readFile(join(themeDirectory, "nebula.json"), "utf8")), "nebula");
+    assert.equal(carthage.dark.hue.yellow[400], "#d5af66");
+    assert.equal(carthage.dark.hue.yellow[300], "#e6c480");
+    assert.ok(nebula.dark.hue.blue[400]);
+    const again = await provisionNativeThemes(directory, ["carthage"]);
+    assert.deepEqual(again.installed, []);
+    await writeFile(join(themeDirectory, "forest.json"), '{"userOwned":true}');
+    await assert.rejects(provisionNativeThemes(directory, ["forest"]), /Refusing to replace/);
+  } finally { await rm(directory, { recursive: true, force: true }); }
+});

package/plugins/carthagent/tests/session-preferences.test.mjs

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { setSessionAutoCompaction } from "../src/ui/session-preferences.mjs";
+
+test("autocompact persists explicit, idempotent session preferences without replacing neighbor metadata", async () => {
+  let current = { "ctg.autoCompaction": false, "ctg.raw": true, "user.flag": "keep" };
+  const updates = [];
+  const client = {
+    async get(input, options) {
+      assert.equal(input.sessionID, "s1");
+      assert.equal(options.location.directory, "/project");
+      assert.ok(options.signal instanceof AbortSignal);
+      return { metadata: current };
+    },
+    async update(input, options) {
+      assert.equal(input.sessionID, "s1");
+      assert.equal(options.location.directory, "/project");
+      current = input.metadata;
+      updates.push(input.metadata);
+    },
+  };
+  const location = { directory: "/project" };
+  assert.equal(await setSessionAutoCompaction(client, "s1", location, "off"), false);
+  assert.equal(updates.length, 0, "repeating off must not write");
+  assert.equal(await setSessionAutoCompaction(client, "s1", location, "on"), true);
+  assert.deepEqual(current, { "ctg.raw": true, "user.flag": "keep" });
+  assert.equal(await setSessionAutoCompaction(client, "s1", location, "toggle"), false);
+  assert.deepEqual(current, { "ctg.autoCompaction": false, "ctg.raw": true, "user.flag": "keep" });
+  assert.equal(await setSessionAutoCompaction(client, "s1", location, "toggle"), true);
+  assert.equal(updates.length, 3);
+});
+
+test("invalid autocompact arguments fail before reading or mutating session state", async () => {
+  let calls = 0;
+  const client = {
+    async get() { calls++; throw new Error("must not read"); },
+    async update() { calls++; throw new Error("must not update"); },
+  };
+  await assert.rejects(setSessionAutoCompaction(client, "s1", { directory: "/project" }, "sometimes"), /Usage: \/autocompact \[on\|off\]/);
+  assert.equal(calls, 0);
+});

package/plugins/carthagent/tests/voyages-navigation.test.tsx

@@ -0,0 +1,269 @@
+/** @jsxImportSource @opentui/solid */
+import { expect, test } from "bun:test";
+import { testRender } from "@opentui/solid";
+import { ScrollBoxRenderable, SelectRenderable, type Renderable } from "@opentui/core";
+import { createSignal } from "solid-js";
+import { PluginContextProvider } from "@opencode/plugin/tui";
+import type { Context } from "@opencode/plugin/tui/context";
+import { parseThemeDocument, resolveThemeDocument } from "@opencode/theme/tui";
+import theme from "../themes/carthage.json";
+import { Voyages } from "../src/voyages-rpc.js";
+import { VoyagesNavigation } from "../src/ui/voyages-navigation.js";
+
+const profile = { profile: { name: "Test captain", shipName: "Test vessel", coins: 10, level: 2, totalXp: 150 } };
+const slate = { slate: { day: "2026-10-30", endsAt: "2026-10-31T00:00:00Z", items: [
+  { id: "quest-one", definition: { title: "Protect a boundary" }, status: "open" },
+  { id: "quest-two", definition: { title: "Review a change" }, status: "assessed_complete" },
+] }, records: [{ request: { evidence: "must not appear in navigation", consent: true } }] };
+
+async function fixture({ width = 30, height = 36, authenticated = true } = {}) {
+  const [active, setActive] = createSignal(true);
+  const [focused, setFocused] = createSignal(false);
+  const [compact, setCompact] = createSignal(false);
+  const [mode, setMode] = createSignal("base");
+  const [sessionID, setSessionID] = createSignal<string | undefined>("coding-session");
+  const routes: unknown[] = [], calls: string[] = [], selected: string[] = [];
+  const responses: Promise<unknown>[] = [];
+  let responseGate: Promise<void> | undefined;
+  let listener: ((event: { details: { type: string } }) => void) | undefined;
+  let listening = true;
+  const context = {
+    theme: resolveThemeDocument(parseThemeDocument(theme), "dark"),
+    location: { directory: "/test-project" },
+    data: {
+      session: { get: () => ({ location: { directory: "/test-project" } }) },
+      location: { default: () => ({ directory: "/test-project" }) },
+      listen: (next: typeof listener) => { listener = next; return () => { listening = false; }; },
+    },
+    client: { rpc: (definition: unknown) => ({ snapshot: () => {
+      calls.push(definition === Voyages ? "profile" : "daily");
+      const response = authenticated ? (responseGate ?? Promise.resolve()).then(() => definition === Voyages ? profile : slate) : Promise.reject({ type: "voyagesError", data: { code: "authentication_required" } });
+      responses.push(response);
+      return response;
+    } }) },
+    keymap: { mode: { current: mode }, dispatch: (id: string) => { calls.push(id); } },
+    ui: {
+      router: { navigate: (route: unknown) => routes.push(route) },
+      navigation: { current: () => "voyages", select: (name: string) => { selected.push(name); return true; } },
+    },
+  } as unknown as Context;
+  const app = await testRender(() => <PluginContextProvider value={context}>
+    <box width={width} height={height} visible={active()}>
+      <VoyagesNavigation width={width} active={active()} compact={compact()} focused={focused()} sessionID={sessionID()} focus={() => { if (mode() !== "base") return; setFocused(true); setMode("navigation"); }} blur={() => { setFocused(false); if (mode() === "navigation") setMode("base"); }} />
+    </box>
+  </PluginContextProvider>, { width, height, kittyKeyboard: true });
+  const settle = async () => { await Promise.allSettled(responses); await app.renderOnce(); };
+  await settle();
+  return {
+    app, calls, routes, selected, mode, setMode, setActive, setFocused, setCompact, setSessionID, settle,
+    focus: async () => { setFocused(true); setMode("navigation"); await app.renderOnce(); },
+    event: (type: string) => listener?.({ details: { type } }),
+    delay: (promise: Promise<void> | undefined) => { responseGate = promise; },
+    listening: () => listening,
+    list: () => app.renderer.currentFocusedRenderable as SelectRenderable,
+    scroll: () => {
+      const find = (node: Renderable): ScrollBoxRenderable | undefined => node instanceof ScrollBoxRenderable ? node : node.getChildren().map(find).find(Boolean);
+      return find(app.renderer.root)!;
+    },
+  };
+}
+
+test.each([30, 18])("real Voyages navigator renders account and assignment summaries at width %i", async (width) => {
+  const f = await fixture({ width });
+  try {
+    const frame = f.app.captureCharFrame();
+    expect(frame).toContain("Test captain");
+    expect(frame).toContain("10 coins");
+    expect(frame).toContain("Daily coding");
+    expect(frame).not.toContain("must not appear");
+    expect(f.calls).toEqual(["profile", "daily"]);
+    expect(f.routes).toHaveLength(0);
+  } finally { f.app.renderer.destroy(); }
+  expect(f.listening()).toBe(false);
+});
+
+test("rail focus owns arrows/Enter; palette or modal mode cannot trigger a route", async () => {
+  const f = await fixture();
+  try {
+    expect(f.app.renderer.currentFocusedRenderable).not.toBeInstanceOf(SelectRenderable);
+    await f.focus();
+    expect(f.list()).toBeInstanceOf(SelectRenderable);
+    f.app.mockInput.pressArrow("down");
+    await f.app.renderOnce();
+    expect(f.list().getSelectedOption()?.value).toBe("quest:quest-one");
+    for (const mode of ["modal", "palette", "base"]) {
+      f.setMode(mode);
+      await f.app.renderOnce();
+      f.app.mockInput.pressEnter();
+      await f.app.renderOnce();
+      expect(f.routes).toHaveLength(0);
+    }
+    f.setMode("navigation");
+    await f.app.renderOnce();
+    f.app.mockInput.pressEnter();
+    await f.app.renderOnce();
+    expect(f.routes).toEqual([{ type: "plugin", name: "daily-quests", data: { sessionID: "coding-session", questID: "quest-one" } }]);
+    expect(f.mode()).toBe("base");
+    expect(f.calls).toEqual(["profile", "daily"]);
+  } finally { f.app.renderer.destroy(); }
+});
+
+test("Projects/Voyages toggles retain selection and do not route, submit or purchase", async () => {
+  const f = await fixture();
+  try {
+    await f.focus();
+    f.app.mockInput.pressArrow("down");
+    await f.app.renderOnce();
+    expect(f.list().getSelectedOption()?.value).toBe("quest:quest-one");
+    f.setActive(false);
+    await f.settle();
+    expect(f.app.captureCharFrame()).not.toContain("Test captain");
+    f.setActive(true);
+    await f.settle();
+    expect(f.list().getSelectedOption()?.value).toBe("quest:quest-one");
+    expect(f.routes).toHaveLength(0);
+    expect(f.calls).toEqual(["profile", "daily", "profile", "daily"]);
+  } finally { f.app.renderer.destroy(); }
+});
+
+test("compact mode uses the same mounted selection and keyboard behavior", async () => {
+  const f = await fixture();
+  try {
+    await f.focus();
+    f.app.mockInput.pressArrow("down");
+    await f.app.renderOnce();
+    const list = f.list();
+    f.setCompact(true);
+    f.app.resize(5, 36);
+    await f.app.renderOnce();
+    expect(f.list()).toBe(list);
+    expect(f.list().getSelectedOption()?.value).toBe("quest:quest-one");
+    expect(f.app.captureCharFrame()).not.toContain("Test captain");
+    f.app.mockInput.pressEnter();
+    await f.app.renderOnce();
+    expect(f.routes).toEqual([{ type: "plugin", name: "daily-quests", data: { sessionID: "coding-session", questID: "quest-one" } }]);
+  } finally { f.app.renderer.destroy(); }
+});
+
+test("switching modes preserves the Voyages scroll position at a short terminal height", async () => {
+  const f = await fixture({ height: 12 });
+  try {
+    const scroll = f.scroll();
+    scroll.scrollBy(5);
+    await f.app.renderOnce();
+    const before = scroll.scrollTop;
+    expect(before).toBeGreaterThan(0);
+    f.setActive(false);
+    await f.settle();
+    f.setActive(true);
+    await f.settle();
+    expect(f.scroll()).toBe(scroll);
+    expect(scroll.scrollTop).toBe(before);
+    expect(f.routes).toHaveLength(0);
+  } finally { f.app.renderer.destroy(); }
+});
+
+test("slow summary reads preserve scrolled position after an intervening loading layout", async () => {
+  const f = await fixture({ height: 12 });
+  try {
+    const scroll = f.scroll();
+    scroll.scrollTo(100);
+    await f.app.renderOnce();
+    const before = scroll.scrollTop;
+    expect(before).toBeGreaterThan(0);
+    f.setActive(false);
+    await f.app.renderOnce();
+    const gate = Promise.withResolvers<void>();
+    f.delay(gate.promise);
+    f.setActive(true);
+    await f.app.renderOnce();
+    expect(f.app.captureCharFrame()).not.toContain("Test captain");
+    expect(f.calls).toEqual(["profile", "daily", "profile", "daily"]);
+    gate.resolve();
+    await f.settle();
+    await f.app.renderOnce();
+    expect(scroll.scrollTop).toBe(before);
+  } finally { f.app.renderer.destroy(); }
+});
+
+test("short terminal keyboard navigation keeps the highlighted action on screen", async () => {
+  const f = await fixture({ height: 12 });
+  try {
+    await f.focus();
+    for (let index = 0; index < 7; index++) {
+      f.app.mockInput.pressArrow("down");
+      await f.app.renderOnce();
+    }
+    expect(f.list().getSelectedOption()?.value).toBe("back");
+    expect(f.app.captureCharFrame()).toContain("Return to coding");
+    expect(f.list().height).toBeLessThanOrEqual(f.scroll().viewport.height);
+    expect(f.routes).toHaveLength(0);
+  } finally { f.app.renderer.destroy(); }
+});
+
+test("mouse press focuses the rail and release opens the clicked row without acting through a modal", async () => {
+  const f = await fixture();
+  try {
+    const row = f.app.captureCharFrame().split("\n").findIndex((line) => line.includes("Daily coding quests"));
+    expect(row).toBeGreaterThanOrEqual(0);
+    for (const mode of ["modal", "palette"]) {
+      f.setMode(mode);
+      await f.app.renderOnce();
+      await f.app.mockMouse.click(5, row);
+      await f.app.renderOnce();
+      expect(f.mode()).toBe(mode);
+      expect(f.routes).toHaveLength(0);
+    }
+    f.setMode("base");
+    f.app.renderer.clearSelection();
+    await f.app.renderOnce();
+    await f.app.mockMouse.pressDown(5, row);
+    await f.app.renderOnce();
+    expect(f.mode()).toBe("navigation");
+    expect(f.app.renderer.currentFocusedRenderable).toBeInstanceOf(SelectRenderable);
+    expect(f.routes).toHaveLength(0);
+    await f.app.mockMouse.release(5, row);
+    await f.app.renderOnce();
+    expect(f.routes).toEqual([{ type: "plugin", name: "daily-quests", data: { sessionID: "coding-session" } }]);
+    expect(f.mode()).toBe("base");
+    const questRow = f.app.captureCharFrame().split("\n").findIndex((line) => line.includes("Review a change"));
+    expect(questRow).toBeGreaterThanOrEqual(0);
+    await f.app.mockMouse.click(5, questRow);
+    await f.app.renderOnce();
+    expect(f.routes).toEqual([
+      { type: "plugin", name: "daily-quests", data: { sessionID: "coding-session" } },
+      { type: "plugin", name: "daily-quests", data: { sessionID: "coding-session", questID: "quest-two" } },
+    ]);
+  } finally { f.app.renderer.destroy(); }
+});
+
+test("signed-out account and invalidation hide protected summaries, reset stale selection, and stay read-only", async () => {
+  const f = await fixture({ authenticated: false });
+  try {
+    expect(f.app.captureCharFrame()).toContain("authentication_required");
+    expect(f.app.captureCharFrame()).not.toContain("Test captain");
+    await f.focus();
+    f.app.mockInput.pressArrow("down");
+    await f.app.renderOnce();
+    f.event("credential.updated");
+    await f.settle();
+    expect(f.list().getSelectedOption()?.value).toBe("daily");
+    expect(f.routes).toHaveLength(0);
+    expect(f.calls).toEqual(["profile", "daily", "profile", "daily"]);
+  } finally { f.app.renderer.destroy(); }
+});
+
+test.each(["coding-session", undefined])("return to coding explicitly navigates to the selected session or Home (%s)", async (sessionID) => {
+  const f = await fixture();
+  try {
+    f.setSessionID(sessionID);
+    await f.focus();
+    const list = f.list();
+    const index = list.options.findIndex((option) => option.value === "back");
+    list.setSelectedIndex(index);
+    f.app.mockInput.pressEnter();
+    await f.app.renderOnce();
+    expect(f.selected).toEqual(["projects"]);
+    expect(f.routes).toEqual([sessionID ? { type: "session", sessionID } : { type: "home" }]);
+  } finally { f.app.renderer.destroy(); }
+});

package/plugins/carthagent/themes/carthage.json

@@ -0,0 +1,67 @@
+{
+  "$schema": "https://opencode.ai/theme.json",
+  "base": {
+    "categorical": ["accent", "purple", "cyan", "green", "blue"],
+    "text": {
+      "base": "$hue.neutral.100",
+      "muted": "$hue.neutral.300",
+      "faint": "$hue.neutral.400",
+      "action": {
+        "primary": { "base": "$hue.purple.400", "$hovered": "$hue.purple.300", "$pressed": "$hue.purple.500" },
+        "secondary": { "base": "$hue.neutral.200", "$hovered": "$hue.yellow.400" },
+        "destructive": { "base": "$hue.red.300", "$hovered": "$hue.red.200" }
+      },
+      "formfield": { "base": "$hue.neutral.100", "$focused": "$hue.yellow.400" },
+      "feedback": {
+        "info": { "base": "$hue.cyan.300", "muted": "$hue.cyan.500" },
+        "success": { "base": "$hue.green.300", "muted": "$hue.green.500" },
+        "warning": { "base": "$hue.yellow.300", "muted": "$hue.yellow.500" },
+        "error": { "base": "$hue.red.300", "muted": "$hue.red.500" }
+      }
+    },
+    "background": {
+      "base": "$hue.neutral.900",
+      "raised": { "base": "$hue.neutral.800", "high": "$hue.neutral.700", "max": "$hue.neutral.600" },
+      "action": {
+        "primary": { "base": "$hue.yellow.400", "$hovered": "$hue.yellow.300", "$pressed": "$hue.yellow.500" },
+        "secondary": { "base": "$hue.neutral.800", "$hovered": "$hue.neutral.700" },
+        "destructive": { "base": "$hue.red.700", "$hovered": "$hue.red.600" }
+      },
+      "formfield": { "base": "$hue.neutral.900", "$focused": "$hue.neutral.800" },
+      "feedback": {
+        "info": { "base": "$hue.blue.800" }, "success": { "base": "$hue.green.800" },
+        "warning": { "base": "$hue.orange.800" }, "error": { "base": "$hue.red.800" }
+      }
+    },
+    "border": { "base": "$hue.neutral.600" },
+    "scrollbar": { "base": "$hue.neutral.600" },
+    "diff": {
+      "text": { "added": "$hue.green.300", "removed": "$hue.red.300", "context": "$hue.neutral.300", "hunkHeader": "$hue.cyan.300" },
+      "background": { "added": "$hue.green.800", "removed": "$hue.red.800", "context": "$hue.neutral.800" },
+      "highlight": { "added": "$hue.green.700", "removed": "$hue.red.700" },
+      "lineNumber": { "text": "$hue.neutral.400", "background": { "added": "$hue.green.900", "removed": "$hue.red.900" } }
+    },
+    "syntax": {
+      "comment": "$hue.neutral.400", "keyword": "$hue.purple.300", "function": "$hue.yellow.300", "variable": "$hue.neutral.100",
+      "string": "$hue.green.300", "number": "$hue.orange.300", "type": "$hue.cyan.300", "operator": "$hue.purple.300", "punctuation": "$hue.neutral.300"
+    },
+    "markdown": {
+      "text": "$hue.neutral.100", "heading": "$hue.yellow.300", "link": "$hue.cyan.300", "linkText": "$hue.cyan.300", "code": "$hue.green.300",
+      "blockQuote": "$hue.neutral.300", "emphasis": "$hue.orange.300", "strong": "$hue.yellow.300", "horizontalRule": "$hue.neutral.500",
+      "listItem": "$hue.yellow.400", "listEnumeration": "$hue.yellow.400", "image": "$hue.purple.300", "imageText": "$hue.neutral.300", "codeBlock": "$hue.neutral.100"
+    }
+  },
+  "dark": {
+    "hue": {
+      "gray": { "100": "#f4eef5", "200": "#d8cbdc", "300": "#c0b3ca", "400": "#9a8ca6", "500": "#705e7a", "600": "#49364f", "700": "#35243d", "800": "#271733", "900": "#160e20" },
+      "red": { "100": "#f6d4dd", "200": "#e8a9ba", "300": "#d58ca2", "400": "#b8758d", "500": "#9c5a73", "600": "#713e55", "700": "#512a40", "800": "#351a2d", "900": "#21101d" },
+      "orange": { "100": "#ffead3", "200": "#f8d8b3", "300": "#eec28b", "400": "#d5af66", "500": "#ad8b50", "600": "#80673e", "700": "#5d4a32", "800": "#3b2e28", "900": "#241c21" },
+      "yellow": { "100": "#fff4d8", "200": "#f5dca9", "300": "#e6c480", "400": "#d5af66", "500": "#b18c4e", "600": "#84683d", "700": "#604a30", "800": "#3e3026", "900": "#251d20" },
+      "green": { "100": "#d9f2df", "200": "#b1e2bd", "300": "#83c996", "400": "#62ad78", "500": "#46885e", "600": "#35684a", "700": "#284d39", "800": "#1e382b", "900": "#17251e" },
+      "cyan": { "100": "#d5f2f3", "200": "#a9e0e2", "300": "#83c8ce", "400": "#62aab5", "500": "#4a8997", "600": "#396874", "700": "#2c4c58", "800": "#203640", "900": "#17242b" },
+      "blue": { "100": "#dce9fb", "200": "#b9d0f0", "300": "#91b2df", "400": "#7193c6", "500": "#5876a4", "600": "#445b7e", "700": "#34445d", "800": "#263342", "900": "#1a222d" },
+      "purple": { "100": "#f0e2f5", "200": "#ddc0e7", "300": "#c99bd7", "400": "#ad7abe", "500": "#895f99", "600": "#694878", "700": "#4d365b", "800": "#352440", "900": "#211629" },
+      "accent": "$hue.yellow", "interactive": "$hue.yellow", "neutral": "$hue.gray"
+    }
+  }
+}

package/plugins/carthagent/tui.ts

@@ -1 +1,26 @@
-export { default } from './src/bootstrap';
+import { Plugin } from '@opencode/plugin/tui';
+import diagnostics from './src/bootstrap';
+import workspace from './src/tui';
+
+export default Plugin.define({
+  id: 'carthagent.tui',
+  async setup(context) {
+    const cleanups: Plugin.Cleanup[] = [];
+    const dispose = async () => {
+      const results = await Promise.allSettled(cleanups.splice(0).reverse().map((cleanup) => Promise.resolve().then(cleanup)));
+      const failures = results.filter((result): result is PromiseRejectedResult => result.status === 'rejected');
+      if (failures.length) throw new AggregateError(failures.map((result) => result.reason), 'Carthagent terminal cleanup failed');
+    };
+    try {
+      for (const definition of [diagnostics, workspace]) {
+        const cleanup = await definition.setup(context);
+        if (cleanup) cleanups.push(cleanup);
+      }
+      return dispose;
+    } catch (error) {
+      try { await dispose(); }
+      catch (cleanupError) { throw new AggregateError([error, cleanupError], 'Carthagent terminal setup failed'); }
+      throw error;
+    }
+  },
+});