@pragma-sh/junie-plugin 0.1.0-alpha.0

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@pragma-sh/junie-plugin",
+  "version": "0.1.0-alpha.0",
+  "description": "JetBrains Junie CLI plugin that reports agent status to Pragma via native hooks.",
+  "license": "AGPL-3.0-only",
+  "files": [
+    ".junie-plugin",
+    "assets",
+    "dist",
+    "hooks",
+    "pragma-plugin.json",
+    "scripts",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    "./pragma-plugin": "./src/pragma-plugin.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun build src/pragma-plugin.ts --outdir dist --format esm --target node --packages bundle && mv dist/pragma-plugin.js dist/pragma-plugin.mjs && bun build scripts/install-local.ts --outfile dist/install.mjs --format esm --target node --packages bundle",
+    "install:local": "bun run scripts/install-local.ts",
+    "prepack": "bun run build",
+    "typecheck": "tsc --noEmit",
+    "test": "bun --bun vitest run",
+    "lint": "oxlint ."
+  },
+  "devDependencies": {
+    "@pragma/plugin": "workspace:*",
+    "@pragma/watcher-kit": "workspace:*",
+    "@types/node": "^24.12.3",
+    "bunup": "^0.16.32",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  },
+  "pragma": {
+    "pluginId": "pragma.junie",
+    "main": "./dist/pragma-plugin.mjs"
+  }
+}

package/pragma-plugin.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://raw.githubusercontent.com/pragma-sh/pragma/main/packages/plugin-registry/pragma-plugin.schema.json",
+  "name": "Junie CLI",
+  "description": "Launch JetBrains Junie CLI in Pragma with live status, approvals, questions, usage limits, and session naming.",
+  "categories": ["agent-plugin"],
+  "images": [
+    {
+      "url": "https://raw.githubusercontent.com/pragma-sh/pragma/main/packages/junie-plugin/assets/junie.svg",
+      "alt": "Junie logo"
+    }
+  ],
+  "install": { "command": "node", "args": ["dist/install.mjs"] },
+  "agentBinary": "junie"
+}

package/scripts/install-local.ts

