@moxxy/plugin-provider-acp 0.0.0-stage → 0.46.0

package/src/opencode-helpers.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+import type { OpenCodeEvent } from './opencode-api.js';
+import { OpenCodeHelpers } from './opencode-helpers.js';
+
+const PARENT = 'ses_parent';
+const CHILD = 'ses_child';
+
+const event = (type: string, properties: Record<string, unknown>): OpenCodeEvent => ({ type, properties });
+const taskPart = (background: boolean) =>
+  event('message.part.updated', {
+    sessionID: PARENT,
+    part: {
+      type: 'tool',
+      tool: 'task',
+      callID: 'call_1',
+      sessionID: PARENT,
+      state: { status: 'running', title: 'inspect', input: { description: 'inspect', prompt: 'p', ...(background ? { background: true } : {}) }, metadata: { sessionId: CHILD, ...(background ? { background: true } : {}) } },
+    },
+  });
+const childText = (id: string, text: string, finished = true) =>
+  event('message.part.updated', { sessionID: CHILD, part: { type: 'text', id, sessionID: CHILD, text, ...(finished ? { time: { start: 1, end: 2 } } : {}) } });
+const childIdle = event('session.status', { sessionID: CHILD, status: { type: 'idle' } });
+
+describe("OpenCode's subagents, read from its events", () => {
+  it('ends a background subagent that failed with the reason OpenCode gives', () => {
+    const helpers = new OpenCodeHelpers(() => PARENT);
+    helpers.take(taskPart(true));
+    helpers.take(event('session.error', { sessionID: CHILD, error: { name: 'APIError', data: { message: 'rate limited' } } }));
+
+    expect(helpers.take(childIdle)).toEqual({ steps: [{ type: 'subagent_completed', id: 'call_1', text: '', error: 'rate limited' }], workChanged: true });
+    expect(helpers.running()).toEqual([]);
+  });
+
+  it('keeps what a subagent did before the task call named its session, and shows it once named', () => {
+    const helpers = new OpenCodeHelpers(() => PARENT);
+    helpers.take(event('session.created', { sessionID: CHILD, info: { id: CHILD, parentID: PARENT } }));
+    helpers.take(childText('prt_task', 'the task itself', false));
+    helpers.take(childText('prt_1', 'Looking.'));
+
+    expect(helpers.take(taskPart(true))).toEqual({ steps: [{ type: 'subagent_message', id: 'call_1', text: 'Looking.' }], workChanged: true });
+  });
+
+  it("ignores other conversations' sessions", () => {
+    const helpers = new OpenCodeHelpers(() => PARENT);
+    helpers.take(taskPart(true));
+
+    expect(helpers.take(event('message.part.updated', { sessionID: 'ses_other', part: { type: 'text', id: 'x', text: 'hi', time: { end: 1 } } }))).toEqual({ steps: [], workChanged: false });
+    expect(helpers.running()).toEqual([{ id: 'call_1', kind: 'agent', label: 'inspect' }]);
+  });
+
+  it('leaves the end of a subagent the turn waits for to its task call', () => {
+    const helpers = new OpenCodeHelpers(() => PARENT);
+    helpers.take(taskPart(false));
+
+    expect(helpers.running()).toEqual([]);
+    expect(helpers.take(childIdle).steps).toEqual([]);
+  });
+
+  it('names the background work OpenCode prompted the conversation about, and whether it failed', () => {
+    const helpers = new OpenCodeHelpers(() => PARENT);
+    helpers.take(taskPart(true));
+    const result = event('message.part.updated', { sessionID: PARENT, part: { type: 'text', synthetic: true, text: `<task id="${CHILD}" state="error">\n<summary>Background task failed: inspect</summary></task>` } });
+
+    expect(helpers.take(result).finished).toEqual({ workId: 'call_1', label: 'inspect', failed: true });
+  });
+
+  it('stops only background work that still runs', () => {
+    const helpers = new OpenCodeHelpers(() => PARENT);
+    helpers.take(taskPart(true));
+
+    expect(helpers.stop('call_9')).toBeUndefined();
+    expect(helpers.stop('call_1')).toBe(CHILD);
+    expect(helpers.take(childIdle).steps).toEqual([{ type: 'subagent_completed', id: 'call_1', text: '', stopped: true }]);
+    expect(helpers.stop('call_1')).toBeUndefined();
+  });
+});

