@macintacos/caret 1.7.0 → 1.8.0

package/opencode/caret.core.ts

@@ -20,7 +20,7 @@ import {
   type SpawnRunner,
 } from "./review-bridge.ts";
 
-/** The caret binary the review tool spawns. Env override wins; else the binary that
+/** The caret binary the OpenCode plugin spawns. Env override wins; else the binary that
  * ships beside this module in the npm package. */
 export function resolveCaretBin(opts: {
   env: Record<string, string | undefined>;
@@ -71,7 +71,8 @@ export function isPlanningAgent(agent: string | undefined): boolean {
 const REVIEW_TOAST_TITLE = "caret: review this plan";
 
 /** A toast's content — structurally both v1's `showToast` body and v2's TUI
- * `ToastOptions`, which `caret.tui.ts` passes it to unchanged. */
+ * `ToastOptions`. v1 forwards it as-is, so a host-only field (v2's `sessionID`) is
+ * added by that host's sink, not here. */
 export type ToastBody = {
   title?: string;
   message: string;
@@ -406,12 +407,16 @@ export type ReviewHost = {
   /** Fail-open: false when the session is unreadable. */
   isSubagent: () => Promise<boolean>;
   /** caret rewrites the file and the model chose the path, so OpenCode's own edit rules
-   * must allow it. false = denied, ask-only, or the check failed. */
-  canEdit: (planFilePath: string) => Promise<boolean>;
+   * must allow it. false = denied or the check failed; a string is the host's own
+   * refusal, returned instead of the not-permitted text. */
+  canEdit: (planFilePath: string) => Promise<boolean | string>;
   /** Aborting it kills the `caret review` child. */
   signal?: AbortSignal;
   /** Fires once with the review URL while the review is pending. */
   onUrl?: (url: string) => void;
+  /** Optional approve-variant ids this host can honor, sent as the envelope's
+   * `approve_variants`; v1 declares none. */
+  approveVariants?: readonly string[];
 };
 
 /** One review-tool call, host-neutral: subagent refusal, plan source, the `path` edit
@@ -425,13 +430,16 @@ export async function runPlanReview(
   if (await host.isSubagent()) return { text: SUBAGENT_REFUSAL };
   const source = resolvePlanSource(args, host.directory, readRegularFile);
   if ("error" in source) return { text: source.error };
-  if (source.planFilePath && !(await host.canEdit(source.planFilePath))) {
-    return { text: notPermittedToEdit(source.planFilePath, deps.plansDir) };
+  if (source.planFilePath) {
+    const editVerdict = await host.canEdit(source.planFilePath);
+    if (typeof editVerdict === "string") return { text: editVerdict };
+    if (!editVerdict) return { text: notPermittedToEdit(source.planFilePath, deps.plansDir) };
   }
   const envelope = buildEnvelope(source.plan, {
     sessionID: host.sessionID,
     directory: host.directory,
     planFilePath: source.planFilePath,
+    approveVariants: host.approveVariants,
   });
   const decision = await runReviewViaCaret(envelope, {
     command: [deps.bin, "review"],

package/opencode/caret.plugin.v2.ts

@@ -23,7 +23,7 @@ import {
   runPlanReview,
   type WarmRunner,
 } from "./caret.core.ts";
-import { editChecks, editPermitted, type Rule } from "./permission.ts";
+import { editChecks, type Rule } from "./permission.ts";
 import { decisionText, nodeSpawnRunner, type SpawnRunner } from "./review-bridge.ts";
 
 /** Appended last, it outranks a config deny-all: v2 disables a tool only when the last
@@ -46,6 +46,13 @@ export function withPlanAllow(
   return [...sessionRules, PLAN_ALLOW_RULE];
 }
 
+/** The `path` refusal on a v2 before 2.0.29, which has no `permission.assert` to ask
+ * whether caret may rewrite the file. Keep 2.0.29 in sync with `V2_FLOOR` in
+ * src/adapters/opencode/host.ts. */
+function cannotAskToEdit(planFilePath: string): string {
+  return `caret: ${REVIEW_TOOL} can't ask the running OpenCode whether it may edit ${planFilePath}, which a path review rewrites. Pass the plan inline as \`plan\`; path reviews need OpenCode 2.0.29 or later, which the user can upgrade to.`;
+}
+
 type SessionInfo = {
   location: { directory: string };
   parentID?: string;
@@ -73,12 +80,22 @@ type ReviewTool = {
   ) => Promise<{ content: string; metadata?: Record<string, string> }>;
 };
 
+/** The approve-variant id for "Approve & build"; must equal BUILD_VARIANT.id in
+ * src/adapters/opencode/approve.ts. */
+export const APPROVE_AND_BUILD = "build";
+
+/** Appended to an approval's tool result when the switch to build fails, so the model asks
+ * rather than implements. */
+export const BUILD_SWITCH_FAILED =
+  "caret could not switch this session to the build agent, so it is still in the plan agent. Ask the user to switch to build before implementing.";
+
 /** The slice of v2's plugin `Context` caret uses. */
 export type SetupContext = {
   location: { directory: string; project: { directory: string } };
   session: {
     get: (input: { sessionID: string }) => Promise<SessionInfo>;
     update: (input: { sessionID: string; permissions: Rule[] }) => Promise<unknown>;
+    switchAgent: (input: { sessionID: string; agent: string }) => Promise<unknown>;
     hook: {
       (name: "context", callback: (event: ContextEvent) => Promise<void>): Promise<unknown>;
       (name: "prompt", callback: (event: PromptEvent) => Promise<void>): Promise<unknown>;
@@ -117,12 +134,24 @@ export function createCaretSetup(opts: {
   run: SpawnRunner;
   warm: WarmRunner;
   plansDir: string;
+  logError: (message: string, error: unknown) => void;
 }): (ctx: SetupContext) => Promise<void> {
-  const { bin, run, warm, plansDir } = opts;
+  const { bin, run, warm, plansDir, logError } = opts;
 
   return async (ctx) => {
     const readSession = (sessionID: string) => ctx.session.get({ sessionID });
 
+    // Catches its own failure: execute's outer catch would turn a throw into a fail-safe deny.
+    async function switchToBuild(sessionID: string, approvalText: string): Promise<string> {
+      try {
+        await ctx.session.switchAgent({ sessionID, agent: "build" });
+        return approvalText;
+      } catch (error) {
+        logError(`caret: could not switch session ${sessionID} to the build agent`, error);
+        return `${approvalText}\n\n${BUILD_SWITCH_FAILED}`;
+      }
+    }
+
     async function execute(
       input: unknown,
       context: ToolContext,
@@ -160,29 +189,25 @@ export function createCaretSetup(opts: {
                   throw error;
                 }
               }
-              // Session rules can deny, so an unreadable session cannot prove allow.
-              if (!session) return false;
-              try {
-                const agent = await ctx.agent.get({ agentID: context.agent });
-                return editPermitted(planFilePath, location, {
-                  agent: agent.data.permissions,
-                  session: session.permissions ?? [],
-                });
-              } catch {
-                return false;
-              }
+              return cannotAskToEdit(planFilePath);
             },
             signal: context.signal,
-            // The TUI half toasts from these progress and result keys.
+            // The TUI half reads these progress and result keys.
             onUrl: (url) => {
               context.progress({ [CARET_URL_KEY]: url }).catch(() => {});
             },
+            // Only a planning session has a build agent to hand off to.
+            ...(isPlanningAgent(context.agent) && { approveVariants: [APPROVE_AND_BUILD] }),
           },
           { bin, run, plansDir },
         );
         // An abort's fail-safe deny is no reviewer's decision; the TUI reads a missing key as cancelled.
         if (!decision || context.signal.aborted) return { content: text };
-        return { content: text, metadata: { [CARET_DECISION_KEY]: decision.behavior } };
+        const content =
+          decision.behavior === "allow" && decision.acceptMode === APPROVE_AND_BUILD
+            ? await switchToBuild(context.sessionID, text)
+            : text;
+        return { content, metadata: { [CARET_DECISION_KEY]: decision.behavior } };
       } catch (error) {
         if (declined !== undefined && error === declined) throw error;
         const message = error instanceof Error ? error.message : String(error);
@@ -269,5 +294,6 @@ const setup = createCaretSetup({
     // v2's plan agent may edit only this dir, and v2 roots it at $HOME, not XDG.
     defaultDir: join(homedir(), ".opencode", "plan"),
   }),
+  logError: (message, error) => console.error(message, error),
 });
 export default setup;

package/opencode/caret.tui.ts

@@ -1,8 +1,16 @@
-// caret's OpenCode v2 TUI plugin: the review-link, decision, and update toasts. v2's server
-// `Context` has no toast surface, so v2 loads this module from package.json
-// `exports["./tui"]` as `{ id, setup }`. v1 keeps its own toasts in `server()`; the no-op
-// `tui` exists because v1's installer may register this module as a v1 TUI plugin, and
-// v1's TUI loader throws on a default without one.
+// caret's OpenCode v2 TUI plugin: the review-link, decision, and update toasts, the
+// `/caret` command that opens the session's waiting plan, and the pending line above a
+// waiting session's prompt. v2's server `Context` has no toast surface, so v2 loads this
+// module from package.json `exports["./tui"]` as `{ id, setup }`. v1 keeps its own toasts
+// in `server()`; the no-op `tui` exists because v1's installer may register this module as
+// a v1 TUI plugin, and v1's TUI loader throws on a default without one. Because v1 can load
+// this module, `@opentui/solid` is imported only dynamically, from `setup`, which v1 never
+// calls. `keymap`, `ui.router`, `ui.slot`, and `storage` stay optional: a feature that
+// needs one runs only when the host has it, so a context without them still gets caret's
+// toasts. `theme` and `renderer` are optional too: without them the pending row renders in
+// OpenTUI's default colours, or opens on every mouse-up, selection or not.
+
+import { spawn } from "node:child_process";
 
 import {
   CARET_DECISION_KEY,
@@ -10,13 +18,21 @@ import {
   decisionToast,
   productionUpdateCheck,
   type ReviewOutcome,
+  resolveCaretBin,
   reviewLinkToast,
   type ToastBody,
   type ToastSink,
   toastBestEffort,
 } from "./caret.core.ts";
 
-type ToolEvent = { data: { id: string; metadata?: Record<string, unknown> } };
+type ToolEvent = {
+  data: { id: string; sessionID: string; metadata?: Record<string, unknown> };
+};
+
+/** v2's `ToastOptions` as caret uses it: the shared body plus the session it is about,
+ * which OpenCode offers to open when that session's family is not open, titling an
+ * untitled toast with the session's title. */
+type TuiToast = ToastBody & { sessionID?: string };
 
 /** The slice of v2's TUI context caret uses, narrow so tests build it without casts;
  * test/opencode/sdk-conformance.ts pins it to v2's real `Context`. */
@@ -27,46 +43,303 @@ export type TuiContext = {
       handler: (event: ToolEvent) => void,
     ) => () => void;
   };
-  ui: { toast: { show: (options: ToastBody) => void } };
+  ui: {
+    toast: { show: (options: TuiToast) => void };
+    slot?: (claim: ComposerClaim) => () => void;
+    router?: { current: () => Route };
+  };
+  keymap?: {
+    layer: (factory: () => { mode: "global"; commands: CaretCommand[] }) => void;
+    shortcuts?: (id: string) => readonly string[];
+  };
+  theme?: TuiTheme;
+  renderer?: { getSelection?: () => { getSelectedText: () => string } | null };
+  storage?: {
+    memory: (
+      key: string,
+      options: { readonly initial: PendingBySession },
+    ) => readonly [PendingBySession, (mutation: (draft: PendingBySession) => void) => void];
+  };
+};
+
+/** The host theme's tokens the pending row paints with; each is an opaque OpenTUI colour. */
+type TuiTheme = {
+  text: { base: unknown; muted: unknown; feedback: { warning: { base: unknown } } };
+  background: { raised: { base: unknown } };
+  border: { base: unknown };
+};
+
+type PendingReview = { callId: string; url: string };
+type PendingBySession = Record<string, PendingReview>;
+
+type ComposerClaim = {
+  readonly prepend: "session.composer.top";
+  // unknown fits the host's JSX.Element only while @opentui/solid is uninstalled (it is any
+  // then); once installed, type this from the host's SlotClaim.
+  readonly render: (input: { readonly sessionID: string }) => unknown;
+};
+
+/** v2's `Route` as caret reads it: only a session route carries `sessionID`. */
+type Route = { type: string; sessionID?: string };
+
+/** caret's one keymap command: the slice of v2's `KeymapCommand` it sets. */
+type CaretCommand = {
+  id: string;
+  title: string;
+  description: string;
+  palette: true;
+  slash: { name: string };
+  bind: string;
+  suggested: () => boolean;
+  run: () => void;
+};
+
+/** Spawns `bin args` detached and unwaited; `onError` hears a child that fails to start
+ * or exits non-zero. */
+export type DetachedSpawn = (bin: string, args: string[], onError: (err: Error) => void) => void;
+
+export const nodeDetachedSpawn: DetachedSpawn = (bin, args, onError) => {
+  // spawn reports ENOENT asynchronously; unhandled, that 'error' takes OpenCode down.
+  const child = spawn(bin, args, { stdio: "ignore", detached: true });
+  child.on("error", onError);
+  // band-link exits 0 on its own failures, so non-zero means caret never ran.
+  child.on("exit", (code) => {
+    if (code) onError(new Error(`exited with status ${code}`));
+  });
+  child.unref();
+};
+
+/** The `@opentui/solid` reconciler calls the pending row takes. */
+type OpenTuiReconciler = {
+  createElement: (tag: "box" | "text" | "span" | "b") => unknown;
+  insertNode: (parent: unknown, child: unknown) => void;
+  insert: (parent: unknown, value: string) => unknown;
+  setProp: <T>(node: unknown, name: string, value: T, prev?: T) => T;
+  effect: <T>(fn: (prev?: T) => T) => void;
 };
 
-/** Build caret's v2 TUI `setup` over an injected update check. */
+const PENDING_LABEL = "plan waiting for your review";
+const PENDING_ACTION = "open in browser";
+
+const plainMemory = (): readonly [
+  PendingBySession,
+  (mutation: (draft: PendingBySession) => void) => void,
+] => {
+  const pending: PendingBySession = {};
+  return [pending, (mutate) => mutate(pending)];
+};
+
+/** caret's v2 TUI setup over injected effects; its cleanup releases the slot claim (which
+ * lands asynchronously) and every subscription. */
 export function createCaretTui(opts: {
   checkUpdate: (show: ToastSink) => void;
+  bin: string;
+  spawn: DetachedSpawn;
+  loadOpenTui: () => Promise<OpenTuiReconciler>;
 }): (ctx: TuiContext) => () => void {
   return (ctx) => {
     const show: ToastSink = (body) => ctx.ui.toast.show(body);
+    const openPlan = (sessionID: string | undefined) => {
+      const args =
+        sessionID === undefined
+          ? ["band-link", "--open"]
+          : ["band-link", "--session", sessionID, "--open"];
+      opts.spawn(opts.bin, args, (err) =>
+        toastBestEffort(show, {
+          title: "caret: open failed",
+          message: `${err.message}. Run caret doctor to see why.`,
+          variant: "error",
+        }),
+      );
+    };
+    // Tool events carry the call id, not the tool name: a session's entry names the one call
+    // whose link it showed, and a later link in that session replaces it.
+    const storage = ctx.storage;
+    const hasReactiveStore = typeof storage?.memory === "function";
+    const [pending, setPending] =
+      typeof storage?.memory === "function"
+        ? storage.memory("caret.pending", { initial: {} })
+        : plainMemory();
+    const routedSession = () => ctx.ui.router?.current().sessionID;
+    if (typeof ctx.keymap?.layer === "function") {
+      try {
+        ctx.keymap.layer(() => ({
+          // The palette and slash completion list only commands reachable from their own input mode.
+          mode: "global",
+          commands: [
+            {
+              id: "caret.open",
+              title: "Open caret",
+              description: "Open this session's waiting plan in the browser, or caret's home page",
+              palette: true,
+              slash: { name: "caret" },
+              bind: "<leader>p",
+              suggested: () => pending[routedSession() ?? ""] !== undefined,
+              run: () => openPlan(routedSession()),
+            },
+          ],
+        }));
+      } catch {
+        // best-effort: a host that rejects the command keeps caret's toasts
+      }
+    }
+    const showIn =
+      (sessionID: string): ToastSink =>
+      (body) =>
+        ctx.ui.toast.show({ ...body, sessionID });
     try {
       opts.checkUpdate(show);
     } catch {
       // best-effort
     }
 
-    // Tool events carry the call id, not the tool name: only calls that showed a link count.
-    const callsWithLink = new Set<string>();
-    const settle = (id: string, outcome: ReviewOutcome) => {
-      if (callsWithLink.delete(id)) toastBestEffort(show, decisionToast(outcome));
+    const settle = (id: string, sessionID: string, outcome: ReviewOutcome) => {
+      if (pending[sessionID]?.callId !== id) return;
+      setPending((draft) => {
+        delete draft[sessionID];
+      });
+      toastBestEffort(showIn(sessionID), decisionToast(outcome));
     };
     const unsubscribers = [
       ctx.data.on("session.tool.progress", ({ data }) => {
         const url = data.metadata?.[CARET_URL_KEY];
         if (typeof url !== "string") return;
-        callsWithLink.add(data.id);
-        toastBestEffort(show, reviewLinkToast(url));
+        setPending((draft) => {
+          draft[data.sessionID] = { callId: data.id, url };
+        });
+        toastBestEffort(showIn(data.sessionID), reviewLinkToast(url));
       }),
       ctx.data.on("session.tool.success", ({ data }) => {
         const decision = data.metadata?.[CARET_DECISION_KEY];
-        settle(data.id, decision === "allow" || decision === "deny" ? decision : "cancelled");
+        settle(
+          data.id,
+          data.sessionID,
+          decision === "allow" || decision === "deny" ? decision : "cancelled",
+        );
       }),
-      ctx.data.on("session.tool.failed", ({ data }) => settle(data.id, "cancelled")),
+      ctx.data.on("session.tool.failed", ({ data }) =>
+        settle(data.id, data.sessionID, "cancelled"),
+      ),
     ];
+
+    let releaseSlot: (() => void) | undefined;
+    let disposed = false;
+    // Without the host's reactive store the line could never update.
+    if (typeof ctx.ui.slot === "function" && hasReactiveStore) {
+      opts
+        .loadOpenTui()
+        .then((openTui) => {
+          if (disposed) return;
+          releaseSlot = ctx.ui.slot?.({
+            prepend: "session.composer.top",
+            render: (input) =>
+              pendingRow(openTui, {
+                // Read live: ctx.theme is a getter that follows theme switches.
+                theme: () => ctx.theme,
+                openKey: ctx.keymap?.shortcuts?.("caret.open")[0] ?? "/caret",
+                // input is reactive: read sessionID at each call, never destructure it.
+                isPending: () => pending[input.sessionID] !== undefined,
+                open: () => {
+                  // As the host's own rows do: a mouse-up that ends a text selection is a copy.
+                  if (ctx.renderer?.getSelection?.()?.getSelectedText()) return;
+                  openPlan(input.sessionID);
+                },
+              }),
+          });
+        })
+        // best-effort: a host whose runtime can't resolve @opentui/solid shows no line
+        .catch(() => {});
+    }
     return () => {
+      disposed = true;
+      releaseSlot?.();
       for (const unsubscribe of unsubscribers) unsubscribe();
     };
   };
 }
 
-const setup = createCaretTui({ checkUpdate: productionUpdateCheck });
+/** The row above a waiting session's composer: the host's queued-card idiom, one row tall,
+ * opening the review on click. */
+function pendingRow(
+  openTui: OpenTuiReconciler,
+  {
+    theme,
+    openKey,
+    isPending,
+    open,
+  }: {
+    theme: () => TuiTheme | undefined;
+    openKey: string;
+    isPending: () => boolean;
+    open: () => void;
+  },
+): unknown {
+  const paint = (node: unknown, name: string, color: (theme: TuiTheme) => unknown) =>
+    openTui.effect((prev) => {
+      const t = theme();
+      return openTui.setProp(node, name, t && color(t), prev);
+    });
+  const styled = (
+    tag: "span" | "b",
+    text: string,
+    color: (theme: TuiTheme) => unknown,
+  ): unknown => {
+    const node = openTui.createElement(tag);
+    openTui.insert(node, text);
+    openTui.effect((prev) => {
+      const t = theme();
+      return openTui.setProp(node, "style", t ? { fg: color(t) } : {}, prev);
+    });
+    return node;
+  };
+  const props = (node: unknown, values: Record<string, unknown>) => {
+    for (const [name, value] of Object.entries(values)) openTui.setProp(node, name, value);
+  };
+  const append = (parent: unknown, ...children: unknown[]) => {
+    for (const child of children) openTui.insertNode(parent, child);
+  };
+
+  // Two boxes, as the host's queued card: the rail cell stays on the base background.
+  const row = openTui.createElement("box");
+  props(row, { border: ["left"], borderStyle: "heavy", marginBottom: 1, onMouseUp: open });
+  paint(row, "borderColor", (t) => t.border.base);
+  openTui.effect((prev) => openTui.setProp(row, "visible", isPending(), prev));
+
+  const card = openTui.createElement("box");
+  props(card, { flexDirection: "row", flexGrow: 1, paddingLeft: 2, paddingRight: 1 });
+  paint(card, "backgroundColor", (t) => t.background.raised.base);
+
+  const label = openTui.createElement("text");
+  props(label, { flexGrow: 1, flexShrink: 1, minWidth: 0, wrapMode: "none", truncate: true });
+  append(
+    label,
+    styled("b", "^", (t) => t.text.feedback.warning.base),
+    styled("span", "caret  ", (t) => t.text.muted),
+    styled("b", PENDING_LABEL, (t) => t.text.base),
+  );
+
+  const hint = openTui.createElement("text");
+  props(hint, { flexShrink: 0, wrapMode: "none" });
+  append(
+    hint,
+    styled("span", openKey, (t) => t.text.base),
+    styled("span", `  ${PENDING_ACTION}`, (t) => t.text.muted),
+  );
+
+  append(card, label, hint);
+  append(row, card);
+  return row;
+}
+
+// The v2 host rewrites only a bare string-literal specifier here; a cast or a variable sends
+// the import to disk, where nothing installs @opentui/solid.
+const loadOpenTui = (): Promise<OpenTuiReconciler> => import("@opentui/solid");
+const setup = createCaretTui({
+  checkUpdate: productionUpdateCheck,
+  bin: resolveCaretBin({ env: process.env, importMetaUrl: import.meta.url }),
+  spawn: nodeDetachedSpawn,
+  loadOpenTui,
+});
 
 export default {
   id: "caret",

package/opencode/opentui-solid.d.ts

@@ -0,0 +1,8 @@
+// The OpenCode v2 TUI host provides this module at runtime; nothing installs it.
+declare module "@opentui/solid" {
+  function createElement(tag: "box" | "text" | "span" | "b"): unknown;
+  function insertNode(parent: unknown, child: unknown): void;
+  function insert(parent: unknown, value: string): unknown;
+  function setProp<T>(node: unknown, name: string, value: T, prev?: T): T;
+  function effect<T>(fn: (prev?: T) => T): void;
+}

package/opencode/permission.ts

@@ -1,8 +1,6 @@
-// OpenCode v2 permission evaluation, for checking a plan file write-back on a v2 before
-// 2.0.29, which gives a plugin no way to ask about it (2.0.29+ asks through
-// `permission.assert`). Copied from anomalyco/opencode at v2.0.18:
-// packages/core/src/util/wildcard.ts (match), packages/core/src/permission.ts (evaluate),
-// the resource forming in packages/core/src/file-access.ts (resolve), and
+// The resources OpenCode v2 checks before its own tools edit a file, so caret can
+// `permission.assert` the same ones before it rewrites a plan file. The resource forming
+// mirrors anomalyco/opencode at v2.0.18: packages/core/src/file-access.ts (resolve) and
 // packages/util/src/fs-util.ts (contains, from FSUtil.contains).
 //
 // Copyright (c) 2025 opencode. MIT License. Permission is hereby granted, free of charge,
@@ -31,32 +29,6 @@ export type Check = { action: string; resource: string };
 
 export type Location = { directory: string; projectDirectory: string };
 
-/** OpenCode's wildcard match: `*` crosses `/`, and a trailing `" *"` also matches the
- * bare prefix. */
-export function wildcardMatch(input: string, pattern: string): boolean {
-  const normalized = input.replaceAll("\\", "/");
-  let escaped = pattern
-    .replaceAll("\\", "/")
-    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
-    .replace(/\*/g, ".*")
-    .replace(/\?/g, ".");
-
-  if (escaped.endsWith(" .*")) escaped = `${escaped.slice(0, -3)}( .*)?`;
-
-  return new RegExp(`^${escaped}$`, process.platform === "win32" ? "si" : "s").test(normalized);
-}
-
-/** The last rule matching both `action` and `resource` wins; no match asks. */
-export function evaluate(action: string, resource: string, ...rulesets: (readonly Rule[])[]): Rule {
-  return (
-    rulesets
-      .flat()
-      .findLast(
-        (rule) => wildcardMatch(action, rule.action) && wildcardMatch(resource, rule.resource),
-      ) ?? { action, resource: "*", effect: "ask" }
-  );
-}
-
 const slash = (value: string) => value.replaceAll("\\", "/");
 
 function contains(parent: string, child: string): boolean {
@@ -88,16 +60,3 @@ export function editChecks(planFilePath: string, location: Location): Check[] {
     { action: "external_directory", resource: slash(path.join(directory, "*")) },
   ];
 }
-
-/** Whether every check OpenCode would run for editing `planFilePath` is `allow`. Session
- * rules outrank agent rules. */
-export function editPermitted(
-  planFilePath: string,
-  location: Location,
-  rules: { agent: readonly Rule[]; session: readonly Rule[] },
-): boolean {
-  return editChecks(planFilePath, location).every(
-    (check) =>
-      evaluate(check.action, check.resource, rules.agent, rules.session).effect === "allow",
-  );
-}

package/opencode/review-bridge.ts

@@ -9,7 +9,7 @@
 import { spawn } from "node:child_process";
 
 export type CaretDecision =
-  | { behavior: "allow"; feedback?: string }
+  | { behavior: "allow"; feedback?: string; acceptMode?: string }
   | { behavior: "deny"; feedback: string };
 
 /** Asks the model to open its plan on a `#` heading, which deriveTitle
@@ -23,12 +23,18 @@ export const PLAN_TITLE_INSTRUCTION =
  * reads — both ends are caret-owned. */
 export function buildEnvelope(
   plan: string,
-  ctx: { sessionID?: string; directory?: string; planFilePath?: string },
+  ctx: {
+    sessionID?: string;
+    directory?: string;
+    planFilePath?: string;
+    approveVariants?: readonly string[];
+  },
 ): string {
   return JSON.stringify({
     session_id: ctx.sessionID,
     cwd: ctx.directory,
     tool_input: { plan, planFilePath: ctx.planFilePath },
+    approve_variants: ctx.approveVariants,
   });
 }
 
@@ -44,11 +50,20 @@ export function parseDecision(stdout: string): CaretDecision {
       .filter(Boolean)
       .at(-1) ?? "";
   try {
-    const parsed = JSON.parse(line) as { behavior?: unknown; feedback?: unknown };
+    const parsed = JSON.parse(line) as {
+      behavior?: unknown;
+      feedback?: unknown;
+      acceptMode?: unknown;
+    };
     if (parsed.behavior === "allow") {
       // Reviewer notes (EXC-791) ride the allow; surface them to the agent below.
       const notes = typeof parsed.feedback === "string" ? parsed.feedback.trim() : "";
-      return notes ? { behavior: "allow", feedback: notes } : { behavior: "allow" };
+      const acceptMode = typeof parsed.acceptMode === "string" ? parsed.acceptMode : "";
+      return {
+        behavior: "allow",
+        ...(notes && { feedback: notes }),
+        ...(acceptMode && { acceptMode }),
+      };
     }
     if (parsed.behavior === "deny") {
       return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@macintacos/caret",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "license": "MIT",
   "type": "module",
   "description": "A Claude Code plugin that replaces the terminal plan-approval prompt with a local web UI for inline review, annotation, and approval.",
@@ -54,7 +54,7 @@
     "@laststance/tailwind-suggest-canonical-classes": "^0.1.1",
     "@lezer/highlight": "^1.2.3",
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@opencode/plugin": "^2.0.18",
+    "@opencode/plugin": "^2.0.29",
     "@pierre/diffs": "1.5.2",
     "@pierre/trees": "1.0.0-beta.6",
     "@playwright/test": "^1.62.1",