@useshifu/coding-harness 0.3.28 → 0.3.30

package/bin/native-preparation.js

@@ -1,7 +1,6 @@
 const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
-const { randomUUID } = require("node:crypto");
 const { spawn } = require("node:child_process");
 const toml = require("smol-toml");
 const jsonc = require("jsonc-parser");
@@ -105,33 +104,43 @@ async function requireFlags(command, prefix, flags, options) {
   }
 }
 
-async function codexInvocation(directory, env, cleanup, deadlineAt) {
+async function codexInvocation(directory, env, deadlineAt, outputSchema = PREPARATION_SCHEMA) {
   const command = resolveNativeBinary("codex", env);
-  await requireFlags(command, ["exec"], ["--ephemeral", "--ignore-user-config", "--ignore-rules", "--output-schema", "--profile"], { cwd: directory, env, deadlineAt });
+  await requireFlags(command, ["exec"], ["--ephemeral", "--ignore-rules", "--output-schema"], { cwd: directory, env, deadlineAt });
   const home = env.CODEX_HOME || path.join(os.homedir(), ".codex");
   let original = optionalConfig(path.join(home, "config.toml"), toml.parse);
   if (typeof original.profile === "string" && /^[A-Za-z0-9_-]+$/.test(original.profile)) {
     original = { ...original, ...optionalConfig(path.join(home, `${original.profile}.config.toml`), toml.parse) };
   }
-  const config = pick(original, ["model", "model_provider", "model_providers", "model_reasoning_effort", "model_reasoning_summary", "model_verbosity", "service_tier"]);
+  const config = pick(original, ["model", "model_provider", "model_providers", "model_reasoning_effort", "model_reasoning_summary", "model_verbosity", "service_tier", "cli_auth_credentials_store"]);
   Object.assign(config, {
     approval_policy: "never", sandbox_mode: "read-only", web_search: "disabled", project_doc_max_bytes: 0,
-    mcp_servers: {}, apps: { _default: { enabled: false } }, tools: { view_image: false }, sqlite_home: directory,
-    features: { shell_tool: false, shell_snapshot: false, hooks: false, apps: false, plugins: false,
+    mcp_servers: {}, apps: { _default: { enabled: false } },
+    tools: { experimental_request_user_input: { enabled: false }, update_plan: { enabled: false } }, sqlite_home: directory,
+    features: { shell_tool: false, view_image: false, goals: false, shell_snapshot: false, hooks: false, apps: false, plugins: false,
       browser_use: false, browser_use_external: false, computer_use: false, multi_agent: false, memories: false,
       skill_mcp_dependency_install: false },
   });
-  const profile = `shifu-preparation-${randomUUID()}`;
-  const profileFile = path.join(home, `${profile}.config.toml`);
-  privateFile(profileFile, toml.stringify(config));
-  cleanup.push(profileFile);
+  const isolatedHome = path.join(directory, "codex");
+  fs.mkdirSync(isolatedHome, { mode: 0o700 });
+  const authFile = path.join(home, "auth.json");
+  if (original.cli_auth_credentials_store === "keyring") {
+    throw new Error("Native preparation requires file-backed Codex authentication for isolated account reuse. Configure Codex file-backed authentication and retry; no source was sent.");
+  }
+  try {
+    if (!fs.statSync(authFile).isFile()) throw new Error("Invalid native account storage");
+    fs.symlinkSync(authFile, path.join(isolatedHome, "auth.json"));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw new Error("Native preparation could not reuse the existing Codex account. Repair native authentication and retry.");
+  }
+  privateFile(path.join(isolatedHome, "config.toml"), toml.stringify(config));
   const schema = path.join(directory, "schema.json");
-  privateFile(schema, JSON.stringify(PREPARATION_SCHEMA));
-  return { command, env: { ...env, CODEX_HOME: home }, args: ["exec", "--ignore-user-config", "--ignore-rules", "--profile", profile,
+  privateFile(schema, JSON.stringify(outputSchema));
+  return { command, env: { ...env, CODEX_HOME: isolatedHome, HOME: directory, PWD: directory }, args: ["exec", "--ignore-rules",
     "--ephemeral", "--json", "--skip-git-repo-check", "--sandbox", "read-only", "--cd", directory, "--output-schema", schema, "-"] };
 }
 
-async function claudeInvocation(directory, env, deadlineAt) {
+async function claudeInvocation(directory, env, deadlineAt, outputSchema = PREPARATION_SCHEMA) {
   const command = resolveNativeBinary("claude_code", env);
   await requireFlags(command, [], ["--safe-mode", "--no-session-persistence", "--tools", "--strict-mcp-config", "--json-schema"], { cwd: directory, env, deadlineAt });
   const isolatedEnv = { ...env };
@@ -139,7 +148,7 @@ async function claudeInvocation(directory, env, deadlineAt) {
   delete isolatedEnv.CLAUDE_CODE_SESSION_ID;
   return { command, env: isolatedEnv, args: ["--print", "--safe-mode", "--no-session-persistence", "--tools", "", "--strict-mcp-config",
     "--mcp-config", '{"mcpServers":{}}', "--disable-slash-commands", "--max-turns", "1", "--output-format", "json",
-    "--json-schema", JSON.stringify(PREPARATION_SCHEMA)] };
+    "--json-schema", JSON.stringify(outputSchema)] };
 }
 
 function parseOpenCodeConfig(text) {
@@ -166,13 +175,14 @@ function readOpenCodeConfig(directory) {
   return config;
 }
 
-async function opencodeInvocation(directory, env, deadlineAt) {
+async function opencodeInvocation(directory, env, deadlineAt, outputSchema = PREPARATION_SCHEMA) {
   const command = resolveNativeBinary("opencode", env);
-  await requireFlags(command, ["run"], ["--pure", "--format", "--agent", "--dir"], { cwd: directory, env, deadlineAt });
-  const version = (await runNativeCommand(command, ["--version"], { cwd: directory, env, deadlineAt, timeoutMs: 10_000 })).trim().match(/^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
-  if (!version || Number(version[1]) < 1 || (Number(version[1]) === 1 && (Number(version[2]) < 18 || (Number(version[2]) === 18 && Number(version[3]) < 30)))) {
+  const version = (await runNativeCommand(command, ["--version"], { cwd: directory, env, deadlineAt, timeoutMs: 10_000 })).trim().match(/^(?:opencode\s+)?v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+  if (!version || ![1, 2].includes(Number(version[1])) || (Number(version[1]) === 1 && (Number(version[2]) < 18 || (Number(version[2]) === 18 && Number(version[3]) < 30)))) {
     throw new Error("Native preparation requires OpenCode 1.18.30 or newer for isolated sessions. Update the native CLI and retry; the source remains pending.");
   }
+  const v2 = Number(version[1]) === 2;
+  await requireFlags(command, ["run"], v2 ? ["--standalone", "--format", "--agent"] : ["--pure", "--format", "--agent", "--dir"], { cwd: directory, env, deadlineAt });
   const originalConfig = path.join(env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "opencode");
   const originalData = path.join(env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share"), "opencode");
   let original = readOpenCodeConfig(originalConfig);
@@ -184,11 +194,21 @@ async function opencodeInvocation(directory, env, deadlineAt) {
     try { original = mergeConfig(original, parseOpenCodeConfig(env.OPENCODE_CONFIG_CONTENT)); }
     catch { throw new Error("Native preparation could not read the existing inline provider configuration. Repair that configuration and retry."); }
   }
-  const config = pick(original, ["model", "small_model", "provider", "enabled_providers", "disabled_providers"]);
-  const selectedAgent = original.agent?.[original.default_agent || "build"];
+  const config = pick(original, ["model", "small_model", "provider", "providers", "enabled_providers", "disabled_providers"]);
+  const selectedAgent = (v2 ? original.agents?.[original.default_agent || "build"] : undefined) || original.agent?.[original.default_agent || "build"];
   if (selectedAgent?.model) config.model = selectedAgent.model;
+  const prompt = `${POLICY}\nReturn raw JSON only, without Markdown or code fences. Return JSON matching this schema exactly. Decisions and verification must be arrays of strings, never objects.\n${JSON.stringify(outputSchema)}`;
   Object.assign(config, { snapshot: false, share: "disabled", autoupdate: false, permission: "deny", instructions: [], mcp: {},
-    default_agent: "shifu-preparation", agent: { "shifu-preparation": { ...pick(selectedAgent || {}, ["model", "variant", "temperature", "top_p"]), mode: "primary", prompt: `${POLICY}\nReturn raw JSON only, without Markdown or code fences. Return JSON matching this schema exactly. Decisions and verification must be arrays of strings, never objects.\n${JSON.stringify(PREPARATION_SCHEMA)}`, permission: "deny", tools: { "*": false }, steps: 1 } } });
+    default_agent: "shifu-preparation", agent: { "shifu-preparation": { ...pick(selectedAgent || {}, ["model", "variant", "temperature", "top_p"]), mode: "primary", prompt, permission: "deny", tools: { "*": false }, steps: 1 } } });
+  if (v2) {
+    delete config.agent;
+    Object.assign(config, { snapshots: false, update: "disable", plugins: [], skills: [], mcp: { servers: {} },
+      permissions: [{ action: "*", resource: "*", effect: "deny" }],
+      policies: [...(original.policies || []).filter((policy) => policy.action === "provider.use"),
+        { action: "tool.use", resource: "*", effect: "deny" }, { action: "integration.use", resource: "*", effect: "deny" }],
+      agents: { "shifu-preparation": { ...pick(selectedAgent || {}, ["model", "request"]), mode: "primary", system: prompt,
+        permissions: [{ action: "*", resource: "*", effect: "deny" }], steps: 1 } } });
+  }
   const configDirectory = path.join(directory, "config", "opencode");
   const dataDirectory = path.join(directory, "data", "opencode");
   const stateDirectory = path.join(directory, "state", "opencode");
@@ -198,7 +218,7 @@ async function opencodeInvocation(directory, env, deadlineAt) {
   try {
     const authFile = path.join(originalData, "auth.json");
     if (!fs.statSync(authFile).isFile()) throw new Error("Invalid native account storage");
-    fs.symlinkSync(authFile, path.join(dataDirectory, "auth.json"));
+    if (!v2) fs.symlinkSync(authFile, path.join(dataDirectory, "auth.json"));
   }
   catch (error) { if (error.code !== "ENOENT") throw new Error("Native preparation could not read the existing OpenCode account. Repair it and retry."); }
   // The native default uses recent models when no configured model is selected.
@@ -209,12 +229,17 @@ async function opencodeInvocation(directory, env, deadlineAt) {
       .map((entry) => ({ providerID: entry.providerID, modelID: entry.modelID }));
     privateFile(path.join(stateDirectory, "model.json"), JSON.stringify({ recent }));
   }
-  const isolatedEnv = { ...env, XDG_CONFIG_HOME: path.join(directory, "config"), XDG_DATA_HOME: path.join(directory, "data"),
+  const isolatedEnv = { ...env, PWD: directory, XDG_CONFIG_HOME: path.join(directory, "config"), XDG_DATA_HOME: path.join(directory, "data"),
     XDG_STATE_HOME: path.join(directory, "state"), XDG_CACHE_HOME: path.join(directory, "cache"), OPENCODE_CONFIG_DIR: configDirectory,
     OPENCODE_DB: ":memory:", OPENCODE_TEST_HOME: directory, OPENCODE_DISABLE_PROJECT_CONFIG: "1", OPENCODE_DISABLE_CLAUDE_CODE: "1",
     OPENCODE_DISABLE_EXTERNAL_SKILLS: "1", OPENCODE_DISABLE_AUTOUPDATE: "1", OPENCODE_AUTO_SHARE: "0" };
   for (const key of ["OPENCODE_CONFIG", "OPENCODE_CONFIG_CONTENT", "OPENCODE_PERMISSION", "OPENCODE_ATTACH"]) delete isolatedEnv[key];
-  return { command, env: isolatedEnv, args: ["run", "--pure", "--format", "json", "--agent", "shifu-preparation", "--title", "Shifu extraction preparation", "--dir", directory] };
+  if (v2) isolatedEnv.OPENCODE_DB = path.join(dataDirectory, "preparation.db");
+  const finalize = v2 ? await require("./opencode-v2-account.js").prepareOpenCodeAccount({
+    command, originalEnv: env, isolatedEnv, directory, deadlineAt, runNativeCommand,
+    legacyAuthFile: path.join(originalData, "auth.json"),
+  }) : undefined;
+  return { command, env: isolatedEnv, finalize, args: ["run", v2 ? "--standalone" : "--pure", "--format", "json", "--agent", "shifu-preparation", "--title", "Shifu extraction preparation", ...v2 ? [] : ["--dir", directory]] };
 }
 
 function parseOutput(harness, text) {
@@ -246,22 +271,29 @@ async function prepareNative(harness, packet, options = {}) {
   const startedAt = Date.now();
   const timeoutMs = Math.min(options.timeoutMs || TIMEOUT_MS, TIMEOUT_MS);
   const deadlineAt = startedAt + timeoutMs;
-  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "shifu-native-preparation-"));
+  const directory = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "shifu-native-preparation-")));
   fs.chmodSync(directory, 0o700);
-  const cleanup = [];
+  let invocation;
   try {
     const env = { ...process.env };
-    const invocation = harness === "codex" ? await codexInvocation(directory, env, cleanup, deadlineAt)
-      : harness === "claude_code" ? await claudeInvocation(directory, env, deadlineAt) : await opencodeInvocation(directory, env, deadlineAt);
-    const input = preparationPrompt(packet, options.validationFeedback);
+    const outputSchema = options.continuity ? require("./continuity-preparation.js").CONTINUITY_SCHEMA : PREPARATION_SCHEMA;
+    invocation = harness === "codex" ? await codexInvocation(directory, env, deadlineAt, outputSchema)
+      : harness === "claude_code" ? await claudeInvocation(directory, env, deadlineAt, outputSchema) : await opencodeInvocation(directory, env, deadlineAt, outputSchema);
+    const input = options.continuity ? require("./continuity-preparation.js").continuityPrompt(packet, options.validationFeedback) : preparationPrompt(packet, options.validationFeedback);
     if (Buffer.byteLength(input) > MAX_OUTPUT_BYTES) throw new Error("Native preparation source packet exceeds the input limit.");
     const remainingMs = timeoutMs - (Date.now() - startedAt);
     if (remainingMs <= 0) throw new Error("Native preparation timed out; the source remains pending.");
     const output = await runNativeCommand(invocation.command, invocation.args, { cwd: directory, env: invocation.env, input, timeoutMs: remainingMs, deadlineAt });
     return parseOutput(harness, output);
   } finally {
-    try { for (const file of cleanup) fs.rmSync(file, { force: true }); }
-    finally { fs.rmSync(directory, { recursive: true, force: true }); }
+    let preservePreparation = false;
+    try { await invocation?.finalize?.(); }
+    catch (error) {
+      preservePreparation = error.preservePreparation === true;
+      throw error;
+    } finally {
+      if (!preservePreparation) fs.rmSync(directory, { recursive: true, force: true });
+    }
   }
 }
 

package/bin/opencode-v2-account.js

@@ -0,0 +1,186 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { createHash, randomUUID } = require("node:crypto");
+const { pathToFileURL } = require("node:url");
+
+const FINALIZATION_TIMEOUT_MS = 10_000;
+const CREDENTIAL_COLUMNS = "id, integration_id, label, value, active, time_created";
+const ACCOUNT_ERROR = "Native preparation could not isolate or preserve the OpenCode account. Check sqlite3 and the native account, then retry; the source remains pending.";
+const LEGACY_OAUTH_ERROR = "Native preparation requires migrated OpenCode 2 OAuth accounts. Open OpenCode 2 once to migrate its native account, then retry; do not reconnect Shifu. The source remains pending.";
+
+async function readCredentials(database, options) {
+  if (!fs.existsSync(database)) return [];
+  const tables = await options.runNativeCommand("sqlite3", ["-readonly", "-json", database], {
+    ...options, input: "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'credential';\n",
+  });
+  if (!JSON.parse(tables || "[]").length) return [];
+  const output = await options.runNativeCommand("sqlite3", ["-readonly", "-json", database], {
+    ...options, input: `SELECT ${CREDENTIAL_COLUMNS} FROM credential ORDER BY active DESC, time_created DESC, id DESC;\n`,
+  });
+  const rows = JSON.parse(output || "[]");
+  for (const row of rows) {
+    if (typeof row.id !== "string" || typeof row.label !== "string" || typeof row.value !== "string") throw new Error(ACCOUNT_ERROR);
+    row.parsedValue = JSON.parse(row.value);
+  }
+  return rows;
+}
+
+function exportedCredentials(rows) {
+  const selected = new Set();
+  return rows.filter((row) => typeof row.integration_id === "string").map((row) => {
+    // Native v2 selects the newest credential when legacy rows lack an active flag.
+    const active = !selected.has(row.integration_id);
+    selected.add(row.integration_id);
+    return { id: row.id, integrationID: row.integration_id, label: row.label, value: row.parsedValue, active };
+  });
+}
+
+function sqlParameter(name, value) {
+  // Hex-encoded bindings cannot introduce SQL or sqlite shell metacommands.
+  return `.parameter set @${name} X'${Buffer.from(value, "utf8").toString("hex")}'\n`;
+}
+
+function requirePrivateDestination(directory, destination) {
+  const relative = path.relative(directory, destination);
+  if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) throw new Error(ACCOUNT_ERROR);
+}
+
+function copyLegacyAccount({ legacyAuthFile, isolatedEnv, directory }) {
+  if (!legacyAuthFile || !fs.existsSync(legacyAuthFile)) return;
+  const text = fs.readFileSync(legacyAuthFile, "utf8");
+  const account = JSON.parse(text);
+  if (!account || typeof account !== "object" || Array.isArray(account)) throw new Error(ACCOUNT_ERROR);
+  // V2 refreshes SQLite credentials, not legacy auth.json; copying OAuth would lose rotated tokens.
+  if (Object.values(account).some((value) => value?.type === "oauth")) throw new Error(LEGACY_OAUTH_ERROR);
+  const destination = path.join(isolatedEnv.XDG_DATA_HOME, "opencode", "auth.json");
+  requirePrivateDestination(directory, destination);
+  fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(destination, text, { mode: 0o600, flag: "wx" });
+}
+
+function credentialRecoveryDirectory(env) {
+  const configRoot = env.SHIFU_CONFIG_ROOT || path.join(env.XDG_CONFIG_HOME || path.join(env.HOME || os.homedir(), ".config"), "shifu", "coding-harness");
+  return path.join(configRoot, "credential-recovery");
+}
+
+function requirePrivateRecoveryDirectory(directory) {
+  const stat = fs.lstatSync(directory);
+  if (!stat.isDirectory() || (stat.mode & 0o077) || (process.getuid && stat.uid !== process.getuid())) throw new Error(ACCOUNT_ERROR);
+}
+
+function recoveryPrefix(database) {
+  return createHash("sha256").update(database).digest("hex");
+}
+
+function credentialRecoveryError(file) {
+  const error = new Error("OpenCode account refresh could not be saved to its native account. A private credential-only recovery file remains in Shifu's credential-recovery directory. Close concurrent OpenCode processes and retry sync to restore it automatically; do not reconnect Shifu. The source remains pending.");
+  error.code = "SHIFU_NATIVE_ACCOUNT_RECOVERY";
+  error.recoveryFile = file;
+  return error;
+}
+
+function retainCredentialRecovery(database, credentials, env) {
+  const recoveryDirectory = credentialRecoveryDirectory(env);
+  fs.mkdirSync(recoveryDirectory, { recursive: true, mode: 0o700 });
+  requirePrivateRecoveryDirectory(recoveryDirectory);
+  const file = path.join(recoveryDirectory, `${recoveryPrefix(database)}-${Date.now()}-${randomUUID()}.credential-recovery`);
+  fs.writeFileSync(file, JSON.stringify({ version: 1, harness: "opencode", database, credentials }), { mode: 0o600, flag: "wx" });
+  return credentialRecoveryError(file);
+}
+
+async function writeCredentialRefreshes(database, credentials, options) {
+  const updates = credentials.map((credential) => sqlParameter("id", credential.id) + sqlParameter("integration", credential.integrationID) +
+    sqlParameter("previous", credential.previousValue) + sqlParameter("updated", credential.value) +
+    "UPDATE credential SET value = CAST(@updated AS TEXT) WHERE id = CAST(@id AS TEXT) AND integration_id = CAST(@integration AS TEXT) AND value = CAST(@previous AS TEXT);\n");
+  // Compare-and-swap leaves concurrent logins, refreshes, deletions and account selection untouched.
+  await options.runNativeCommand("sqlite3", [`${pathToFileURL(database).href}?mode=rw`], {
+    ...options, input: `.bail on\n.timeout 1000\n.parameter init\nBEGIN IMMEDIATE;\n${updates.join("")}COMMIT;\n`,
+  });
+}
+
+async function recoverCredentialRefreshes(database, options) {
+  const directory = credentialRecoveryDirectory(options.env);
+  if (!fs.existsSync(directory)) return;
+  requirePrivateRecoveryDirectory(directory);
+  const prefix = recoveryPrefix(database);
+  const pattern = new RegExp(`^${prefix}-[0-9]+-[a-f0-9-]+\\.credential-recovery$`);
+  const files = fs.readdirSync(directory).filter((name) => pattern.test(name)).sort();
+  // Recovery is bounded separately from source discovery and never reads unrelated files.
+  if (files.length > 32) throw credentialRecoveryError(path.join(directory, files[0]));
+  for (const name of files) {
+    const file = path.join(directory, name);
+    try {
+      const stat = fs.lstatSync(file);
+      if (!stat.isFile() || (stat.mode & 0o077) || (process.getuid && stat.uid !== process.getuid()) || stat.size > 256 * 1024) throw new Error(ACCOUNT_ERROR);
+      const recovery = JSON.parse(fs.readFileSync(file, "utf8"));
+      if (recovery.version !== 1 || recovery.harness !== "opencode" || recovery.database !== database ||
+          !Array.isArray(recovery.credentials) || !recovery.credentials.length || recovery.credentials.length > 128 ||
+          !recovery.credentials.every((credential) => typeof credential.id === "string" && typeof credential.integrationID === "string" &&
+            typeof credential.previousValue === "string" && typeof credential.value === "string" &&
+            JSON.parse(credential.previousValue)?.type === "oauth" && JSON.parse(credential.value)?.type === "oauth")) throw new Error(ACCOUNT_ERROR);
+      await writeCredentialRefreshes(database, recovery.credentials, options);
+      fs.unlinkSync(file);
+    } catch {
+      throw credentialRecoveryError(file);
+    }
+  }
+}
+
+async function preserveRefreshes(originalDatabase, snapshots, options, originalEnv) {
+  const isolatedDatabase = options.env.OPENCODE_DB;
+  const current = await readCredentials(isolatedDatabase, options);
+  const credentials = [];
+  for (const row of current) {
+    const original = snapshots.find((snapshot) => snapshot.id === row.id);
+    if (!original || original.parsedValue.type !== "oauth" || row.parsedValue.type !== "oauth" ||
+        original.integration_id !== row.integration_id || JSON.stringify(original.parsedValue) === JSON.stringify(row.parsedValue)) continue;
+    credentials.push({ id: row.id, integrationID: original.integration_id, previousValue: original.value, value: row.value });
+  }
+  if (!credentials.length) return;
+  try {
+    await writeCredentialRefreshes(originalDatabase, credentials, options);
+  } catch {
+    throw retainCredentialRecovery(originalDatabase, credentials, originalEnv);
+  }
+}
+
+/** Copy only native v2 credentials into the isolated database, then preserve token refreshes. */
+async function prepareOpenCodeAccount({ command, originalEnv, isolatedEnv, directory, deadlineAt, runNativeCommand, legacyAuthFile }) {
+  const originalOptions = { cwd: directory, env: originalEnv, deadlineAt, runNativeCommand };
+  const isolatedOptions = { cwd: directory, env: isolatedEnv, deadlineAt, runNativeCommand };
+  try {
+    requirePrivateDestination(directory, isolatedEnv.OPENCODE_DB);
+    const database = (await runNativeCommand(command, ["debug", "paths", "db"], originalOptions)).trim();
+    if (!path.isAbsolute(database) || /[\r\n]/.test(database)) throw new Error(ACCOUNT_ERROR);
+    await recoverCredentialRefreshes(database, originalOptions);
+    const snapshots = await readCredentials(database, originalOptions);
+    const credentials = exportedCredentials(snapshots);
+    if (!credentials.length) {
+      copyLegacyAccount({ legacyAuthFile, isolatedEnv, directory });
+      return async () => {};
+    }
+    await runNativeCommand(command, ["auth", "import", "--standalone"], {
+      ...isolatedOptions, input: JSON.stringify(credentials),
+    });
+    if (fs.existsSync(isolatedEnv.OPENCODE_DB)) fs.chmodSync(isolatedEnv.OPENCODE_DB, 0o600);
+    if (!snapshots.some((snapshot) => snapshot.parsedValue.type === "oauth")) return async () => {};
+    return async () => {
+      try {
+        const finalizationOptions = { ...isolatedOptions, deadlineAt: Date.now() + FINALIZATION_TIMEOUT_MS };
+        await preserveRefreshes(database, snapshots, finalizationOptions, originalEnv);
+      } catch (error) {
+        if (error.code === "SHIFU_NATIVE_ACCOUNT_RECOVERY") throw error;
+        const recoveryError = new Error("OpenCode account recovery could not be saved safely. Private preparation files were retained locally to prevent losing refreshed native credentials. Close concurrent OpenCode processes and ask your assistant to recover the native account before retrying; do not reconnect Shifu. The source remains pending.");
+        recoveryError.preservePreparation = true;
+        recoveryError.recoveryDirectory = directory;
+        throw recoveryError;
+      }
+    };
+  } catch (error) {
+    if (error.message === LEGACY_OAUTH_ERROR || error.code === "SHIFU_NATIVE_ACCOUNT_RECOVERY") throw error;
+    throw new Error(ACCOUNT_ERROR);
+  }
+}
+
+module.exports = { prepareOpenCodeAccount };