@useshifu/coding-harness 0.3.28 → 0.3.29

package/README.md

@@ -44,6 +44,8 @@ To disconnect this device, run `npx --yes @useshifu/coding-harness disconnect --
 
 ## Operate
 
+Version `0.3.29` verifies native v5 sync across Codex, Claude Code, OpenCode 1 and OpenCode 2. Codex now loads a private allowlisted configuration and home instead of an ignored profile, with executable tools disabled. OpenCode 2 uses its standalone CLI, native provider/agent configuration, typed session database and isolated account storage. Native CI tests exercise original-source discovery, extraction, redaction, frozen retries and matching receipt checkpoints against local synthetic endpoints, without live credentials or paid models.
+
 Version `0.3.28` adds one isolated, pre-queue correction attempt for invalid v5 preparation, with field-specific reference and privacy diagnostics. Both attempts share the 180-second deadline. Privacy rules, trusted source binding, accepted checkpoints and exact queued retries remain unchanged.
 
 Version `0.3.27` adds a concrete topic-and-relationship retrieval playbook. Execution is the default for project work, first-person decision history and technical feedback; Growth requires explicit personal-development intent. The caller omits optional lexical query filters by default, accounts for Pi's internal expansion attempts, and preserves source authorship separately from contribution credit. Server retrieval reserves candidates for reformulation, ranks Execution without attribution metadata, and reports observed source groups without presenting repeated copies as independent confirmations.
@@ -51,7 +53,7 @@ Version `0.3.27` adds a concrete topic-and-relationship retrieval playbook. Exec
 
 Version `0.3.26` adds branded onboarding, independent growth-feedback and decision-alignment preferences, and an initial-history choice. `sessions --initial-history` uses the saved selection date when a backfill resumes instead of shifting a rolling days window. Publish this package version before deploying app setup prompts that reference it.
 
-Version `0.3.25` moves scheduled and pending preparation to the source-grounded v5 path across Codex, Claude Code and OpenCode. It caches each redacted payload before upload, preserves exact retries and queued legacy payloads, and leaves unfinished or failed ranges pending. The matching native CLI must support the required isolation flags; OpenCode requires 1.18.30 or newer.
+Version `0.3.25` moves scheduled and pending preparation to the source-grounded v5 path across Codex, Claude Code and OpenCode. It caches each redacted payload before upload, preserves exact retries and queued legacy payloads, and leaves unfinished or failed ranges pending. The matching native CLI must support the required isolation flags; OpenCode 1 requires 1.18.30 or newer. OpenCode 2 requires harness 0.3.29 or newer and `sqlite3` for local source/account access.
 
 Version `0.3.23` introduced the context guidance below. It retrieves context at substantive task starts and new topics, tracks current topic coverage, and surfaces Shifu-attributed support or discrepancies alongside proposals and actions. Current user instructions take precedence over historical context; adopted choices and rationale remain available to existing session sync.
 
@@ -86,6 +88,10 @@ To upgrade an existing installation, run `npx --yes @useshifu/coding-harness@lat
 
 Scheduled runs and `pending` prepare version-five payloads using the matching Codex, Claude Code, or OpenCode CLI and its existing account and model configuration. The selected raw source is processed by that native model provider in an isolated temporary invocation; it is never uploaded to Shifu or appended to the original conversation. Tools, project instructions, plugins, and MCP access are disabled during preparation, and temporary preparation files are removed afterwards. No separate extraction API key is required. Unattended native preparation currently requires macOS or Linux.
 
+Native sync gates pin Codex 0.163.0, Claude Code 2.1.301, OpenCode 1.18.30 and OpenCode 2.0.31. Other releases are checked for the required capabilities rather than assumed compatible. Codex file-backed authentication is shared without copying its session history; an explicit keyring-only store remains pending with an authentication remedy because its keyring namespace is tied to the original home. OpenCode 2 copies only native credentials into private temporary storage and conditionally preserves rotated OAuth values without overwriting concurrent account changes. No accepted history is replayed by this upgrade.
+
+OpenCode 2 account finalization has a separate 10-second recovery budget after model preparation ends. If native account write-back fails, an owner-only credential recovery artifact is retained outside session discovery and replayed safely before the next preparation; source storage is removed. If credentials cannot be read or the recovery artifact cannot be saved, private preparation storage is retained locally for assisted account recovery instead of deleting potentially rotated credentials. Neither recovery path uploads source or credentials. Legacy OAuth accounts must first be migrated by opening OpenCode 2 normally; reconnecting Shifu is unnecessary.
+
 Each preparation invocation handles at most four ranges, each covering up to 12 original turns, 128 source messages, and 256 KiB. Oversized automatic ranges are shortened before preparation rather than silently truncating text. A native preparation has a 180-second deadline. Unfinished trailing turns stay pending regardless of age; partial assistant text and intermediate tool calls do not count as final reports. An unsupported native CLI, missing required isolation flags, unavailable account, timeout, or invalid model output leaves the range pending. Update or repair the matching CLI and retry; the runner does not fall back to the old keyword projection.
 
 Before queueing, invalid structured preparation receives at most one isolated correction attempt using only privacy-safe validator diagnostics and the same source packet, within the original 180-second deadline. Reference errors identify the evidence position and decision or verification field without exposing source text. Native invocation failures are not retried through this correction path. If correction still fails, the range remains pending.
