carthagent 1.0.7 → 1.1.0-beta.1

package/docs/opencode-runtime.md

@@ -5,8 +5,20 @@ CTG runs the package-owned native OpenCode v2.0.32 CLI from the pinned
 user installation. An explicitly supplied `CTG_OPENCODE_BIN` is accepted only
 when its version is exactly 2.0.32.
 
+Runtime identity records the concrete executable path and SHA-256, including
+when an explicit bare command is resolved through the supplied `PATH`. A
+healthy process registered to a different runtime remains untouched and blocks
+selection changes. A dead registration, including a legacy record without an
+identity, is removed only after its PID is confirmed dead, so it cannot
+permanently prevent startup.
+
 ## Isolation and persistence
 
+An additional separately distributed pinned source variant is documented in
+[`opencode-owned-runtime.md`](./opencode-owned-runtime.md). It is opt-in via
+`CTG_OWNED_OPENCODE_RUNTIME`; unset behavior remains the package-owned
+`@opencode/cli@2.0.32` runtime described here.
+
 The default CTG profile is `~/.carthagent/opencode`. `CTG_OPENCODE_HOME` (or a
 `root` argument in the runtime API) can select another profile. CTG applies
 private `XDG_CONFIG_HOME`, `XDG_DATA_HOME`, `XDG_STATE_HOME`, and

package/docs/opencode-theme-provider-proof/README.md

@@ -0,0 +1,55 @@
+# Live plugin theme provider proof
+
+This focused integration test closes a boundary left open by
+`plugin-theme.test.tsx` in the approved live-theme API patch: those unit tests
+mock `host.themes`, while this proof mounts the real Solid `ThemeProvider` and
+`ConfigProvider` and passes the actual provider service to `createPluginContext`.
+
+## Reproduction
+
+Start from upstream OpenCode
+`843a6c514e606b436a7fe713422ace0a93ad3d61` (v2.0.32), apply
+`session-ui-base.patch` followed by `live-theme-api-base.patch`, then apply
+`plugin-theme-provider.patch`. Then run:
+
+```sh
+bun --cwd packages/tui test test/plugin-theme-provider.test.tsx
+```
+
+The test provides dual-mode and dark-only custom theme documents in memory via
+the real provider theme source. It verifies the plugin API reports the selected
+theme and resolved mode, rendered provider tokens change reactively without a
+provider remount, and successful changes update the settings object through the
+injected in-memory `ConfigProvider` service. This proves the config update call
+and in-process state, not filesystem persistence or survival across a restart.
+Unknown theme names and unsupported explicit modes return `false` without
+changing the selection, mode, tokens, or settings object. Omitting a mode for a
+dark-only theme selects the actual dark fallback and updates the selected name
+in the in-memory config service.
+
+No external provider or network is used; both the theme documents and config
+service are test-local. No host API changes beyond the approved patch are made.
+
+## Validation
+
+Run against the exact upstream base plus the two approved patch files, with Bun
+1.4.2:
+
+All five consecutive reruns passed (each **1 pass, 0 fail, 18 expectations**).
+
+The test-only source patch is `plugin-theme-provider.patch`.
+
+## Independently verified patch digests
+
+SHA-256 digests for the exact patch inputs used in the independent review:
+
+| Patch | SHA-256 |
+| --- | --- |
+| `session-ui-base.patch` (base patch) | `36379e0bf4ec0f63929c12b5ac96dfc73df60b124cef9f4adeb36d86287bc92f` |
+| `live-theme-api-base.patch` | `0bcb1462688c00a09564e9874c3e01429baf92fe004bfc6400704fb24133c123` |
+| `plugin-theme-provider.patch` (test-only patch) | `1afe7901f43261ed1ffa324b1dcf3a317404ecd2175956a1513ca29139427714` |
+
+`bun typecheck` from `packages/tui` also passed. The isolated source checkout's
+Git common directory was removed by an environment restart, but its source tree
+and test remain at `/tmp/opencode/ctg-live-theme-proof-clean` for evidence. The
+test was rerun after a fresh frozen-lockfile install and passed.

package/docs/opencode-theme-provider-proof/live-theme-api-base.patch

