@mortz.prk/opencode-auto-mode 0.1.3 → 1.0.1

package/src/config.ts

@@ -1,27 +1,32 @@
-import type { PolicyOptions } from "./policy.js";
-import type { Decision } from "./reviewer.js";
-import { compileExpression } from "./rules.js";
+import { Model } from "@opencode/schema/model";
+import type { ReviewPolicy } from "./policy.js";
+import { logsUrl, type OtlpOptions } from "./otlp.js";
 
-export type ReviewerModel = { id: string; providerID: string; variant?: string };
-export type UserRule = { expression: string; decision: Decision };
+export type ReviewerModel = string;
+export type ReviewerModelRef = { id: string; providerID: string; variant?: string };
 export type DecisionProvider = {
-  model?: string;
   apiKeyEnv?: string;
   minConfidence?: number;
   timeoutMs?: number;
 };
+
+export type DecisionStage = {
+  type: "decision";
+  model: string;
+  endpoint?: string;
+  policy?: Partial<ReviewPolicy>;
+} & DecisionProvider;
+
 export type ClassifierStage =
   | { type: "static"; allowInProjectEdits?: boolean }
-  | { type: "rules"; rules: UserRule[] }
-  | ({ type: "jev" | "openai-decision" } & DecisionProvider)
-  | ({ type: "laya"; endpoint?: string } & DecisionProvider)
-  | { type: "llm"; model?: ReviewerModel };
-export interface AutoModeOptions extends PolicyOptions {
-  model?: ReviewerModel;
-  review?: "all" | "prompts";
-  agents?: string[];
-  allowInProjectEdits?: boolean;
-  classifier?: { stages: ClassifierStage[] };
+  | DecisionStage
+  | { type: "llm"; model?: ReviewerModel; policy?: Partial<ReviewPolicy> };
+
+export interface AutoModeOptions {
+  classifiers: ClassifierStage[];
+  tui?: boolean;
+  auditLog?: boolean | string;
+  otlp?: boolean | OtlpOptions;
 }
 
 export function object(value: unknown): value is Record<string, unknown> {
@@ -36,38 +41,53 @@ function only(value: Record<string, unknown>, keys: string[]): boolean {
   return Object.keys(value).every((key) => keys.includes(key));
 }
 
+export function parseReviewerModel(value: string): ReviewerModelRef {
+  const ref = Model.Ref.parse(value);
+  return {
+    id: ref.id,
+    providerID: ref.providerID,
+    ...(ref.variant === undefined ? {} : { variant: ref.variant }),
+  };
+}
+
 function model(value: unknown): value is ReviewerModel {
-  return object(value) && only(value, ["id", "providerID", "variant"]) &&
-    text(value.id) && text(value.providerID) && (value.variant === undefined || text(value.variant));
+  if (typeof value !== "string" || !text(value)) return false;
+  try { parseReviewerModel(value); return true; } catch { return false; }
 }
 
-function rule(value: unknown): value is UserRule {
-  if (!object(value) || !only(value, ["expression", "decision"]) || !text(value.expression) ||
-      typeof value.decision !== "string" || !["allow", "deny", "ask"].includes(value.decision)) return false;
-  try { compileExpression(value.expression); return true; } catch { return false; }
+function policy(value: unknown): value is Partial<ReviewPolicy> {
+  return object(value) && only(value, ["trusted", "blocks", "exceptions"]) &&
+    Object.values(value).every((list) => Array.isArray(list) && list.length <= 256 && list.every(text));
 }
 
 export function localEndpoint(value: string): string {
   const url = new URL(value);
   if (!['http:', 'https:'].includes(url.protocol) ||
       !['127.0.0.1', '[::1]'].includes(url.hostname) || url.username || url.password || url.search || url.hash ||
-      url.pathname !== '/v1/systemone') throw new Error("Laya requires a loopback /v1/systemone endpoint");
+      url.pathname !== '/v1/systemone') throw new Error("Local System One requires a loopback /v1/systemone endpoint");
   return url.href;
 }
 
-function stage(value: unknown): value is ClassifierStage {
-  if (!object(value)) return false;
-  if (value.type === "static") return only(value, ["type", "allowInProjectEdits"]) &&
-    (value.allowInProjectEdits === undefined || typeof value.allowInProjectEdits === "boolean");
-  if (value.type === "rules") return only(value, ["type", "rules"]) && Array.isArray(value.rules) &&
-    value.rules.length <= 256 && value.rules.every(rule);
-  if (value.type === "llm") return only(value, ["type", "model"]) &&
-    (value.model === undefined || model(value.model));
-  if (typeof value.type !== "string" || !["jev", "openai-decision", "laya"].includes(value.type)) return false;
-  if (!only(value, value.type === "laya" ?
-      ["type", "model", "apiKeyEnv", "minConfidence", "timeoutMs", "endpoint"] :
-      ["type", "model", "apiKeyEnv", "minConfidence", "timeoutMs"])) return false;
-  if (value.model !== undefined && !text(value.model)) return false;
+function otlp(value: unknown): value is OtlpOptions {
+  if (!object(value) || !only(value, ["endpoint", "headers", "timeoutMs"])) return false;
+  if (value.endpoint !== undefined) {
+    if (!text(value.endpoint)) return false;
+    try { logsUrl(value.endpoint); } catch { return false; }
+  }
+  if (value.headers !== undefined && (!object(value.headers) || Object.keys(value.headers).length > 32 ||
+      !Object.entries(value.headers).every(([key, header]) => /^[A-Za-z0-9-]{1,128}$/.test(key) && text(header)))) return false;
+  return value.timeoutMs === undefined || (typeof value.timeoutMs === "number" && Number.isInteger(value.timeoutMs) &&
+    value.timeoutMs >= 1 && value.timeoutMs <= 10_000);
+}
+
+export const DECISION_PROVIDERS = ["typesafe-ai", "laya", "openai"] as const;
+
+function decision(value: Record<string, unknown>): value is DecisionStage {
+  if (!only(value, ["type", "model", "apiKeyEnv", "minConfidence", "timeoutMs", "endpoint", "policy"])) return false;
+  if (value.policy !== undefined && !policy(value.policy)) return false;
+  if (!model(value.model)) return false;
+  const ref = parseReviewerModel(value.model);
+  if (ref.variant !== undefined || !(DECISION_PROVIDERS as readonly string[]).includes(ref.providerID)) return false;
   if (value.apiKeyEnv !== undefined &&
       (typeof value.apiKeyEnv !== "string" || !/^[A-Z_][A-Z0-9_]{0,127}$/.test(value.apiKeyEnv))) return false;
   if (value.minConfidence !== undefined &&
@@ -77,35 +97,32 @@ function stage(value: unknown): value is ClassifierStage {
       (typeof value.timeoutMs !== "number" || !Number.isInteger(value.timeoutMs) ||
        value.timeoutMs < 1 || value.timeoutMs > 30_000)) return false;
   if (value.endpoint !== undefined) {
-    if (!text(value.endpoint)) return false;
+    if (ref.providerID !== "laya" || !text(value.endpoint)) return false;
     try { localEndpoint(value.endpoint); } catch { return false; }
   }
   return true;
 }
 
+function stage(value: unknown): value is ClassifierStage {
+  if (!object(value)) return false;
+  if (value.type === "static") return only(value, ["type", "allowInProjectEdits"]) &&
+    (value.allowInProjectEdits === undefined || typeof value.allowInProjectEdits === "boolean");
+  if (value.type === "llm") return only(value, ["type", "model", "policy"]) &&
+    (value.model === undefined || model(value.model)) &&
+    (value.policy === undefined || policy(value.policy));
+  return value.type === "decision" && decision(value);
+}
+
 export function parseOptions(value: unknown): AutoModeOptions {
   if (!object(value)) throw new Error("Invalid auto-mode options");
-  if (!only(value, ["model", "review", "agents", "allowInProjectEdits", "classifier", "trusted", "blocks", "exceptions", "keybinds"]))
+  if (!only(value, ["classifiers", "tui", "auditLog", "otlp"]))
     throw new Error("Unknown auto-mode option");
-  if (value.model !== undefined && !model(value.model)) throw new Error("Invalid reviewer model");
-  if (value.review !== undefined && value.review !== "all" && value.review !== "prompts")
-    throw new Error("Invalid review scope");
-  for (const key of ["trusted", "blocks", "exceptions", "agents"]) {
-    if (value[key] !== undefined && (!Array.isArray(value[key]) || value[key].length > 256 || !value[key].every(text)))
-      throw new Error(`Invalid ${key}`);
-  }
-  if (value.allowInProjectEdits !== undefined && typeof value.allowInProjectEdits !== "boolean")
-    throw new Error("Invalid edit configuration");
-  if (value.classifier !== undefined && (!object(value.classifier) || !only(value.classifier, ["stages"]) ||
-      !Array.isArray(value.classifier.stages) || value.classifier.stages.length === 0 ||
-      value.classifier.stages.length > 16 || !value.classifier.stages.every(stage)))
-    throw new Error("Invalid classifier stages");
-  return value as AutoModeOptions;
-}
-
-export function stagesFor(options: AutoModeOptions): ClassifierStage[] {
-  return options.classifier?.stages ?? [
-    { type: "static", allowInProjectEdits: options.allowInProjectEdits === true },
-    { type: "llm", model: options.model },
-  ];
+  if (value.tui !== undefined && typeof value.tui !== "boolean") throw new Error("Invalid TUI setting");
+  if (value.auditLog !== undefined && typeof value.auditLog !== "boolean" && !text(value.auditLog))
+    throw new Error("Invalid audit log");
+  if (value.otlp !== undefined && typeof value.otlp !== "boolean" && !otlp(value.otlp)) throw new Error("Invalid OTLP options");
+  if (!Array.isArray(value.classifiers) || value.classifiers.length === 0 ||
+      value.classifiers.length > 16 || !value.classifiers.every(stage))
+    throw new Error("A valid nonempty classifiers array is required");
+  return value as unknown as AutoModeOptions;
 }

package/src/decisions.ts

@@ -0,0 +1,213 @@
+import { Effect } from "effect";
+import {
+  Evaluation,
+  EvaluationClient,
+  EvaluationModel,
+  EvaluationResponse,
+  type EvaluationAnswer,
+  type EvaluationInput,
+  type EvaluationRoute,
+} from "@opencode/ai/experimental";
+import { AIError, InvalidProviderOutputError, ModelID } from "@opencode/ai";
+import { localEndpoint, parseReviewerModel, type DecisionStage } from "./config.js";
+import { buildReviewPrompt, type Decision, type PermissionRequest, type StageResult } from "./reviewer.js";
+import type { ReviewPolicy } from "./policy.js";
+
+const choices = {
+  allow: "The whole action is safe and authorized by the user for this exact scope.",
+  deny: "The action violates the supplied policy or attempts to bypass a block.",
+  ask: "Authorization, evidence, or impact is uncertain; the human must decide.",
+} as const;
+const MAX_BYTES = 65_536;
+const SYSTEM_ONE_URL = "https://api.typesafe.ai/v1/systemone";
+const LOCAL_SYSTEM_ONE_URL = "http://127.0.0.1:8000/v1/systemone";
+const OPENAI_URL = "https://api.openai.com/v1/decisions";
+const API_KEY_ENV = {
+  "typesafe-ai": "TYPESAFE_API_KEY",
+  laya: "LAYA_API_KEY",
+  openai: "OPENAI_API_KEY",
+} as const;
+
+type RuntimeDecisionStage = DecisionStage & { readonly apiKey?: string };
+
+function probability(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+
+function object(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function answer(value: unknown, stage: RuntimeDecisionStage): StageResult {
+  if (!object(value) || value.type !== "choice" || typeof value.choice !== "string" || !Object.hasOwn(choices, value.choice) ||
+      !probability(value.confidence) || !object(value.probabilities))
+    throw new Error("Invalid decision response");
+  const entries = Object.entries(value.probabilities);
+  if (entries.length !== 3 || entries.some(([key, value]) => !Object.hasOwn(choices, key) || !probability(value)))
+    throw new Error("Invalid decision probabilities");
+  const probabilities = value.probabilities as Record<Decision, number>;
+  if (Math.abs(Object.values(probabilities).reduce((a, b) => a + b, 0) - 1) > 0.01 ||
+      probabilities[value.choice as Decision] < Math.max(...Object.values(probabilities)))
+    throw new Error("Inconsistent decision probabilities");
+  if (value.choice === "ask") return { decision: "ask", reason: `${stage.model} requested human review` };
+  const threshold = stage.minConfidence ?? 0.9;
+  if (value.confidence < threshold || probabilities[value.choice as Decision] < threshold) {
+    if (value.choice === "deny") return { decision: "ask", reason: `${stage.model} returned a low-confidence deny` };
+    return { decision: "abstain", reason: `${stage.model} abstained below the confidence threshold` };
+  }
+  return { decision: value.choice as Decision, reason: `${stage.model} decision (confidence ${value.confidence})` };
+}
+
+async function readJSON(response: Response): Promise<unknown> {
+  if (!response.ok || !response.body) throw new Error("Decision provider failed");
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.length;
+      if (size > MAX_BYTES) throw new Error("Decision response too large");
+      chunks.push(value);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } finally {
+    await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}
+
+function state(request: PermissionRequest): EvaluationInput {
+  const value = JSON.parse(JSON.stringify(request)) as EvaluationInput;
+  if (Buffer.byteLength(JSON.stringify(value)) > MAX_BYTES) throw new Error("Decision request too large");
+  return value;
+}
+
+function systemOneEndpoint(stage: RuntimeDecisionStage): string {
+  return stage.endpoint === undefined ? LOCAL_SYSTEM_ONE_URL : localEndpoint(stage.endpoint);
+}
+
+function evaluationChoice(value: unknown): EvaluationAnswer {
+  if (!object(value) || value.type !== "choice" || typeof value.choice !== "string") throw new Error("Invalid System One answer");
+  if (!object(value.probabilities) || !probability(value.confidence)) throw new Error("Invalid System One answer");
+  return {
+    type: "choice",
+    choice: value.choice,
+    probabilities: value.probabilities as Record<string, number>,
+    confidence: value.confidence,
+  };
+}
+
+function systemOneRoute(stage: RuntimeDecisionStage, modelID: string, url: string, fetcher: typeof fetch): EvaluationRoute {
+  return {
+    id: "system-one",
+    evaluate: (request) => Effect.tryPromise({
+      try: async () => {
+        const payload = JSON.stringify({ model: modelID, state: request.state, questions: request.questions });
+        if (Buffer.byteLength(payload) > MAX_BYTES) throw new Error("Decision request too large");
+        const response = await fetcher(url, {
+          method: "POST", redirect: "error", signal: AbortSignal.timeout(stage.timeoutMs ?? 10_000),
+          headers: { "Content-Type": "application/json", ...(stage.apiKey === undefined ? {} : { Authorization: `Bearer ${stage.apiKey}` }) },
+          body: payload,
+        });
+        const parsed = await readJSON(response);
+        const value = object(parsed) && object(parsed.answers) ? parsed.answers.permission : undefined;
+        return new EvaluationResponse({
+          model: ModelID.make(modelID),
+          answers: { permission: evaluationChoice(value) },
+        });
+      },
+      catch: (cause) => new AIError({
+        reason: new InvalidProviderOutputError({ route: "system-one", message: "System One request failed", cause }),
+      }),
+    }),
+  };
+}
+
+async function systemOneDecision(
+  stage: RuntimeDecisionStage,
+  request: PermissionRequest,
+  policy: ReviewPolicy,
+  fetcher: typeof fetch,
+): Promise<StageResult> {
+  const ref = parseReviewerModel(stage.model);
+  const key = stage.apiKey;
+  if (ref.providerID !== "laya" && !key) throw new Error("Missing decision provider credentials");
+  const model = EvaluationModel.make({
+    id: ref.id,
+    provider: ref.providerID,
+    route: systemOneRoute(stage, ref.id, ref.providerID === "laya" ? systemOneEndpoint(stage) : SYSTEM_ONE_URL, fetcher),
+  });
+  const response = await Effect.runPromise(
+    Evaluation.run({
+      model,
+      state: state(request),
+      questions: {
+        permission: { type: "choice", instructions: buildReviewPrompt(request, policy), criteria: choices },
+      },
+    }).pipe(Effect.provide(EvaluationClient.fetchLayer)),
+  );
+  return answer(response.answers.permission, stage);
+}
+
+async function openAIDecision(
+  stage: RuntimeDecisionStage,
+  request: PermissionRequest,
+  policy: ReviewPolicy,
+  fetcher: typeof fetch,
+): Promise<StageResult> {
+  const ref = parseReviewerModel(stage.model);
+  if (!stage.apiKey) throw new Error("Missing decision provider credentials");
+  const body = {
+    model: ref.id,
+    input: JSON.stringify(request),
+    questions: [{
+      name: "permission",
+      type: "choice",
+      instructions: buildReviewPrompt(request, policy),
+      choices: Object.entries(choices).map(([value, description]) => ({ value, description })),
+    }],
+  };
+  const payload = JSON.stringify(body);
+  if (Buffer.byteLength(payload) > MAX_BYTES) throw new Error("Decision request too large");
+  const response = await fetcher(OPENAI_URL, {
+    method: "POST", redirect: "error", signal: AbortSignal.timeout(stage.timeoutMs ?? 10_000),
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${stage.apiKey}` },
+    body: payload,
+  });
+  const parsed = await readJSON(response);
+  if (!object(parsed) || !Array.isArray(parsed.answers) || parsed.answers.length !== 1 || !object(parsed.answers[0]) ||
+      parsed.answers[0].name !== "permission") throw new Error("Invalid OpenAI answer");
+  const selected = parsed.answers[0];
+  if (selected.type === "refusal") return { decision: "abstain", reason: `${stage.model} declined the decision` };
+  if (!Array.isArray(selected.probabilities) || selected.probabilities.length !== 3)
+    throw new Error("Invalid OpenAI probabilities");
+  const distribution: Record<string, unknown> = {};
+  for (const entry of selected.probabilities) {
+    if (!object(entry) || typeof entry.value !== "string" || !Object.hasOwn(choices, entry.value) ||
+        Object.hasOwn(distribution, entry.value)) throw new Error("Invalid OpenAI probability entry");
+    distribution[entry.value] = entry.probability;
+  }
+  return answer({ ...selected, probabilities: distribution }, stage);
+}
+
+export async function decisionStage(
+  input: DecisionStage,
+  request: PermissionRequest,
+  policy: ReviewPolicy,
+  fetcher: typeof fetch = fetch,
+): Promise<StageResult> {
+  try {
+    const ref = parseReviewerModel(input.model);
+    if (!Object.hasOwn(API_KEY_ENV, ref.providerID)) throw new Error("Unsupported decision provider");
+    const stage: RuntimeDecisionStage = {
+      ...input,
+      apiKey: process.env[input.apiKeyEnv ?? API_KEY_ENV[ref.providerID as keyof typeof API_KEY_ENV]],
+    };
+    return ref.providerID === "openai" ? await openAIDecision(stage, request, policy, fetcher) :
+      await systemOneDecision(stage, request, policy, fetcher);
+  } catch {
+    return { decision: "abstain", reason: `${input.model} unavailable or returned an invalid decision` };
+  }
+}

package/src/index.ts

@@ -1,36 +1,50 @@
 import { Plugin } from "@opencode/plugin";
 import { createLogger } from "./logger.js";
-import { recordDecision } from "./state.js";
+import { clearConfigError, recordConfigError, recordDecision } from "./state.js";
 import { defaultPolicy } from "./policy.js";
-import { extractTranscript } from "./transcript.js";
+import { extractReviewContext } from "./transcript.js";
 import { scanResultContent, withInjectionWarning } from "./probe.js";
-import { buildStage1Prompt, buildStage2Prompt, parseDecision, parseStage1, withDenySuffix, type PermissionRequest, type ReviewResult } from "./reviewer.js";
-import { parseOptions, stagesFor, type ReviewerModel } from "./config.js";
+import { buildStage1Prompt, buildStage2Prompt, parseDecision, parseStage1, withDenySuffix, type PermissionRequest, type ReviewResult, type StageResult } from "./reviewer.js";
+import { parseOptions, parseReviewerModel, type ReviewerModelRef } from "./config.js";
 import { compositeDecision } from "./classifier.js";
-import { providerDecision } from "./providers.js";
+import { decisionStage } from "./decisions.js";
+import { createAuditLog } from "./audit.js";
+import { createOtlpExporter } from "./otlp.js";
+import { createTraceExporter } from "./traces.js";
 
-export type { AutoModeOptions, ClassifierStage, DecisionProvider, UserRule, ReviewerModel } from "./config.js";
+export type { AutoModeOptions, ClassifierStage, DecisionProvider, DecisionStage, ReviewerModel } from "./config.js";
 
 export default Plugin.define({
   id: "opencode-auto-mode",
   setup: async (ctx) => {
     const log = createLogger("events.log");
+    const directory = ctx.location?.directory;
     let options: ReturnType<typeof parseOptions> | undefined;
-    try { options = parseOptions(ctx.options); }
-    catch { log.log("Invalid configuration; automatic approval disabled"); }
+    try {
+      options = parseOptions(ctx.options);
+      if (directory !== undefined) clearConfigError(directory);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      log.log(`Invalid configuration; automatic approval disabled: ${detail}`);
+      if (directory !== undefined) recordConfigError(directory, detail);
+    }
+    const sinks = [createAuditLog(options?.auditLog), createOtlpExporter(options?.otlp)].filter((sink) => sink !== undefined);
+    const traces = createTraceExporter(options?.otlp);
     const counts = new Map<string, number>();
     let reviewCounter = 0;
     const permissionRegistration = await ctx.permission.hook("evaluate", async (event) => {
-      if (event.effect === "deny") return;
+      if (event.effect !== "ask") return;
       if (!options) {
         event.effect = "ask";
         event.message = "Invalid auto-mode configuration; please decide yourself";
         return;
       }
-      if (options.agents && (!event.agent || !options.agents.includes(event.agent))) return;
-      if (options.review === "prompts" && event.effect !== "ask") return;
       const reviewID = `review-${process.pid}-${Date.now()}-${reviewCounter++}`;
       recordDecision({ requestID: reviewID, sessionID: event.sessionID, decision: "reviewing", action: event.action.slice(0, 128), reason: "", at: Date.now() });
+      const startedAt = Date.now();
+      const trace = traces?.begin(startedAt);
+      const hostEffect = event.effect;
+      let failure: string | undefined;
       let result: ReviewResult;
       try {
         const info = await withTimeout(ctx.session.get({ sessionID: event.sessionID }), 3_000).catch(() => undefined);
@@ -40,20 +54,38 @@ export default Plugin.define({
           isDelegation: event.action === "task" || event.action === "subagent",
         };
         let contextLoaded = false;
-        result = await compositeDecision(stagesFor(options), request, async (stage) => {
+        let contextComplete = false;
+        let contextReason = "User authorization context is unavailable";
+        result = await compositeDecision(options.classifiers, request, async (stage) => {
           if (!contextLoaded) {
             const messages = await withTimeout(ctx.session.context({ sessionID: event.sessionID }), 3_000);
-            request.transcript = extractTranscript(messages);
+            const context = extractReviewContext(messages);
+            request.transcript = context.transcript;
+            contextComplete = context.complete;
+            contextReason = context.reason ?? contextReason;
             contextLoaded = true;
           }
-          if (!request.transcript?.startsWith("User messages") || request.transcript.includes("…"))
-            return { decision: "ask", reason: "User authorization context is unavailable" };
-          const policy = defaultPolicy(options);
-          return stage.type === "llm" ? llmDecision(ctx, request, policy, stage.model ?? options?.model) :
-            providerDecision(stage, request, policy);
+          if (!contextComplete)
+            return { decision: "ask", reason: contextReason };
+          const policy = defaultPolicy(stage.policy);
+          const attemptStartedAt = Date.now();
+          let outcome: StageResult;
+          try {
+            outcome = stage.type === "llm" ? await llmDecision(ctx, request, policy, stage.model, info?.model) :
+              await decisionStage(stage, request, policy);
+          } catch {
+            outcome = { decision: "abstain", reason: `${stage.type} reviewer unavailable` };
+          }
+          trace?.attempts.push({
+            index: options.classifiers.indexOf(stage), type: stage.type,
+            model: stage.model ?? (info?.model ? `${info.model.providerID}/${info.model.id}` : undefined),
+            startedAt: attemptStartedAt, durationMs: Date.now() - attemptStartedAt, result: outcome,
+          });
+          return outcome;
         });
-      } catch {
-        result = { decision: "ask", reason: "Auto-mode review failed; please decide yourself" };
+      } catch (error) {
+        failure = error instanceof Error ? error.message : String(error);
+        result = { decision: "ask", reason: "Auto-mode review failed; please decide yourself", stage: "error" };
       }
       event.effect = result.decision;
       event.message = result.decision === "deny" ? withDenySuffix(result.reason) : result.reason;
@@ -63,6 +95,15 @@ export default Plugin.define({
         counts.set(event.sessionID, count);
         log.log(`Action denied (${count} in session)`);
       }
+      const auditRecord = {
+        ts: new Date().toISOString(), reviewID, sessionID: event.sessionID, agent: event.agent,
+        action: event.action, resources: [...event.resources], hostEffect,
+        decision: result.decision, stage: result.stage ?? "unknown", reason: result.reason,
+        durationMs: Date.now() - startedAt, ...(failure !== undefined ? { error: true, errorDetail: failure } : {}),
+        ...(trace ? { traceID: trace.traceID, spanID: trace.spanID } : {}),
+      };
+      trace?.finish(auditRecord);
+      for (const sink of sinks) sink.write(auditRecord);
       recordDecision({ requestID: reviewID, sessionID: event.sessionID, decision: event.effect, reason: "", at: Date.now() });
     });
     const toolRegistration = await ctx.tool.hook("execute.after", (event) => {
@@ -85,15 +126,17 @@ export default Plugin.define({
 });
 
 interface ReviewerContext {
-  generate: { text(input: { prompt: string; model?: ReviewerModel | null }): Promise<{ text: string }> };
+  generate: { text(input: { prompt: string; model?: ReviewerModelRef | null }): Promise<{ text: string }> };
 }
 
-async function llmDecision(ctx: ReviewerContext, request: PermissionRequest, policy: ReturnType<typeof defaultPolicy>, model?: ReviewerModel): Promise<ReviewResult> {
+async function llmDecision(ctx: ReviewerContext, request: PermissionRequest, policy: ReturnType<typeof defaultPolicy>, model?: string, sessionModel?: ReviewerModelRef): Promise<StageResult> {
+  const ref = model ? parseReviewerModel(model) : sessionModel;
+  if (!ref) return { decision: "abstain", reason: "Session model is unavailable; configure a reviewer model" };
   const prompt = buildStage1Prompt(request, policy);
   if (Buffer.byteLength(prompt) > 65_536) return { decision: "ask", reason: "Request too large for automatic review" };
-  const triage = await withTimeout(ctx.generate.text({ prompt, model: model ?? null }), 30_000);
+  const triage = await withTimeout(ctx.generate.text({ prompt, model: ref }), 30_000);
   if (parseStage1(triage.text) === "allow") return { decision: "allow", reason: "LLM triage approved" };
-  const response = await withTimeout(ctx.generate.text({ prompt: buildStage2Prompt(request, policy), model: model ?? null }), 30_000);
+  const response = await withTimeout(ctx.generate.text({ prompt: buildStage2Prompt(request, policy), model: ref }), 30_000);
   return parseDecision(response.text);
 }
 

package/src/otlp.ts

@@ -0,0 +1,74 @@
+import type { AuditLog, AuditRecord } from "./audit.js";
+
+export interface OtlpOptions { endpoint?: string; headers?: Record<string, string>; timeoutMs?: number }
+
+const MAX_TIMEOUT_MS = 10_000;
+
+function parseHeaders(raw: string | undefined): Record<string, string> {
+  const headers: Record<string, string> = {};
+  for (const pair of (raw ?? "").split(",")) {
+    const index = pair.indexOf("=");
+    if (index > 0) headers[pair.slice(0, index).trim()] = pair.slice(index + 1).trim();
+  }
+  return headers;
+}
+
+export function logsUrl(base: string): string {
+  const url = new URL(base);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new Error("Invalid OTLP endpoint");
+  if (!url.pathname.endsWith("/v1/logs")) url.pathname = `${url.pathname.replace(/\/+$/, "")}/v1/logs`;
+  return url.href;
+}
+
+const attr = (key: string, value: string | number | boolean) => ({
+  key,
+  value: typeof value === "string" ? { stringValue: value } : typeof value === "boolean" ? { boolValue: value } : { intValue: String(value) },
+});
+
+export function toLogRecord(record: AuditRecord) {
+  const severity = record.decision === "deny" ? { severityNumber: 13, severityText: "WARN" } : { severityNumber: 9, severityText: "INFO" };
+  return {
+    timeUnixNano: String(BigInt(Date.parse(record.ts)) * 1_000_000n),
+    ...(record.traceID === undefined ? {} : { traceId: record.traceID, spanId: record.spanID }),
+    ...severity,
+    body: { stringValue: record.reason },
+    attributes: [
+      attr("event.name", "auto_mode.decision"),
+      attr("session.id", record.sessionID),
+      attr("review.id", record.reviewID),
+      attr("agent", record.agent ?? ""),
+      attr("action", record.action),
+      attr("resources", record.resources.join(" ; ")),
+      attr("host_effect", record.hostEffect),
+      attr("decision", record.decision),
+      attr("stage", record.stage),
+      attr("duration_ms", record.durationMs),
+      attr("error", record.error === true),
+      ...(record.errorDetail === undefined ? [] : [attr("error.detail", record.errorDetail)]),
+    ],
+  };
+}
+
+/** Exports each decision as an OTLP/HTTP JSON log record. Defaults follow the OpenCode telemetry environment. */
+export function createOtlpExporter(setting: boolean | OtlpOptions | undefined, env: NodeJS.ProcessEnv = process.env): AuditLog | undefined {
+  if (setting === undefined || setting === false) return undefined;
+  const options = setting === true ? {} : setting;
+  const base = options.endpoint ?? env.OPENCODE_OTLP_ENDPOINT ?? env.OTEL_EXPORTER_OTLP_ENDPOINT;
+  if (!base) return undefined;
+  let url: string;
+  try { url = logsUrl(base); } catch { return undefined; }
+  const headers = { "content-type": "application/json", ...parseHeaders(env.OTEL_EXPORTER_OTLP_HEADERS), ...parseHeaders(env.OPENCODE_OTLP_HEADERS), ...options.headers };
+  const timeout = Math.min(options.timeoutMs ?? 3_000, MAX_TIMEOUT_MS);
+  return {
+    write(record) {
+      const body = JSON.stringify({
+        resourceLogs: [{
+          resource: { attributes: [attr("service.name", "opencode-auto-mode")] },
+          scopeLogs: [{ scope: { name: "opencode-auto-mode" }, logRecords: [toLogRecord(record)] }],
+        }],
+      });
+      // Fire and forget: telemetry must never delay or fail a permission review.
+      fetch(url, { method: "POST", headers, body, signal: AbortSignal.timeout(timeout), redirect: "error" }).catch(() => {});
+    },
+  };
+}

package/src/policy.ts

@@ -4,12 +4,6 @@ export interface ReviewPolicy {
   exceptions: string[];
 }
 
-export interface PolicyOptions {
-  trusted?: string[];
-  blocks?: string[];
-  exceptions?: string[];
-}
-
 const DEFAULT_TRUSTED = [
   "the git repo in the session's working directory (reviewable via version control)",
 ];
@@ -33,10 +27,10 @@ const DEFAULT_EXCEPTIONS = [
   "Read-only inspection (listing, diffing, dry runs) before a guarded action.",
 ];
 
-export function defaultPolicy(options?: PolicyOptions): ReviewPolicy {
+export function defaultPolicy(options?: Partial<ReviewPolicy>): ReviewPolicy {
   return {
-    trusted: options?.trusted?.length ? options.trusted : [...DEFAULT_TRUSTED],
-    blocks: options?.blocks?.length ? options.blocks : [...DEFAULT_BLOCKS],
-    exceptions: options?.exceptions?.length ? options.exceptions : [...DEFAULT_EXCEPTIONS],
+    trusted: [...(options?.trusted ?? DEFAULT_TRUSTED)],
+    blocks: [...(options?.blocks ?? DEFAULT_BLOCKS)],
+    exceptions: [...(options?.exceptions ?? DEFAULT_EXCEPTIONS)],
   };
 }