@@ -0,0 +1,127 @@
+// Installs the Pragma status bridge into Junie's global configuration.
+//
+// Junie has exactly one hook-discovery mechanism: a `hooks` object in
+// `~/.junie/config.json` (or a file passed with `--config-location`). A
+// project-local `.junie/config.json` is ignored by default "for safety", so a
+// per-checkout install would never fire — the global file is the only reliable
+// target.
+//
+// `hooks/hooks.json` stays the single source of truth for the event map; this
+// only rewrites `${JUNIE_PLUGIN_ROOT}` to this package's absolute path and
+// merges the result into the existing config, preserving every key Junie or the
+// user already owns. Entries are matched by their command containing this
+// package's root, so re-running replaces the previous install instead of
+// stacking duplicates. Because the installed commands point back at this
+// checkout, edits to `hooks/report.sh` take effect on Junie's next session with
+// no reinstall.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** One command Junie runs for a hook event. */
+interface JunieHookCommand {
+  type: string;
+  command: string;
+  timeout?: number;
+}
+
+/** One matcher group inside a hook event's array. */
+interface JunieHookEntry {
+  matcher?: string;
+  hooks: JunieHookCommand[];
+}
+
+/** Junie's global configuration file, of which only `hooks` is ours. */
+interface JunieConfig {
+  hooks?: Record<string, JunieHookEntry[]>;
+  [key: string]: unknown;
+}
+
+/** Where Junie reads its global configuration from. */
+const JUNIE_HOME = process.env.JUNIE_HOME ?? join(homedir(), ".junie");
+const CONFIG_PATH = join(JUNIE_HOME, "config.json");
+/**
+ * Path fragment that identifies this package's hook script in an installed
+ * command. The absolute plugin root changes per checkout (worktrees), so this
+ * marker lets a reinstall from a different checkout replace the previous
+ * install instead of stacking a second set of hooks.
+ */
+const HOOK_SCRIPT_MARKER = join("packages", "junie-plugin", "hooks", "report.sh");
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const template = readFileSync(join(root, "hooks", "hooks.json"), "utf8");
+const ours = (JSON.parse(template.replaceAll("${JUNIE_PLUGIN_ROOT}", root)) as JunieConfig).hooks;
+if (ours === undefined) {
+  throw new Error("hooks/hooks.json has no `hooks` object");
+}
+
+const existing = readConfig(CONFIG_PATH);
+const installed: JunieConfig = { ...existing, hooks: mergeHooks(existing.hooks ?? {}, ours, root) };
+
+mkdirSync(JUNIE_HOME, { recursive: true });
+writeFileSync(CONFIG_PATH, `${JSON.stringify(installed, null, 2)}\n`);
+
+process.stdout.write(`Installed the Pragma Junie hooks into ${CONFIG_PATH}\n`);
+process.stdout.write(`They run \`${join(root, "hooks", "report.sh")}\`.\n`);
+process.stdout.write("Start a new Junie session to load them.\n");
+
+/** Reads Junie's config, treating a missing file as an empty one. */
+function readConfig(path: string): JunieConfig {
+  if (!existsSync(path)) {
+    return {};
+  }
+  const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+  if (!isPlainObject(parsed)) {
+    throw new Error(`${path} is not a JSON object`);
+  }
+  return parsed as JunieConfig;
+}
+
+/**
+ * Merges this package's hook entries into the user's, dropping any entry a
+ * previous install of *this* package left behind so the result is idempotent.
+ * Hooks contributed by other tools are kept untouched.
+ */
+function mergeHooks(
+  existingHooks: Record<string, JunieHookEntry[]>,
+  ownHooks: Record<string, JunieHookEntry[]>,
+  pluginRoot: string,
+): Record<string, JunieHookEntry[]> {
+  const merged = dropOwnEntries(existingHooks, pluginRoot);
+  for (const [event, entries] of Object.entries(ownHooks)) {
+    merged[event] = [...(merged[event] ?? []), ...entries];
+  }
+  return merged;
+}
+
+/** Keeps only hook entries that do not belong to this package. */
+function dropOwnEntries(
+  existingHooks: Record<string, JunieHookEntry[]>,
+  pluginRoot: string,
+): Record<string, JunieHookEntry[]> {
+  const merged: Record<string, JunieHookEntry[]> = {};
+  for (const [event, entries] of Object.entries(existingHooks)) {
+    const kept = entries.filter((entry) => !isOwnEntry(entry, pluginRoot));
+    if (kept.length > 0) {
+      merged[event] = kept;
+    }
+  }
+  return merged;
+}
+
+/** True when every command in an entry comes from this package. */
+function isOwnEntry(entry: JunieHookEntry, pluginRoot: string): boolean {
+  return (entry.hooks ?? []).some((hook) => {
+    const command = hook.command ?? "";
+    // The absolute root changes per checkout (worktrees), so also match the
+    // package's hook-script path: reinstalling from a different worktree must
+    // replace the previous install instead of stacking a second set of hooks.
+    return command.includes(pluginRoot) || command.includes(HOOK_SCRIPT_MARKER);
+  });
+}
+
+/** Narrows an unknown to a plain object (not an array). */
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/acp.ts