@@ -0,0 +1,122 @@
+diff --git a/packages/plugin/src/tui/context.ts b/packages/plugin/src/tui/context.ts
+index fe641b3..21ec351 100644
+--- a/packages/plugin/src/tui/context.ts
++++ b/packages/plugin/src/tui/context.ts
+@@ -490,6 +490,13 @@ export interface Keymap {
+ export interface UI {
+   readonly dialog: Dialog
+   readonly toast: Toast
++  /** Live host theme controls. Theme files must already be available to the host. */
++  readonly theme: {
++    /** Returns the selected theme name and active color mode. */
++    current(): { readonly name: string; readonly mode: "dark" | "light" }
++    /** Switches the live theme and optionally locks its color mode; returns false if either is unavailable. */
++    set(selection: { readonly name: string; readonly mode?: "dark" | "light" }): boolean
++  }
+   readonly format: {
+     path(value: string): string
+   }
+diff --git a/packages/tui/src/context/theme.tsx b/packages/tui/src/context/theme.tsx
+index ed568e6..2d7d363 100644
+--- a/packages/tui/src/context/theme.tsx
++++ b/packages/tui/src/context/theme.tsx
+@@ -94,6 +94,7 @@ type Themes = {
+   mode: Accessor<"dark" | "light">
+   modes: Accessor<readonly ("dark" | "light")[]>
+   supports(mode: "dark" | "light"): boolean
++  supportsThemeMode(theme: string, mode: "dark" | "light"): boolean
+   locked: Accessor<boolean>
+   lock(): void
+   unlock(): void
+@@ -329,6 +330,10 @@ const themeContext = createSimpleContext({
+       mode,
+       modes,
+       supports: (requested) => modes().includes(requested),
++      supportsThemeMode: (theme, requested) => {
++        const source = available()[theme]
++        return source !== undefined && themeModes(parseTheme(source, theme)).includes(requested)
++      },
+       locked: () => store.lock !== undefined,
+       lock: () => pin(mode()),
+       unlock: free,
+diff --git a/packages/tui/src/plugin/api.tsx b/packages/tui/src/plugin/api.tsx
+index 35a4eac..4150ba9 100644
+--- a/packages/tui/src/plugin/api.tsx
++++ b/packages/tui/src/plugin/api.tsx
+@@ -204,6 +204,16 @@ export function createPluginContext(input: {
+     ui: {
+       dialog: dialogApi,
+       toast: toastApi,
++      theme: {
++        current: () => ({ name: host.themes.selected, mode: host.themes.mode() }),
++        set(selection) {
++          if (!selection || typeof selection.name !== "string" || !host.themes.has(selection.name)) return false
++          if (selection.mode !== undefined && !host.themes.supportsThemeMode(selection.name, selection.mode)) return false
++          if (!host.themes.set(selection.name)) return false
++          if (selection.mode !== undefined) host.themes.setMode(selection.mode)
++          return true
++        },
++      },
+       format: {
+         path: (value) => abbreviateHome(value, host.paths.home),
+       },
+diff --git a/packages/tui/test/plugin-theme.test.tsx b/packages/tui/test/plugin-theme.test.tsx
+new file mode 100644
+index 0000000..9a46b4d
+--- /dev/null
++++ b/packages/tui/test/plugin-theme.test.tsx
+@@ -0,0 +1,54 @@
++import { expect, test } from "bun:test"
++import { createPluginContext, type Registry, type usePluginHost } from "../src/plugin/api"
++
++function setup() {
++  let selected = "opencode"
++  let mode: "dark" | "light" = "dark"
++  const available = new Set(["opencode", "custom"])
++  const host = {
++    app: {},
++    client: {},
++    keymap: {},
++    shortcuts: {},
++    keymapState: {},
++    sessionTabs: {},
++    themes: {
++      get selected() {
++        return selected
++      },
++      mode: () => mode,
++      has: (name: string) => available.has(name),
++      supportsThemeMode: (name: string, requested: "dark" | "light") => requested === "dark" || name === "custom",
++      set(name: string) {
++        if (!available.has(name)) return false
++        selected = name
++        return true
++      },
++      setMode(requested: "dark" | "light") {
++        mode = requested
++        return true
++      },
++    },
++  } as unknown as ReturnType<typeof usePluginHost>
++  const registry: Registry = { has: () => false, set() {}, remove() {}, active: () => true }
++  const theme = createPluginContext({ host, id: "test", options: undefined, owned: [], registry }).ui.theme
++  return { theme, current: () => ({ selected, mode }) }
++}
++
++test("plugin theme setter applies available theme and mode live through the host service", () => {
++  const harness = setup()
++  expect(harness.theme.current()).toEqual({ name: "opencode", mode: "dark" })
++  expect(harness.theme.set({ name: "custom", mode: "light" })).toBe(true)
++  expect(harness.theme.current()).toEqual({ name: "custom", mode: "light" })
++  expect(harness.current()).toEqual({ selected: "custom", mode: "light" })
++})
++
++test("plugin theme setter rejects unknown themes and unsupported modes without partial changes", () => {
++  const harness = setup()
++  expect(harness.theme.set({ name: "missing", mode: "dark" })).toBe(false)
++  expect(harness.theme.set({ name: "custom", mode: "light" })).toBe(true)
++  expect(harness.theme.set({ name: "opencode", mode: "light" })).toBe(false)
++  expect(harness.theme.current()).toEqual({ name: "custom", mode: "light" })
++  expect(harness.theme.set({ name: "opencode" })).toBe(true)
++  expect(harness.theme.current()).toEqual({ name: "opencode", mode: "light" })
++})

package/docs/opencode-theme-provider-proof/plugin-theme-provider.patch

@@ -0,0 +1,107 @@
+--- a/packages/tui/test/plugin-theme-provider.test.tsx
++++ b/packages/tui/test/plugin-theme-provider.test.tsx
+@@ -0,0 +1,104 @@
++/** @jsxImportSource @opentui/solid */
++import { testRender } from "@opentui/solid"
++import { expect, test } from "bun:test"
++import { ConfigProvider, type Info } from "../src/config"
++import { ThemeProvider, useThemes } from "../src/context/theme"
++import { createPluginContext, type Registry, type usePluginHost } from "../src/plugin/api"
++import opencode from "../src/theme/assets/v2/opencode.json" with { type: "json" }
++import { emptyThemeSource, tmpdir } from "./fixture/fixture"
++import { TestTuiContexts } from "./fixture/tui-environment"
++import { createTuiResolvedConfig } from "./fixture/tui-runtime"
++
++const custom = {
++  ...opencode,
++  base: {
++    ...opencode.base,
++    background: { ...opencode.base.background, base: "#aabbcc" },
++    text: { ...opencode.base.text, base: "#123456" },
++  },
++  dark: { hue: opencode.dark.hue },
++  light: { hue: opencode.dark.hue },
++}
++const darkOnly = {
++  ...custom,
++  base: {
++    ...custom.base,
++    background: { ...custom.base.background, base: "#334455" },
++  },
++  light: undefined,
++}
++
++test("plugin theme API reactively updates real ThemeProvider palette and persists selection", async () => {
++  await using temporary = await tmpdir()
++  const settings: Info = {}
++  let themes!: ReturnType<typeof useThemes>
++  let plugin!: ReturnType<typeof createPluginContext>
++  const app = await testRender(() => (
++    <TestTuiContexts paths={{ state: temporary.path }}>
++      <ConfigProvider
++        config={createTuiResolvedConfig(settings)}
++        service={{
++          get: async () => settings,
++          update: async (update) => {
++            update(settings)
++            return settings
++          },
++        }}
++      >
++        <ThemeProvider
++          mode="dark"
++          source={{
++            ...emptyThemeSource,
++            discover: async () => ({ "fixture-live": custom, "fixture-dark-only": darkOnly }),
++          }}
++        >
++          <Probe />
++        </ThemeProvider>
++      </ConfigProvider>
++    </TestTuiContexts>
++  ))
++
++  function Probe() {
++    themes = useThemes()
++    const host = {
++      app: {}, client: {}, keymap: {}, shortcuts: {}, keymapState: {}, sessionTabs: {},
++      themes,
++    } as unknown as ReturnType<typeof usePluginHost>
++    const registry: Registry = { has: () => false, set() {}, remove() {}, active: () => true }
++    plugin = createPluginContext({ host, id: "fixture", options: undefined, owned: [], registry })
++    return <text>{`${plugin.ui.theme.current().name} ${plugin.ui.theme.current().mode} ${plugin.theme.background.base} ${plugin.theme.text.base}`}</text>
++  }
++
++  try {
++    app.renderer.start()
++    await app.waitForFrame(() => themes?.ready)
++    await app.waitForFrame((frame) => frame.includes("opencode dark"))
++    expect(plugin.ui.theme.current()).toEqual({ name: "opencode", mode: "dark" })
++
++    expect(plugin.ui.theme.set({ name: "fixture-live", mode: "light" })).toBe(true)
++    await app.waitForFrame((frame) => frame.includes("fixture-live light"))
++    expect(plugin.ui.theme.current()).toEqual({ name: "fixture-live", mode: "light" })
++    expect(settings.theme).toEqual({ name: "fixture-live", mode: "light" })
++    expect(plugin.theme.background.base.toInts()).toEqual([170, 187, 204, 255])
++    expect(plugin.theme.text.base.toInts()).toEqual([18, 52, 86, 255])
++
++    const before = structuredClone(settings.theme)
++    expect(plugin.ui.theme.set({ name: "missing-theme", mode: "dark" })).toBe(false)
++    expect(plugin.ui.theme.set({ name: "fixture-dark-only", mode: "light" })).toBe(false)
++    expect(plugin.ui.theme.current()).toEqual({ name: "fixture-live", mode: "light" })
++    expect(settings.theme).toEqual(before)
++    expect(plugin.ui.theme.set({ name: "fixture-dark-only" })).toBe(true)
++    await app.waitForFrame((frame) => frame.includes("fixture-dark-only dark"))
++    expect(plugin.theme.background.base.toInts()).toEqual([51, 68, 85, 255])
++    expect(plugin.ui.theme.current()).toEqual({ name: "fixture-dark-only", mode: "dark" })
++    expect(settings.theme).toEqual({ name: "fixture-dark-only", mode: "light" })
++    const afterFallback = structuredClone(settings.theme)
++    expect(plugin.ui.theme.set({ name: "fixture-live", mode: "invalid" as "dark" })).toBe(false)
++    await Bun.sleep(20)
++    expect(plugin.ui.theme.current()).toEqual({ name: "fixture-dark-only", mode: "dark" })
++    expect(settings.theme).toEqual(afterFallback)
++    expect(before).toEqual({ name: "fixture-live", mode: "light" })
++  } finally {
++    app.renderer.destroy()
++  }
++})