package/src/opencode-helpers.ts

@@ -0,0 +1,195 @@
+import type { AgentBackgroundWork, AgentStepEvent } from '@moxxy/sdk';
+import type { OpenCodeEvent } from './opencode-api.js';
+import { shownCall } from './translate.js';
+
+/** What one OpenCode event meant for the conversation. */
+export interface HelperNews {
+  /** What subagents did: their tools, what they said, how they ended. */
+  readonly steps: AgentStepEvent[];
+  /** The background work list changed. */
+  readonly workChanged: boolean;
+  /** OpenCode prompted the conversation's session itself with a background subagent's result: it starts a turn of its own. */
+  readonly finished?: { readonly workId: string; readonly label: string; readonly failed: boolean };
+  /** The conversation's session started or stopped working. */
+  readonly status?: 'busy' | 'idle';
+  /** OpenCode waits for the person's account limit (its free tier, its Go plan) to reset before it tries again. */
+  readonly limitReached?: true;
+}
+
+interface Helper {
+  /** The `task` call that started it: the id of its `subagent_*` events and of its background work. */
+  readonly callId: string;
+  readonly label: string;
+  readonly background: boolean;
+  /** Its last finished text, its answer once it ends. */
+  said: string;
+  error: string | undefined;
+  stopping: boolean;
+  done: boolean;
+  /** Its tool parts already shown. */
+  readonly shownTools: Set<string>;
+  readonly shownTexts: Set<string>;
+}
+
+/** Events of a subagent session OpenCode reported before the `task` call naming it; kept until it does. */
+const MAX_EARLY_EVENTS = 64;
+const TASK_TOOL = 'task';
+const ABORTED = 'MessageAbortedError';
+const TASK_RESULT = /^<task id="([^"]+)" state="([a-z]+)">/;
+/** Why OpenCode 1.19 retries when an account limit, not the provider, holds it up. */
+const LIMIT_REASONS = new Set(['free_tier_limit', 'account_rate_limit']);
+
+const quiet: HelperNews = { steps: [], workChanged: false };
+
+/**
+ * The subagents OpenCode runs in one conversation's session, read from its
+ * HTTP API's events: ACP reports a `task` call and its answer, not what the
+ * subagent does, nor the end of one working in the background (OpenCode 1.19,
+ * `task` with `background: true`). Each subagent works in a session of its
+ * own, named by the conversation's `task` tool part.
+ */
+export class OpenCodeHelpers {
+  /** By the subagent's session id. */
+  private readonly helpers = new Map<string, Helper>();
+  private readonly early = new Map<string, OpenCodeEvent[]>();
+
+  constructor(private readonly parent: () => string) {}
+
+  take(event: OpenCodeEvent): HelperNews {
+    const session = sessionOf(event);
+    if (!session) return quiet;
+    if (session === this.parent()) return this.fromParent(event);
+    if (event.type === 'session.created') {
+      const info = record(event.properties.info);
+      if (info.parentID === this.parent() && !this.helpers.has(session)) this.early.set(session, []);
+      return quiet;
+    }
+    const helper = this.helpers.get(session);
+    if (!helper) {
+      const kept = this.early.get(session);
+      if (kept && kept.length < MAX_EARLY_EVENTS) kept.push(event);
+      return quiet;
+    }
+    return this.fromHelper(helper, event);
+  }
+
+  /** What runs in the background now. */
+  running(): AgentBackgroundWork[] {
+    return [...this.helpers.values()].flatMap((helper) => (helper.background && !helper.done ? [{ id: helper.callId, kind: 'agent' as const, label: helper.label }] : []));
+  }
+
+  /** Whether the subagent of the `task` call `callId` works in the background. */
+  inBackground(callId: string): boolean {
+    for (const helper of this.helpers.values()) if (helper.callId === callId) return helper.background;
+    return false;
+  }
+
+  /** The session of the background subagent `workId` that still works, marked as being stopped by the person. */
+  stop(workId: string): string | undefined {
+    for (const [session, helper] of this.helpers) {
+      if (helper.callId !== workId || !helper.background || helper.done) continue;
+      helper.stopping = true;
+      return session;
+    }
+    return undefined;
+  }
+
+  /** Stopping it failed: its end is reported as it comes. */
+  unstop(workId: string): void {
+    for (const helper of this.helpers.values()) if (helper.callId === workId) helper.stopping = false;
+  }
+
+  /** The OpenCode running them is gone, and they with it. */
+  clear(): void {
+    this.helpers.clear();
+    this.early.clear();
+  }
+
+  private fromParent(event: OpenCodeEvent): HelperNews {
+    if (event.type === 'session.status') {
+      const status = record(event.properties.status);
+      if (status.type === 'retry') return { ...quiet, status: 'busy', ...(LIMIT_REASONS.has(String(record(status.action).reason)) ? { limitReached: true as const } : {}) };
+      return status.type === 'idle' || status.type === 'busy' ? { ...quiet, status: status.type } : quiet;
+    }
+    if (event.type !== 'message.part.updated') return quiet;
+    const part = record(event.properties.part);
+    if (part.type === 'tool' && part.tool === TASK_TOOL && typeof part.callID === 'string') return this.named(part.callID, record(part.state));
+    if (part.type === 'text' && part.synthetic === true && typeof part.text === 'string') {
+      const result = TASK_RESULT.exec(part.text);
+      const helper = result?.[1] ? this.helpers.get(result[1]) : undefined;
+      if (helper?.background) return { ...quiet, finished: { workId: helper.callId, label: helper.label, failed: result?.[2] !== 'completed' } };
+    }
+    return quiet;
+  }
+
+  /** The conversation's `task` call names its subagent's session once it runs. */
+  private named(callId: string, state: Record<string, unknown>): HelperNews {
+    const metadata = record(state.metadata);
+    const session = typeof metadata.sessionId === 'string' ? metadata.sessionId : undefined;
+    if (!session || this.helpers.has(session)) return quiet;
+    const input = record(state.input);
+    const label = text(input.description) ?? text(state.title) ?? 'subagent';
+    const background = metadata.background === true || input.background === true;
+    const helper: Helper = { callId, label, background, said: '', error: undefined, stopping: false, done: false, shownTools: new Set(), shownTexts: new Set() };
+    this.helpers.set(session, helper);
+    const early = this.early.get(session) ?? [];
+    this.early.delete(session);
+    const steps = early.flatMap((event) => this.fromHelper(helper, event).steps);
+    return { ...quiet, steps, workChanged: background };
+  }
+
+  private fromHelper(helper: Helper, event: OpenCodeEvent): HelperNews {
+    if (helper.done) return quiet;
+    if (event.type === 'session.error') {
+      const error = record(event.properties.error);
+      if (error.name === ABORTED) helper.stopping = true;
+      else helper.error = text(record(error.data).message) ?? text(error.name) ?? 'the subagent failed';
+      return quiet;
+    }
+    if (event.type === 'session.status') {
+      // A subagent the turn waits for ends with its `task` call, which ACP reports.
+      if (record(event.properties.status).type !== 'idle' || !helper.background) return quiet;
+      helper.done = true;
+      const end: AgentStepEvent = helper.stopping
+        ? { type: 'subagent_completed', id: helper.callId, text: helper.said, stopped: true }
+        : { type: 'subagent_completed', id: helper.callId, text: helper.said, ...(helper.error ? { error: helper.error } : {}) };
+      return { ...quiet, steps: [end], workChanged: true };
+    }
+    if (event.type !== 'message.part.updated') return quiet;
+    const part = record(event.properties.part);
+    const partId = text(part.id);
+    if (!partId) return quiet;
+    if (part.type === 'tool' && typeof part.tool === 'string') {
+      const state = record(part.state);
+      const input = record(state.input);
+      if (helper.shownTools.has(partId) || state.status === 'pending' || Object.keys(input).length === 0) return quiet;
+      helper.shownTools.add(partId);
+      const shown = shownCall(part.tool, undefined, input);
+      return { ...quiet, steps: [{ type: 'subagent_tool_call', id: helper.callId, name: shown.name, input: shown.input }] };
+    }
+    // What the subagent said, once a part of it is finished; its task, the first message of its session, has no time.
+    if (part.type === 'text' && part.synthetic !== true && record(part.time).end !== undefined) {
+      const said = text(part.text)?.trim();
+      if (!said || helper.shownTexts.has(partId)) return quiet;
+      helper.shownTexts.add(partId);
+      helper.said = said;
+      return { ...quiet, steps: [{ type: 'subagent_message', id: helper.callId, text: said }] };
+    }
+    return quiet;
+  }
+}
+
+function sessionOf(event: OpenCodeEvent): string | undefined {
+  const { sessionID } = event.properties;
+  if (typeof sessionID === 'string') return sessionID;
+  const fromPart = record(event.properties.part).sessionID;
+  return typeof fromPart === 'string' ? fromPart : undefined;
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+function text(value: unknown): string | undefined {
+  return typeof value === 'string' && value ? value : undefined;
+}

package/src/protocol.ts

@@ -0,0 +1,104 @@
+/**
+ * The part of the Agent Client Protocol (ACP, protocol version 1) Moxxy
+ * speaks, written by hand from recorded `opencode acp` 1.18.35 sessions.
+ * Agents send more than this; anything not listed here is left alone.
+ */
+
+export const ACP_PROTOCOL_VERSION = 1;
+
+export interface AcpSelectOption {
+  readonly value: string;
+  readonly name?: string;
+}
+
+/** A session setting the agent offers (`model`, `mode`, `effort`), changed with `session/set_config_option`. */
+export interface AcpConfigOption {
+  readonly id: string;
+  readonly name?: string;
+  /** `model`, `mode`, `thought_level`, … */
+  readonly category?: string;
+  readonly type: string;
+  readonly currentValue: string;
+  readonly options?: ReadonlyArray<AcpSelectOption>;
+}
+
+/** What `initialize` answers, as far as Moxxy reads it. */
+export interface AcpInitializeResponse {
+  readonly agentCapabilities?: { readonly sessionCapabilities?: { readonly list?: object } };
+}
+
+/** One page of `session/list`. */
+export interface AcpSessionList {
+  readonly sessions: ReadonlyArray<{ readonly sessionId: string; readonly cwd?: string }>;
+  readonly nextCursor?: string;
+}
+
+export interface AcpSessionResponse {
+  readonly sessionId?: string;
+  readonly configOptions?: ReadonlyArray<AcpConfigOption>;
+}
+
+export type AcpStopReason = 'end_turn' | 'max_tokens' | 'max_turn_requests' | 'refusal' | 'cancelled';
+
+export interface AcpUsage {
+  /** Prompt tokens not served from the cache. */
+  readonly inputTokens?: number;
+  readonly outputTokens?: number;
+  readonly thoughtTokens?: number;
+  readonly cachedReadTokens?: number;
+  readonly cachedWriteTokens?: number;
+  readonly totalTokens?: number;
+}
+
+export interface AcpPromptResponse {
+  readonly stopReason: AcpStopReason;
+  readonly usage?: AcpUsage;
+}
+
+export type AcpContentBlock =
+  | { readonly type: 'text'; readonly text: string }
+  | { readonly type: 'image'; readonly mimeType: string; readonly data: string }
+  | {
+      readonly type: 'resource';
+      readonly resource: { readonly uri: string; readonly mimeType?: string; readonly text?: string; readonly blob?: string };
+    };
+
+export type AcpToolKind = 'read' | 'edit' | 'delete' | 'move' | 'search' | 'execute' | 'think' | 'fetch' | 'switch_mode' | 'other';
+
+export type AcpToolStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+
+export type AcpToolCallContent =
+  | { readonly type: 'content'; readonly content: { readonly type: string; readonly text?: string } }
+  | { readonly type: 'diff'; readonly path: string; readonly oldText?: string | null; readonly newText: string }
+  | { readonly type: 'terminal'; readonly terminalId: string };
+
+/** A `tool_call` or `tool_call_update`: each update carries only what changed. */
+export interface AcpToolCall {
+  readonly toolCallId: string;
+  readonly title?: string;
+  readonly kind?: AcpToolKind;
+  readonly status?: AcpToolStatus;
+  readonly rawInput?: unknown;
+  readonly rawOutput?: unknown;
+  readonly content?: ReadonlyArray<AcpToolCallContent>;
+  readonly locations?: ReadonlyArray<{ readonly path: string }>;
+}
+
+export type AcpSessionUpdate =
+  | { readonly sessionUpdate: 'agent_message_chunk'; readonly messageId?: string; readonly content: { readonly type: string; readonly text?: string } }
+  | { readonly sessionUpdate: 'agent_thought_chunk'; readonly messageId?: string; readonly content: { readonly type: string; readonly text?: string } }
+  | ({ readonly sessionUpdate: 'tool_call' } & AcpToolCall)
+  | ({ readonly sessionUpdate: 'tool_call_update' } & AcpToolCall)
+  | { readonly sessionUpdate: string; readonly [key: string]: unknown };
+
+export type AcpPermissionOptionKind = 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
+
+export interface AcpPermissionRequest {
+  readonly sessionId: string;
+  readonly toolCall: AcpToolCall;
+  readonly options: ReadonlyArray<{ readonly optionId: string; readonly kind: AcpPermissionOptionKind; readonly name?: string }>;
+}
+
+export type AcpPermissionOutcome =
+  | { readonly outcome: { readonly outcome: 'selected'; readonly optionId: string } }
+  | { readonly outcome: { readonly outcome: 'cancelled' } };

package/src/rules.test.ts

@@ -0,0 +1,107 @@
+/** OpenCode's permission rules as `opencode debug agent <name>` reports them, read and turned into asks. */
+import { describe, expect, it } from 'vitest';
+import { askingConfig, askingRules, asksOutsideProject, openCodeOwnAutoApprove, runsWithoutAsking, type OpenCodeRule } from './rules.js';
+
+const rule = (permission: string, pattern: string, action: OpenCodeRule['action']): OpenCodeRule => ({ permission, pattern, action });
+
+/** OpenCode 1.18's defaults for the build agent, abridged. */
+const DEFAULTS: OpenCodeRule[] = [
+  rule('*', '*', 'allow'),
+  rule('doom_loop', '*', 'ask'),
+  rule('external_directory', '*', 'ask'),
+  rule('read', '*', 'allow'),
+  rule('read', '*.env', 'ask'),
+];
+
+describe('reading how OpenCode runs', () => {
+  it('runs without asking on its defaults', () => {
+    expect(runsWithoutAsking(DEFAULTS)).toBe(true);
+  });
+
+  it('asks when the person set it to ask before edits or commands', () => {
+    expect(runsWithoutAsking([...DEFAULTS, rule('edit', '*', 'ask')])).toBe(false);
+    expect(runsWithoutAsking([...DEFAULTS, rule('bash', '*', 'ask')])).toBe(false);
+  });
+
+  it('counts only the rule for any input, not one for a single command', () => {
+    expect(runsWithoutAsking([...DEFAULTS, rule('bash', 'git push *', 'ask')])).toBe(true);
+  });
+});
+
+describe('the rules that make OpenCode ask', () => {
+  it('turns what OpenCode allows into asks, before edits, commands and web requests', () => {
+    expect(askingRules(DEFAULTS)).toEqual({ edit: { '*': 'ask' }, bash: { '*': 'ask' }, webfetch: 'ask', websearch: 'ask' });
+  });
+
+  it('keeps what the person denied or set to ask, in their order', () => {
+    const rules = [...DEFAULTS, rule('bash', '*', 'allow'), rule('bash', 'git push *', 'deny'), rule('bash', 'git status', 'allow'), rule('webfetch', '*', 'deny')];
+
+    expect(askingRules(rules)).toEqual({
+      edit: { '*': 'ask' },
+      bash: { '*': 'ask', 'git push *': 'deny', 'git status': 'ask' },
+      webfetch: 'deny',
+      websearch: 'ask',
+    });
+    expect(Object.keys((askingRules(rules) as { bash: object }).bash)).toEqual(['*', 'git push *', 'git status']);
+  });
+
+  it('keeps a later rule for the same pattern, in its later place', () => {
+    const rules = [...DEFAULTS, rule('bash', 'rm *', 'deny'), rule('bash', 'ls', 'allow'), rule('bash', 'rm *', 'allow')];
+
+    expect(Object.entries((askingRules(rules) as { bash: object }).bash)).toEqual([
+      ['*', 'ask'],
+      ['ls', 'ask'],
+      ['rm *', 'ask'],
+    ]);
+  });
+
+  it('leaves edits denied where the agent denies them (OpenCode plan)', () => {
+    expect((askingRules([...DEFAULTS, rule('edit', '*', 'deny')]) as { edit: unknown }).edit).toEqual({ '*': 'deny' });
+  });
+
+  it('hands them to the agent the person runs, for this OpenCode only', () => {
+    expect(JSON.parse(askingConfig('build', DEFAULTS))).toEqual({ agent: { build: { permission: askingRules(DEFAULTS) } } });
+  });
+
+  it('keeps the inline config the person already passes OpenCode', () => {
+    const inline = JSON.stringify({ model: 'openai/gpt-6-luna', agent: { build: { temperature: 0.2, permission: { bash: 'allow' } }, review: { mode: 'subagent' } } });
+
+    expect(JSON.parse(askingConfig('build', DEFAULTS, inline))).toEqual({
+      model: 'openai/gpt-6-luna',
+      agent: { build: { temperature: 0.2, permission: askingRules(DEFAULTS) }, review: { mode: 'subagent' } },
+    });
+  });
+});
+
+describe('asks about work outside the project', () => {
+  it('knows them by the folder a file or a command names', () => {
+    expect(asksOutsideProject({ filepath: '/elsewhere/a.txt', parentDir: '/elsewhere' })).toBe(true);
+    expect(asksOutsideProject({ command: 'ls /elsewhere', directories: ['/elsewhere'], patterns: ['/elsewhere/*'] })).toBe(true);
+  });
+
+  it('leaves every other ask alone', () => {
+    expect(asksOutsideProject({ filepath: '/work/app/a.txt', diff: '+x' })).toBe(false);
+    expect(asksOutsideProject({ command: 'git push' })).toBe(false);
+    expect(asksOutsideProject(undefined)).toBe(false);
+  });
+});
+
+describe("the auto-approve of the person's own OpenCode", () => {
+  it("is read from the build agent's rules in the conversation folder: on when they ask for nothing", async () => {
+    const read: Array<{ cwd: string; agent: string }> = [];
+    const own = (rules: OpenCodeRule[] | undefined) =>
+      openCodeOwnAutoApprove('/work/app', async (opts) => {
+        read.push(opts);
+        return rules;
+      });
+
+    expect(await own(DEFAULTS)).toBe(true);
+    expect(await own([...DEFAULTS, rule('edit', '*', 'ask')])).toBe(false);
+    expect(await own(undefined)).toBeUndefined();
+    expect(read[0]).toEqual({ cwd: '/work/app', agent: 'build' });
+  });
+
+  it('is unknown when OpenCode cannot be asked', async () => {
+    expect(await openCodeOwnAutoApprove('/work/app', async () => Promise.reject(new Error('spawn opencode ENOENT')))).toBeUndefined();
+  });
+});

package/src/rules.ts

@@ -0,0 +1,102 @@
+/**
+ * OpenCode's permission rules, as `opencode debug agent <name>` reports them:
+ * an ordered list in which the last rule matching a permission and input wins.
+ */
+export interface OpenCodeRule {
+  readonly permission: string;
+  readonly pattern: string;
+  readonly action: 'allow' | 'ask' | 'deny';
+}
+
+type Action = OpenCodeRule['action'];
+
+/** Reads the rules of one of the person's OpenCode agents; `undefined` when OpenCode cannot say. */
+export type ReadAgentRules = (opts: { readonly cwd: string; readonly agent: string }) => Promise<ReadonlyArray<OpenCodeRule> | undefined>;
+
+/** Reads the names of the person's own MCP servers that are on; `undefined` when the agent cannot say. */
+export type ReadAgentMcpServers = (opts: { readonly cwd: string }) => Promise<ReadonlyArray<string> | undefined>;
+
+/** Permissions whose rules take an input pattern (a command, a path). */
+const PATTERNED = ['edit', 'bash'] as const;
+/** Permissions with one action for every input. */
+const UNPATTERNED = ['webfetch', 'websearch'] as const;
+
+/** Whether OpenCode edits files and runs commands without asking anyone. */
+export function runsWithoutAsking(rules: ReadonlyArray<OpenCodeRule>): boolean {
+  return PATTERNED.every((permission) => anyInput(rules, permission) === 'allow');
+}
+
+/**
+ * Whether the person's own OpenCode runs without asking in `cwd`, from its
+ * default `build` agent's rules; `undefined` when OpenCode cannot be asked.
+ */
+export async function openCodeOwnAutoApprove(cwd: string, readRules: ReadAgentRules): Promise<boolean | undefined> {
+  const rules = await readRules({ cwd, agent: 'build' }).catch(() => undefined);
+  return rules ? runsWithoutAsking(rules) : undefined;
+}
+
+/**
+ * The permission config that makes OpenCode ask before what it would do on its
+ * own. Each permission's rules are repeated in their order with every allow
+ * turned into an ask, so what the person denied stays denied. Given as the
+ * agent's own permissions, they come after every other rule and win.
+ */
+export function askingRules(rules: ReadonlyArray<OpenCodeRule>): Record<string, Action | Record<string, Action>> {
+  const config: Record<string, Action | Record<string, Action>> = {};
+  for (const permission of PATTERNED) {
+    const patterns = new Map<string, Action>();
+    for (const rule of rules) {
+      if (rule.permission !== permission && !(rule.pattern === '*' && matches(rule.permission, permission))) continue;
+      // An earlier rule for the same pattern never wins over this one.
+      patterns.delete(rule.pattern);
+      patterns.set(rule.pattern, asked(rule.action));
+    }
+    if (!patterns.has('*')) patterns.set('*', 'ask');
+    config[permission] = Object.fromEntries(patterns);
+  }
+  for (const permission of UNPATTERNED) config[permission] = asked(anyInput(rules, permission) ?? 'allow');
+  return config;
+}
+
+/**
+ * `OPENCODE_CONFIG_CONTENT` for an OpenCode that asks: the agent's permissions,
+ * nothing written to disk. Inline config the person already passes is kept;
+ * its rules are already among those read, so this agent's permissions replace them.
+ */
+export function askingConfig(agent: string, rules: ReadonlyArray<OpenCodeRule>, inline?: string): string {
+  let config: { agent?: Record<string, Record<string, unknown>> } & Record<string, unknown> = {};
+  try {
+    const parsed: unknown = inline ? JSON.parse(inline) : {};
+    if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) config = parsed as typeof config;
+  } catch {
+    // OpenCode skips inline config it cannot read; so does Moxxy.
+  }
+  const agents = config.agent ?? {};
+  return JSON.stringify({ ...config, agent: { ...agents, [agent]: { ...agents[agent], permission: askingRules(rules) } } });
+}
+
+/**
+ * Whether an ask is OpenCode's `external_directory`, which it puts to the
+ * person even on its defaults: about a file it names the parent folder
+ * (`parentDir`), about a command the folders (`directories`).
+ */
+export function asksOutsideProject(rawInput: unknown): boolean {
+  if (typeof rawInput !== 'object' || rawInput === null) return false;
+  const input = rawInput as Record<string, unknown>;
+  return typeof input.parentDir === 'string' || Array.isArray(input.directories);
+}
+
+/** The action for an input no narrower rule names. */
+function anyInput(rules: ReadonlyArray<OpenCodeRule>, permission: string): Action | undefined {
+  return rules.findLast((rule) => rule.pattern === '*' && matches(rule.permission, permission))?.action;
+}
+
+function asked(action: Action): Action {
+  return action === 'allow' ? 'ask' : action;
+}
+
+function matches(pattern: string, name: string): boolean {
+  if (!pattern.includes('*')) return pattern === name;
+  const source = pattern.split('*').map((part) => part.replace(/[.+?^${}()|[\]\\]/g, '\\$&')).join('.*');
+  return new RegExp(`^${source}$`).test(name);
+}