carthagent 1.0.7 → 1.1.0-beta.2

package/plugins/carthagent/src/ui/daily-quests.tsx

@@ -0,0 +1,235 @@
+/** @jsxImportSource @opentui/solid */
+import { For, Show, createEffect, createSignal, on, onCleanup, onMount } from "solid-js";
+import { createHash, randomUUID } from "node:crypto";
+import type { ScrollBoxRenderable, SelectRenderable, TextareaRenderable } from "@opentui/core";
+import { usePlugin } from "@opencode/plugin/tui";
+import { clickSelect } from "./select-mouse.js";
+import { dailyQuestsClient, dailySourceClient } from "./client.js";
+import type { DailyEvidence, DailyQuestDetail, DailySnapshot, DailySubmission, DailyRecord } from "../daily-quests-rpc.js";
+import type { DailySourceReport } from "../daily-source-rpc.js";
+import { createDailyQuestsState, dailySubmissionLabel } from "./daily-quests-state.mjs";
+import { handleDailyQuestsEvent } from "./daily-quests-events.mjs";
+import { syncDailyEditor } from "./daily-editor.mjs";
+import { createDailyEditorFocus } from "./daily-editor-focus.mjs";
+
+type Request = NonNullable<DailyRecord['request']>;
+type View = {
+  snapshot?: DailySnapshot; detail?: DailyQuestDetail; busy: boolean; error: string;
+  draft?: { accountKey: string; questId: string; id: string; text: string; provenance: string };
+  preview?: Request; phase: "overview" | "edit" | "preview";
+};
+
+/** Stable opaque references, not proof of authorship. Never send a local path. */
+function reference(...parts: string[]) {
+  const h = createHash("sha256").update(JSON.stringify(parts)).digest("hex");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+}
+
+const privacy = "Only the exact preview below is sent to Carthagent. External JEV receives the revision, goal, change, checks, findings and server rubric, not project/outcome/run IDs. No transcript or whole project is uploaded. Review and remove secrets yourself; automatic secret detection is not provided.\n\nBackend raw evidence: pending up to 24 hours, erased on terminal processing (outages can delay cleanup). Metadata: 90 days. Provider policy applies; immediate provider/backup deletion is not promised. Unknown-send recovery stores this exact payload in a private local journal until acceptance is known or for up to 24 hours on the next journal access, not a background deletion timer. You can erase its local payload while retaining the submission ID.\n\nClassifier assessment is not independent verification. No coins, XP, distance, inventory or other rewards. Signing in or running Ship is not consent.";
+
+export function DailyQuestsPage(props: { sessionID?: string; questID?: string }) {
+  const context = usePlugin();
+  const location = () => (props.sessionID ? context.data.session.get(props.sessionID)?.location : undefined) ?? context.location ?? context.data.location.default();
+  const [view, setView] = createSignal<View>({ busy: false, error: "", phase: "overview" });
+  const [editorFocus, setEditorFocus] = createSignal(true);
+  const [replayID, setReplayID] = createSignal<string>();
+  const [cancellationNotice, setCancellationNotice] = createSignal("");
+  const controller = createDailyQuestsState({ api: dailyQuestsClient(context, location), changed: (next: View) => setView(next) });
+  const sourceApi = dailySourceClient(context, location);
+  let summary: ScrollBoxRenderable | undefined;
+  let editor: TextareaRenderable | undefined;
+  let actions: SelectRenderable | undefined;
+  const focus = createDailyEditorFocus({
+    state: () => ({ phase: view().phase, hasDraft: !!view().draft, busy: view().busy, editorFocus: editorFocus(), mode: context.keymap.mode.current() }),
+    editor: () => editor,
+  });
+  createEffect(() => focus.reconcile());
+  const preview = () => { if (view().phase === "edit") syncDailyEditor(editor, controller); controller.preview(); };
+  let activeDialog: symbol | undefined;
+  const ownDialog = async <T,>(show: () => Promise<T>): Promise<T> => {
+    const token = Symbol(); activeDialog = token;
+    try { return await show(); } finally { if (activeDialog === token) activeDialog = undefined; }
+  };
+  const closeOwnDialog = () => {
+    if (!activeDialog) return;
+    activeDialog = undefined;
+    context.ui.dialog.clear();
+  };
+  const confirm = (title: string, message: string, label: string) => ownDialog(() => context.ui.dialog.confirm({ title, message, label: { confirm: label, cancel: "Cancel" } }));
+  context.keymap.layer(() => ({ commands: [
+    { bind: "ctrl+u", title: "Scroll daily quest preview up", run: () => { summary?.scrollBy(-1); } },
+    { bind: "ctrl+d", title: "Scroll daily quest preview down", run: () => { summary?.scrollBy(1); } },
+    { bind: "ctrl+g", title: "Validate daily evidence preview", enabled: () => view().phase === "edit" && !view().busy, run: preview },
+    { bind: "tab", title: "Switch evidence editor / actions", enabled: () => view().phase === "edit" && !view().busy, run: () => { setEditorFocus((focused) => !focused); } },
+  ] }));
+
+  const chooseProjection = async (source: DailySourceReport, sessionID: string, live: () => boolean): Promise<DailyEvidence | undefined> => {
+    let goal = false, change = false;
+    const checks = new Set<string>(), findings = new Set<string>();
+    while (live()) {
+      const selected = await ownDialog(() => context.ui.dialog.select({
+        title: "Select local evidence · nothing included by default",
+        options: [
+          { title: "Done selecting", value: "done", description: "Open editable JSON; nothing is sent yet" },
+          { title: `${goal ? "Remove" : "Include"} recorded goal`, value: "goal", description: "May contain private task text" },
+          { title: `${change ? "Remove" : "Include"} recorded change`, value: "change", description: source.change ? "Recorded claim, not independently verified" : "Not recorded; remains empty" },
+          ...source.checks.map((c) => ({ title: `${checks.has(c.id) ? "Remove" : "Include"} check ${c.id}`, value: `check:${c.id}`, description: `${c.after} · ${c.after === "passed" ? "fresh" : "not fresh"} · includes output tail, potentially sensitive; before not recorded` })),
+          ...source.findings.map((f) => ({ title: `${findings.has(f.id) ? "Remove" : "Include"} finding ${f.id}`, value: `finding:${f.id}`, description: "Includes issue, evidence and resolution text; model/user-authored claim" })),
+        ],
+      }));
+      if (!live() || selected === undefined) return;
+      if (selected === "done") break;
+      if (selected === "goal") goal = !goal;
+      else if (selected === "change") change = !change;
+      else {
+        const isCheck = selected.startsWith("check:");
+        const id = selected.slice(isCheck ? 6 : 8), set = isCheck ? checks : findings;
+        if (set.has(id)) set.delete(id); else set.add(id);
+      }
+    }
+    if (!live()) return;
+    const session = context.data.session.get(sessionID);
+    const project = reference("daily-project-v1", session?.projectID ?? location().directory);
+    return {
+      projectId: project, outcomeId: reference("daily-outcome-v1", project, source.runId), runId: source.runId,
+      revision: source.revision, goal: goal ? source.goal : "", change: change ? source.change : "",
+      checks: source.checks.filter((c) => checks.has(c.id)).map(({ id, before, after, revision, result }) => ({ name: id, before, after, revision, result })),
+      findings: source.findings.filter((f) => findings.has(f.id)).map(({ issue, evidence, resolution }) => ({ issue, evidence, resolution })),
+    };
+  };
+
+  const compose = () => controller.compose(async (_quest: DailyQuestDetail, live: () => boolean, signal: AbortSignal) => {
+    const kind = await ownDialog(() => context.ui.dialog.select({ title: "Choose evidence source", options: [
+      { title: "Select actual local Ship report", value: "local", description: "Owned session only; choose individual checks/findings, no transcript" },
+      { title: "Write a structured manual claim", value: "manual", description: "Blank evidence, not a claim that checks ran; edit every field" },
+    ] }));
+    if (!kind || !live()) return;
+    if (kind === "manual") {
+      const project = reference("daily-project-v1", props.sessionID ? context.data.session.get(props.sessionID)?.projectID ?? location().directory : location().directory);
+      return { id: randomUUID(), evidence: { projectId: project, outcomeId: randomUUID(), runId: randomUUID(), revision: "", goal: "", change: "", checks: [], findings: [] }, provenance: "Manual user claim. Enter a genuine 40/64-hex revision. Empty evidence does not establish completion. Keep project/outcome/run IDs when revising the same outcome; they do not prove authorship." };
+    }
+    const sessions = context.data.session.list().filter((s) => s.location.directory === location().directory);
+    const sessionID = props.sessionID ?? await ownDialog(() => context.ui.dialog.select({ title: "Choose local Ship session", options: sessions.map((s) => ({ title: s.title ?? s.id, value: s.id, description: s.id })) }));
+    if (!sessionID || !live()) return;
+    const { source } = await sourceApi.report({ sessionID }, AbortSignal.any([signal, AbortSignal.timeout(15_000)]));
+    if (!live()) return;
+    if (!source) throw new Error("daily_source_unavailable");
+    const evidence = await chooseProjection(source, sessionID, live);
+    if (!evidence || !live()) return;
+    return { id: randomUUID(), evidence, provenance: `Local Ship session ${sessionID} · run ${source.runId} · plan revision ${source.planRevision} · ${source.freshness}. Source revision is the actual workspace fingerprint, not the plan revision. Earlier failed-before execution is not recorded and is never inferred. Selected text is editable and remains a user claim, not independent verification.${source.truncated ? " Source projection is truncated; inspect and correct missing details before submitting." : ""}` };
+  });
+
+  const submit = () => controller.submit(({ quest, request }: { quest: DailyQuestDetail; request: Request }) => confirm(
+    "Explicit consent for this one JEV submission",
+    `${quest.definition.title}\nSubmission ${request.id}\nSend only the exact JSON shown in the scrollable preview to Carthagent for external JEV grading? Review/redact before consent. Raw backend evidence: pending up to 24h, erased on terminal processing; metadata 90d. Outages can delay cleanup. Provider/backup deletion is not guaranteed. No rewards or independent verification.\n\nCancel to review the preview and full retention notice again. This authorizes this submission only.`,
+    "Consent and send",
+  ));
+  const retry = (id: string) => controller.retry(id, (record: DailyRecord) => confirm("Retry the SAME consented submission?", `Submission ${record.id}\nReplay only the exact saved ID/body shown in the scrollable recovery preview to Carthagent/external JEV under the same retention notice? Poll first when possible. This cannot edit evidence or create a replacement ID. Cancel keeps it pending.`, "Replay same request"));
+  const forget = (id: string) => controller.forget(id, (record: DailyRecord) => confirm("Erase local recovery payload?", `Submission ${record.id}\nErase the selected evidence from the local journal. Keep the stable submission/quest IDs for read-only status checks. Exact replay will no longer be possible. This does not cancel a server job, withdraw evidence already sent, or promise provider/backup deletion.`, "Erase local payload"));
+
+  const statusText = (submission: DailySubmission) => `${dailySubmissionLabel(submission)}\nSubmission ${submission.id} · provider attempts ${submission.attempts}/4\nCreated ${submission.createdAt}${submission.nextAttemptAt ? ` · next attempt ${submission.nextAttemptAt}` : ""}${submission.finishedAt ? ` · finished ${submission.finishedAt}` : ""}${submission.errorCode ? `\nProcessing code: ${submission.errorCode}` : ""}${submission.model ? `\nModel ${submission.model} · rubric ${submission.rubricVersion}` : ""}${submission.scores ? `\nUncalibrated rubric scores (not confidence): ${Object.entries(submission.scores).map(([id, score]) => `${id}: ${score}`).join(" · ")}` : ""}`;
+  const options = () => {
+    const state = view(), detail = state.detail;
+    const basic = [
+      { name: "Refresh daily assignments and recovery journal", description: "Read-only; never uploads or replays evidence", value: "refresh" },
+      { name: "Sign in / reconnect", description: "Native Carthagent Cloud device sign-in; not grading consent", value: "signin" },
+      { name: "Back to Voyages", description: "Discard unsent editor contents", value: "back" },
+    ];
+    if (!state.snapshot) return basic;
+    return [...basic,
+      ...(replayID() ? [
+        { name: "Confirm exact saved replay…", description: "Review the scrollable recovery preview first; explicit same-ID replay", value: "confirm-replay" },
+        { name: "Close recovery preview", description: "No replay; keep saved payload", value: "close-replay" },
+      ] : []),
+      ...state.snapshot.slate.items.map((q) => ({ name: `${q.definition.title} · ${q.status}`, description: `${q.definition.kind} · UTC window ends ${q.endsAt}`, value: `quest:${q.id}` })),
+      ...(detail?.status === "open" && !state.draft ? [{ name: "Choose evidence for selected quest", description: "Select local report data or write a manual claim; no upload", value: "compose" }] : []),
+      ...(state.phase === "edit" ? [{ name: "Validate and preview exact payload", description: "Ctrl+G; canonical UTF-8 limits, no network", value: "preview" }] : []),
+      ...(state.phase === "preview" ? [
+        { name: "Consent and submit this preview…", description: "Fresh explicit consent dialog; no automatic acceptance or rewards", value: "submit" },
+        { name: "Edit / redact evidence again", description: "Invalidates the preview; requires validation and fresh consent", value: "edit" },
+      ] : []),
+      ...(state.draft ? [{ name: "Discard unsent evidence", description: "Clear local editor; no submission", value: "cancel" }] : []),
+      ...(detail?.latestSubmission ? [{ name: "Poll selected quest's latest submission", description: "Read-only authoritative status; no provider dispatch", value: `poll:${detail.latestSubmission.id}` }] : []),
+      ...state.snapshot.records.flatMap((r) => [
+        { name: `Poll saved ${r.id}`, description: r.submission ? dailySubmissionLabel(r.submission) : "Outcome unknown; stable ID retained, including previous UTC days", value: `poll:${r.id}` },
+        ...(r.request ? [
+          { name: `Review exact replay ${r.id}`, description: "Saved same ID/body; explicit confirmation, never automatic", value: `retry:${r.id}` },
+          { name: `Erase local payload ${r.id}`, description: "Keep ID for polling; cannot replay afterward", value: `forget:${r.id}` },
+        ] : []),
+      ]),
+    ];
+  };
+  const select = (value?: string) => {
+    // A stale native refocus must not turn editor Enter into an action.
+    if (!value || !focus.actionsEnabled()) return;
+    if (value === "back") { context.ui.router.navigate({ type: "plugin", name: "voyages", data: { ...(props.sessionID ? { sessionID: props.sessionID } : {}) } }); return; }
+    if (value === "signin") { controller.invalidate(); closeOwnDialog(); context.keymap.dispatch("provider.connect"); return; }
+    if (value === "refresh") { setReplayID(undefined); void controller.refresh(); return; }
+    if (value === "compose") { setCancellationNotice(""); setEditorFocus(true); void compose(); return; }
+    if (value === "preview") { preview(); return; }
+    if (value === "submit") { void submit(); return; }
+    if (value === "edit") { setEditorFocus(true); controller.backToEdit(); return; }
+    if (value === "cancel") { controller.cancelDraft(); return; }
+    if (value === "close-replay") { setReplayID(undefined); return; }
+    if (value === "confirm-replay") { const id = replayID(); if (id) { void retry(id).finally(() => setReplayID(undefined)); } return; }
+    const colon = value.indexOf(":"), id = value.slice(colon + 1);
+    if (value.startsWith("quest:")) void controller.select(id);
+    if (value.startsWith("poll:")) void controller.poll(id);
+    if (value.startsWith("retry:")) { setCancellationNotice(""); controller.cancelDraft(); setReplayID(id); }
+    if (value.startsWith("forget:")) void forget(id);
+  };
+  onMount(() => {
+    let binding = JSON.stringify(location());
+    const stop = context.data.listen(({ details }) => {
+      const nextBinding = JSON.stringify(location());
+      const changedLocation = binding !== nextBinding;
+      binding = nextBinding;
+      void handleDailyQuestsEvent({
+        controller, event: details, location: location(), changedLocation, actions,
+        interrupted: !!(view().draft || view().preview || replayID() || activeDialog),
+        clearReplay: () => setReplayID(undefined), closeDialog: closeOwnDialog, notice: setCancellationNotice,
+      });
+    });
+    // A navigator link selects only an assignment in the authenticated slate.
+    // It never composes evidence or opens a consent dialog.
+    void controller.refresh().then(() => { if (props.questID) return controller.select(props.questID); });
+    // The router reuses this page when another rail quest is opened.
+    createEffect(on(() => props.questID, (questID) => { if (questID) void controller.select(questID); }, { defer: true }));
+    onCleanup(() => { focus.dispose(); stop(); actions = undefined; controller.dispose(); closeOwnDialog(); });
+  });
+  return <box flexDirection="column" flexGrow={1} padding={1}>
+    <text flexShrink={0} fg={context.theme.text.action.primary.base}>CARTHAGENT · DAILY CODING QUESTS</text>
+    <scrollbox ref={summary} flexBasis={0} flexGrow={1} minHeight={1} contentOptions={{ flexDirection: "column" }}>
+      <text flexShrink={0} fg={context.theme.text.muted}>Classifier-assessed submitted evidence, not independent verification. No rewards. Refresh/poll never uploads evidence.</text>
+      <Show when={cancellationNotice()}><text flexShrink={0} fg={context.theme.text.feedback.warning.base}>{cancellationNotice()}</text></Show>
+      <Show when={view().busy}><text flexShrink={0} fg={context.theme.text.feedback.warning.base}>Awaiting response / explicit selection or consent. Other actions locked.</text></Show>
+      <Show when={view().error}><text flexShrink={0} fg={context.theme.text.feedback.error.base}>{view().error}</text></Show>
+      <Show when={view().snapshot} fallback={<text flexShrink={0} fg={context.theme.text.muted}>Protected assignments and evidence hidden until successful authentication and refresh.</text>}>{(snapshot) => <box flexDirection="column" flexShrink={0}>
+        <text flexShrink={0} fg={context.theme.text.base}>UTC day {snapshot().slate.day} · closes {snapshot().slate.endsAt} · policy {snapshot().slate.policyVersion}</text>
+        <text flexShrink={0} fg={context.theme.text.muted}>New submissions close at the server's UTC boundary. Accepted jobs can finish afterward. Select a quest below for its actual criteria.</text>
+        <For each={snapshot().records}>{(r) => <text flexShrink={0} fg={context.theme.text.muted}>{r.submission ? statusText(r.submission) : `Outcome unknown / no confirmed acceptance · submission ${r.id} · quest ${r.questId}${r.request ? " · exact replay payload available" : " · payload erased; poll ID only"}`}</text>}</For>
+      </box>}</Show>
+      <Show when={view().detail}>{(detail) => <box flexDirection="column" flexShrink={0}>
+        <text flexShrink={0} fg={context.theme.text.action.primary.base}>{detail().definition.title} · {detail().status}</text>
+        <text flexShrink={0} fg={context.theme.text.muted}>Quest {detail().id} · {detail().definition.kind} · ends {detail().endsAt} · rubric {detail().definition.rubricVersion}</text>
+        <For each={detail().definition.criteria}>{(c) => <text flexShrink={0} fg={context.theme.text.base}>{c.id}: {c.text}</text>}</For>
+        <Show when={detail().latestSubmission}>{(s) => <text flexShrink={0} fg={context.theme.text.base}>{statusText(s())}</text>}</Show>
+      </box>}</Show>
+      <Show when={view().draft}><text flexShrink={0} fg={context.theme.text.muted}>{view().draft?.provenance}</text></Show>
+      <Show when={view().phase === "preview" && view().preview}>
+        <text flexShrink={0} fg={context.theme.text.base}>{privacy}</text>
+        <text flexShrink={0} fg={context.theme.text.base}>{`Exact request for quest ${view().draft?.questId}:\n${JSON.stringify(view().preview, null, 2)}`}</text>
+      </Show>
+      <Show when={view().snapshot?.records.find((r) => r.id === replayID() && r.request)}>{(record) => <box flexDirection="column" flexShrink={0}>
+        <text flexShrink={0} fg={context.theme.text.base}>{privacy}</text>
+        <text flexShrink={0} fg={context.theme.text.base}>{`Exact saved recovery request · quest ${record().questId}:\n${JSON.stringify(record().request, null, 2)}`}</text>
+      </box>}</Show>
+    </scrollbox>
+    <Show when={view().phase === "edit" && view().draft}>
+      <text flexShrink={0} fg={context.theme.text.faint}>Ctrl+J newline · Tab actions · Ctrl+G preview, never sends</text>
+      <textarea ref={editor} flexBasis={0} flexGrow={1} minHeight={2} initialValue={view().draft?.text ?? ""} focused={focus.editorEnabled()} onContentChange={() => syncDailyEditor(editor, controller)} keyBindings={[{ name: "g", ctrl: true, action: "submit" }]} onSubmit={preview} />
+    </Show>
+    <text flexShrink={0} fg={context.theme.text.faint}>↑/↓ Enter · PgUp/Dn · Ctrl+U/D details · Cancel: no send</text>
+    <select ref={(node) => { actions = node; focus.attachActions(node); }} onMouseUp={(event) => { if (focus.actionsEnabled()) clickSelect(actions, event); }} flexBasis={0} flexGrow={1} flexShrink={0} minHeight={3} showScrollIndicator options={options()} focused={focus.actionsEnabled()} keyBindings={[{ name: "pageup", action: "move-up-fast" }, { name: "pagedown", action: "move-down-fast" }]} onSelect={(_index, option) => select(option?.value)} />
+  </box>;
+}

