@hiai-gg/hiai-opencode 0.1.0

package/src/tools/delegate-task/subagent-resolver.ts

@@ -0,0 +1,225 @@
+import type { DelegateTaskArgs } from "./types"
+import type { ExecutorContext } from "./executor-types"
+import type { DelegatedModelConfig } from "./types"
+import { isPlanFamily } from "./constants"
+import {
+  SUB_AGENT_CONFIG_KEY,
+  resolveCanonicalDelegateAgentKey,
+} from "./sub-agent"
+import { applyCategoryParams } from "./delegated-model-config"
+import { resolveEffectiveFallbackEntry } from "./fallback-entry-resolution"
+import { applyFallbackEntrySettings } from "./fallback-entry-settings"
+import {
+  type AgentInfo,
+  sanitizeSubagentType,
+  mergeWithClaudeCodeAgents,
+  findPrimaryAgentMatch,
+  findCallableAgentMatch,
+  listCallableAgentNames,
+} from "./subagent-discovery"
+import { normalizeModelFormat } from "../../shared/model-format-normalizer"
+import { AGENT_MODEL_REQUIREMENTS } from "../../shared/model-requirements"
+import { normalizeFallbackModels, flattenToFallbackModelStrings } from "../../shared/model-resolver"
+import { buildFallbackChainFromModels } from "../../shared/fallback-chain-from-models"
+import { getAgentConfigKey, stripAgentListSortPrefix } from "../../shared/agent-display-names"
+import { normalizeSDKResponse } from "../../shared"
+import { log } from "../../shared/logger"
+import { getAvailableModelsForDelegateTask } from "./available-models"
+import type { FallbackEntry } from "../../shared/model-requirements"
+import { resolveModelForDelegateTask } from "./model-selection"
+import { fuzzyMatchModel } from "../../shared/model-availability"
+
+export async function resolveSubagentExecution(
+  args: DelegateTaskArgs,
+  executorCtx: ExecutorContext,
+  parentAgent: string | undefined,
+  categoryExamples: string
+): Promise<{ agentToUse: string; categoryModel: DelegatedModelConfig | undefined; fallbackChain?: FallbackEntry[]; error?: string }> {
+  const { client, agentOverrides, userCategories } = executorCtx
+
+  if (!args.subagent_type?.trim()) {
+    return { agentToUse: "", categoryModel: undefined, error: `Agent name cannot be empty.` }
+  }
+
+  const requestedAgentName = sanitizeSubagentType(args.subagent_type)
+  const requestedCanonicalAgentKey = resolveCanonicalDelegateAgentKey(requestedAgentName)
+
+  if (requestedCanonicalAgentKey === SUB_AGENT_CONFIG_KEY) {
+    return {
+      agentToUse: "",
+      categoryModel: undefined,
+      error: `Cannot use subagent_type="${args.subagent_type}" directly. Use category parameter instead (e.g., ${categoryExamples}).
+
+SubAgent is spawned automatically when you specify a category. Pick the appropriate category for your task domain.`,
+    }
+  }
+
+  if (requestedCanonicalAgentKey === "agent-skills") {
+    return {
+      agentToUse: "",
+      categoryModel: undefined,
+      error: `Cannot use subagent_type="${args.subagent_type}" directly. Agent Skills is a hidden system agent for skill registry and discovery, not a normal task executor.`,
+    }
+  }
+
+  const canonicalParentAgent = parentAgent ? resolveCanonicalDelegateAgentKey(parentAgent) : undefined
+  if (isPlanFamily(requestedCanonicalAgentKey) && isPlanFamily(canonicalParentAgent)) {
+    return {
+      agentToUse: "",
+      categoryModel: undefined,
+    error: `You are a plan-family agent (plan/strategist). You cannot delegate to other plan-family agents via task.
+
+Create the work plan directly - that's your job as the planning agent.`,
+    }
+  }
+
+  let agentToUse = requestedAgentName
+  let categoryModel: DelegatedModelConfig | undefined
+  let fallbackChain: FallbackEntry[] | undefined = undefined
+
+  try {
+    const agentsResult = await client.app.agents()
+    const agents = normalizeSDKResponse(agentsResult, [] as AgentInfo[], {
+      preferResponseOnMissingData: true,
+    })
+
+    const mergedAgents = mergeWithClaudeCodeAgents(agents, executorCtx.directory)
+    const matchedPrimaryAgent = findPrimaryAgentMatch(mergedAgents, agentToUse)
+
+    if (matchedPrimaryAgent) {
+      return {
+        agentToUse: "",
+        categoryModel: undefined,
+        error: `Cannot delegate to primary agent "${stripAgentListSortPrefix(matchedPrimaryAgent.name)}" via task. Select that agent directly instead.`,
+      }
+    }
+
+    const matchedAgent = findCallableAgentMatch(mergedAgents, agentToUse)
+    if (!matchedAgent) {
+      return {
+        agentToUse: "",
+        categoryModel: undefined,
+        error: `Unknown agent: "${requestedAgentName}". Available agents: ${listCallableAgentNames(mergedAgents)}`,
+      }
+    }
+
+    agentToUse = stripAgentListSortPrefix(matchedAgent.name)
+
+    const matchedAgentConfigKey = getAgentConfigKey(agentToUse).toLowerCase()
+    const canonicalAgentConfigKey = resolveCanonicalDelegateAgentKey(agentToUse).toLowerCase()
+    const agentConfigLookupKeys = Array.from(new Set([
+      canonicalAgentConfigKey,
+      matchedAgentConfigKey,
+    ]))
+
+    const agentOverride = agentOverrides
+      ? Object.entries(agentOverrides).find(([key]) => agentConfigLookupKeys.includes(key.toLowerCase()))?.[1]
+      : undefined
+    const agentRequirement = agentConfigLookupKeys
+      .map((key) => AGENT_MODEL_REQUIREMENTS[key])
+      .find((requirement): requirement is NonNullable<typeof requirement> => requirement !== undefined)
+    const agentCategoryConfig = agentOverride?.category
+      ? userCategories?.[agentOverride.category]
+      : undefined
+    const agentCategoryModel = agentCategoryConfig?.model
+    const normalizedAgentFallbackModels = normalizeFallbackModels(
+      agentOverride?.fallback_models
+      ?? agentCategoryConfig?.fallback_models
+    )
+
+    const availableModels = await getAvailableModelsForDelegateTask(client)
+
+    if (agentOverride?.model || agentCategoryModel || agentRequirement || matchedAgent.model) {
+
+      const normalizedMatchedModel = matchedAgent.model
+        ? normalizeModelFormat(matchedAgent.model)
+        : undefined
+      const matchedAgentModelStr = normalizedMatchedModel
+        ? `${normalizedMatchedModel.providerID}/${normalizedMatchedModel.modelID}`
+        : undefined
+
+      const resolution = resolveModelForDelegateTask({
+        userModel: agentOverride?.model ?? agentCategoryModel,
+        userFallbackModels: flattenToFallbackModelStrings(normalizedAgentFallbackModels),
+        categoryDefaultModel: matchedAgentModelStr,
+        fallbackChain: agentRequirement?.fallbackChain,
+        availableModels,
+        systemDefaultModel: undefined,
+      })
+
+      const resolutionSkipped = resolution && 'skipped' in resolution
+
+      if (resolution && !resolutionSkipped) {
+        const normalized = normalizeModelFormat(resolution.model)
+        if (normalized) {
+          const variantToUse = agentOverride?.variant ?? resolution.variant ?? agentCategoryConfig?.variant
+          const resolvedModel = variantToUse ? { ...normalized, variant: variantToUse } : normalized
+          categoryModel = applyCategoryParams(resolvedModel, agentCategoryConfig)
+        }
+      } else if (resolutionSkipped && (agentOverride?.model ?? agentCategoryModel)) {
+        const normalized = normalizeModelFormat((agentOverride?.model ?? agentCategoryModel)!)
+        if (normalized) {
+          const variantToUse = agentOverride?.variant ?? agentCategoryConfig?.variant
+          const resolvedModel = variantToUse ? { ...normalized, variant: variantToUse } : normalized
+          categoryModel = applyCategoryParams(resolvedModel, agentCategoryConfig)
+          log("[delegate-task] Cold cache: using explicit user override for subagent", {
+            agent: agentToUse,
+            model: agentOverride?.model ?? agentCategoryModel,
+          })
+        }
+      }
+
+      const defaultProviderID = categoryModel?.providerID
+        ?? normalizedMatchedModel?.providerID
+        ?? "opencode"
+      const configuredFallbackChain = buildFallbackChainFromModels(
+        normalizedAgentFallbackModels,
+        defaultProviderID,
+      )
+      fallbackChain = configuredFallbackChain ?? (resolutionSkipped ? undefined : agentRequirement?.fallbackChain)
+      const effectiveEntry = resolveEffectiveFallbackEntry({
+        categoryModel,
+        configuredFallbackChain,
+        resolution,
+      })
+
+      if (categoryModel && effectiveEntry) {
+        categoryModel = applyFallbackEntrySettings({
+          categoryModel,
+          effectiveEntry,
+          variantOverride: agentOverride?.variant,
+        })
+      }
+    }
+
+    if (!categoryModel && matchedAgent.model) {
+      const normalizedMatchedModel = normalizeModelFormat(matchedAgent.model)
+      if (normalizedMatchedModel) {
+        const fullModel = `${normalizedMatchedModel.providerID}/${normalizedMatchedModel.modelID}`
+        if (availableModels.size === 0 || fuzzyMatchModel(fullModel, availableModels, [normalizedMatchedModel.providerID])) {
+          categoryModel = normalizedMatchedModel
+        } else {
+          log("[delegate-task] Skipping unavailable agent default model", {
+            agent: agentToUse,
+            model: fullModel,
+          })
+        }
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    log("[delegate-task] Failed to resolve subagent execution", {
+      requestedAgent: agentToUse,
+      parentAgent,
+      error: errorMessage,
+    })
+
+    return {
+      agentToUse: "",
+      categoryModel: undefined,
+      error: `Failed to delegate to agent "${agentToUse}": ${errorMessage}`,
+    }
+  }
+
+  return { agentToUse, categoryModel, fallbackChain }
+}

package/src/tools/delegate-task/sync-continuation-deps.ts

@@ -0,0 +1,9 @@
+import { pollSyncSession } from "./sync-session-poller"
+import { fetchSyncResult } from "./sync-result-fetcher"
+
+export const syncContinuationDeps = {
+  pollSyncSession,
+  fetchSyncResult,
+}
+
+export type SyncContinuationDeps = typeof syncContinuationDeps

package/src/tools/delegate-task/sync-continuation.ts

@@ -0,0 +1,149 @@
+import type { DelegateTaskArgs, ToolContextWithMetadata } from "./types"
+import type { ExecutorContext, SessionMessage } from "./executor-types"
+import { isPlanFamily } from "./constants"
+import { storeToolMetadata } from "../../features/tool-metadata-store"
+import { resolveCallID } from "./resolve-call-id"
+import { getTaskToastManager } from "../../features/task-toast-manager"
+import { getAgentToolRestrictions } from "../../shared/agent-tool-restrictions"
+import { getMessageDir } from "../../shared"
+import { promptWithModelSuggestionRetry } from "../../shared/model-suggestion-retry"
+import { findNearestMessageWithFields } from "../../features/hook-message-injector"
+import { formatDuration } from "./time-formatter"
+import { syncContinuationDeps, type SyncContinuationDeps } from "./sync-continuation-deps"
+import { setSessionTools } from "../../shared/session-tools-store"
+import { normalizeSDKResponse } from "../../shared"
+import { buildTaskPrompt } from "./prompt-builder"
+
+export async function executeSyncContinuation(
+  args: DelegateTaskArgs,
+  ctx: ToolContextWithMetadata,
+  executorCtx: ExecutorContext,
+  deps: SyncContinuationDeps = syncContinuationDeps
+): Promise<string> {
+  const { client, syncPollTimeoutMs, bobAgentConfig } = executorCtx
+  const toastManager = getTaskToastManager()
+  const taskId = `resume_sync_${args.session_id!.slice(0, 8)}`
+  const startTime = new Date()
+
+  if (toastManager) {
+    toastManager.addTask({
+      id: taskId,
+      description: args.description,
+      agent: "continue",
+      isBackground: false,
+    })
+  }
+
+  let syncContMeta: { title: string; metadata: Record<string, unknown> } | undefined
+
+  let resumeAgent: string | undefined
+  let resumeModel: { providerID: string; modelID: string } | undefined
+  let resumeVariant: string | undefined
+  let anchorMessageCount: number | undefined
+
+  try {
+    try {
+      const messagesResp = await client.session.messages({ path: { id: args.session_id! } })
+      const messages = normalizeSDKResponse(messagesResp, [] as SessionMessage[])
+      anchorMessageCount = messages.length
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const info = messages[i].info
+        if (info?.agent || info?.model || (info?.modelID && info?.providerID)) {
+          resumeAgent = info.agent
+          resumeModel = info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined)
+          resumeVariant = info.variant
+          break
+        }
+      }
+    } catch {
+      const resumeMessageDir = getMessageDir(args.session_id!)
+      const resumeMessage = resumeMessageDir ? findNearestMessageWithFields(resumeMessageDir) : null
+      resumeAgent = resumeMessage?.agent
+      resumeModel = resumeMessage?.model?.providerID && resumeMessage?.model?.modelID
+        ? { providerID: resumeMessage.model.providerID, modelID: resumeMessage.model.modelID }
+        : undefined
+      resumeVariant = resumeMessage?.model?.variant
+    }
+
+    syncContMeta = {
+      title: `Continue: ${args.description}`,
+      metadata: {
+        prompt: args.prompt,
+        load_skills: args.load_skills,
+        description: args.description,
+        run_in_background: args.run_in_background,
+        sessionId: args.session_id,
+        sync: true,
+        command: args.command,
+        model: resumeModel,
+      },
+    }
+    await ctx.metadata?.(syncContMeta)
+    const callID = resolveCallID(ctx)
+    if (callID) {
+      storeToolMetadata(ctx.sessionID, callID, syncContMeta)
+    }
+
+    const allowTask = isPlanFamily(resumeAgent)
+    const tddEnabled = bobAgentConfig?.tdd
+    const effectivePrompt = buildTaskPrompt(args.prompt, resumeAgent, tddEnabled)
+    const tools = {
+      task: allowTask,
+      call_omo_agent: true,
+      question: false,
+      ...(resumeAgent ? getAgentToolRestrictions(resumeAgent) : {}),
+    }
+    setSessionTools(args.session_id!, tools)
+
+    await promptWithModelSuggestionRetry(client, {
+      path: { id: args.session_id! },
+      body: {
+        ...(resumeAgent !== undefined ? { agent: resumeAgent } : {}),
+        ...(resumeModel !== undefined ? { model: resumeModel } : {}),
+        ...(resumeVariant !== undefined ? { variant: resumeVariant } : {}),
+        tools,
+        parts: [{ type: "text", text: effectivePrompt }],
+      },
+    })
+   } catch (promptError) {
+     if (toastManager) {
+       toastManager.removeTask(taskId)
+     }
+     const errorMessage = promptError instanceof Error ? promptError.message : String(promptError)
+     return `Failed to send continuation prompt: ${errorMessage}\n\nSession ID: ${args.session_id}`
+   }
+
+    try {
+      const pollError = await deps.pollSyncSession(ctx, client, {
+        sessionID: args.session_id!,
+        agentToUse: resumeAgent ?? "continue",
+        toastManager,
+        taskId,
+        anchorMessageCount,
+      }, syncPollTimeoutMs)
+      if (pollError) {
+        return pollError
+      }
+
+      const result = await deps.fetchSyncResult(client, args.session_id!, anchorMessageCount)
+      if (!result.ok) {
+        return result.error
+      }
+
+     const duration = formatDuration(startTime)
+
+     return `Task continued and completed in ${duration}.
+
+---
+
+${result.textContent || "(No text output)"}
+
+<task_metadata>
+session_id: ${args.session_id}
+${resumeAgent ? `subagent: ${resumeAgent}\n` : ""}</task_metadata>`
+   } finally {
+     if (toastManager) {
+       toastManager.removeTask(taskId)
+     }
+   }
+}