@@ -120,7 +126,7 @@ The AI Profile page shows detected categories, model and thinking labels, and Je
 
 The connection endpoint returns `recommendedPackageVersion`, pinned to a published release. Before `sync`, `sync-files`, `approve`, or `scheduled-sync`, the runner compares its embedded release version with that property. An older runner installs the exact recommended release through npm and resumes the original command with the updated runner. Equal or newer runners continue unchanged. Explicitly recommended major releases follow the same comparison rule. Missing or invalid recommendations, connection failures, and npm failures do not block sync. The connection, pending work, checkpoints, and schedule are preserved.
 
-This update mechanism first ships in `0.3.10`. Runners from earlier releases need a one-time installation of a release containing it (`npx --yes @useshifu/coding-harness@0.3.28 install --harness codex`). Raise the server recommendation only after the target release is published and its backend requirements are deployed.
+This update mechanism first ships in `0.3.10`. Runners from earlier releases need a one-time installation of a release containing it (`npx --yes @useshifu/coding-harness@0.3.29 install --harness codex`). Raise the server recommendation only after the target release is published and its backend requirements are deployed.
 
 ## Force sync local work
 
@@ -155,7 +161,7 @@ Setup preserves other instruction text and MCP settings. Package installation re
 The context branch adds a remote MCP connection using the same saved Codex key:
 
 ```sh
-npx --yes @useshifu/coding-harness@0.3.28 mcp-setup --harness codex --mcp-url https://YOUR-BRANCH-HOST/mcp
+npx --yes @useshifu/coding-harness@0.3.29 mcp-setup --harness codex --mcp-url https://YOUR-BRANCH-HOST/mcp
 ```
 
 For development, install dependencies and run from the checkout root:
@@ -186,7 +192,7 @@ Official configuration reference: https://learn.chatgpt.com/docs/config-file/con
 OpenCode uses the same `/mcp` endpoint and three tools, authenticated with its own saved OpenCode connection key:
 
 ```sh
-npx --yes @useshifu/coding-harness@0.3.28 mcp-setup --harness opencode --mcp-url https://YOUR-SHIFU-HOST/mcp
+npx --yes @useshifu/coding-harness@0.3.29 mcp-setup --harness opencode --mcp-url https://YOUR-SHIFU-HOST/mcp
 ```
 
 For checkout usage, install dependencies with `npm ci --prefix packages/shifu-coding-harness --ignore-scripts` from the checkout root, then run the checkout CLI with the same arguments. Setup preserves existing sync settings and other MCP servers, checks authenticated initialization and tool discovery, and installs the `shifu-context` usage instructions. A missing OpenCode connection prompts for its key in the terminal. A Codex key cannot authorize an OpenCode connection.
@@ -206,7 +212,7 @@ For the optional native integration gate, set `SHIFU_TEST_OPENCODE_BIN` to a tem
 Claude Code connects to the same `/mcp` endpoint and three tools with its own saved connection key:
 
 ```sh
-npx --yes @useshifu/coding-harness@0.3.28 mcp-setup --harness claude_code --mcp-url https://YOUR-SHIFU-HOST/mcp
+npx --yes @useshifu/coding-harness@0.3.29 mcp-setup --harness claude_code --mcp-url https://YOUR-SHIFU-HOST/mcp
 ```
 
 For checkout usage, install dependencies as above and run the checkout CLI with these arguments. Setup checks the existing Claude Code key, authenticated initialization and tool discovery, and installs the `shifu-context` skill. It preserves the sync endpoint, schedule, checkpoints and other MCP servers. A missing connection prompts for a Claude Code key in the terminal; do not substitute a Codex or OpenCode key.

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,29 +104,39 @@ async function requireFlags(command, prefix, flags, options) {
   }
 }
 
-async function codexInvocation(directory, env, cleanup, deadlineAt) {
+async function codexInvocation(directory, env, deadlineAt) {
   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,
+  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, "-"] };
 }
 
