portable-agent-layer 0.84.5 → 0.85.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.84.5",
+  "version": "0.85.2",
   "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/interaction-reaction.ts

@@ -9,13 +9,16 @@ import { extractKeywords, similarity } from "./text-similarity";
 export type Reaction = "corrected" | "repeated" | "approved" | "new-topic" | "follow-up";
 
 const CORRECTION_RE =
-  /^(?:(?:no|nope|wrong)(?:[,.!]|$)|(?:that'?s|this is|it'?s) (?:wrong|not)\b|not what i\b|i said\b|i told you\b|you forgot\b|you missed\b|still (?:broken|failing|wrong)\b)/i;
+  /^(?:(?:no|nope|wrong)(?:[,.!]|$)|(?:that'?s|this is|it'?s) (?:wrong|not)\b|not what i\b|i said\b|i told you\b|you forgot\b|you missed\b|still (?:broken|failing|wrong)\b|i don'?t see (?:the|your) (?!(?:problem|issue|point|harm|difference|need|reason)\b))/i;
+
+const CLAIM_DISPUTED_RE =
+  /\byou(?:'re| are) (?:partially |partly |completely |totally )?wrong\b|\b(?:isn'?t|wasn'?t|aren'?t|weren'?t) (?:added|included|fixed|pushed|committed|applied|merged)\b/i;
 
 const APPROVAL_RE =
-  /^(?:good|great|nice|perfect|cool|amazing|awesome|excellent|brilliant|works|it works|thanks|thank you|thx|y+e+s+|yep|yeah|yup|sure|exactly|correct|agreed|lgtm|well done|love it|sounds good|looks good|that'?s it|(?:it|this|that) (?:is|'s) (?:fine|good|great|right))\b/i;
+  /^(?:(?:understood|got it|ok(?:ay)?),?\s+)?(?:good|great|nice|perfect|cool|amazing|awesome|excellent|brilliant|works|it works|thanks|thank you|thx|y+e+s+|yep|yeah|yup|sure|exactly|correct|agreed|lgtm|well done|love it|sounds good|looks good|that'?s it|(?:it|this|that) (?:is|'s) (?:fine|good|great|right))\b/i;
 
 const GO_AHEAD_RE =
-  /^(?:go ahead|go|do it|proceed|continue|merge|push|ship|commit|build|start|fix (?:all|them|both)|approved|let'?s (?:see|do|go))\b/i;
+  /^(?:go ahead|go|do it|proceed|continue|merge|push|ship|commit|build|start|fix (?:all|them|both)|approved|let'?s (?:see|do|go|build|start|fix|ship)|(?:add|do|fix) (?:it )?(?:pls|please))\b/i;
 
 const NEW_TOPIC_RE =
   /^(?:(?:ok(?:ay)?|btw|also),?\s+)?(?:new (?:\w+ ){0,2}(?:task|topic|question|thing)|(?:different|unrelated|separate|another) (?:task|topic|question|thing)|unrelated\b|switching (?:gears|topics?)|change of (?:topic|subject))/i;
@@ -23,11 +26,13 @@ const NEW_TOPIC_RE =
 const GO_AHEAD_MAX_WORDS = 6;
 const BARE_OK_RE = /^(?:ok(?:ay)?|k)[,.!]?(?:\s+\S+){0,2}$/i;
 const HEDGE_RE = /\b(?:but|however|though|except|instead)\b/i;
+const FAILURE_RE = /\b(?:fail(?:ed|s|ing)?|broken|broke|errors?|crash(?:ed|es)?)\b/i;
 const REPEAT_SIMILARITY = 0.6;
 const REPEAT_MIN_KEYWORDS = 5;
 
 export function isCorrection(text: string): boolean {
-  return CORRECTION_RE.test(text.trim());
+  const trimmed = text.trim();
+  return CORRECTION_RE.test(trimmed) || CLAIM_DISPUTED_RE.test(trimmed);
 }
 
 export function isRepeat(text: string, previous: string | undefined): boolean {
@@ -39,21 +44,21 @@ function isShortGoAhead(sentence: string): boolean {
   return GO_AHEAD_RE.test(sentence) && sentence.split(/\s+/).length <= GO_AHEAD_MAX_WORDS;
 }
 
-function lastSentence(text: string): string {
-  return (
-    text
-      .split(/[.!\n]\s*/)
-      .filter(Boolean)
-      .at(-1)
-      ?.trim() ?? ""
-  );
+function sentences(text: string): string[] {
+  return text
+    .split(/[.!\n]\s*/)
+    .map((s) => s.trim())
+    .filter(Boolean);
 }
 
 function isApproval(text: string): boolean {
   const trimmed = text.trim();
-  if (trimmed.includes("?") || HEDGE_RE.test(trimmed.split(/[.!?\n]/)[0])) return false;
+  if (trimmed.includes("?") || FAILURE_RE.test(trimmed)) return false;
+  if (HEDGE_RE.test(trimmed.split(/[.!?\n]/)[0])) return false;
   if (APPROVAL_RE.test(trimmed) || BARE_OK_RE.test(trimmed)) return true;
-  return isShortGoAhead(trimmed) || isShortGoAhead(lastSentence(trimmed));
+  const all = sentences(trimmed);
+  if (isShortGoAhead(all.at(-1) ?? "")) return true;
+  return isShortGoAhead(all[0] ?? "") && !HEDGE_RE.test(trimmed);
 }
 
 /** Word overlap was measured against real messages and does not separate topics; only saying so does. */

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