package/src/tools/delegate-task/sync-prompt-sender.ts

@@ -0,0 +1,137 @@
+import type { DelegateTaskArgs, OpencodeClient, DelegatedModelConfig } from "./types"
+import type { BobAgentConfig } from "../../config/schema"
+import { isPlanFamily } from "./constants"
+import { buildTaskPrompt } from "./prompt-builder"
+import {
+  promptSyncWithModelSuggestionRetry,
+  promptWithModelSuggestionRetry,
+} from "../../shared/model-suggestion-retry"
+import { formatDetailedError } from "./error-formatting"
+import { getAgentToolRestrictions } from "../../shared/agent-tool-restrictions"
+import { stripInvisibleAgentCharacters } from "../../shared/agent-display-names"
+import { applySessionPromptParams } from "../../shared/session-prompt-params-helpers"
+import { setSessionTools } from "../../shared/session-tools-store"
+import { createInternalAgentTextPart } from "../../shared/internal-initiator-marker"
+
+type SendSyncPromptDeps = {
+  promptWithModelSuggestionRetry: typeof promptWithModelSuggestionRetry
+  promptSyncWithModelSuggestionRetry: typeof promptSyncWithModelSuggestionRetry
+}
+
+const sendSyncPromptDeps: SendSyncPromptDeps = {
+  promptWithModelSuggestionRetry,
+  promptSyncWithModelSuggestionRetry,
+}
+
+function buildPromptGenerationParams(model: DelegatedModelConfig | undefined): Record<string, unknown> {
+  if (!model) {
+    return {}
+  }
+
+  const promptOptions: Record<string, unknown> = {
+    ...(model.reasoningEffort ? { reasoningEffort: model.reasoningEffort } : {}),
+    ...(model.thinking ? { thinking: model.thinking } : {}),
+  }
+
+  return {
+    ...(model.temperature !== undefined ? { temperature: model.temperature } : {}),
+    ...(model.top_p !== undefined ? { topP: model.top_p } : {}),
+    ...(model.maxTokens !== undefined ? { maxOutputTokens: model.maxTokens } : {}),
+    ...(Object.keys(promptOptions).length > 0 ? { options: promptOptions } : {}),
+  }
+}
+
+function isStrategistAgent(agentToUse: string): boolean {
+  const normalizedAgent = stripInvisibleAgentCharacters(agentToUse).toLowerCase()
+  return normalizedAgent === "strategist"
+}
+
+function isUnexpectedEofError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error)
+  const lowered = message.toLowerCase()
+  return lowered.includes("unexpected eof") || lowered.includes("json parse error")
+}
+
+export async function sendSyncPrompt(
+  client: OpencodeClient,
+  input: {
+    sessionID: string
+    agentToUse: string
+    args: DelegateTaskArgs
+    systemContent: string | undefined
+    categoryModel: DelegatedModelConfig | undefined
+    toastManager: { removeTask: (id: string) => void } | null | undefined
+    taskId: string | undefined
+    bobAgentConfig?: BobAgentConfig
+  },
+  deps: SendSyncPromptDeps = sendSyncPromptDeps
+): Promise<string | null> {
+  const allowTask = isPlanFamily(input.agentToUse)
+  const tddEnabled = input.bobAgentConfig?.tdd
+  const effectivePrompt = buildTaskPrompt(input.args.prompt, input.agentToUse, tddEnabled)
+  const tools = {
+    task: allowTask,
+    call_omo_agent: true,
+    question: false,
+    ...getAgentToolRestrictions(input.agentToUse),
+  }
+  setSessionTools(input.sessionID, tools)
+
+  applySessionPromptParams(input.sessionID, input.categoryModel)
+
+  const promptArgs = {
+    path: { id: input.sessionID },
+    body: {
+      agent: stripInvisibleAgentCharacters(input.agentToUse),
+      system: input.systemContent,
+      tools,
+      parts: [createInternalAgentTextPart(effectivePrompt)],
+      ...(input.categoryModel
+        ? {
+            model: {
+              providerID: input.categoryModel.providerID,
+              modelID: input.categoryModel.modelID,
+            },
+          }
+        : {}),
+      ...(input.categoryModel?.variant ? { variant: input.categoryModel.variant } : {}),
+      ...buildPromptGenerationParams(input.categoryModel),
+    },
+  }
+
+  try {
+    await deps.promptWithModelSuggestionRetry(client, promptArgs)
+  } catch (promptError) {
+    if (isStrategistAgent(input.agentToUse) && isUnexpectedEofError(promptError)) {
+      try {
+        await deps.promptSyncWithModelSuggestionRetry(client, promptArgs)
+        return null
+      } catch (strategistRetryError) {
+        promptError = strategistRetryError
+      }
+    }
+
+    if (input.toastManager && input.taskId !== undefined) {
+      input.toastManager.removeTask(input.taskId)
+    }
+    const errorMessage = promptError instanceof Error ? promptError.message : String(promptError)
+    if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
+      return formatDetailedError(new Error(`Agent "${input.agentToUse}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.`), {
+        operation: "Send prompt to agent",
+        args: input.args,
+        sessionID: input.sessionID,
+        agent: input.agentToUse,
+        category: input.args.category,
+      })
+    }
+    return formatDetailedError(promptError, {
+      operation: "Send prompt",
+      args: input.args,
+      sessionID: input.sessionID,
+      agent: input.agentToUse,
+      category: input.args.category,
+    })
+  }
+
+  return null
+}

