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

package/dist/index.d.ts

@@ -399,6 +399,10 @@ interface ClaudeCodeConfig {
      * 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;
     /**
@@ -492,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`. */
@@ -569,6 +575,35 @@ interface ClaudeCodeProviderSettings {
      * `/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
@@ -1347,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`
@@ -1354,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.