package/plugins/carthagent/src/ui/host-state.ts

@@ -0,0 +1,42 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+export type NativeCliConfig = Record<string, unknown> & { theme?: { name?: string } | string };
+
+/** Resolve OpenCode's native CLI profile config (not CTG's separate user profile). */
+export function cliConfigPath(env = process.env, home = process.env.HOME ?? "") {
+  const configRoot = env.OPENCODE_CONFIG_DIR || join(env.XDG_CONFIG_HOME || join(home, ".config"), "opencode");
+  return join(configRoot, "cli.json");
+}
+
+/** Native TUI themes are discovered from config/opencode/themes for this profile. */
+export function cliConfigDirectory(env = process.env, home = process.env.HOME ?? "") {
+  return env.OPENCODE_CONFIG_DIR || join(env.XDG_CONFIG_HOME || join(home, ".config"), "opencode");
+}
+
+export async function readCliConfig(path: string): Promise<NativeCliConfig> {
+  try {
+    const value: unknown = JSON.parse(await readFile(path, "utf8"));
+    return value && typeof value === "object" && !Array.isArray(value) ? value as NativeCliConfig : {};
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    throw error;
+  }
+}
+
+/** Atomically preserve unrelated native CLI settings while selecting a theme. */
+export async function writeNativeTheme(path: string, name: string) {
+  const config = await readCliConfig(path);
+  config.theme = typeof config.theme === "object" && config.theme !== null
+    ? { ...config.theme, name }
+    : { name };
+  await mkdir(dirname(path), { recursive: true });
+  const temp = `${path}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  try {
+    await writeFile(temp, `${JSON.stringify(config, null, 2)}\n`, { encoding: "utf8", flag: "wx", mode: 0o600 });
+    await rename(temp, path);
+  } catch (error) {
+    await import("node:fs/promises").then(({ rm }) => rm(temp, { force: true })).catch(() => undefined);
+    throw error;
+  }
+}

package/plugins/carthagent/src/ui/model-command.ts

@@ -0,0 +1,32 @@
+type CatalogModel = { providerID: string; modelID: string; id: string; name: string };
+
+export type ModelCommandHost = {
+  sync(): Promise<unknown>;
+  list(): readonly CatalogModel[];
+  select(options: Array<{ title: string; value: CatalogModel; description: string }>): Promise<CatalogModel | undefined>;
+  switchModel(sessionID: string, model: { providerID: string; id: string }): Promise<unknown>;
+  /** Opens the native configured-model picker (the `/models` command) with an optional search. */
+  openNativePicker(query: string): void;
+  providerName(providerID: string): string;
+  toast(message: string, variant: "success" | "warning"): void;
+};
+
+/**
+ * `/model [name]`. Without a session the choice belongs to the next session's draft, which only the native
+ * picker owns, so it is opened directly; inside a session the selection is committed to that session.
+ */
+export async function runModelCommand(host: ModelCommandHost, input: { sessionID?: string; arg: string }) {
+  if (!input.sessionID) {
+    host.openNativePicker(input.arg);
+    return;
+  }
+  await host.sync();
+  const query = input.arg.toLowerCase();
+  const options = host.list()
+    .filter((model) => !query || `${host.providerName(model.providerID)} ${model.providerID}/${model.modelID} ${model.name}`.toLowerCase().includes(query))
+    .map((model) => ({ title: `${host.providerName(model.providerID)}/${model.modelID}`, value: model, description: model.name }));
+  const selected = await host.select(options);
+  if (!selected) return;
+  await host.switchModel(input.sessionID, { providerID: selected.providerID, id: selected.id });
+  host.toast(`Selected ${host.providerName(selected.providerID)}/${selected.modelID}.`, "success");
+}

package/plugins/carthagent/src/ui/native-navigation.ts

@@ -0,0 +1,23 @@
+import type { Context } from "@opencode/plugin/tui/context";
+import type { JSX } from "solid-js";
+
+/** Optional host extension: released runtimes retain slash-command navigation. */
+export type NavigationInput = {
+  readonly width: number;
+  readonly compact: boolean;
+  readonly active: boolean;
+  readonly focused: boolean;
+  readonly sessionID?: string;
+  readonly focus: () => void;
+  readonly blur: () => void;
+};
+
+export type NativeNavigation = {
+  register(pane: { name: string; title: string; render(input: NavigationInput): JSX.Element }): () => void;
+  select(name: string): boolean;
+  current(): string;
+};
+
+export function nativeNavigation(context: Pick<Context, "ui">) {
+  return (context.ui as Context["ui"] & { navigation?: NativeNavigation }).navigation;
+}

package/plugins/carthagent/src/ui/native-review.d.mts

@@ -0,0 +1,33 @@
+export interface NativeReviewOffer {
+  sessionID: string;
+  runKey: string;
+  writes: number;
+  start: () => Promise<boolean>;
+}
+
+export interface NativeReviewConsumerOptions {
+  mode: (sessionID: string) => string;
+  diff: (sessionID: string, signal?: AbortSignal) => Promise<unknown>;
+  offer: (value: NativeReviewOffer) => Promise<unknown>;
+  kickoff: (sessionID: string, signal?: AbortSignal) => Promise<unknown>;
+  /** False or a rejection suppresses the offer (e.g. blocked formal delivery). */
+  eligible?: (sessionID: string, signal?: AbortSignal) => Promise<boolean>;
+  isLoopActive?: (sessionID: string) => boolean;
+  setLoopActive?: (sessionID: string, active: boolean) => void;
+  signal?: AbortSignal;
+}
+
+export function sendNativeReviewKickoff(options: { client: any; sessionID: string; signal?: AbortSignal; prompt?: string }): Promise<void>;
+export function nativeReviewMode(session: any, config: any, explicitMode?: string): string;
+export function createNativeReviewConsumer(options: NativeReviewConsumerOptions): {
+  setLoopActive(sessionID: string, active: boolean): void;
+  onUserPromptAdmitted(sessionID: string, message?: { type?: string; metadata?: Record<string, unknown> }): void;
+  onInboxDelivered(event: any, message?: { type?: string; metadata?: Record<string, unknown> }): void;
+  onStarted(event: any): void;
+  onSucceeded(event: any): Promise<void>;
+  onFailed(event: any): Promise<void>;
+  onInterrupted(event: any): Promise<void>;
+  enqueueInboxDelivery(event: any, getMessage: (sessionID: string, messageID: string, signal: AbortSignal) => Promise<{ type?: string; metadata?: Record<string, unknown> } | undefined>): Promise<void>;
+  dispose(): void;
+};
+export function subscribeNativeReviewEvents(data: any, consumer: ReturnType<typeof createNativeReviewConsumer>, onError?: (error: unknown) => void, getMessage?: (sessionID: string, messageID: string, signal: AbortSignal) => Promise<{ type?: string; metadata?: Record<string, unknown> } | undefined>): Array<() => void>;

package/plugins/carthagent/src/ui/native-review.mjs

@@ -0,0 +1,159 @@
+import { reviewKickoff } from "../../../../lib/review.mjs";
+import { resolveReviewMode } from "../../../../lib/review.mjs";
+import { SESSION_OPTIONS_KEY } from "../../../../lib/opencode/session-options.mjs";
+
+/** Send the PR ↔ fresh-review ↔ fixes instruction to the working session. */
+export async function sendNativeReviewKickoff({ client, sessionID, signal, prompt = reviewKickoff() }) {
+  await client.session.prompt({ sessionID, text: prompt, metadata: { "ctg.raw": true, "ctg.reviewKickoff": true } }, { signal });
+}
+
+/** Explicit launch mode persisted for the session wins over the profile default. */
+export function nativeReviewMode(session, config, explicitMode) {
+  return resolveReviewMode(explicitMode ?? session?.metadata?.[SESSION_OPTIONS_KEY]?.review, config);
+}
+
+/** Correlate host executions and admit one current-run kickoff per session. */
+/** @param {{ mode: (sessionID: string) => string, diff: (sessionID: string, signal?: AbortSignal) => Promise<unknown>, offer: (value: { sessionID: string; runKey: string; writes: number; start: () => Promise<boolean> }) => Promise<unknown>, eligible?: (sessionID: string, signal?: AbortSignal) => Promise<boolean>, kickoff: (sessionID: string, signal?: AbortSignal) => Promise<unknown>, isLoopActive?: (sessionID: string) => boolean, setLoopActive?: (sessionID: string, active: boolean) => void, signal?: AbortSignal }} options */
+export function createNativeReviewConsumer({ mode, diff, offer, kickoff, eligible = async () => true, isLoopActive = () => false, setLoopActive = () => {}, signal }) {
+  const runs = new Map();
+  const admitted = new Set();
+  const pending = new Set();
+  const loopSessions = new Set();
+  const admissionTails = new Map();
+  const loopGenerations = new Map();
+  const admissionAbort = new AbortController();
+  let sequence = 0;
+  let disposed = false;
+
+  async function finish(sessionID, succeeded) {
+    const run = runs.get(sessionID);
+    if (!run || disposed) return;
+    // Inbox delivery follows execution.started and precedes the terminal event.
+    // Wait for the exact delivered message lookup before deciding whether the
+    // restored review loop still suppresses this run.
+    const admissionTail = admissionTails.get(sessionID);
+    try { await admissionTail; } catch {}
+    if (admissionTails.get(sessionID) === admissionTail) admissionTails.delete(sessionID);
+    if (disposed || runs.get(sessionID) !== run || run.finished) return;
+    run.finished = true;
+    if (!succeeded || signal?.aborted || loopSessions.has(sessionID) || isLoopActive(sessionID)) return;
+
+    let baseline;
+    try { baseline = await run.baseline; }
+    catch { return; }
+    if (disposed || signal?.aborted || runs.get(sessionID) !== run) return;
+    let changes;
+    try { changes = await diff(sessionID, signal); }
+    catch { return; }
+    if (disposed || signal?.aborted || runs.get(sessionID) !== run) return;
+    if (!Array.isArray(changes) || !Array.isArray(baseline)) return;
+    const before = new Map(baseline.map((file) => [file.file, `${file.status}\0${file.patch}`]));
+    const writes = changes.filter((file) => file && (file.additions > 0 || file.deletions > 0 || file.status === "added" || file.status === "deleted") && before.get(file.file) !== `${file.status}\0${file.patch}`).length;
+    const runKey = `${sessionID}@${run.id}`;
+    const currentMode = mode(sessionID);
+    if (!(currentMode === "ask" || currentMode === "yes") || writes <= 0 || admitted.has(runKey) || (currentMode === "yes" && loopSessions.has(sessionID))) return;
+    // A formally blocked or unfinished delivery is not a reviewable run.
+    let reviewable;
+    try { reviewable = await eligible(sessionID, signal); }
+    catch { return; }
+    if (!reviewable || disposed || signal?.aborted || runs.get(sessionID) !== run || admitted.has(runKey)) return;
+    admitted.add(runKey);
+
+    const start = async () => {
+      if (disposed || signal?.aborted || runs.get(sessionID) !== run || pending.has(sessionID) || loopSessions.has(sessionID) || isLoopActive(sessionID)) return false;
+      pending.add(sessionID);
+      loopSessions.add(sessionID);
+      setLoopActive(sessionID, true);
+      try {
+        await kickoff(sessionID, signal);
+        return true;
+      } catch (error) {
+        loopSessions.delete(sessionID);
+        setLoopActive(sessionID, false);
+        throw error;
+      } finally {
+        pending.delete(sessionID);
+      }
+    };
+
+    if (currentMode === "yes") {
+      await start();
+      return;
+    }
+    let offered = false;
+    await offer({ sessionID, runKey, writes, start: async () => {
+      if (offered) return false;
+      offered = true;
+      if (runs.get(sessionID) !== run) return false;
+      return start();
+    } });
+  }
+
+  return {
+    onUserPromptAdmitted(sessionID, message, expectedGeneration) {
+      if (!sessionID || message?.type !== "user" || message.metadata?.["ctg.reviewKickoff"] === true) return;
+      if (expectedGeneration !== undefined && (loopGenerations.get(sessionID) ?? 0) !== expectedGeneration) return;
+      loopSessions.delete(sessionID);
+      if (isLoopActive(sessionID)) setLoopActive(sessionID, false);
+    },
+    setLoopActive(sessionID, active) {
+      if (!sessionID) return;
+      if (active) {
+        loopSessions.add(sessionID);
+        loopGenerations.set(sessionID, (loopGenerations.get(sessionID) ?? 0) + 1);
+      }
+      else loopSessions.delete(sessionID);
+      setLoopActive(sessionID, active);
+    },
+    onStarted(event) {
+      const sessionID = event?.data?.sessionID;
+      if (!sessionID || disposed) return;
+      const id = event.id ?? `${event.created ?? Date.now()}-${++sequence}`;
+      // A rejection is handled here, not left as an unhandled promise if the run fails.
+      const baseline = Promise.resolve().then(() => diff(sessionID, signal)).catch(() => undefined);
+      runs.set(sessionID, { id, baseline, finished: false });
+    },
+    onSucceeded(event) { return finish(event?.data?.sessionID, true); },
+    onFailed(event) { return finish(event?.data?.sessionID, false); },
+    onInterrupted(event) { return finish(event?.data?.sessionID, false); },
+    onInboxDelivered(event, message) {
+      const sessionID = event?.data?.sessionID;
+      if (!sessionID || disposed) return;
+      this.onUserPromptAdmitted(sessionID, message);
+    },
+    enqueueInboxDelivery(event, getMessage) {
+      const sessionID = event?.data?.sessionID;
+      const messageID = event?.data?.inboxID;
+      if (!sessionID || !messageID || disposed) return Promise.resolve();
+      const expectedGeneration = loopGenerations.get(sessionID) ?? 0;
+      const previous = admissionTails.get(sessionID) ?? Promise.resolve();
+      const current = previous.catch(() => {}).then(async () => {
+        if (disposed) return;
+        const timeout = AbortSignal.timeout(5_000);
+        const lookupSignal = signal ? AbortSignal.any([signal, admissionAbort.signal, timeout]) : AbortSignal.any([admissionAbort.signal, timeout]);
+        lookupSignal.throwIfAborted();
+        const message = await Promise.race([
+          getMessage(sessionID, messageID, lookupSignal),
+          new Promise((resolve) => lookupSignal.addEventListener("abort", () => resolve(undefined), { once: true })),
+        ]);
+        if (!disposed && !lookupSignal.aborted) this.onUserPromptAdmitted(sessionID, message, expectedGeneration);
+      });
+      admissionTails.set(sessionID, current);
+      return current;
+    },
+    dispose() { disposed = true; admissionAbort.abort(); admissionTails.clear(); runs.clear(); pending.clear(); },
+  };
+}
+
+/** Wire host admission and execution events; returned disposers belong to plugin setup. */
+export function subscribeNativeReviewEvents(data, consumer, onError = (_error) => {}, getMessage = async () => undefined) {
+  return [
+    data.on("session.inbox.delivered", (event) => {
+      return consumer.enqueueInboxDelivery(event, getMessage).catch(onError);
+    }),
+    data.on("session.execution.started", (event) => consumer.onStarted(event)),
+    data.on("session.execution.succeeded", (event) => consumer.onSucceeded(event).catch(onError)),
+    data.on("session.execution.failed", (event) => consumer.onFailed(event).catch(onError)),
+    data.on("session.execution.interrupted", (event) => consumer.onInterrupted(event).catch(onError)),
+  ];
+}

package/plugins/carthagent/src/ui/resume-session.mjs

@@ -0,0 +1,34 @@
+/** Resolve session IDs independently of the host's title-oriented search filter. */
+export async function findNativeResumeSession({ query, directory, client, pageSize = 100 }) {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) return undefined;
+  const isSessionID = /^ses(?:sion)?[_-]/i.test(query.trim());
+
+  if (isSessionID) {
+    try {
+      const exact = await client.session.get({ sessionID: query.trim() });
+      if (exact && !exact.parentID && exact.location.directory === directory) return exact;
+    } catch { /* non-exact IDs continue as prefix search */ }
+  }
+
+  const loadPages = async (search) => {
+    const sessions = [];
+    let cursor;
+    do {
+      const page = await client.session.list({
+        limit: pageSize, order: 'desc', directory,
+        ...(cursor ? { cursor } : {}), ...(search ? { search } : {}),
+      });
+      sessions.push(...page.data.filter((session) => !session.parentID));
+      cursor = page.cursor.next ?? undefined;
+    } while (cursor);
+    return sessions;
+  };
+
+  const unfiltered = await loadPages();
+  if (isSessionID) {
+    const prefix = unfiltered.find((session) => session.id.toLowerCase().startsWith(normalized));
+    if (prefix) return prefix;
+  }
+  return (await loadPages(query)).find((session) => (session.title ?? '').toLowerCase().includes(normalized));
+}

package/plugins/carthagent/src/ui/select-mouse.ts

@@ -0,0 +1,17 @@
+import type { MouseEvent, SelectRenderable } from "@opentui/core";
+
+// SelectRenderable only handles keys; map a left click to the fully drawn row under the pointer and activate it.
+// Bind it to mouse-up: an action that opens a dialog on mouse-down is closed by that dialog's backdrop on release.
+export function clickSelect(node: SelectRenderable | undefined, event: MouseEvent) {
+  if (!node || event.button !== 0) return;
+  const { scrollOffset, linesPerItem, maxVisibleItems } = node as unknown as {
+    scrollOffset: number;
+    linesPerItem: number;
+    maxVisibleItems: number;
+  };
+  const row = Math.floor((event.y - node.screenY) / Math.max(1, linesPerItem));
+  const index = scrollOffset + row;
+  if (row < 0 || row >= maxVisibleItems || index >= node.options.length) return;
+  node.setSelectedIndex(index);
+  node.selectCurrent();
+}

package/plugins/carthagent/src/ui/session-preferences.d.mts

@@ -0,0 +1,7 @@
+import type { JsonValue } from "@opencode/client";
+export type AutoCompactionAction = "on" | "off" | "toggle";
+export interface SessionMetadataClient {
+  get(input: { sessionID: string }, options: { location: unknown; signal: AbortSignal }): Promise<{ metadata?: Record<string, JsonValue> }>;
+  update(input: { sessionID: string; metadata: Record<string, JsonValue> }, options: { location: unknown; signal: AbortSignal }): Promise<unknown>;
+}
+export function setSessionAutoCompaction(client: SessionMetadataClient, sessionID: string, location: unknown, action: AutoCompactionAction): Promise<boolean>;

package/plugins/carthagent/src/ui/session-preferences.mjs

@@ -0,0 +1,14 @@
+/** Persist the host-owned per-session opt-out without disturbing neighbor metadata. */
+export async function setSessionAutoCompaction(client, sessionID, location, action) {
+  if (action !== "toggle" && action !== "on" && action !== "off") throw new TypeError("Usage: /autocompact [on|off].");
+  const options = { location, signal: AbortSignal.timeout(15_000) };
+  const session = await client.get({ sessionID }, options);
+  const metadata = { ...session.metadata };
+  const enabled = metadata["ctg.autoCompaction"] !== false;
+  const next = action === "on" ? true : action === "off" ? false : !enabled;
+  if (next === enabled) return enabled;
+  if (next) delete metadata["ctg.autoCompaction"];
+  else metadata["ctg.autoCompaction"] = false;
+  await client.update({ sessionID, metadata }, { location, signal: AbortSignal.timeout(15_000) });
+  return next;
+}

package/plugins/carthagent/src/ui/theme-provision.d.mts

@@ -0,0 +1,3 @@
+export declare function convertLegacyTheme(name: string, palette: Record<string, unknown>, lightPalette?: Record<string, unknown>): Record<string, unknown>;
+export declare function provisionNativeThemes(profileConfigDir: string, names?: readonly string[]): Promise<{ directory: string; installed: string[] }>;
+export declare function provisionDefaultNativeTheme(profileConfigDir: string): Promise<{ directory: string; installed: string[] }>;