package/src/tools/delegate-task/sync-result-fetcher.ts

@@ -0,0 +1,60 @@
+import type { OpencodeClient } from "./types"
+import type { SessionMessage } from "./executor-types"
+import { normalizeSDKResponse } from "../../shared"
+
+export async function fetchSyncResult(
+  client: OpencodeClient,
+  sessionID: string,
+  anchorMessageCount?: number
+): Promise<{ ok: true; textContent: string } | { ok: false; error: string }> {
+  const messagesResult = await client.session.messages({
+    path: { id: sessionID },
+  })
+
+  if ((messagesResult as { error?: unknown }).error) {
+    return { ok: false, error: `Error fetching result: ${(messagesResult as { error: unknown }).error}\n\nSession ID: ${sessionID}` }
+  }
+
+  const messages = normalizeSDKResponse(messagesResult, [] as SessionMessage[], {
+    preferResponseOnMissingData: true,
+  })
+
+  const messagesAfterAnchor = anchorMessageCount !== undefined ? messages.slice(anchorMessageCount) : messages
+
+  if (anchorMessageCount !== undefined && messagesAfterAnchor.length === 0) {
+    return {
+      ok: false,
+      error: `Session completed but no new response was generated. The model may have failed silently.\n\nSession ID: ${sessionID}`,
+    }
+  }
+
+  const assistantMessages = messagesAfterAnchor
+    .filter((m) => m.info?.role === "assistant")
+    .sort((a, b) => (b.info?.time?.created ?? 0) - (a.info?.time?.created ?? 0))
+  const lastMessage = assistantMessages[0]
+
+  if (anchorMessageCount !== undefined && !lastMessage) {
+    return {
+      ok: false,
+      error: `Session completed but no new response was generated. The model may have failed silently.\n\nSession ID: ${sessionID}`,
+    }
+  }
+
+  if (!lastMessage) {
+    return { ok: false, error: `No assistant response found.\n\nSession ID: ${sessionID}` }
+  }
+
+  // Search assistant messages (newest first) for one with text/reasoning content.
+  // The last assistant message may only contain tool calls with no text.
+  let textContent = ""
+  for (const msg of assistantMessages) {
+    const textParts = msg.parts?.filter((p) => p.type === "text" || p.type === "reasoning") ?? []
+    const content = textParts.map((p) => p.text ?? "").filter(Boolean).join("\n")
+    if (content) {
+      textContent = content
+      break
+    }
+  }
+
+  return { ok: true, textContent }
+}

