@khalilgharbaoui/opencode-claude-code-plugin 0.52.0 → 0.53.1

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/claude-code-language-model.ts
-import { join as join13 } from "path";
+import { join as join15 } from "path";
 
 // src/ids.ts
 import { randomInt } from "crypto";
@@ -1844,6 +1844,9 @@ function failoverUntil(resetsAt) {
   return resetsAtToMs(resetsAt);
 }
 
+// src/subagent-dispatch.ts
+import { join as join4 } from "path";
+
 // src/agent-models.ts
 import { readFile, readdir } from "fs/promises";
 import path2 from "path";
@@ -2441,6 +2444,252 @@ function agentDirectories(home, projectDirectory) {
   return directories;
 }
 
+// src/dispatch-choice-store.ts
+import { mkdirSync as mkdirSync2, readFileSync, renameSync as renameSync2, writeFileSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join2 } from "path";
+var MAX_DISPATCH_CHOICE_SESSIONS = 128;
+var MAX_DISPATCH_CHOICES_PER_SESSION = 32;
+var DISPATCH_CHOICE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var sessions = null;
+var pathOverride = null;
+function dispatchChoiceStorePath() {
+  if (pathOverride) return pathOverride;
+  const stateRoot = process.env.XDG_STATE_HOME || join2(homedir3(), ".local", "state");
+  return join2(stateRoot, "opencode-claude-code-plugin", "subagent-dispatch.json");
+}
+function isChoice(value) {
+  const choice = value;
+  if (!choice || typeof choice !== "object" || Array.isArray(choice)) return false;
+  const ok = (field) => field === void 0 || typeof field === "string";
+  if (!ok(choice.model) || !ok(choice.effort) || !ok(choice.account)) return false;
+  return !!(choice.model || choice.effort || choice.account);
+}
+function isSessionRecord(value) {
+  const record = value;
+  if (!record || typeof record !== "object" || Array.isArray(record)) return false;
+  if (typeof record.updatedAt !== "number" || !Number.isFinite(record.updatedAt)) {
+    return false;
+  }
+  const choices = record.choices;
+  if (!choices || typeof choices !== "object" || Array.isArray(choices)) return false;
+  return Object.values(choices).every(isChoice);
+}
+function trimChoices(choices) {
+  const entries = Object.entries(choices).filter(([, choice]) => isChoice(choice));
+  return Object.fromEntries(entries.slice(-MAX_DISPATCH_CHOICES_PER_SESSION));
+}
+function readFile2(file) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    const entries = parsed && typeof parsed === "object" ? parsed.sessions : null;
+    if (!entries || typeof entries !== "object") return out;
+    const cutoff = Date.now() - DISPATCH_CHOICE_MAX_AGE_MS;
+    const valid = Object.entries(entries).filter((entry) => isSessionRecord(entry[1])).filter(([, record]) => record.updatedAt >= cutoff).sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+    for (const [key, record] of valid) out.set(key, record);
+  } catch {
+  }
+  return out;
+}
+function load() {
+  if (!sessions) sessions = readFile2(dispatchChoiceStorePath());
+  return sessions;
+}
+function save(update) {
+  const file = dispatchChoiceStorePath();
+  const merged = readFile2(file);
+  update(merged);
+  const cutoff = Date.now() - DISPATCH_CHOICE_MAX_AGE_MS;
+  const kept = [...merged.entries()].filter(([, record]) => record.updatedAt >= cutoff).filter(([, record]) => Object.keys(record.choices).length > 0).sort((a, b) => a[1].updatedAt - b[1].updatedAt).slice(-MAX_DISPATCH_CHOICE_SESSIONS);
+  sessions = new Map(kept);
+  try {
+    mkdirSync2(join2(file, ".."), { recursive: true, mode: 448 });
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
+      mode: 384
+    });
+    renameSync2(tmp, file);
+  } catch (err) {
+    log.debug("could not write the subagent dispatch choice store", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function readDispatchChoice(opencodeSessionId, agent) {
+  if (!opencodeSessionId || opencodeSessionId === "default") return void 0;
+  const record = load().get(opencodeSessionId);
+  const choice = record?.choices[agent];
+  return choice ? { ...choice } : void 0;
+}
+function writeDispatchChoice(opencodeSessionId, agent, choice) {
+  if (!opencodeSessionId || opencodeSessionId === "default" || !agent) return;
+  const stored = {
+    ...choice.model ? { model: choice.model } : {},
+    ...choice.effort ? { effort: choice.effort } : {},
+    ...choice.account ? { account: choice.account } : {}
+  };
+  if (!isChoice(stored)) return;
+  const current = load().get(opencodeSessionId)?.choices[agent];
+  if (current && current.model === stored.model && current.effort === stored.effort && current.account === stored.account) {
+    return;
+  }
+  save((merged) => {
+    const record = merged.get(opencodeSessionId) ?? { choices: {}, updatedAt: 0 };
+    const choices = { ...record.choices };
+    delete choices[agent];
+    choices[agent] = stored;
+    merged.delete(opencodeSessionId);
+    merged.set(opencodeSessionId, {
+      choices: trimChoices(choices),
+      updatedAt: Date.now()
+    });
+  });
+}
+function forgetDispatchChoices(opencodeSessionId) {
+  if (!load().has(opencodeSessionId)) return;
+  save((merged) => {
+    merged.delete(opencodeSessionId);
+  });
+}
+
+// src/tmp.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path3 from "path";
+var PLUGIN_TMP_PREFIX = "opencode-claude-code-";
+var PID_TMP_DIR = path3.join(
+  os.tmpdir(),
+  `${PLUGIN_TMP_PREFIX}${process.pid}`
+);
+var currentDir = null;
+var createdDirs = /* @__PURE__ */ new Set();
+var registered = false;
+function currentUid() {
+  return typeof process.getuid === "function" ? process.getuid() : void 0;
+}
+function untrustworthyReason(dir) {
+  let stat;
+  try {
+    stat = fs.lstatSync(dir);
+  } catch {
+    return null;
+  }
+  if (stat.isSymbolicLink()) return "path is a symlink";
+  if (!stat.isDirectory()) return "path is not a directory";
+  const uid = currentUid();
+  if (uid !== void 0 && stat.uid !== uid) {
+    return `directory is owned by uid ${stat.uid}, not ${uid}`;
+  }
+  return null;
+}
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    fs.chmodSync(dir, 448);
+  } catch {
+  }
+}
+function chooseDir() {
+  const reason = untrustworthyReason(PID_TMP_DIR);
+  if (!reason) return PID_TMP_DIR;
+  const fallback = fs.mkdtempSync(path3.join(os.tmpdir(), PLUGIN_TMP_PREFIX));
+  log.warn("refusing the pid-named scratch directory", {
+    path: PID_TMP_DIR,
+    reason,
+    fallback
+  });
+  return fallback;
+}
+function registerExitCleanup() {
+  if (registered) return;
+  registered = true;
+  process.on("exit", () => {
+    for (const dir of createdDirs) {
+      try {
+        fs.rmSync(dir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  });
+}
+var PID_DIR_NAME = /^opencode-claude-code-(\d+)$/;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function sweepStalePluginTmpDirs(keep) {
+  const removed = [];
+  if (process.env.OPENCODE_CLAUDE_CODE_NO_TMP_SWEEP === "1") return removed;
+  const root = os.tmpdir();
+  let entries;
+  try {
+    entries = fs.readdirSync(root);
+  } catch {
+    return removed;
+  }
+  const uid = currentUid();
+  const keepPath = keep ? path3.resolve(keep) : null;
+  for (const entry of entries) {
+    const match = PID_DIR_NAME.exec(entry);
+    if (!match) continue;
+    const pid = Number(match[1]);
+    if (!Number.isSafeInteger(pid) || pid <= 0) continue;
+    if (pid === process.pid) continue;
+    const dir = path3.join(root, entry);
+    if (keepPath && path3.resolve(dir) === keepPath) continue;
+    let stat;
+    try {
+      stat = fs.lstatSync(dir);
+    } catch {
+      continue;
+    }
+    if (stat.isSymbolicLink() || !stat.isDirectory()) continue;
+    if (uid !== void 0 && stat.uid !== uid) continue;
+    if (isProcessAlive(pid)) continue;
+    try {
+      fs.rmSync(dir, { recursive: true, force: true });
+      removed.push(dir);
+    } catch (err) {
+      log.debug("could not remove a stale scratch directory", {
+        dir,
+        error: String(err)
+      });
+    }
+  }
+  if (removed.length > 0) {
+    log.info("removed stale plugin scratch directories", {
+      count: removed.length,
+      dirs: removed
+    });
+  }
+  return removed;
+}
+var swept = false;
+function sweepOnce(keep) {
+  if (swept) return;
+  swept = true;
+  try {
+    sweepStalePluginTmpDirs(keep);
+  } catch (err) {
+    log.warn("stale scratch directory sweep failed", { error: String(err) });
+  }
+}
+function pluginTmpDir() {
+  if (currentDir === null || untrustworthyReason(currentDir) !== null) {
+    currentDir = chooseDir();
+  }
+  ensureDir(currentDir);
+  createdDirs.add(currentDir);
+  registerExitCleanup();
+  sweepOnce(currentDir);
+  return currentDir;
+}
+
 // src/subagent-dispatch.ts
 var SUBAGENT_DISPATCH_MARKER = "\u258C **subagent dispatch:**";
 var SUBAGENT_DISPATCH_TOOL_CALL_PREFIX = "subagent_dispatch_";
@@ -2449,6 +2698,7 @@ var DEFAULT_ANSWER = "Default";
 var LAST_ANSWER_PREFIX = "Same as last time";
 var CUSTOMISE_ANSWER = "Customise\u2026";
 var PER_TASK_ANSWER = "Per task\u2026";
+var PER_TYPE_ANSWER = "Per type\u2026";
 var DISPATCH_COMBOS = [
   {
     model: "claude-haiku-5-5",
@@ -2487,30 +2737,49 @@ function isSubagentDispatchActive(input) {
   if (input.configured !== "ask") return false;
   return input.opencodeHasQuestion;
 }
-var lastChoices = /* @__PURE__ */ new Map();
-var MAX_REMEMBERED_CHOICES = 256;
-function lastChoiceKey(parentSessionId, agent) {
-  return `${parentSessionId}${KEY_SEPARATOR3}${agent}`;
-}
 function rememberDispatchChoice(parentSessionId, agent, choice) {
-  if (!parentSessionId || parentSessionId === "default") return;
-  const key = lastChoiceKey(parentSessionId, agent);
-  lastChoices.delete(key);
-  lastChoices.set(key, { ...choice });
-  while (lastChoices.size > MAX_REMEMBERED_CHOICES) {
-    const oldest = lastChoices.keys().next().value;
-    if (oldest === void 0) break;
-    lastChoices.delete(oldest);
-  }
+  writeDispatchChoice(parentSessionId, agent, choice);
 }
 function recallDispatchChoice(parentSessionId, agent) {
-  return lastChoices.get(lastChoiceKey(parentSessionId, agent));
+  return readDispatchChoice(parentSessionId, agent);
+}
+function forgetDispatchChoicesForSession(opencodeSessionId) {
+  forgetDispatchChoices(opencodeSessionId);
+}
+function usableRemembered(context, agent) {
+  const remembered = recallDispatchChoice(context.parentSessionId, agent);
+  if (!remembered) return void 0;
+  const choice = {};
+  if (remembered.model && Object.hasOwn(defaultModels, remembered.model)) {
+    choice.model = remembered.model;
+  }
+  if (remembered.effort && REASONING_EFFORTS.includes(remembered.effort)) {
+    choice.effort = remembered.effort;
+  }
+  let droppedAccount;
+  if (remembered.account) {
+    if (dispatchAccountCandidates(context).includes(remembered.account)) {
+      choice.account = remembered.account;
+    } else {
+      droppedAccount = remembered.account;
+    }
+  }
+  if (!choice.model && !choice.effort && !choice.account) {
+    return droppedAccount ? { choice, droppedAccount } : void 0;
+  }
+  return droppedAccount ? { choice, droppedAccount } : { choice };
 }
 var CLAIM_TTL_MS = 15 * 6e4;
 var MAX_CLAIMS = 512;
 var claims = [];
 var sessionChoices = /* @__PURE__ */ new Map();
 var MAX_SESSION_CHOICES = 512;
+function promptMatchesClaim(claimPrompt, childPrompt) {
+  if (childPrompt === claimPrompt) return true;
+  if (claimPrompt.length === 0) return false;
+  return childPrompt.endsWith(`
+${claimPrompt}`);
+}
 function pruneClaims(now) {
   for (let i = claims.length - 1; i >= 0; i--) {
     if (now - claims[i].createdAt > CLAIM_TTL_MS) claims.splice(i, 1);
@@ -2541,7 +2810,9 @@ function lookupSessionChoice(sessionId) {
 function hasCandidateClaim(agent, prompt, now = Date.now()) {
   if (!agent || prompt === void 0) return false;
   pruneClaims(now);
-  return claims.some((claim) => claim.agent === agent && claim.prompt === prompt);
+  return claims.some(
+    (claim) => claim.agent === agent && promptMatchesClaim(claim.prompt, prompt)
+  );
 }
 function claimDispatchChoice(input) {
   const existing = sessionChoices.get(input.sessionId);
@@ -2550,9 +2821,14 @@ function claimDispatchChoice(input) {
     return void 0;
   }
   pruneClaims(input.now ?? Date.now());
-  const index = claims.findIndex(
-    (claim2) => claim2.parentSessionId === input.parentSessionId && claim2.agent === input.agent && claim2.prompt === input.prompt
-  );
+  const belongsHere = (claim2) => claim2.parentSessionId === input.parentSessionId && claim2.agent === input.agent;
+  const childPrompt = input.prompt;
+  let index = claims.findIndex((claim2) => belongsHere(claim2) && claim2.prompt === childPrompt);
+  if (index === -1) {
+    index = claims.findIndex(
+      (claim2) => belongsHere(claim2) && promptMatchesClaim(claim2.prompt, childPrompt)
+    );
+  }
   if (index === -1) return void 0;
   const [claim] = claims.splice(index, 1);
   sessionChoices.set(input.sessionId, claim.choice);
@@ -2636,7 +2912,11 @@ function comboLabel(model, effort) {
   return effort ? `${model} / ${effort}` : model;
 }
 function describeChoice(choice, fallback) {
-  return comboLabel(choice.model ?? fallback.model, choice.effort ?? fallback.effort);
+  const combo = comboLabel(choice.model ?? fallback.model, choice.effort ?? fallback.effort);
+  return choice.account ? `${combo} @${choice.account}` : combo;
+}
+function droppedAccountPhrase(account) {
+  return ` The account "${account}" you picked last time is no longer available to this conversation, so this stays on the account you are on.`;
 }
 function availableCombos() {
   return DISPATCH_COMBOS.filter((combo) => Object.hasOwn(defaultModels, combo.model));
@@ -2654,16 +2934,25 @@ function dispatchAccountCandidates(context) {
   }
   return out;
 }
-function accountQuestion(context) {
+function accountQuestion(context, scope) {
   const candidates = dispatchAccountCandidates(context);
   if (candidates.length < 2) return null;
   const source = candidates[0];
+  const perType = "agent" in scope;
+  const subject = perType ? `the "${scope.agent}" subagents` : "these subagents";
+  const options = candidates.map((account) => ({
+    label: account,
+    description: account === source ? `Stay on this conversation's own account. This is what happens today.` : `Spawn ${subject} with "${account}"'s Claude config dir, so the work draws on that account's usage window.`
+  }));
+  if (!perType && scope.types > 1) {
+    options.push({
+      label: PER_TYPE_ANSWER,
+      description: `Choose the account separately for each of these ${scope.types} agent types on the next screen.`
+    });
+  }
   return {
-    question: "Which Claude account should these subagents run on?",
-    options: candidates.map((account) => ({
-      label: account,
-      description: account === source ? `Stay on this conversation's own account. This is what happens today.` : `Spawn each subagent with "${account}"'s Claude config dir, so its work draws on that account's usage window.`
-    }))
+    question: perType ? `Which Claude account should the "${scope.agent}" subagents run on?` : "Which Claude account should these subagents run on?",
+    options
   };
 }
 function summaryQuestion(tasks, context) {
@@ -2674,13 +2963,14 @@ function summaryQuestion(tasks, context) {
   });
   const question = tasks.length === 1 ? `About to dispatch the "${tasks[0].agent}" subagent (${tasks[0].description || "no description"}). How should it run?` : `About to dispatch ${tasks.length} subagents (${counts.join(", ")}). How should they run?`;
   const options = [];
-  const remembered = types.map((agent) => recallDispatchChoice(context.parentSessionId, agent));
-  if (remembered.every((choice) => choice !== void 0)) {
+  const remembered = types.map((agent) => usableRemembered(context, agent));
+  if (remembered.every((entry) => entry !== void 0)) {
+    const dropped = remembered.map((entry) => entry.droppedAccount).find((account) => !!account);
     options.push({
       label: LAST_ANSWER_PREFIX,
       description: types.map(
-        (agent, index) => `${agent}: ${describeChoice(remembered[index], context.describeDefault(agent))}`
-      ).join(". ")
+        (agent, index) => `${agent}: ${describeChoice(remembered[index].choice, context.describeDefault(agent))}`
+      ).join(". ") + (dropped ? `.${droppedAccountPhrase(dropped)}` : "")
     });
   }
   options.push({
@@ -2698,20 +2988,20 @@ function summaryQuestion(tasks, context) {
   }
   options.push({
     label: CUSTOMISE_ANSWER,
-    description: tasks.length === 1 ? "Choose the account, or type a model and effort of your own." : "Choose per agent type on the next screen, and per task after that."
+    description: tasks.length === 1 ? "Choose the account, or type a model and effort of your own." : "Choose per agent type on the next screen, and per account or per task after that."
   });
   return { question, options };
 }
 function typeQuestion(agent, tasks, context) {
   const mine = tasks.filter((task) => task.agent === agent);
   const fallback = context.describeDefault(agent);
-  const question = mine.length === 1 ? `"${agent}" (${mine[0].description || "no description"}): how should it run?` : `"${agent}" (${mine.length} subagents): how should they run?`;
+  const question = (mine.length === 1 ? `"${agent}" (${mine[0].description || "no description"}): how should it run?` : `"${agent}" (${mine.length} subagents): how should they run?`) + accountHint(context);
   const options = [];
-  const remembered = recallDispatchChoice(context.parentSessionId, agent);
+  const remembered = usableRemembered(context, agent);
   if (remembered) {
     options.push({
       label: LAST_ANSWER_PREFIX,
-      description: `${describeChoice(remembered, fallback)}, the last thing you picked for "${agent}" in this conversation.`
+      description: `${describeChoice(remembered.choice, fallback)}, the last thing you picked for "${agent}" in this conversation.` + (remembered.droppedAccount ? droppedAccountPhrase(remembered.droppedAccount) : "")
     });
   }
   options.push({
@@ -2735,7 +3025,7 @@ function typeQuestion(agent, tasks, context) {
 function taskQuestion(task, typeChoice, context) {
   const fallback = context.describeDefault(task.agent);
   const options = [];
-  if (typeChoice && (typeChoice.model || typeChoice.effort)) {
+  if (typeChoice && (typeChoice.model || typeChoice.effort || typeChoice.account)) {
     options.push({
       label: `Same as the rest (${describeChoice(typeChoice, fallback)})`,
       description: `What you picked for every "${task.agent}" subagent in this dispatch.`
@@ -2749,10 +3039,15 @@ function taskQuestion(task, typeChoice, context) {
     options.push({ label: comboLabel(combo.model, combo.effort), description: combo.description });
   }
   return {
-    question: `"${task.agent}": ${task.description || task.prompt.slice(0, 60)}`,
+    question: `"${task.agent}": ${task.description || task.prompt.slice(0, 60)}${accountHint(context)}`,
     options
   };
 }
+function accountHint(context) {
+  const candidates = dispatchAccountCandidates(context);
+  if (candidates.length < 2) return "";
+  return ` Add "@${candidates[1]}" to a typed answer to send it to that account.`;
+}
 function header(text) {
   return text.length <= 30 ? text : `${text.slice(0, 29)}\u2026`;
 }
@@ -2787,17 +3082,26 @@ function createSubagentDispatchQuestion(sessionKey2, heldCallIds, tasks, context
     fields: [{ kind: "all" }],
     choices: /* @__PURE__ */ new Map(),
     account: void 0,
+    typeAccounts: /* @__PURE__ */ new Map(),
+    typeChoices: /* @__PURE__ */ new Map(),
+    droppedAccounts: [],
     context
   };
   const summary = summaryQuestion(tasks, context);
   return buildCall(entry, [{ header: "Subagents", ...summary }], toolCallId);
 }
-function parseCustomChoice(answer) {
+function parseCustomChoice(answer, candidates = []) {
   const words2 = answer.trim().split(/[\s,/]+/).map((word) => word.trim()).filter(Boolean);
   if (words2.length === 0) return null;
   const choice = {};
   for (const word of words2) {
     const lower = word.toLowerCase();
+    if (lower.startsWith("@")) {
+      const account = normalizeAccountName(lower.slice(1));
+      if (!account || !candidates.includes(account)) return null;
+      choice.account = account;
+      continue;
+    }
     if (REASONING_EFFORTS.includes(lower)) {
       choice.effort = lower;
       continue;
@@ -2808,7 +3112,7 @@ function parseCustomChoice(answer) {
     }
     return null;
   }
-  return choice.model || choice.effort ? choice : null;
+  return choice.model || choice.effort || choice.account ? choice : null;
 }
 function parseComboLabel(answer) {
   for (const combo of availableCombos()) {
@@ -2818,7 +3122,7 @@ function parseComboLabel(answer) {
   }
   return null;
 }
-function classifyAnswer(answer) {
+function classifyAnswer(answer, candidates = []) {
   const trimmed = answer.trim();
   if (!trimmed) return { kind: "default" };
   if (trimmed === DEFAULT_ANSWER) return { kind: "default" };
@@ -2828,7 +3132,7 @@ function classifyAnswer(answer) {
   if (trimmed.startsWith("Same as the rest")) return { kind: "sameAsRest" };
   const combo = parseComboLabel(trimmed);
   if (combo) return { kind: "choice", choice: combo };
-  const custom = parseCustomChoice(trimmed);
+  const custom = parseCustomChoice(trimmed, candidates);
   if (custom) return { kind: "choice", choice: custom };
   return { kind: "unknown", answer: trimmed };
 }
@@ -2869,19 +3173,28 @@ function advance(entry, part) {
     case "types":
       return advanceTypes(entry, answers);
     default:
-      return advanceTasks(entry, answers);
+      return advanceDetail(entry, answers);
   }
 }
 function applyToAll(entry, choice) {
   for (const index of entry.tasks.keys()) entry.choices.set(index, { ...choice });
 }
+function noteDroppedAccount(entry, agent, account) {
+  if (entry.droppedAccounts.some((dropped) => dropped.agent === agent)) return;
+  entry.droppedAccounts.push({ agent, account });
+}
 function advanceSummary(entry, answers) {
-  const answer = classifyAnswer(answers.get(entry.questions[0]) ?? "");
+  const candidates = dispatchAccountCandidates(entry.context);
+  const answer = classifyAnswer(answers.get(entry.questions[0]) ?? "", candidates);
   if (answer.kind === "customise") return typesForm(entry);
   if (answer.kind === "last") {
     for (const [index, task] of entry.tasks.entries()) {
-      const remembered = recallDispatchChoice(entry.context.parentSessionId, task.agent);
-      if (remembered) entry.choices.set(index, { ...remembered });
+      const remembered = usableRemembered(entry.context, task.agent);
+      if (!remembered) continue;
+      if (remembered.droppedAccount) {
+        noteDroppedAccount(entry, task.agent, remembered.droppedAccount);
+      }
+      entry.choices.set(index, { ...remembered.choice });
     }
     return release(entry, null);
   }
@@ -2908,7 +3221,7 @@ function typesForm(entry) {
     ...typeQuestion(agent, entry.tasks, entry.context)
   }));
   const fields = types.map((agent) => ({ kind: "type", agent }));
-  const account = accountQuestion(entry.context);
+  const account = accountQuestion(entry.context, { types: types.length });
   if (account) {
     prompts.push({ header: "Account", ...account });
     fields.push({ kind: "account" });
@@ -2920,25 +3233,30 @@ function typesForm(entry) {
     call: buildCall(entry, prompts, questionCallId("types"))
   };
 }
+function readAccountAnswer(entry, raw, agent) {
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed === DEFAULT_ANSWER) return void 0;
+  const picked = normalizeAccountName(trimmed.startsWith("@") ? trimmed.slice(1) : trimmed);
+  const candidates = dispatchAccountCandidates(entry.context);
+  if (picked && candidates.includes(picked)) return picked;
+  log.notice("subagent dispatch account answer refused", {
+    sessionKey: entry.sessionKey,
+    agent,
+    answer: trimmed,
+    candidates
+  });
+  return void 0;
+}
 function advanceTypes(entry, answers) {
+  const candidates = dispatchAccountCandidates(entry.context);
   const perTask = [];
-  const typeChoices = /* @__PURE__ */ new Map();
+  let perTypeAccounts = false;
   for (const [position, field] of entry.fields.entries()) {
     const raw = answers.get(entry.questions[position]) ?? "";
-    const answer = classifyAnswer(raw);
+    const answer = classifyAnswer(raw, candidates);
     if (field.kind === "account") {
-      if (answer.kind === "unknown") {
-        const picked = normalizeAccountName(answer.answer);
-        const candidates = dispatchAccountCandidates(entry.context);
-        if (candidates.includes(picked)) entry.account = picked;
-        else {
-          log.notice("subagent dispatch account answer refused", {
-            sessionKey: entry.sessionKey,
-            answer: answer.answer,
-            candidates
-          });
-        }
-      }
+      if (raw.trim() === PER_TYPE_ANSWER) perTypeAccounts = true;
+      else entry.account = readAccountAnswer(entry, raw, null) ?? entry.account;
       continue;
     }
     if (field.kind !== "type") continue;
@@ -2947,12 +3265,15 @@ function advanceTypes(entry, answers) {
       continue;
     }
     if (answer.kind === "last") {
-      const remembered = recallDispatchChoice(entry.context.parentSessionId, field.agent);
-      if (remembered) typeChoices.set(field.agent, { ...remembered });
+      const remembered = usableRemembered(entry.context, field.agent);
+      if (remembered?.droppedAccount) {
+        noteDroppedAccount(entry, field.agent, remembered.droppedAccount);
+      }
+      if (remembered) applyTypeChoice(entry, field.agent, remembered.choice);
       continue;
     }
     if (answer.kind === "choice") {
-      typeChoices.set(field.agent, answer.choice);
+      applyTypeChoice(entry, field.agent, answer.choice);
       continue;
     }
     if (answer.kind === "unknown") {
@@ -2964,31 +3285,60 @@ function advanceTypes(entry, answers) {
     }
   }
   for (const [index, task] of entry.tasks.entries()) {
-    const choice = typeChoices.get(task.agent);
+    const choice = entry.typeChoices.get(task.agent);
     if (choice) entry.choices.set(index, { ...choice });
   }
-  if (perTask.length > 0) return tasksForm(entry, perTask, typeChoices);
+  if (perTask.length > 0 || perTypeAccounts) {
+    return detailForm(entry, perTask, perTypeAccounts);
+  }
   return release(entry, null);
 }
-function tasksForm(entry, agents, typeChoices) {
+function applyTypeChoice(entry, agent, choice) {
+  const { account, ...rest } = choice;
+  if (account) entry.typeAccounts.set(agent, account);
+  entry.typeChoices.set(agent, rest);
+}
+function detailForm(entry, perTaskAgents, perTypeAccounts) {
   const prompts = [];
   const fields = [];
+  if (perTypeAccounts) {
+    for (const agent of dispatchAgentTypes(entry.tasks)) {
+      const account = accountQuestion(entry.context, { agent });
+      if (!account) continue;
+      prompts.push({ header: `${agent} account`, ...account });
+      fields.push({ kind: "typeAccount", agent });
+    }
+  }
   for (const [index, task] of entry.tasks.entries()) {
-    if (!agents.includes(task.agent)) continue;
+    if (!perTaskAgents.includes(task.agent)) continue;
+    const typeChoice = entry.typeChoices.get(task.agent);
+    const typeAccount = entry.typeAccounts.get(task.agent);
     prompts.push({
       header: task.description || task.agent,
-      ...taskQuestion(task, typeChoices.get(task.agent), entry.context)
+      ...taskQuestion(
+        task,
+        typeChoice || typeAccount ? { ...typeChoice, ...typeAccount ? { account: typeAccount } : {} } : void 0,
+        entry.context
+      )
     });
     fields.push({ kind: "task", taskIndex: index });
   }
-  entry.stage = "tasks";
+  if (prompts.length === 0) return release(entry, null);
+  entry.stage = "detail";
   entry.fields = fields;
-  return { kind: "form", call: buildCall(entry, prompts, questionCallId("tasks")) };
+  return { kind: "form", call: buildCall(entry, prompts, questionCallId("detail")) };
 }
-function advanceTasks(entry, answers) {
+function advanceDetail(entry, answers) {
+  const candidates = dispatchAccountCandidates(entry.context);
   for (const [position, field] of entry.fields.entries()) {
+    const raw = answers.get(entry.questions[position]) ?? "";
+    if (field.kind === "typeAccount") {
+      const picked = readAccountAnswer(entry, raw, field.agent);
+      if (picked) entry.typeAccounts.set(field.agent, picked);
+      continue;
+    }
     if (field.kind !== "task") continue;
-    const answer = classifyAnswer(answers.get(entry.questions[position]) ?? "");
+    const answer = classifyAnswer(raw, candidates);
     if (answer.kind === "choice") {
       entry.choices.set(field.taskIndex, answer.choice);
       continue;
@@ -3008,13 +3358,18 @@ function advanceTasks(entry, answers) {
   }
   return release(entry, null);
 }
+function droppedAccountNote(dropped) {
+  const list2 = dropped.map((entry) => `"${entry.agent}" (was "${entry.account}")`).join(", ");
+  return `
+${SUBAGENT_DISPATCH_MARKER} The account you last picked for ${list2} is no longer configured for this conversation, or no longer in its account group, so that work stays on the account you are on. Everything else you picked still applies.
+`;
+}
 function release(entry, note) {
-  if (entry.account) {
-    for (const [index, task] of entry.tasks.entries()) {
-      const current = entry.choices.get(index) ?? {};
-      entry.choices.set(index, { ...current, account: entry.account });
-      void task;
-    }
+  for (const [index, task] of entry.tasks.entries()) {
+    const current = entry.choices.get(index);
+    const account = current?.account ?? entry.typeAccounts.get(task.agent) ?? entry.account;
+    if (!account) continue;
+    entry.choices.set(index, { ...current ?? {}, account });
   }
   const seen = /* @__PURE__ */ new Set();
   for (const [index, task] of entry.tasks.entries()) {
@@ -3024,6 +3379,15 @@ function release(entry, note) {
     seen.add(task.agent);
     rememberDispatchChoice(entry.context.parentSessionId, task.agent, choice);
   }
+  if (!note && entry.droppedAccounts.length > 0) {
+    log.notice("a remembered subagent dispatch account is no longer available", {
+      sessionKey: entry.sessionKey,
+      // `agent` rather than a key of its own: `dropped` already means a count
+      // in the bundle allowlist, and these are agent names like every other.
+      agent: entry.droppedAccounts.map((dropped) => dropped.agent)
+    });
+    note = droppedAccountNote(entry.droppedAccounts);
+  }
   return {
     kind: "release",
     heldCallIds: entry.heldCallIds,
@@ -3060,8 +3424,8 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 
 // src/windows-spawn.ts
-import * as fs from "fs";
-import * as path3 from "path";
+import * as fs2 from "fs";
+import * as path4 from "path";
 var DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
 function envValue(env, name) {
   const direct = env[name];
@@ -3071,7 +3435,7 @@ function envValue(env, name) {
 }
 function defaultIsFile(candidate) {
   try {
-    return fs.statSync(candidate).isFile();
+    return fs2.statSync(candidate).isFile();
   } catch {
     return false;
   }
@@ -3081,7 +3445,7 @@ function executableExtensions(env = process.env) {
   return raw.split(";").map((ext) => ext.trim().toLowerCase()).filter(Boolean).map((ext) => ext.startsWith(".") ? ext : `.${ext}`);
 }
 function isBatchFile(file) {
-  const ext = path3.win32.extname(file).toLowerCase();
+  const ext = path4.win32.extname(file).toLowerCase();
   return ext === ".cmd" || ext === ".bat";
 }
 function resolveWindowsCommand(command, deps = {}) {
@@ -3089,7 +3453,7 @@ function resolveWindowsCommand(command, deps = {}) {
   const isFile = deps.isFile ?? defaultIsFile;
   const extensions = executableExtensions(env);
   const candidatesFor = (base) => {
-    const ext = path3.win32.extname(base).toLowerCase();
+    const ext = path4.win32.extname(base).toLowerCase();
     if (ext && extensions.includes(ext)) return [base];
     return [...extensions.map((candidate) => base + candidate), base];
   };
@@ -3100,10 +3464,10 @@ function resolveWindowsCommand(command, deps = {}) {
     return null;
   }
   const pathValue = envValue(env, "PATH") ?? "";
-  for (const entry of pathValue.split(path3.win32.delimiter)) {
+  for (const entry of pathValue.split(path4.win32.delimiter)) {
     const directory = entry.trim().replace(/^"(.*)"$/, "$1");
     if (!directory) continue;
-    for (const candidate of candidatesFor(path3.win32.join(directory, command))) {
+    for (const candidate of candidatesFor(path4.win32.join(directory, command))) {
       if (isFile(candidate)) return candidate;
     }
   }
@@ -3132,7 +3496,7 @@ function quoteBatchArgument(arg) {
 }
 function planCmdInvocation(file, args, env = process.env) {
   const comspec = envValue(env, "ComSpec") ?? "cmd.exe";
-  const line = [`"${path3.win32.normalize(file)}"`, ...args.map(quoteBatchArgument)];
+  const line = [`"${path4.win32.normalize(file)}"`, ...args.map(quoteBatchArgument)];
   return {
     file: comspec,
     args: ["/d", "/s", "/c", `"${line.join(" ")}"`],
@@ -3376,145 +3740,6 @@ import * as fs3 from "fs";
 import * as path5 from "path";
 import * as crypto from "crypto";
 import { EventEmitter } from "events";
-
-// src/tmp.ts
-import * as fs2 from "fs";
-import * as os from "os";
-import * as path4 from "path";
-var PLUGIN_TMP_PREFIX = "opencode-claude-code-";
-var PID_TMP_DIR = path4.join(
-  os.tmpdir(),
-  `${PLUGIN_TMP_PREFIX}${process.pid}`
-);
-var currentDir = null;
-var createdDirs = /* @__PURE__ */ new Set();
-var registered = false;
-function currentUid() {
-  return typeof process.getuid === "function" ? process.getuid() : void 0;
-}
-function untrustworthyReason(dir) {
-  let stat;
-  try {
-    stat = fs2.lstatSync(dir);
-  } catch {
-    return null;
-  }
-  if (stat.isSymbolicLink()) return "path is a symlink";
-  if (!stat.isDirectory()) return "path is not a directory";
-  const uid = currentUid();
-  if (uid !== void 0 && stat.uid !== uid) {
-    return `directory is owned by uid ${stat.uid}, not ${uid}`;
-  }
-  return null;
-}
-function ensureDir(dir) {
-  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
-  try {
-    fs2.chmodSync(dir, 448);
-  } catch {
-  }
-}
-function chooseDir() {
-  const reason = untrustworthyReason(PID_TMP_DIR);
-  if (!reason) return PID_TMP_DIR;
-  const fallback = fs2.mkdtempSync(path4.join(os.tmpdir(), PLUGIN_TMP_PREFIX));
-  log.warn("refusing the pid-named scratch directory", {
-    path: PID_TMP_DIR,
-    reason,
-    fallback
-  });
-  return fallback;
-}
-function registerExitCleanup() {
-  if (registered) return;
-  registered = true;
-  process.on("exit", () => {
-    for (const dir of createdDirs) {
-      try {
-        fs2.rmSync(dir, { recursive: true, force: true });
-      } catch {
-      }
-    }
-  });
-}
-var PID_DIR_NAME = /^opencode-claude-code-(\d+)$/;
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === "EPERM";
-  }
-}
-function sweepStalePluginTmpDirs(keep) {
-  const removed = [];
-  if (process.env.OPENCODE_CLAUDE_CODE_NO_TMP_SWEEP === "1") return removed;
-  const root = os.tmpdir();
-  let entries;
-  try {
-    entries = fs2.readdirSync(root);
-  } catch {
-    return removed;
-  }
-  const uid = currentUid();
-  const keepPath = keep ? path4.resolve(keep) : null;
-  for (const entry of entries) {
-    const match = PID_DIR_NAME.exec(entry);
-    if (!match) continue;
-    const pid = Number(match[1]);
-    if (!Number.isSafeInteger(pid) || pid <= 0) continue;
-    if (pid === process.pid) continue;
-    const dir = path4.join(root, entry);
-    if (keepPath && path4.resolve(dir) === keepPath) continue;
-    let stat;
-    try {
-      stat = fs2.lstatSync(dir);
-    } catch {
-      continue;
-    }
-    if (stat.isSymbolicLink() || !stat.isDirectory()) continue;
-    if (uid !== void 0 && stat.uid !== uid) continue;
-    if (isProcessAlive(pid)) continue;
-    try {
-      fs2.rmSync(dir, { recursive: true, force: true });
-      removed.push(dir);
-    } catch (err) {
-      log.debug("could not remove a stale scratch directory", {
-        dir,
-        error: String(err)
-      });
-    }
-  }
-  if (removed.length > 0) {
-    log.info("removed stale plugin scratch directories", {
-      count: removed.length,
-      dirs: removed
-    });
-  }
-  return removed;
-}
-var swept = false;
-function sweepOnce(keep) {
-  if (swept) return;
-  swept = true;
-  try {
-    sweepStalePluginTmpDirs(keep);
-  } catch (err) {
-    log.warn("stale scratch directory sweep failed", { error: String(err) });
-  }
-}
-function pluginTmpDir() {
-  if (currentDir === null || untrustworthyReason(currentDir) !== null) {
-    currentDir = chooseDir();
-  }
-  ensureDir(currentDir);
-  createdDirs.add(currentDir);
-  registerExitCleanup();
-  sweepOnce(currentDir);
-  return currentDir;
-}
-
-// src/proxy-mcp.ts
 var PROXY_KEEPALIVE_MS = 15e3;
 function acceptsEventStream(acceptHeader) {
   return typeof acceptHeader === "string" && acceptHeader.toLowerCase().includes("text/event-stream");
@@ -6023,17 +6248,17 @@ function tailIsReplyOnly(history, from) {
 }
 
 // src/session-resume-store.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync3, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join8 } from "path";
 var MAX_RESUME_RECORDS = 256;
 var RESUME_RECORD_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
 var records = null;
-var pathOverride = null;
+var pathOverride2 = null;
 function resumeStorePath() {
-  if (pathOverride) return pathOverride;
-  const stateRoot = process.env.XDG_STATE_HOME || join6(homedir5(), ".local", "state");
-  return join6(stateRoot, "opencode-claude-code-plugin", "claude-sessions.json");
+  if (pathOverride2) return pathOverride2;
+  const stateRoot = process.env.XDG_STATE_HOME || join8(homedir6(), ".local", "state");
+  return join8(stateRoot, "opencode-claude-code-plugin", "claude-sessions.json");
 }
 function isDigest(value) {
   const entry = value;
@@ -6043,11 +6268,11 @@ function isRecord2(value) {
   const record = value;
   return !!record && typeof record.claudeSessionId === "string" && typeof record.cliPath === "string" && typeof record.updatedAt === "number" && Array.isArray(record.chain) && record.chain.every(isDigest) && (record.shape === void 0 || Array.isArray(record.shape) && record.shape.every(isDigest)) && (record.configDir === void 0 || typeof record.configDir === "string") && (record.account === void 0 || typeof record.account === "string");
 }
-function load() {
+function load2() {
   if (records) return records;
   records = /* @__PURE__ */ new Map();
   try {
-    const parsed = JSON.parse(readFileSync3(resumeStorePath(), "utf8"));
+    const parsed = JSON.parse(readFileSync4(resumeStorePath(), "utf8"));
     const entries = parsed && typeof parsed === "object" ? parsed.sessions : null;
     if (entries && typeof entries === "object") {
       const cutoff = Date.now() - RESUME_RECORD_MAX_AGE_MS;
@@ -6058,11 +6283,11 @@ function load() {
   }
   return records;
 }
-function save(update) {
+function save2(update) {
   const file = resumeStorePath();
   const merged = /* @__PURE__ */ new Map();
   try {
-    const onDisk = JSON.parse(readFileSync3(file, "utf8"))?.sessions;
+    const onDisk = JSON.parse(readFileSync4(file, "utf8"))?.sessions;
     if (onDisk && typeof onDisk === "object") {
       for (const [key, record] of Object.entries(onDisk)) {
         if (isRecord2(record)) merged.set(key, record);
@@ -6075,12 +6300,12 @@ function save(update) {
   const kept = [...merged.entries()].filter(([, record]) => record.updatedAt >= cutoff).sort((a, b) => a[1].updatedAt - b[1].updatedAt).slice(-MAX_RESUME_RECORDS);
   records = new Map(kept);
   try {
-    mkdirSync3(join6(file, ".."), { recursive: true, mode: 448 });
+    mkdirSync4(join8(file, ".."), { recursive: true, mode: 448 });
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync3(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
+    writeFileSync4(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
       mode: 384
     });
-    renameSync2(tmp, file);
+    renameSync3(tmp, file);
   } catch (err) {
     log.debug("could not write the claude session resume store", {
       error: err instanceof Error ? err.message : String(err)
@@ -6093,11 +6318,11 @@ function recordResumePoint(sessionKey2, claudeSessionId, prompt, cliPath, where)
   const shape2 = conversationDigests(prompt, { assistantContent: false });
   const configDir = where?.configDir;
   const account = where?.account;
-  const current = load().get(sessionKey2);
+  const current = load2().get(sessionKey2);
   if (current && current.claudeSessionId === claudeSessionId && current.cliPath === cliPath && current.shape !== void 0 && current.configDir === configDir && current.account === account && current.chain.length === chain.length && current.chain.every((entry, i) => entry.digest === chain[i].digest)) {
     return;
   }
-  save((merged) => {
+  save2((merged) => {
     merged.delete(sessionKey2);
     merged.set(sessionKey2, {
       claudeSessionId,
@@ -6111,22 +6336,22 @@ function recordResumePoint(sessionKey2, claudeSessionId, prompt, cliPath, where)
   });
 }
 function forgetResumePoint(sessionKey2) {
-  if (!load().has(sessionKey2)) return;
-  save((merged) => {
+  if (!load2().has(sessionKey2)) return;
+  save2((merged) => {
     merged.delete(sessionKey2);
   });
 }
 function moveResumePoint(fromKey, toKey) {
-  const record = load().get(fromKey);
+  const record = load2().get(fromKey);
   if (!record) return;
-  save((merged) => {
+  save2((merged) => {
     merged.delete(fromKey);
     if (merged.has(toKey)) return;
     merged.set(toKey, { ...record, updatedAt: Date.now() });
   });
 }
 function findResumePoint(opts) {
-  const record = load().get(opts.sessionKey);
+  const record = load2().get(opts.sessionKey);
   if (!record) {
     opts.onRefused?.("no-session-recorded");
     return void 0;
@@ -6159,7 +6384,7 @@ function findSiblingResumePoint(opts) {
   let best;
   let bestUpdatedAt = -1;
   let refusal;
-  for (const [key, record] of load()) {
+  for (const [key, record] of load2()) {
     if (key === opts.sessionKey) continue;
     if (modelSiblingSignature(key, providers) !== signature) continue;
     const siblingAccount = providers ? sessionKeyAccount(key, providers) : void 0;
@@ -6228,7 +6453,7 @@ function findForeignAccountSibling(opts) {
   }
   let found;
   let foundUpdatedAt = -1;
-  for (const [key, record] of load()) {
+  for (const [key, record] of load2()) {
     const hit = consider(key);
     if (hit && record.updatedAt >= foundUpdatedAt) {
       found = hit;
@@ -6848,6 +7073,7 @@ function deleteActiveProcessesForSession(sessionID) {
   }
   for (const key of released) clearBackgroundTasks(key);
   forgetSessionChoice(sessionID);
+  forgetDispatchChoicesForSession(sessionID);
   return released;
 }
 function killAllActiveProcesses() {
@@ -7583,7 +7809,7 @@ async function handleBtwCommand(client, input, options = {}) {
 // src/diagnostic-bundle.ts
 import { createHash as createHash4, randomBytes as randomBytes2 } from "crypto";
 import { openSync, readSync, closeSync, fstatSync, realpathSync } from "fs";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 
 // src/log-messages.ts
 var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
@@ -7593,6 +7819,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "Code Mode execute not forwarded: read-only permission preset",
   "MCP server asked for operator input and was declined: a headless Claude Code session cannot prompt, so its elicitation can only be refused. Run that server's flow in Claude Code directly, or configure it not to elicit.",
   "MCP tool not routed through the proxy: another proxy tool already holds that name, and it keeps it",
+  "a remembered subagent dispatch account is no longer available",
   "account failover declined; ending the turn",
   "accountGroups must be an object mapping an account name to a group name; ignoring it",
   "accountGroups names an account that is not configured; ignoring it",
@@ -7974,7 +8201,7 @@ function createIdHasher(salt = randomBytes2(16).toString("hex")) {
   return (raw) => createHash4("sha256").update(salt).update("\0").update(raw).digest("hex").slice(0, 8);
 }
 function createRedactionContext(options = {}) {
-  const home = options.home ?? homedir6();
+  const home = options.home ?? homedir7();
   const homes = /* @__PURE__ */ new Set();
   if (home) homes.add(home);
   if (home) {
@@ -10116,9 +10343,9 @@ async function resolveSkillPluginDirs(opts) {
 // src/claude-session-wrapper.ts
 import { EventEmitter as EventEmitter4 } from "events";
 import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync4, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync4, writeFileSync as writeFileSync6 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join13 } from "path";
 
 // src/claude-session-bun.ts
 import * as os5 from "os";
@@ -11299,8 +11526,8 @@ ${text2}`
 }
 function stageImage(data, extension) {
   try {
-    const file = join11(pluginTmpDir(), `attachment-${randomUUID5()}.${extension}`);
-    writeFileSync5(file, data, { mode: 384, flag: "wx" });
+    const file = join13(pluginTmpDir(), `attachment-${randomUUID5()}.${extension}`);
+    writeFileSync6(file, data, { mode: 384, flag: "wx" });
     return file;
   } catch (err) {
     log.warn("interactive transport could not stage an image", {
@@ -11841,13 +12068,13 @@ function dedupe2(dirs) {
 }
 
 // src/prompts.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir9 } from "os";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir10 } from "os";
 import { randomUUID as randomUUID7 } from "crypto";
-import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join12 } from "path";
+import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join14 } from "path";
 function readPromptFileIfPresent(path15) {
   try {
-    const content = readFileSync7(path15, "utf8").trim();
+    const content = readFileSync8(path15, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -11856,7 +12083,7 @@ function readPromptFileIfPresent(path15) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join12(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join14(dir, "AGENTS.md"));
     if (content) return content;
     const parent = dirname6(dir);
     if (parent === dir) return void 0;
@@ -11952,9 +12179,9 @@ function extractSystemMessages(prompt) {
 }
 var CLAUDE_NATIVE_INSTRUCTION_FILES = /* @__PURE__ */ new Set(["CLAUDE.md", "CLAUDE.local.md"]);
 function userAuthoredInstructions(forwarded, opts = {}) {
-  const readFile2 = opts.readFile ?? ((path15) => {
+  const readFile3 = opts.readFile ?? ((path15) => {
     try {
-      return readFileSync7(path15, "utf8");
+      return readFileSync8(path15, "utf8");
     } catch {
       return null;
     }
@@ -11970,7 +12197,7 @@ function userAuthoredInstructions(forwarded, opts = {}) {
     if (seen.has(path15) || !isAbsolute3(path15)) continue;
     if (CLAUDE_NATIVE_INSTRUCTION_FILES.has(basename2(path15))) continue;
     seen.add(path15);
-    const file = readFile2(path15);
+    const file = readFile3(path15);
     if (!file?.trim()) continue;
     const start = match.index + match[0].length + 1;
     const content = forwarded.startsWith(file, start) ? file : forwarded.startsWith(file.trimEnd(), start) ? file.trimEnd() : null;
@@ -11995,8 +12222,8 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join12(homedir9(), ".config");
-  const globalAgents = readPromptFileIfPresent(join12(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join14(homedir10(), ".config");
+  const globalAgents = readPromptFileIfPresent(join14(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   const forwarded = extraSystemContent.join("\n\n");
   const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
@@ -12012,9 +12239,9 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path15 = join12(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
+  const path15 = join14(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
   try {
-    writeFileSync6(path15, content, { encoding: "utf8", mode: 384 });
+    writeFileSync7(path15, content, { encoding: "utf8", mode: 384 });
     return path15;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
@@ -15346,7 +15573,7 @@ var ClaudeCodeLanguageModel = class {
     let replayReason = "no-session-for-key";
     if (this.config.resumeAfterRestart !== false && includeHistoryContext && !compactionMode && !forkFromClaudeSessionId && failoverAnswer?.kind !== "switch") {
       const configDir = resolveConfigDir(this.config.configDir);
-      const transcriptPath2 = (id, dir) => join13(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
+      const transcriptPath2 = (id, dir) => join15(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
       const resumePoint = findResumePoint({
         sessionKey: sk,
         prompt: options.prompt,
@@ -16693,7 +16920,7 @@ var ClaudeCodeLanguageModel = class {
 };
 
 // src/account-tier.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import path13 from "path";
 var ORGANIZATION_TYPE_LABELS = {
   claude_max: "Max",
@@ -16736,7 +16963,7 @@ function readTierFromConfigDir(configDir, allowLegacyFallback) {
 function readOauthAccount(file) {
   let raw;
   try {
-    raw = readFileSync8(file, "utf8");
+    raw = readFileSync9(file, "utf8");
   } catch {
     return void 0;
   }
@@ -16764,14 +16991,14 @@ function tierLabel(oauthAccount) {
 // src/cleanup-stale.ts
 import {
   existsSync as existsSync5,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync9,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync10,
   realpathSync as realpathSync4,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "fs";
-import { homedir as homedir10 } from "os";
-import { dirname as dirname7, join as join14, resolve as resolve5 } from "path";
+import { homedir as homedir11 } from "os";
+import { dirname as dirname7, join as join16, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -16779,20 +17006,20 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join14(xdg, "opencode") : null,
-    join14(homedir10(), ".cache", "opencode"),
-    join14(homedir10(), "Library", "Caches", "opencode")
+    xdg ? join16(xdg, "opencode") : null,
+    join16(homedir11(), ".cache", "opencode"),
+    join16(homedir11(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join14(homedir10(), ".config");
-  return join14(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join16(homedir11(), ".config");
+  return join16(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
   if (!existsSync5(cfg)) return false;
   try {
-    const json = JSON.parse(readFileSync9(cfg, "utf8"));
+    const json = JSON.parse(readFileSync10(cfg, "utf8"));
     const plugins = json.plugin;
     if (!Array.isArray(plugins)) return false;
     return plugins.some(
@@ -16813,19 +17040,19 @@ function ourLoadedDir() {
 function ourVersion(dir) {
   if (!dir) return null;
   try {
-    const pkg = JSON.parse(readFileSync9(join14(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync10(join16(dir, "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
   } catch {
     return null;
   }
 }
 function markerPath() {
-  const stateRoot = process.env.XDG_STATE_HOME ?? join14(homedir10(), ".local", "state");
-  return join14(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
+  const stateRoot = process.env.XDG_STATE_HOME ?? join16(homedir11(), ".local", "state");
+  return join16(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
 }
 function markerVersion() {
   try {
-    const marker = JSON.parse(readFileSync9(markerPath(), "utf8"));
+    const marker = JSON.parse(readFileSync10(markerPath(), "utf8"));
     return typeof marker.version === "string" ? marker.version : null;
   } catch {
     return null;
@@ -16834,8 +17061,8 @@ function markerVersion() {
 function writeMarker(version) {
   const file = markerPath();
   try {
-    mkdirSync5(dirname7(file), { recursive: true });
-    writeFileSync7(
+    mkdirSync6(dirname7(file), { recursive: true });
+    writeFileSync8(
       file,
       JSON.stringify({ version, at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n",
       "utf8"
@@ -16870,7 +17097,7 @@ function cleanupStaleUnscopedInstall() {
 }
 function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync5(cacheRoot)) return;
-  const stalePath = join14(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  const stalePath = join16(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
   if (!existsSync5(stalePath)) return;
   let realStalePath = stalePath;
   try {
@@ -16878,11 +17105,11 @@ function cleanupOne(cacheRoot, ourDir) {
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join14(stalePath, "package.json");
+  const pkgJsonPath = join16(stalePath, "package.json");
   if (!existsSync5(pkgJsonPath)) return;
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync9(pkgJsonPath, "utf8"));
+    pkg = JSON.parse(readFileSync10(pkgJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -16898,13 +17125,13 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join14(cacheRoot, "package.json");
+  const cachePkgJson = join16(cacheRoot, "package.json");
   if (!existsSync5(cachePkgJson)) return;
   try {
-    const cfg = JSON.parse(readFileSync9(cachePkgJson, "utf8"));
+    const cfg = JSON.parse(readFileSync10(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
-      writeFileSync7(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
+      writeFileSync8(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
       log.info("cleanup-stale: pruned dep from cache package.json");
     }
   } catch (err) {