@@ -0,0 +1,223 @@
+// Shared transport for the two things Pragma needs to read out of Junie: the
+// launcher's model catalog and the account's quota. Both come from a
+// short-lived `junie --acp=true` process speaking ACP (JSON-RPC 2.0) — Junie's
+// documented programmatic entry point — so neither the launcher nor the usage
+// provider ever reads Junie's credentials. Junie owns them and refreshes them
+// itself; Pragma never sees a token.
+//
+// Unlike a single-shot extension method, both answers require a *session*:
+// `session/new` returns the model catalog as ACP config options, and `/usage`
+// is a session slash command whose reply arrives as an `agent_message_chunk`
+// notification. The session id is only known after `session/new` answers, so
+// the shell below keeps Junie's stdin open through a FIFO and feeds the prompt
+// back once it has read the id. The program is POSIX-only (mkfifo, trap,
+// case…esac), so `readJunieAcp` probes for a POSIX shell before sending it —
+// `sdk.exec.run` uses the host's default shell, which is PowerShell or cmd on
+// Windows, where the program would only fail to parse. A Windows host
+// therefore reports Junie as missing rather than an empty catalog.
+// `--cache-dir` points Junie's caches at a throwaway directory so these probe
+// sessions leave nothing behind but an empty session folder (they never reach
+// `sessions/index.jsonl`, so they do not show up in `junie --resume`).
+import type { PluginContext } from "@pragma/plugin/catalog";
+
+/** Exit status the wrapper uses to say `junie` is not installed. */
+const MISSING_STATUS = 20;
+
+/** Request id of the `initialize` handshake. */
+const INITIALIZE_ID = 1;
+/** Request id of `session/new`, whose result carries the model catalog. */
+const SESSION_ID = 2;
+/** Request id of the `/usage` prompt. */
+const PROMPT_ID = 3;
+
+/** Poll cadence and bound the shell uses while waiting on Junie. */
+const POLL_SECONDS = "0.1";
+const POLL_ATTEMPTS = 900;
+
+/**
+ * Cheap POSIX-shell availability probe. Under PowerShell this parses as a
+ * subexpression and fails; under cmd `command` is not found; under any POSIX
+ * `sh` it exits 0. Written to fail in every non-POSIX shell rather than to
+ * succeed by accident.
+ */
+const SHELL_PROBE = "(command -v sh >/dev/null 2>&1) && exit 0 || exit 1";
+
+/** One JSON-RPC response line, already narrowed to result-or-error. */
+export type AcpResponse =
+  | { ok: true; result: unknown }
+  | { ok: false; message: string | null }
+  | undefined;
+
+/** Result of one `junie --acp=true` round trip. */
+export interface AcpSnapshot {
+  /** True when `junie` is not on PATH; every field below is then `undefined`. */
+  missing: boolean;
+  /**
+   * True when the host has no POSIX shell to run the ACP driver in (e.g. a
+   * Windows host, where `sdk.exec.run` lands in PowerShell or cmd). Treated
+   * like `missing` by callers, but lets the usage provider say why.
+   */
+  unsupportedShell: boolean;
+  /** The `session/new` response, whose `configOptions` hold the model catalog. */
+  session: AcpResponse;
+  /** Concatenated assistant text of the `/usage` reply, or null when not requested. */
+  usageText: string | null;
+}
+
+/**
+ * Runs the ACP handshake and returns the session response, optionally following
+ * it with the `/usage` slash command.
+ */
+export async function readJunieAcp(
+  ctx: PluginContext,
+  options: { usage: boolean },
+): Promise<AcpSnapshot> {
+  const cwd = ctx.project?.path ?? "/tmp";
+  // `sdk.exec.run` runs the command through the host's default shell. On
+  // Windows that is PowerShell or cmd, neither of which can parse the POSIX
+  // `sh` program below (mkfifo, trap, case…esac). Probe for `sh` first: with
+  // no POSIX shell there is no transport, and the model catalog and the usage
+  // refresh degrade to empty instead of failing on a parse error.
+  const [shell] = await ctx.sdk.exec.run({ cwd, commands: [SHELL_PROBE] });
+  if (shell?.status !== 0) {
+    return { missing: false, unsupportedShell: true, session: undefined, usageText: null };
+  }
+  const [result] = await ctx.sdk.exec.run({ cwd, commands: [buildCommand(options.usage)] });
+  if (result?.status === MISSING_STATUS) {
+    return { missing: true, unsupportedShell: false, session: undefined, usageText: null };
+  }
+  if (!result || result.status !== 0) {
+    throw new Error(result?.stderr.trim() || "Junie ACP request failed");
+  }
+  return {
+    missing: false,
+    unsupportedShell: false,
+    session: findResponse(result.stdout, SESSION_ID),
+    usageText: options.usage ? collectAgentText(result.stdout) : null,
+  };
+}
+
+/**
+ * Builds the POSIX `sh` program that drives one ACP conversation.
+ *
+ * A FIFO carries Junie's stdin so the writer can stay open while the reader
+ * decides what to send next: the prompt request is written to `$work/next` by
+ * the reader as soon as `session/new` answers, and the writer forwards it. The
+ * conversation ends when the reader sees the response it is waiting for, which
+ * closes the FIFO and makes Junie exit on EOF.
+ */
+function buildCommand(usage: boolean): string {
+  const finalId = usage ? PROMPT_ID : SESSION_ID;
+  return [
+    `command -v junie >/dev/null 2>&1 || exit ${MISSING_STATUS};`,
+    "work=$(mktemp -d) || exit 1;",
+    `trap 'rm -rf "$work"' 0;`,
+    'mkfifo "$work/in" || exit 1;',
+    "{",
+    `printf '%s\\n' ${shellQuote(request(INITIALIZE_ID, "initialize", { protocolVersion: 1, clientCapabilities: {} }))};`,
+    `printf '%s\\n' '{"jsonrpc":"2.0","id":${SESSION_ID},"method":"session/new","params":{"cwd":"'"$PWD"'","mcpServers":[]}}';`,
+    ...(usage
+      ? [
+          "n=0;",
+          `while [ ! -s "$work/next" ] && [ ! -e "$work/done" ] && [ "$n" -lt ${POLL_ATTEMPTS} ]; do sleep ${POLL_SECONDS}; n=$((n + 1)); done;`,
+          '[ -s "$work/next" ] && cat "$work/next";',
+        ]
+      : []),
+    "n=0;",
+    `while [ ! -e "$work/done" ] && [ "$n" -lt ${POLL_ATTEMPTS} ]; do sleep ${POLL_SECONDS}; n=$((n + 1)); done;`,
+    '} >"$work/in" &',
+    'junie --acp=true --skip-update-check --cache-dir "$work/cache" <"$work/in" 2>/dev/null |',
+    "while IFS= read -r line; do",
+    `printf '%s\\n' "$line";`,
+    ...(usage
+      ? [
+          `case "$line" in *'"sessionId":"'*)`,
+          'if [ ! -s "$work/next" ]; then',
+          `sid=$(printf '%s' "$line" | sed -n 's/.*"sessionId":"\\([^"]*\\)".*/\\1/p' | head -n 1);`,
+          'if [ -n "$sid" ]; then',
+          `printf '{"jsonrpc":"2.0","id":${PROMPT_ID},"method":"session/prompt","params":{"sessionId":"%s","prompt":[{"type":"text","text":"/usage"}]}}\\n' "$sid" >"$work/next";`,
+          "fi;",
+          "fi;",
+          ";; esac;",
+        ]
+      : []),
+    `case "$line" in *'"id":${finalId}'*) : >"$work/done" ;; esac;`,
+    "done",
+  ].join(" ");
+}
+
+/** Builds one JSON-RPC request line. */
+function request(id: number, method: string, params: unknown): string {
+  return JSON.stringify({ jsonrpc: "2.0", id, method, params });
+}
+
+/**
+ * Scans NDJSON output for the response to `id`. Junie interleaves notifications
+ * and answers, so lines that fail to parse or carry another id are skipped
+ * rather than treated as an error.
+ */
+export function findResponse(stdout: string, id: number): AcpResponse {
+  for (const line of stdout.split("\n")) {
+    let message: unknown;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const record = asRecord(message);
+    if (record === null || record.id !== id) {
+      continue;
+    }
+    if ("result" in record) {
+      return { ok: true, result: record.result };
+    }
+    return { ok: false, message: asText(asRecord(record.error)?.message) };
+  }
+  return undefined;
+}
+
+/** Concatenates every `agent_message_chunk` notification in an ACP stream. */
+export function collectAgentText(stdout: string): string {
+  const parts: string[] = [];
+  for (const line of stdout.split("\n")) {
+    let message: unknown;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const update = asRecord(asRecord(asRecord(message)?.params)?.update);
+    if (update?.sessionUpdate !== "agent_message_chunk") {
+      continue;
+    }
+    const text = asText(asRecord(update.content)?.text);
+    if (text !== null) {
+      parts.push(text);
+    }
+  }
+  return parts.join("");
+}
+
+/** Single-quotes a value for POSIX `sh`. */
+export function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+
+/**
+ * Narrows an unknown to a plain object, or null.
+ *
+ * Returning null rather than acting as a type predicate lets callers chain
+ * (`asRecord(x)?.y`) through Junie's deeply optional payloads without a nested
+ * `if` per level.
+ */
+export function asRecord(value: unknown): Record<string, unknown> | null {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+/** Returns a trimmed non-empty string, or null. */
+export function asText(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}

package/src/pragma-plugin.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+
+import { collectAgentText, findResponse } from "./acp";
+import { parseJunieModels } from "./pragma-plugin";
+
+/** A trimmed `session/new` result in the shape Junie 26.8.3 answers with. */
+const SESSION_RESULT = {
+  sessionId: "session-260806-110849-19an",
+  configOptions: [
+    {
+      type: "select",
+      id: "model",
+      currentValue: "gemini-3-flash-preview",
+      options: [
+        { value: "gemini-3-flash-preview", name: "Gemini 3 Flash Preview" },
+        { value: "claude-opus-5", name: "Claude Opus 5" },
+        { value: "broken" },
+      ],
+    },
+    {
+      type: "select",
+      id: "effort",
+      currentValue: "high",
+      options: [
+        { value: "low", name: "◎ Low effort" },
+        { value: "high", name: "◕ High effort" },
+      ],
+    },
+    { type: "select", id: "brave_mode", currentValue: "auto", options: [{ value: "off" }] },
+  ],
+};
+
+describe("parseJunieModels", () => {
+  it("reads the model catalog and attaches the shared effort levels", () => {
+    const reasoning = [
+      { id: "low", name: "◎ Low effort" },
+      { id: "high", name: "◕ High effort" },
+    ];
+    expect(parseJunieModels(SESSION_RESULT)).toEqual([
+      { id: "gemini-3-flash-preview", name: "Gemini 3 Flash Preview", reasoning },
+      { id: "claude-opus-5", name: "Claude Opus 5", reasoning },
+      { id: "broken", name: "broken", reasoning },
+    ]);
+  });
+
+  it("returns nothing for a result without config options", () => {
+    expect(parseJunieModels({ sessionId: "s" })).toEqual([]);
+    expect(parseJunieModels(null)).toEqual([]);
+  });
+});
+
+describe("findResponse", () => {
+  const stdout = [
+    '{"type":"…","method":"session/update","params":{}}',
+    "not json",
+    '{"id":2,"result":{"sessionId":"s"},"jsonrpc":"2.0"}',
+    '{"id":3,"error":{"message":"Method not found"},"jsonrpc":"2.0"}',
+  ].join("\n");
+
+  it("finds a result by request id", () => {
+    expect(findResponse(stdout, 2)).toEqual({ ok: true, result: { sessionId: "s" } });
+  });
+
+  it("surfaces an error response", () => {
+    expect(findResponse(stdout, 3)).toEqual({ ok: false, message: "Method not found" });
+  });
+
+  it("returns undefined when the response never arrived", () => {
+    expect(findResponse(stdout, 9)).toBeUndefined();
+  });
+});
+
+describe("collectAgentText", () => {
+  it("concatenates the agent message chunks of a slash-command reply", () => {
+    const stdout = [
+      '{"method":"session/update","params":{"update":{"sessionUpdate":"available_commands_update"}}}',
+      '{"method":"session/update","params":{"update":{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"License: X"}}}}',
+      '{"method":"session/update","params":{"update":{"sessionUpdate":"agent_message_chunk","content":{"type":"text","text":"Balance left: $1.00"}}}}',
+    ].join("\n");
+    expect(collectAgentText(stdout)).toBe("License: XBalance left: $1.00");
+  });
+});

package/src/pragma-plugin.ts

@@ -0,0 +1,193 @@
+import {
+  defineAgent,
+  definePlugin,
+  defineUsageLimitProvider,
+  type AgentModelEntry,
+  type PluginContext,
+  type PluginDefinition,
+} from "@pragma/plugin/catalog";
+import { createTuiWatcher } from "@pragma/watcher-kit";
+
+import { asRecord, asText, readJunieAcp } from "./acp";
+import { loadJunieUsageLimits, PRIMARY_LIMIT_ID } from "./usage-limits";
+
+export { loadJunieUsageLimits, parseJunieUsage } from "./usage-limits";
+
+/** Junie boots a JVM and paints its TUI a few seconds later; prefill after it. */
+const PREFILL_DELAY_MS = 6000;
+/** Each refresh spawns a short-lived `junie --acp=true` JVM; don't poll it hard. */
+const USAGE_REFRESH_INTERVAL_MS = 900_000;
+
+const baseWatcher = createTuiWatcher({
+  agent: "junie",
+  // Command approvals go through Junie's blocking `PermissionRequest` hook (see
+  // hooks/report.sh), so the watcher must not also answer them.
+  handleDecisions: false,
+  // Questions are different: `ask_user` / `ask_user_choice` are ordinary tools
+  // whose prompt Junie's own TUI owns, and no hook can return an answer to
+  // them, so a remote reply has to arrive as keystrokes.
+  handleQuestionAnswers: true,
+  // Junie's question list ignores digit shortcuts: it navigates with Down,
+  // marks the row with Space ("space to select"), and submits with Enter.
+  questionSelectMode: "arrow-space",
+  // Selection opens Junie's answer summary; one more Enter submits it.
+  questionFinalizeKeys: "\r",
+});
+
+/**
+ * Pragma plugin for the JetBrains Junie CLI, bundled to `dist/pragma-plugin.mjs`.
+ *
+ * Lifecycle reporting is a declarative hook bundle (`hooks/hooks.json` ->
+ * `hooks/report.sh`) merged into Junie's global `~/.junie/config.json` by
+ * `scripts/install-local.ts`, because Junie loads no in-process JavaScript
+ * plugin and ignores project-local hook config by default. This module
+ * contributes only the Pragma-side launcher, model provider, usage-limit
+ * provider and watcher.
+ */
+export const junieAgentPlugin: PluginDefinition = definePlugin({
+  name: "Junie",
+  description: "Launch the JetBrains Junie CLI from Pragma.",
+  usageLimits: [
+    defineUsageLimitProvider({
+      id: "junie",
+      title: "Junie",
+      dashboardUrl: "https://junie.jetbrains.com/cli",
+      iconPath: "assets/junie.svg",
+      primaryLimitId: PRIMARY_LIMIT_ID,
+      refreshIntervalMs: USAGE_REFRESH_INTERVAL_MS,
+      load: loadJunieUsageLimits,
+    }),
+  ],
+  watchers: [
+    {
+      agent: "junie",
+      async watch(ctx) {
+        try {
+          await baseWatcher.watch(ctx);
+        } finally {
+          // `SessionEnd` already clears a graceful exit; this covers a session
+          // killed hard enough that no hook runs.
+          try {
+            await ctx.sdk.agents.report({
+              agent: ctx.agentId,
+              tabId: ctx.session.tabId,
+              worktreeId: ctx.session.worktreeId,
+              status: "cleared",
+              attentionKind: null,
+            });
+          } catch {
+            // Session-exit cleanup must never disrupt watcher shutdown.
+          }
+        }
+      },
+    },
+  ],
+  agents: [
+    defineAgent({
+      id: "junie",
+      name: "Junie",
+      icon: () => null,
+      iconPath: "assets/junie.svg",
+      launch: { command: ["junie"] },
+      prefillDelayMs: PREFILL_DELAY_MS,
+      prefillMode: "plain",
+      prefillSubmit: "\r",
+      models: loadJunieModels,
+      // Junie's approval behaviour is the `brave_mode` setting, whose only
+      // command-line lever is `--brave` (equivalent to `Brave: on`). Leaving it
+      // off keeps whatever the user configured, which defaults to `auto`.
+      permissionModes: [
+        { id: "default", name: "Ask for approval" },
+        { id: "brave", name: "Brave mode (no approvals)" },
+      ],
+      // `subagents`: Junie runs subagents inside the same process and fires no
+      // per-agent hook (`PreToolUse` carries no agent or session id), so their
+      // start and finish are not observable from a hook bridge.
+      excludeFeatures: ["subagents"],
+      args: {
+        model: (modelId: string) => ["--model", modelId],
+        reasoning: (reasoningId: string) => ["--effort", reasoningId],
+        permissionMode: (permissionModeId: string) =>
+          permissionModeId === "brave" ? ["--brave"] : [],
+      },
+    }),
+  ],
+});
+
+export default junieAgentPlugin;
+
+/**
+ * Reads the launcher's model list from the ACP session handshake. Junie has no
+ * machine-readable `models` subcommand, but `session/new` answers with the same
+ * catalog its `/model` picker shows, as ACP config options.
+ */
+export async function loadJunieModels(ctx: PluginContext): Promise<AgentModelEntry[]> {
+  let snapshot;
+  try {
+    snapshot = await readJunieAcp(ctx, { usage: false });
+  } catch {
+    // The launcher must still open when Junie cannot be queried (offline, not
+    // signed in); Junie then starts on its own configured default model.
+    return [];
+  }
+  if (snapshot.missing || snapshot.session?.ok !== true) {
+    return [];
+  }
+  return parseJunieModels(snapshot.session.result);
+}
+
+/**
+ * Normalizes a `session/new` result's `configOptions` into launcher entries.
+ *
+ * Junie's reasoning effort is a session-wide setting rather than a per-model
+ * one, so the same effort list is attached to every model.
+ */
+export function parseJunieModels(value: unknown): AgentModelEntry[] {
+  const options = asRecord(value)?.configOptions;
+  const reasoning = parseReasoning(findOption(options, "effort"));
+  const models: AgentModelEntry[] = [];
+  for (const candidate of records(findOption(options, "model")?.options)) {
+    const id = asText(candidate.value);
+    if (id === null) {
+      continue;
+    }
+    const name = asText(candidate.name) ?? id;
+    models.push(reasoning.length > 0 ? { id, name, reasoning } : { id, name });
+  }
+  return models;
+}
+
+/** Finds one entry of a `configOptions` array by its `id`. */
+function findOption(value: unknown, id: string): Record<string, unknown> | undefined {
+  return records(value).find((option) => asText(option.id) === id);
+}
+
+/** Reads the selectable reasoning efforts, if Junie reported any. */
+function parseReasoning(
+  option: Record<string, unknown> | undefined,
+): NonNullable<AgentModelEntry["reasoning"]> {
+  const entries: NonNullable<AgentModelEntry["reasoning"]> = [];
+  for (const effort of records(option?.options)) {
+    const id = asText(effort.value);
+    if (id === null) {
+      continue;
+    }
+    entries.push({ id, name: asText(effort.name) ?? titleCase(id) });
+  }
+  return entries;
+}
+
+/** Keeps only the array entries that are plain objects. */
+function records(value: unknown): Record<string, unknown>[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    const record = asRecord(entry);
+    return record === null ? [] : [record];
+  });
+}
+
+function titleCase(value: string): string {
+  return `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}`;
+}