portable-agent-layer 0.84.5 → 0.85.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.84.5",
+  "version": "0.85.1",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {

package/src/cli/index.ts

@@ -49,6 +49,7 @@ import {
 import { inference, previewInferenceRoute } from "../hooks/lib/inference";
 import { logDebug, recentHookErrors } from "../hooks/lib/log";
 import { ensureRegistered, writeRegistryEntry } from "../hooks/lib/machine";
+import { opencodeBackgroundModel } from "../hooks/lib/opencode-config";
 import { palHome, palPkg, paths, platform, toPath } from "../hooks/lib/paths";
 import { auditBindings, describeBindingIssue } from "../hooks/lib/projects";
 import { telosStatus } from "../hooks/lib/telos-topics";
@@ -1051,6 +1052,14 @@ function doctor(silent = false): DoctorResult {
         ok(`Would route to: ${preview.route} (${preview.reason})`);
       }
     }
+    if (opencode.available) {
+      const model = opencodeBackgroundModel();
+      model
+        ? ok(`opencode background model: ${model}`)
+        : warn(
+            `opencode background model: not pinned — background inference uses the model last picked in the TUI. Pin one with "model" in ${resolve(platform.opencodeDir(), "config.json")}`
+          );
+    }
     if (process.env.PAL_INFERENCE_DISABLED === "1") {
       warn(
         "PAL_INFERENCE_DISABLED=1 — test kill-switch leaked into prod env; every inference call will return failure"

package/src/hooks/lib/inference.ts

@@ -31,8 +31,9 @@ import {
   isCursor,
   isOpencode,
 } from "./agent";
-import { logDebug } from "./log";
+import { logDebug, logError } from "./log";
 import { HAIKU_MODEL } from "./models";
+import { writeInstructionFreeConfig } from "./opencode-config";
 import { buildSpawnGuardEnv, getInferenceDepth, SPAWN_GUARD_ENV } from "./spawn-guard";
 import { findBinaryOnPath } from "./which";
 
@@ -171,13 +172,7 @@ export async function inference(opts: InferenceOptions): Promise<InferenceResult
     const bin = getOpencodeBinary();
     if (bin) {
       logDebug("inference", `${tag} route=opencode-spawn agent=${agent}`);
-      return inferenceViaCliSpawn(
-        bin,
-        buildOpencodeArgs(opts),
-        buildCliPrompt(opts),
-        opts,
-        extractOpencodeText
-      );
+      return inferenceViaOpencodeSpawn(bin, opts);
     }
   }
   if (isCopilot()) {
@@ -366,6 +361,34 @@ export function buildOpencodeArgs(_opts: InferenceOptions): string[] {
   return ["run", "--pure", "--format", "json"];
 }
 
+// Without its own AGENTS.md, opencode falls back to ~/.claude/CLAUDE.md, and it
+// lists every Claude and external skill in its tool description.
+const OPENCODE_WITHOUT_EXTERNAL_CONTEXT = {
+  OPENCODE_DISABLE_CLAUDE_CODE: "1",
+  OPENCODE_DISABLE_EXTERNAL_SKILLS: "1",
+};
+
+/** Runs from an empty directory so no project AGENTS.md is in reach either. */
+async function inferenceViaOpencodeSpawn(
+  bin: string,
+  opts: InferenceOptions
+): Promise<InferenceResult> {
+  const dir = await mkdtemp(join(tmpdir(), "pal-opencode-"));
+  try {
+    writeInstructionFreeConfig(dir);
+    return await inferenceViaCliSpawn(
+      bin,
+      buildOpencodeArgs(opts),
+      buildCliPrompt(opts),
+      opts,
+      extractOpencodeText,
+      { cwd: dir, env: { XDG_CONFIG_HOME: dir, ...OPENCODE_WITHOUT_EXTERNAL_CONTEXT } }
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
 /**
  * Build the argv for `cursor-agent -p …` from inference options. Pure.
  *
@@ -513,7 +536,8 @@ async function singleCliAttempt(
   args: string[],
   stdinInput: string,
   env: NodeJS.ProcessEnv,
-  timeout: number
+  timeout: number,
+  cwd?: string
 ): Promise<RawSpawnResult> {
   return new Promise<RawSpawnResult>((resolve) => {
     let stdout = "";
@@ -530,13 +554,14 @@ async function singleCliAttempt(
     try {
       proc = Bun.spawn([binary, ...args], {
         env,
+        cwd,
         stdin: "pipe",
         stdout: "pipe",
         stderr: "pipe",
         windowsHide: true,
       });
     } catch (err) {
-      void logError("inference:spawn", err);
+      logError("inference:spawn", err);
       finish({ code: null, stdout: "", stderr: "", timedOut: false });
       return;
     }
@@ -563,7 +588,7 @@ async function singleCliAttempt(
         if (stdinInput) stdinWriter.write(stdinInput);
         stdinWriter.end();
       } catch (err) {
-        void logError("inference:stdin", err);
+        logError("inference:stdin", err);
       }
     }
 
@@ -593,6 +618,11 @@ async function singleCliAttempt(
   });
 }
 
+interface SpawnPlace {
+  cwd?: string;
+  env?: Record<string, string>;
+}
+
 /**
  * Generic CLI dispatcher: spawn `binary args`, write stdinInput to stdin (may be
  * empty for argv-only CLIs like codex), capture stdout, retry once on empty-abort.
@@ -603,10 +633,11 @@ async function inferenceViaCliSpawn(
   args: string[],
   stdinInput: string,
   opts: InferenceOptions,
-  extractText?: (rawStdout: string) => string
+  extractText?: (rawStdout: string) => string,
+  place: SpawnPlace = {}
 ): Promise<InferenceResult> {
   const timeout = opts.timeout ?? 15000;
-  const env = buildSpawnGuardEnv(process.env);
+  const env = { ...buildSpawnGuardEnv(process.env), ...place.env };
   const started = Date.now();
   const caller = opts.caller ?? "anonymous";
   const session = opts.sessionId ?? "-";
@@ -616,7 +647,7 @@ async function inferenceViaCliSpawn(
   const binaryName = basename(binary).replace(/\.(cmd|bat|exe|com)$/i, "");
 
   // Attempt 1
-  let attempt = await singleCliAttempt(binary, args, stdinInput, env, timeout);
+  let attempt = await singleCliAttempt(binary, args, stdinInput, env, timeout, place.cwd);
 
   // Universal retry on empty-output exit≠0 (correlates strongly with burst-
   // concurrency races — the binary silently aborts without writing to either
@@ -633,7 +664,7 @@ async function inferenceViaCliSpawn(
       `${tag} retry: empty-abort binary=${binaryName} exit=${attempt.code} after ${Date.now() - started}ms, jitter=${jitterMs}ms`
     );
     await new Promise((r) => setTimeout(r, jitterMs));
-    attempt = await singleCliAttempt(binary, args, stdinInput, env, timeout);
+    attempt = await singleCliAttempt(binary, args, stdinInput, env, timeout, place.cwd);
   }
 
   const elapsedMs = Date.now() - started;
@@ -646,14 +677,11 @@ async function inferenceViaCliSpawn(
   };
 
   if (attempt.timedOut) {
-    void logError(
-      "inference:spawn",
-      `${tag} timeout binary=${binaryName} after ${timeout}ms`
-    );
+    logError("inference:spawn", `${tag} timeout binary=${binaryName} after ${timeout}ms`);
     return finish({ success: false });
   }
   if (attempt.code !== 0) {
-    void logError(
+    logError(
       "inference:spawn",
       `${tag} exited=${attempt.code} binary=${binaryName} argv=${JSON.stringify(args)} stderr(${attempt.stderr.length})=${attempt.stderr.slice(0, 300)} stdout(${attempt.stdout.length})=${attempt.stdout.slice(0, 300)}`
     );
@@ -665,7 +693,7 @@ async function inferenceViaCliSpawn(
   if (!text) {
     // Extraction returned empty — the binary succeeded but our extractor found
     // no usable text. Log the raw stdout so we can see what was actually emitted.
-    void logError(
+    logError(
       "inference:spawn",
       `${tag} extract-empty binary=${binaryName} rawStdout(${rawText.length})=${rawText.slice(0, 500)}`
     );
@@ -679,11 +707,6 @@ async function inferenceViaCliSpawn(
   return finish({ success: true, output: text });
 }
 
-async function logError(scope: string, err: unknown): Promise<void> {
-  const { logError: log } = await import("./log");
-  log(scope, err);
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Anthropic API path — used when no claude binary is available, or when the
 // active agent is not claude. Preserves the original PAL inference behavior.
@@ -733,7 +756,7 @@ async function inferenceViaApi(opts: InferenceOptions): Promise<InferenceResult>
 
     if (!response.ok) {
       const errBody = await response.text().catch(() => "");
-      await logError("inference", `HTTP ${response.status}: ${errBody.slice(0, 200)}`);
+      logError("inference", `HTTP ${response.status}: ${errBody.slice(0, 200)}`);
       return { success: false };
     }
 
@@ -752,7 +775,7 @@ async function inferenceViaApi(opts: InferenceOptions): Promise<InferenceResult>
 
     return { success: true, output: text, usage };
   } catch (err) {
-    await logError("inference", err);
+    logError("inference", err);
     return { success: false };
   }
 }
@@ -813,10 +836,7 @@ async function inferenceViaOpenAiApi(opts: InferenceOptions): Promise<InferenceR
 
     if (!response.ok) {
       const errBody = await response.text().catch(() => "");
-      await logError(
-        "inference:openai",
-        `HTTP ${response.status}: ${errBody.slice(0, 200)}`
-      );
+      logError("inference:openai", `HTTP ${response.status}: ${errBody.slice(0, 200)}`);
       return { success: false };
     }
 
@@ -840,7 +860,7 @@ async function inferenceViaOpenAiApi(opts: InferenceOptions): Promise<InferenceR
 
     return { success: true, output: text, usage };
   } catch (err) {
-    await logError("inference:openai", err);
+    logError("inference:openai", err);
     return { success: false };
   }
 }

package/src/hooks/lib/opencode-config.ts

@@ -0,0 +1,50 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { platform } from "./paths";
+
+const GLOBAL_CONFIG_FILES = ["config.json", "opencode.json", "opencode.jsonc"];
+
+type OpencodeConfig = Record<string, unknown>;
+
+function readConfig(name: string): OpencodeConfig | null {
+  try {
+    const config = Bun.JSONC.parse(
+      readFileSync(resolve(platform.opencodeDir(), name), "utf-8")
+    );
+    return config && typeof config === "object" ? (config as OpencodeConfig) : null;
+  } catch {
+    return null;
+  }
+}
+
+function pinnedModel(config: OpencodeConfig | null): string | null {
+  return typeof config?.model === "string" && config.model ? config.model : null;
+}
+
+/** Without a pinned model, `opencode run` falls back to whatever was last picked in the TUI. */
+export function opencodeBackgroundModel(): string | null {
+  for (const name of GLOBAL_CONFIG_FILES) {
+    const model = pinnedModel(readConfig(name));
+    if (model) return model;
+  }
+  return null;
+}
+
+function withoutInstructions(config: OpencodeConfig): OpencodeConfig {
+  const { instructions: _, ...rest } = config;
+  return rest;
+}
+
+/**
+ * opencode loads the global AGENTS.md and every `instructions` file into each run,
+ * so PAL's identity and output format would reach background inference too.
+ */
+export function writeInstructionFreeConfig(configHome: string): void {
+  const dir = resolve(configHome, "opencode");
+  mkdirSync(dir, { recursive: true });
+  for (const name of GLOBAL_CONFIG_FILES) {
+    const config = readConfig(name);
+    if (config)
+      writeFileSync(resolve(dir, name), JSON.stringify(withoutInstructions(config)));
+  }
+}

package/src/targets/opencode/plugin.ts

@@ -25,6 +25,10 @@ async function lib<T>(mod: string): Promise<T> {
 
 type TranscriptMessage = { role: string; content: string };
 
+function isSessionEvent(type: string): boolean {
+  return type.startsWith("session.");
+}
+
 const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
   // Pre-load shared modules
   const { buildSystemReminder } =
@@ -125,7 +129,7 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
     // --- Session events: start and stop handling ---
     event: async ({ event }) => {
       if (isPalSpawnedInference()) return;
-      logDebug("opencode:event", `Event: ${event.type}`);
+      if (isSessionEvent(event.type)) logDebug("opencode:event", `Event: ${event.type}`);
 
       if (event.type === "server.instance.disposed") {
         const { autoUpdateOnClose } =
@@ -139,7 +143,7 @@ const PALPlugin: Plugin = async ({ directory, client }: PluginInput) => {
         regenerateIfNeeded();
       }
 
-      if (event.type === "session.idle" || event.type === "session.diff") {
+      if (event.type === "session.idle") {
         logDebug("opencode:event", "Running stop handlers...");
         try {
           const sessionID = (event as { properties?: { sessionID?: string } })?.properties