@@ -168,11 +177,12 @@ function readOpenCodeConfig(directory) {
 
 async function opencodeInvocation(directory, env, deadlineAt) {
   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(PREPARATION_SCHEMA)}`;
   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,12 +271,12 @@ 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)
+    invocation = harness === "codex" ? await codexInvocation(directory, env, deadlineAt)
       : harness === "claude_code" ? await claudeInvocation(directory, env, deadlineAt) : await opencodeInvocation(directory, env, deadlineAt);
     const input = preparationPrompt(packet, options.validationFeedback);
     if (Buffer.byteLength(input) > MAX_OUTPUT_BYTES) throw new Error("Native preparation source packet exceeds the input limit.");
@@ -260,8 +285,14 @@ async function prepareNative(harness, packet, options = {}) {
     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 };

package/bin/shifu-harness.js

@@ -46,7 +46,7 @@ const MAX_TURNS_PER_SEGMENT = 12;
 const MAX_TITLE_LENGTH = 160;
 const MAX_WORK_DETAIL_LENGTH = 600;
 const CONFIG_VERSION = 2;
-const RUNNER_VERSION = "0.3.28";
+const RUNNER_VERSION = "0.3.29";
 const REDACTION_VERSION = 5;
 const LEGACY_REDACTION_VERSION = 4;
 const MAX_PREPARATIONS_PER_RUN = 4;
@@ -109,13 +109,9 @@ function claudeSessionsRoot() {
 function opencodeQuery(query) {
   if (process.env.SHIFU_OPENCODE_DB && !process.env.SHIFU_OPENCODE_BIN) {
     try {
-      const sqliteOutput = execFileSync("sqlite3", ["-json", process.env.SHIFU_OPENCODE_DB, query], {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "pipe"],
-        maxBuffer: 64 * 1024 * 1024,
-      });
-      return JSON.parse(sqliteOutput);
-    } catch {
+      return openCodeDatabaseQuery(process.env.SHIFU_OPENCODE_DB, query);
+    } catch (error) {
+      if (error.code === "SHIFU_SQLITE_UNAVAILABLE") throw error;
       throw new Error("Could not read OpenCode session metadata. Ensure the opencode command is installed and its local database is available.");
     }
   }
@@ -137,16 +133,13 @@ function opencodeQuery(query) {
       try { fs.closeSync(fd); } catch {}
       fd = undefined;
     }
-    const dbPath = process.env.SHIFU_OPENCODE_DB || path.join(process.env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share"), "opencode", "opencode.db");
+    const dbPath = process.env.SHIFU_OPENCODE_DB || openCodeDatabasePath();
     if (fs.existsSync(dbPath)) {
       try {
-        const sqliteOutput = execFileSync("sqlite3", ["-json", dbPath, query], {
-          encoding: "utf8",
-          stdio: ["ignore", "pipe", "pipe"],
-          maxBuffer: 64 * 1024 * 1024,
-        });
-        return JSON.parse(sqliteOutput);
-      } catch {}
+        return openCodeDatabaseQuery(dbPath, query);
+      } catch (error) {
+        if (error.code === "SHIFU_SQLITE_UNAVAILABLE") throw error;
+      }
     }
     throw new Error("Could not read OpenCode session metadata. Ensure the opencode command is installed and its local database is available.");
   } finally {
@@ -157,6 +150,55 @@ function opencodeQuery(query) {
   }
 }
 
+function openCodeDatabasePath() {
+  try {
+    const { resolveNativeBinary, nativeEnvironment } = require("./native-preparation.js");
+    const location = execFileSync(resolveNativeBinary("opencode"), ["debug", "paths", "db"], {
+      env: nativeEnvironment(), encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 10_000, maxBuffer: 1024 * 1024,
+    }).trim();
+    if (path.isAbsolute(location) && !/[\r\n\0]/.test(location)) return location;
+  } catch {}
+  return path.join(process.env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share"), "opencode", "opencode.db");
+}
+
+function openCodeDatabaseQuery(dbPath, query) {
+  function read(sql) {
+    let output;
+    try {
+      output = execFileSync("sqlite3", ["-readonly", "-json", "-cmd", ".timeout 5000", dbPath, sql], {
+        encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 10_000, maxBuffer: 64 * 1024 * 1024,
+      });
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      const unavailable = new Error("Reading the local OpenCode database requires sqlite3. Install sqlite3 and retry; no work was synced.");
+      unavailable.code = "SHIFU_SQLITE_UNAVAILABLE";
+      throw unavailable;
+    }
+    return output.trim() ? JSON.parse(output) : [];
+  }
+  const tables = read("SELECT name FROM sqlite_master WHERE type = 'table' AND name IN ('session_v2', 'session_message')");
+  if (tables.length !== 2) return read(query);
+  // V2 stores typed messages, ordered by sequence, instead of separate parts.
+  // Read-only CTEs retain the existing adapter contract without changing its database.
+  const projection = `WITH
+    session AS (SELECT id, time_created, time_updated FROM session_v2),
+    message AS (
+      SELECT id, session_id, seq, time_created, json_object(
+        'role', type, 'finish', CASE WHEN json_extract(data, '$.time.completed') IS NOT NULL THEN json_extract(data, '$.finish') END,
+        'error', json_extract(data, '$.error'), 'modelID', json_extract(data, '$.model.id'), 'storageVersion', 2
+      ) AS data FROM session_message WHERE type IN ('user', 'assistant', 'idle')
+    ),
+    part AS (
+      SELECT id || '_user' AS id, id AS message_id, json_object('type', 'text', 'text', json_extract(data, '$.text')) AS data
+      FROM session_message WHERE type = 'user'
+      UNION ALL
+      SELECT m.id || '_' || printf('%08d', p.key), m.id, p.value
+      FROM session_message m, json_each(m.data, '$.content') p WHERE m.type = 'assistant'
+    ) `;
+  return read(projection + query.replaceAll("ORDER BY s.time_updated, m.time_created", "ORDER BY s.time_updated, m.seq")
+    .replaceAll("ORDER BY m.time_created, p.id", "ORDER BY m.seq, p.id"));
+}
+
 function opencodeSessions(rows) {
   const sessions = new Map();
   for (const row of rows) {
@@ -589,7 +631,7 @@ function reviewSourcePacket(harness, sessionRef, fromTurn, toTurn, scheduled = f
 
 function sourceRecords(harness, sessionRef) {
   if (harness === "opencode") {
-    return opencodeQuery(`SELECT m.id AS messageId, m.time_created AS createdAt, json_extract(m.data, '$.role') AS role, json_extract(m.data, '$.finish') AS finish, json_extract(m.data, '$.error') AS error, p.data AS part FROM message m LEFT JOIN part p ON p.message_id = m.id WHERE m.session_id = ${JSON.stringify(sessionRef)} ORDER BY m.time_created, p.id`);
+    return opencodeQuery(`SELECT m.id AS messageId, m.time_created AS createdAt, json_extract(m.data, '$.role') AS role, json_extract(m.data, '$.finish') AS finish, json_extract(m.data, '$.error') AS error, json_extract(m.data, '$.storageVersion') AS storageVersion, p.data AS part FROM message m LEFT JOIN part p ON p.message_id = m.id WHERE m.session_id = ${JSON.stringify(sessionRef)} ORDER BY m.time_created, p.id`);
   }
   const file = sessionFile(harness, sessionRef);
   try { return fs.readFileSync(file, "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line)); }
@@ -1231,7 +1273,7 @@ function copyRunner() {
     const installedDependency = path.join(configRoot(), "node_modules", name);
     if (!sameFile(dependency, installedDependency)) copyDirectory(dependency, installedDependency);
   }
-  for (const name of ["source-review.js", "v5-payload.js", "native-preparation.js", "context-preferences.js", "setup-options.js", "initial-history.js", "onboarding-ui.js"]) {
+  for (const name of ["source-review.js", "v5-payload.js", "native-preparation.js", "opencode-v2-account.js", "context-preferences.js", "setup-options.js", "initial-history.js", "onboarding-ui.js"]) {
     const source = path.join(__dirname, name);
     const destination = path.join(configRoot(), name);
     if (!sameFile(source, destination)) {

package/bin/source-review.js

@@ -191,7 +191,8 @@ function completedSourceTurn(selection, records) {
       if (message.role === "user") {
         turnCount += 1;
         closed = false;
-      } else if (message.role === "assistant") closed = message.finish === "stop" && message.error == null;
+      } else if (message.role === "assistant") closed = message.storageVersion !== 2 && message.finish === "stop" && message.error == null;
+      else if (message.storageVersion === 2 && message.role === "idle") closed = true;
     }
   } else throw new Error("Unsupported original-source harness.");
   return Math.max(0, turnCount - (closed ? 0 : 1));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useshifu/coding-harness",
-  "version": "0.3.28",
+  "version": "0.3.29",
   "description": "Scheduled, redacted coding-harness activity sync for Shifu",
   "bin": {
     "coding-harness": "bin/shifu-harness.js",

package/skills/shifu-context/SKILL.md

@@ -12,7 +12,7 @@ Before first connection or MCP personalization, ask for any choices that are not
 When asked to connect Shifu context, run:
 
 ```sh
-npx --yes @useshifu/coding-harness@0.3.28 mcp-setup --harness codex
+npx --yes @useshifu/coding-harness@0.3.29 mcp-setup --harness codex
 ```
 
 MCP setup verifies the connection and tools, saves the choices and installs instructions; it does not sync sessions or upload the selected history. History selection governs eligible work for subsequent sync. Do not start sync as part of this setup unless the user separately asks for it. If a saved connection exists, reuse its key and do not run `connect` again.