package/src/tools/delegate-task/sync-session-creator.ts

@@ -0,0 +1,29 @@
+import type { OpencodeClient } from "./types"
+import { QUESTION_DENIED_SESSION_PERMISSION } from "../../shared/question-denied-session-permission"
+
+export async function createSyncSession(
+  client: OpencodeClient,
+  input: { parentSessionID: string; agentToUse: string; description: string; defaultDirectory: string }
+): Promise<{ ok: true; sessionID: string; parentDirectory: string } | { ok: false; error: string }> {
+  const parentSession = client.session.get
+    ? await client.session.get({ path: { id: input.parentSessionID } }).catch(() => null)
+    : null
+  const parentDirectory = parentSession?.data?.directory ?? input.defaultDirectory
+
+  const createResult = await client.session.create({
+    body: {
+      parentID: input.parentSessionID,
+      title: `${input.description} (@${input.agentToUse} subagent)`,
+      permission: QUESTION_DENIED_SESSION_PERMISSION,
+    } as Record<string, unknown>,
+    query: {
+      directory: parentDirectory,
+    },
+  })
+
+  if (createResult.error) {
+    return { ok: false, error: `Failed to create session: ${createResult.error}` }
+  }
+
+  return { ok: true, sessionID: createResult.data.id, parentDirectory }
+}