@khalilgharbaoui/opencode-claude-code-plugin 0.50.0 → 0.52.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,16 @@ 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;
+    /** See `ClaudeCodeProviderSettings.subagentDispatch`. */
+    subagentDispatch?: SubagentDispatchMode;
+    /** See `ClaudeCodeProviderSettings.subagentDispatchCrossGroup`. */
+    subagentDispatchCrossGroup?: boolean;
     providerID?: string;
     skipPermissions?: boolean;
     /**
@@ -483,6 +496,8 @@ type WebSearchRouting = "claude" | "disabled" | (string & {});
  * behaviour, where the turn ends with the rate-limit error.
  */
 type AccountFailoverMode = "ask" | "off";
+/** `subagentDispatch`. Unset behaves as `"off"`; see the option's own note. */
+type SubagentDispatchMode = "ask" | "off";
 interface ClaudeCodeProviderSettings {
     cliPath?: string;
     /** Internal: set by the opencode 2 entrypoint. See `ClaudeCodeConfig.hostApi`. */
@@ -531,6 +546,64 @@ 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>;
+    /**
+     * Ask, before a proxied `task` or `task_batch` dispatch reaches opencode,
+     * how the subagents it is about to start should run: which model, which
+     * reasoning effort, and which Claude account.
+     *
+     * `"off"` by default, and unset behaves as `"off"`: with it unset the
+     * dispatch is handed to opencode exactly as it is today, no form is raised
+     * and nothing is recorded.
+     *
+     * With `"ask"`, the dispatch is held, the operator gets one question (so the
+     * common answer is one click: `Default`, or `Same as last time`), and only
+     * then are the real `task` calls released, inside the same opencode turn.
+     * `Customise…` opens a second form with one row per agent type, and a row
+     * can ask for a third form with one row per task. Dismissing any of them
+     * dispatches with the defaults and says so; the dispatch is never lost.
+     *
+     * See `docs/configuration/subagents.md` and `src/subagent-dispatch.ts`.
+     */
+    subagentDispatch?: SubagentDispatchMode;
+    /**
+     * Let the dispatch form offer Claude accounts outside the dispatching
+     * account's own `accountGroups` group. **False by default, and never
+     * implied**: a subagent is handed the task text the main agent writes, which
+     * can quote the conversation, and it reads the repository, so offering
+     * another group is offering that group the conversation by another route.
+     * Does nothing when `accountGroups` is unset, where every account is already
+     * one group.
+     */
+    subagentDispatchCrossGroup?: boolean;
     /**
      * Model that subagents run on when their own definition pins nothing.
      * Unset means no implicit override at all, so an agent keeps inheriting the
@@ -1309,6 +1382,17 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
     private skillBridgeSpawn;
     /** Share one lazy registry request within a turn without making it stale. */
     private createLiveToolInfoLoader;
+    /**
+     * What a subagent dispatch form chose for THIS session, or undefined.
+     *
+     * Two lookups, cheapest first. A session that already claimed a choice keeps
+     * it for the rest of its life, because the model and effort are in its
+     * session key and a choice that came and went mid-conversation would strand
+     * the key behind it. Otherwise, and only when a released dispatch actually
+     * recorded a claim this session could match, the parent is fetched and the
+     * claim taken: a choice must never land on the wrong child (h #g227).
+     */
+    private resolveDispatchChoice;
     /**
      * Whether the ExitPlanMode approval bridge is live for this turn: the
      * operator opted in AND opencode's registry actually has the `question`
@@ -1316,6 +1400,26 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
      * `⚙ invalid` and wedge the turn, so the plugin keeps the text path.
      */
     private resolvePlanModeQuestion;
+    /**
+     * A dispatch form, as a turn: one synthetic `question` tool call and a
+     * `tool-calls` finish, which is how the operator's answer comes back on the
+     * next `doStream` as a `tool-result` with the same id. The same mechanism
+     * `finishWithQuestionCall` gives the plan-approval bridge and the
+     * account-switch form, minus a Claude process, because there is nothing for
+     * the CLI to do while the operator reads a form.
+     */
+    private subagentDispatchFormStream;
+    /**
+     * The release: the dispatch the form was holding, handed to opencode as the
+     * `task` tool calls it would have been without the form, with every task's
+     * answer recorded as a claim its child will take.
+     *
+     * A held call that is gone (its deadline, an abort, the child dying while
+     * the form was up) is skipped rather than invented, and with every call gone
+     * the turn finishes on `stop`: there is nothing left to dispatch and ending
+     * on `tool-calls` with no tool calls is a protocol violation.
+     */
+    private subagentDispatchReleaseStream;
     /**
      * Create a proxy MCP server for a single active Claude process/session.
      * The process lifecycle owns the server lifecycle via session-manager.