@khalilgharbaoui/opencode-claude-code-plugin 0.50.0 → 0.51.0

package/dist/index.d.ts

@@ -335,6 +335,9 @@ type OpenCodeHooks = {
 };
 type OpenCodePlugin = (input: unknown, options?: Record<string, unknown>) => Promise<OpenCodeHooks>;
 
+/** Account name -> group name. Empty is never stored; `null` means no guard. */
+type AccountGroups = Readonly<Record<string, string>>;
+
 type LogLevel = "debug" | "info" | "notice" | "warn" | "error";
 type LogMode = "silent" | "debug";
 
@@ -390,6 +393,12 @@ interface ClaudeCodeConfig {
      */
     accountInProcess?: boolean;
     accountFailover?: AccountFailoverMode;
+    /**
+     * The resolved `accountGroups` guard, or null for "no guard". Resolved once
+     * by `createClaudeCode` from the user's option, so every turn reads a value
+     * that has already been validated and warned about (h #g226).
+     */
+    accountGroups?: AccountGroups | null;
     providerID?: string;
     skipPermissions?: boolean;
     /**
@@ -531,6 +540,35 @@ interface ClaudeCodeProviderSettings {
      * error. See README "Account failover".
      */
     accountFailover?: AccountFailoverMode;
+    /**
+     * Which accounts may see each other's conversations. A map from an account
+     * name in `accounts` to a group name, e.g. `{ "appical": "work" }`.
+     *
+     * **Off unless set**, and unset is the default: with no map, or an empty one,
+     * every account behaves as one group and nothing about today's behaviour
+     * changes. Every account not named here, `default` included, is in one
+     * implicit group, so naming the one account that must stay apart is the whole
+     * configuration.
+     *
+     * When it is set, the plugin only ever moves a conversation between accounts
+     * in the SAME group: the by-hand switch (picking a model under another
+     * account's provider), the account-switch form, the override that form sets,
+     * and `crossAccountResume`. A switch ACROSS groups sends the other account
+     * nothing at all, not the Claude transcript and not a text replay of the
+     * thread either, because the replay is the same history by another route. The
+     * turn there starts fresh with only the current message and says so once, in
+     * one `▌ **account group:**` note naming both accounts. The conversation is
+     * left intact on the account it was on, so switching back continues it.
+     *
+     * The switch form offers only accounts in the limited account's own group,
+     * and with none left it behaves as a single-account install does.
+     *
+     * An account name that is not in `accounts` is a typo, so it is ignored with
+     * one WARN rather than silently creating a group that guards nothing. The
+     * resolved map is printed in the startup block and in
+     * `/claude-code-doctor`, names only.
+     */
+    accountGroups?: Record<string, string>;
     /**
      * Model that subagents run on when their own definition pins nothing.
      * Unset means no implicit override at all, so an agent keeps inheriting the

package/dist/index.js

@@ -572,6 +572,139 @@ function titleizeAccount(account) {
   return normalizeAccountName(account).split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 }
 
+// src/account-groups.ts
+var DEFAULT_ACCOUNT_GROUP = "default";
+function normalizeGroupName(value) {
+  return value.trim().toLowerCase();
+}
+var warnedUnknownAccounts = /* @__PURE__ */ new Set();
+var warnedShape = false;
+function resolveAccountGroups(value, knownAccounts) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value !== "object" || Array.isArray(value)) {
+    if (!warnedShape) {
+      warnedShape = true;
+      log.warn(
+        "accountGroups must be an object mapping an account name to a group name; ignoring it",
+        { type: Array.isArray(value) ? "array" : typeof value }
+      );
+    }
+    return null;
+  }
+  const known = knownAccounts ? new Set(knownAccounts.map((account) => normalizeAccountName(String(account)))) : void 0;
+  const out = {};
+  for (const [rawAccount, rawGroup] of Object.entries(value)) {
+    const account = normalizeAccountName(rawAccount);
+    if (!account) continue;
+    if (typeof rawGroup !== "string") {
+      if (!warnedShape) {
+        warnedShape = true;
+        log.warn(
+          "accountGroups must be an object mapping an account name to a group name; ignoring it",
+          { account, type: typeof rawGroup }
+        );
+      }
+      continue;
+    }
+    const group = normalizeGroupName(rawGroup);
+    if (!group) continue;
+    if (known && !known.has(account)) {
+      if (!warnedUnknownAccounts.has(account)) {
+        warnedUnknownAccounts.add(account);
+        log.warn("accountGroups names an account that is not configured; ignoring it", {
+          account,
+          group
+        });
+      }
+      continue;
+    }
+    out[account] = group;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+function accountGroup(account, groups) {
+  const name = normalizeAccountName(account || DEFAULT_ACCOUNT);
+  return groups?.[name] ?? DEFAULT_ACCOUNT_GROUP;
+}
+function accountsShareGroup(a, b, groups) {
+  if (!groups) return true;
+  return accountGroup(a, groups) === accountGroup(b, groups);
+}
+function accountsInGroupOf(account, accounts, groups) {
+  const out = [];
+  for (const raw of accounts ?? []) {
+    const name = normalizeAccountName(String(raw));
+    if (!name || out.includes(name)) continue;
+    if (!accountsShareGroup(account, name, groups)) continue;
+    out.push(name);
+  }
+  return out;
+}
+function describeAccountGroups(groups) {
+  if (!groups) return [];
+  return Object.entries(groups).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([account, group]) => `${account}=${group}`);
+}
+function accountProviderMap(accounts) {
+  const out = /* @__PURE__ */ new Map();
+  for (const raw of accounts ?? []) {
+    const account = normalizeAccountName(String(raw));
+    if (!account) continue;
+    out.set(`${BASE_PROVIDER_ID}-${account}`, account);
+  }
+  return out;
+}
+var CONTEXT_PREFIX = "context=";
+function sessionKeyContextBlob(sessionKey2) {
+  const parts = sessionKey2.split("::");
+  if (parts.length < 5) return void 0;
+  if (parts[2] === "compaction") return void 0;
+  const withoutEffort = parts[parts.length - 1].startsWith("effort=") ? parts.slice(0, -1) : parts;
+  if (withoutEffort.length < 5) return void 0;
+  const tail = withoutEffort.slice(4).join("::");
+  return tail.startsWith(CONTEXT_PREFIX) ? tail.slice(CONTEXT_PREFIX.length) : void 0;
+}
+function sessionKeyProvider(sessionKey2) {
+  const blob = sessionKeyContextBlob(sessionKey2);
+  if (blob === void 0) return void 0;
+  try {
+    const parsed = JSON.parse(blob);
+    const first = Array.isArray(parsed) ? parsed[0] : void 0;
+    return typeof first === "string" ? first : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function sessionKeyAccount(sessionKey2, providers) {
+  const provider = sessionKeyProvider(sessionKey2);
+  return provider === void 0 ? void 0 : providers.get(provider);
+}
+function blankAccountProvider(sessionKey2, providers) {
+  if (providers.size === 0) return sessionKey2;
+  const blob = sessionKeyContextBlob(sessionKey2);
+  if (blob === void 0) return sessionKey2;
+  let parsed;
+  try {
+    parsed = JSON.parse(blob);
+  } catch {
+    return sessionKey2;
+  }
+  if (!Array.isArray(parsed)) return sessionKey2;
+  const provider = parsed[0];
+  if (typeof provider !== "string" || !providers.has(provider)) return sessionKey2;
+  const blanked = [...parsed];
+  blanked[0] = "*";
+  const prefix = sessionKey2.slice(0, sessionKey2.length - blob.length);
+  return `${prefix}${JSON.stringify(blanked)}`;
+}
+var ACCOUNT_GROUP_MARKER = "\u258C **account group:**";
+function formatAccountGroupNote(input) {
+  const source = normalizeAccountName(input.sourceAccount || DEFAULT_ACCOUNT);
+  const target = normalizeAccountName(input.targetAccount || DEFAULT_ACCOUNT);
+  return `
+${ACCOUNT_GROUP_MARKER} this conversation was running on the Claude account "${source}" (group "${input.sourceGroup}") and is now on "${target}" (group "${input.targetGroup}"), so none of it was carried over: accountGroups keeps a conversation inside one group. This account is starting fresh and sees only your latest message. The conversation is still on "${source}"; switch back to it to continue where you stopped.
+`;
+}
+
 // src/types.ts
 var READ_ONLY_PERMISSION_MODE = "read-only";
 var DEFAULT_PROXY_TOOL_NAMES = [
@@ -1489,12 +1622,13 @@ function isAccountFailoverQuestionActive(input) {
   if (input.candidates.length === 0) return false;
   return input.opencodeHasQuestion;
 }
-function failoverCandidates(accounts, source) {
+function failoverCandidates(accounts, source, groups) {
   const from = normalizeAccountName(source || DEFAULT_ACCOUNT);
   const out = [];
   for (const raw of accounts ?? []) {
     const name = normalizeAccountName(String(raw));
     if (!name || name === from || out.includes(name)) continue;
+    if (!accountsShareGroup(from, name, groups)) continue;
     out.push(name);
   }
   return out;
@@ -4544,7 +4678,7 @@ function forkSiblingSignature(sessionKey2) {
   blanked[3] = "*";
   return blanked.join("::");
 }
-function modelSiblingSignature(sessionKey2) {
+function modelSiblingSignature(sessionKey2, accountProviders) {
   const parts = sessionKey2.split("::");
   if (parts.length < 5) return null;
   if (parts[2] === "compaction") return null;
@@ -4552,7 +4686,8 @@ function modelSiblingSignature(sessionKey2) {
   if (withoutEffort.length < 5) return null;
   const blanked = [...withoutEffort];
   blanked[1] = "*";
-  return blanked.join("::");
+  const signature = blanked.join("::");
+  return accountProviders && accountProviders.size > 0 ? blankAccountProvider(signature, accountProviders) : signature;
 }
 function moveForkFingerprint(fromKey, toKey) {
   const record = fingerprints.get(fromKey);
@@ -4657,7 +4792,7 @@ function isDigest(value) {
 }
 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));
+  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() {
   if (records) return records;
@@ -4703,17 +4838,27 @@ function save(update) {
     });
   }
 }
-function recordResumePoint(sessionKey2, claudeSessionId, prompt, cliPath) {
+function recordResumePoint(sessionKey2, claudeSessionId, prompt, cliPath, where) {
   const chain = conversationDigests(prompt);
   if (chain.length === 0) return;
   const shape2 = conversationDigests(prompt, { assistantContent: false });
+  const configDir = where?.configDir;
+  const account = where?.account;
   const current = load().get(sessionKey2);
-  if (current && current.claudeSessionId === claudeSessionId && current.cliPath === cliPath && current.shape !== void 0 && current.chain.length === chain.length && current.chain.every((entry, i) => entry.digest === chain[i].digest)) {
+  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) => {
     merged.delete(sessionKey2);
-    merged.set(sessionKey2, { claudeSessionId, cliPath, chain, shape: shape2, updatedAt: Date.now() });
+    merged.set(sessionKey2, {
+      claudeSessionId,
+      cliPath,
+      chain,
+      shape: shape2,
+      ...configDir === void 0 ? {} : { configDir },
+      ...account === void 0 ? {} : { account },
+      updatedAt: Date.now()
+    });
   });
 }
 function forgetResumePoint(sessionKey2) {
@@ -4755,18 +4900,31 @@ function findResumePoint(opts) {
   return { claudeSessionId: record.claudeSessionId, matched: record.chain.length };
 }
 function findSiblingResumePoint(opts) {
-  const signature = modelSiblingSignature(opts.sessionKey);
+  const providers = opts.accountProviders;
+  const signature = modelSiblingSignature(opts.sessionKey, providers);
   if (!signature) {
     opts.onRefused?.("no-sibling-possible");
     return void 0;
   }
+  const ownAccount = providers ? sessionKeyAccount(opts.sessionKey, providers) : void 0;
   let best;
   let bestUpdatedAt = -1;
   let refusal;
   for (const [key, record] of load()) {
     if (key === opts.sessionKey) continue;
-    if (modelSiblingSignature(key) !== signature) continue;
-    if (record.cliPath !== opts.cliPath) {
+    if (modelSiblingSignature(key, providers) !== signature) continue;
+    const siblingAccount = providers ? sessionKeyAccount(key, providers) : void 0;
+    const crossAccount = ownAccount !== void 0 && siblingAccount !== void 0 && siblingAccount !== ownAccount;
+    if (crossAccount) {
+      if (opts.allowAccount && !opts.allowAccount(siblingAccount)) {
+        refusal = "sibling-another-account-group";
+        continue;
+      }
+      if (!record.configDir) {
+        refusal = "sibling-account-dir-unknown";
+        continue;
+      }
+    } else if (record.cliPath !== opts.cliPath) {
       refusal = "sibling-another-claude-binary";
       continue;
     }
@@ -4780,7 +4938,7 @@ function findSiblingResumePoint(opts) {
       refusal = "sibling-still-writing";
       continue;
     }
-    if (!existsSync2(opts.transcriptPath(record.claudeSessionId))) {
+    if (!existsSync2(opts.transcriptPath(record.claudeSessionId, record.configDir))) {
       refusal = "sibling-transcript-gone";
       continue;
     }
@@ -4789,7 +4947,8 @@ function findSiblingResumePoint(opts) {
       best = {
         claudeSessionId: record.claudeSessionId,
         siblingKey: key,
-        matched: record.chain.length
+        matched: record.chain.length,
+        ...crossAccount ? { siblingAccount, siblingConfigDir: record.configDir } : {}
       };
     }
   }
@@ -4800,6 +4959,35 @@ function findSiblingResumePoint(opts) {
   }
   return best;
 }
+function findForeignAccountSibling(opts) {
+  const providers = opts.accountProviders;
+  if (providers.size === 0) return void 0;
+  const signature = modelSiblingSignature(opts.sessionKey, providers);
+  if (!signature) return void 0;
+  const ownAccount = sessionKeyAccount(opts.sessionKey, providers);
+  if (ownAccount === void 0) return void 0;
+  const consider = (key) => {
+    if (key === opts.sessionKey) return void 0;
+    if (modelSiblingSignature(key, providers) !== signature) return void 0;
+    const account = sessionKeyAccount(key, providers);
+    if (account === void 0 || account === ownAccount) return void 0;
+    return { siblingKey: key, account };
+  };
+  for (const key of opts.extraKeys ?? []) {
+    const hit = consider(key);
+    if (hit) return hit;
+  }
+  let found;
+  let foundUpdatedAt = -1;
+  for (const [key, record] of load()) {
+    const hit = consider(key);
+    if (hit && record.updatedAt >= foundUpdatedAt) {
+      found = hit;
+      foundUpdatedAt = record.updatedAt;
+    }
+  }
+  return found;
+}
 
 // src/permission-presets.ts
 var READ_ONLY_DISALLOWED_CLI_TOOLS = [
@@ -5472,6 +5660,9 @@ async function deleteActiveProcessAndWait(key, options = {}) {
 function getClaudeSessionId(key) {
   return claudeSessions.get(key);
 }
+function listClaudeSessionKeys() {
+  return claudeSessions.keys();
+}
 var MAX_CLAUDE_SESSION_ENTRIES = 64;
 function claudeSessionIsBusy(key) {
   if (activeProcesses.has(key)) return true;
@@ -6151,6 +6342,8 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "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",
   "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",
   "agent effort override refused: unknown level",
   "agent model override refused: unknown model",
   "agent prompt cache ttl refused: unknown value",
@@ -6261,6 +6454,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "replaying stdout the child emitted between turns",
   "replaying the conversation as text: no claude session was available to continue",
   "replaying this conversation as text on the other account",
+  "replaying this conversation rather than carrying it across accounts",
   "result fallback timer fired \u2014 closing stream without result event",
   "resuming the claude session from before the restart instead of replaying it",
   "shared Claude capability already exists; leaving untouched",
@@ -6268,6 +6462,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "skipping local MCP server with no command",
   "skipping remote MCP server with no url",
   "stale scratch directory sweep failed",
+  "starting fresh on this account: it is in another account group",
   "task_batch resolving with child results missing",
   "the interactive transport has not been measured on this Claude Code version; it reads the TUI's screen and transcript, which a new release can change. If a turn hangs or a dialog is not handled, run /claude-code-doctor bundle and report it",
   "the interactive turn did not take a forwarded user message",
@@ -6403,7 +6598,13 @@ var BUNDLE_DATA_ALLOWLIST = {
   // doctor table already prints the same class of value (providers, accounts,
   // proxyTools, MCP servers), so a bundle is no more revealing than the report
   // it is attached to.
+  // An account name and a group name are both operator-chosen labels of the
+  // same class as `accounts`, which the doctor table already prints a column
+  // of; `from` is already here as the account a conversation came from.
+  account: "name",
   accounts: "name",
+  accountGroups: "name",
+  group: "name",
   agent: "name",
   bundled: "name",
   excluded: "name",
@@ -7029,6 +7230,15 @@ function collectStartupDiagnostics(providers, opencodeVersion) {
     cwd,
     providers: Object.keys(providers),
     accounts,
+    // One guard per install, so the first provider that declares one answers
+    // for all of them; it is validated against the accounts the expansion
+    // produced, which is the same list every provider carries.
+    accountGroups: describeAccountGroups(
+      resolveAccountGroups(
+        firstOption(providers, "accountGroups"),
+        stringList(firstOption(providers, "failoverAccounts"))
+      )
+    ),
     proxyTools: stringList(firstOption(providers, "proxyTools")),
     mcpServers,
     permissionPresets: Object.entries(providers).map(
@@ -7301,6 +7511,9 @@ function formatDoctorReport(report) {
   lines.push(`| cwd | \`${report.cwd.resolved}\` (${report.cwd.source}) |`);
   lines.push(`| providers | ${list(report.providers)} |`);
   lines.push(`| accounts | ${list(report.accounts)} |`);
+  lines.push(
+    `| accountGroups | ${report.accountGroups.length > 0 ? list(report.accountGroups) : "none (every account is one group)"} |`
+  );
   lines.push(`| proxyTools | ${list(report.proxyTools)} |`);
   lines.push(`| MCP servers (on disk) | ${list(report.mcpServers)} |`);
   lines.push(`| permissionPreset | ${describePermissionPresets(report.permissionPresets)} |`);
@@ -7554,6 +7767,7 @@ async function gatherDoctorReport(options) {
     cwd: base.cwd,
     providers: base.providers,
     accounts: base.accounts,
+    accountGroups: base.accountGroups,
     proxyTools: base.proxyTools,
     mcpServers: base.mcpServers,
     permissionPresets: base.permissionPresets,
@@ -8398,6 +8612,7 @@ var PLUGIN_NOTE_MARKERS = [
   SILENT_TURN_MARKER,
   FAILOVER_MARKER,
   ACCOUNT_BLOCK_MARKER,
+  ACCOUNT_GROUP_MARKER,
   USAGE_LIMIT_MARKER,
   MODEL_FALLBACK_MARKER,
   UNATTENDED_REPLAY_MARKER,
@@ -13930,6 +14145,8 @@ var ClaudeCodeLanguageModel = class {
     const sourceAccount = normalizeAccountName(
       this.config.account ?? DEFAULT_ACCOUNT
     );
+    const accountProviders = accountProviderMap(this.config.failoverAccounts);
+    const groups = this.config.accountGroups ?? null;
     const baseCliPath = this.config.baseCliPath ?? this.config.cliPath;
     let failover = compactionMode ? { cliPath: this.config.cliPath, modelId: effectiveModelId, failedOver: false } : await resolveFailoverSpawn({
       account: sourceAccount,
@@ -14091,7 +14308,11 @@ var ClaudeCodeLanguageModel = class {
     }
     const failoverAnswer = compactionMode || mode === "generate" ? null : consumeAccountFailoverAnswer(sk, options.prompt, {
       sourceAccount,
-      candidates: failoverCandidates(this.config.failoverAccounts, sourceAccount)
+      candidates: failoverCandidates(
+        this.config.failoverAccounts,
+        sourceAccount,
+        groups
+      )
     });
     if (failoverAnswer?.kind === "stop") {
       log.warn("account failover declined; ending the turn", {
@@ -14173,8 +14394,13 @@ var ClaudeCodeLanguageModel = class {
         // Every account's own directory, plus this model's configured one:
         // `configDir` is an option, so an account's directory is not always
         // the `~/.claude-<name>` the name alone would build.
+        // Same-group accounts only (h #g226): a transcript sitting in an
+        // account from another group is not a source this may read from, and
+        // with no groups configured this is the full list exactly as before.
         accountConfigDirs: [
-          ...(this.config.failoverAccounts ?? []).map(configDirForAccount),
+          ...accountsInGroupOf(sourceAccount, this.config.failoverAccounts, groups).map(
+            configDirForAccount
+          ),
           resolveConfigDir(this.config.configDir)
         ]
       });
@@ -14208,6 +14434,32 @@ var ClaudeCodeLanguageModel = class {
     if (failoverAnswer?.kind === "switch" && hasPriorConversation && !conversationOnTarget) {
       includeHistoryContext = true;
     }
+    let accountGroupNote = null;
+    if (!compactionMode && groups && accountProviders.size > 0 && includeHistoryContext && failoverAnswer?.kind !== "switch") {
+      const foreign = findForeignAccountSibling({
+        sessionKey: sk,
+        accountProviders,
+        // The live process's own view, so the guard holds with
+        // `resumeAfterRestart: false`, where the store is never written.
+        extraKeys: listClaudeSessionKeys()
+      });
+      if (foreign && !accountsShareGroup(sourceAccount, foreign.account, groups)) {
+        includeHistoryContext = false;
+        accountGroupNote = formatAccountGroupNote({
+          sourceAccount: foreign.account,
+          sourceGroup: accountGroup(foreign.account, groups),
+          targetAccount: sourceAccount,
+          targetGroup: accountGroup(sourceAccount, groups)
+        });
+        log.notice("starting fresh on this account: it is in another account group", {
+          sessionKey: sk,
+          reason: "another-account-group",
+          account: sourceAccount,
+          from: foreign.account,
+          group: accountGroup(sourceAccount, groups)
+        });
+      }
+    }
     let forkFromClaudeSessionId;
     if (this.config.forkSessions === true && includeHistoryContext && !compactionMode && failoverAnswer?.kind !== "switch") {
       const parent = findForkParent({
@@ -14251,7 +14503,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) => join13(configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
+      const transcriptPath2 = (id, dir) => join13(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
       const resumePoint = findResumePoint({
         sessionKey: sk,
         prompt: options.prompt,
@@ -14279,25 +14531,70 @@ var ClaudeCodeLanguageModel = class {
           // timers on everything it touches (the same reason the fork lookup
           // above uses it).
           isBusy: claudeSessionIsWriting,
+          // The ACCOUNT is the third thing that may differ (h #g226), and the
+          // guard is where a cross-group sibling is refused by name.
+          accountProviders,
+          allowAccount: (account) => this.config.crossAccountResume !== false && accountsShareGroup(sourceAccount, account, groups),
           onRefused: (reason) => {
             replayReason = reason;
           }
         });
         if (sibling) {
-          deleteActiveProcess(sibling.siblingKey);
-          const carried = transferClaudeSession(sibling.siblingKey, sk);
-          if (carried) {
-            includeHistoryContext = false;
-            log.notice(
-              "continuing this conversation's claude session under the new model or effort instead of replaying it",
-              {
-                sessionKey: sk,
-                siblingKey: sibling.siblingKey,
-                matchedMessages: sibling.matched
-              }
-            );
+          let carriedSessionId;
+          let carryRefused;
+          if (sibling.siblingAccount && sibling.siblingConfigDir) {
+            const carry = await carryTranscriptToAccount({
+              sessionId: sibling.claudeSessionId,
+              cwd,
+              targetConfigDir: resolveConfigDir(this.skillBridgeSpawn(failover).configDir),
+              // The sibling's recorded directory first, then every same-group
+              // account's. The recorded one can be stale by a turn (it is
+              // rewritten only when a turn succeeds), so the conventional
+              // directories are what make a stale record recoverable rather
+              // than a refusal.
+              accountConfigDirs: [
+                sibling.siblingConfigDir,
+                ...accountsInGroupOf(sourceAccount, this.config.failoverAccounts, groups).map(
+                  configDirForAccount
+                ),
+                configDir
+              ]
+            });
+            if (carry.kind === "carried" || carry.kind === "already-there") {
+              carriedSessionId = carry.sessionId;
+            } else {
+              carryRefused = carry.reason;
+            }
+          }
+          if (carryRefused) {
+            replayReason = `sibling-${carryRefused}`;
+            log.notice("replaying this conversation rather than carrying it across accounts", {
+              sessionKey: sk,
+              siblingKey: sibling.siblingKey,
+              reason: carryRefused,
+              account: sourceAccount,
+              from: sibling.siblingAccount
+            });
           } else {
-            replayReason = "sibling-carry-over-failed";
+            deleteActiveProcess(sibling.siblingKey);
+            const carried = transferClaudeSession(sibling.siblingKey, sk);
+            if (carried) {
+              if (carriedSessionId && carriedSessionId !== carried) {
+                setClaudeSessionId(sk, carriedSessionId);
+              }
+              includeHistoryContext = false;
+              log.notice(
+                "continuing this conversation's claude session under the new model or effort instead of replaying it",
+                {
+                  sessionKey: sk,
+                  siblingKey: sibling.siblingKey,
+                  matchedMessages: sibling.matched,
+                  ...sibling.siblingAccount ? { from: sibling.siblingAccount, account: sourceAccount } : {}
+                }
+              );
+            } else {
+              replayReason = "sibling-carry-over-failed";
+            }
           }
         }
       }
@@ -14379,7 +14676,8 @@ var ClaudeCodeLanguageModel = class {
     }
     const failoverAccounts = failoverCandidates(
       this.config.failoverAccounts,
-      sourceAccount
+      sourceAccount,
+      groups
     );
     const failoverAskActive = failoverAccounts.length > 0 && this.config.accountFailover === "ask" && !compactionMode && // A `doGenerate` caller takes the override and reports the plain
     // rate-limit error, never the form. See `TurnMode`.
@@ -14971,6 +15269,14 @@ var ClaudeCodeLanguageModel = class {
             });
             state.endTextBlock();
           }
+          if (accountGroupNote) {
+            controller.enqueue({
+              type: "text-delta",
+              id: state.startTextBlock(),
+              delta: accountGroupNote
+            });
+            state.endTextBlock();
+          }
           if (failoverNote) {
             controller.enqueue({
               type: "text-delta",
@@ -14983,7 +15289,10 @@ var ClaudeCodeLanguageModel = class {
           const completeResult = (msg) => {
             if (state.controllerClosed) return;
             if (self.config.resumeAfterRestart !== false && !compactionMode && msg.is_error !== true && typeof msg.session_id === "string") {
-              recordResumePoint(sk, msg.session_id, options.prompt, cliPath);
+              recordResumePoint(sk, msg.session_id, options.prompt, cliPath, {
+                configDir: resolveConfigDir(self.skillBridgeSpawn(failover).configDir),
+                account: failover.target ?? sourceAccount
+              });
             }
             if (deliverPendingCompletions(state)) {
               if (state.drainBuffer.length > 0) drainNow(state);
@@ -16322,6 +16631,12 @@ function applyPermissionPreset(settings, defaultProxyTools) {
   }
   return resolved;
 }
+function accountGroups(settings) {
+  return resolveAccountGroups(
+    settings.accountGroups,
+    settings.failoverAccounts ?? settings.accounts
+  );
+}
 function createClaudeCode(settings = {}) {
   if (settings.logging) {
     configureLogger({
@@ -16352,6 +16667,11 @@ function createClaudeCode(settings = {}) {
       // unset option must stay unset rather than being written to one mode or
       // the other in only one of the two entry points (h #g194).
       accountFailover: settings.accountFailover,
+      // Resolved once here rather than per turn, so the WARNs an invalid entry
+      // raises are tied to provider creation and a turn reads a value that is
+      // already validated. `failoverAccounts` is what the expansion configured,
+      // which is exactly the set a group may name (h #g226).
+      accountGroups: accountGroups(settings),
       providerID: settings.providerID,
       skipPermissions: preset?.skipPermissions ?? settings.skipPermissions ?? true,
       permissionMode: preset?.permissionMode ?? settings.permissionMode,