Method spawnChildSessionOnce

packages/runtime/src/session-manager.ts:3042–3280

(
    parentSessionId: string,
    input: ResolvedSpawnChildSessionInput,
    requestFingerprint: string,
    runtimeOwner: { execution: RuntimeExecutionClaim },
  )

  }

  private async spawnChildSessionOnce(
    parentSessionId: string,
    input: ResolvedSpawnChildSessionInput,
    requestFingerprint: string,
    runtimeOwner: { execution: RuntimeExecutionClaim },
  ): Promise<SpawnChildSessionResult> {
    if (input.abortSignal?.aborted) {
      throw new Error('Child session spawn was cancelled before creation');
    }
    if (!this.deps.runStore || !this.deps.runtimeEventStore) {
      throw new Error('Child session creation requires AgentRunStore and RuntimeEventStore');
    }
    const [parentHeader, parentRun, parentBoundary] = await Promise.all([
      this.deps.store.readHeader(parentSessionId),
      this.deps.runStore.readRun(parentSessionId, input.spawnedBy.parentRunId),
      this.deps.store.readExecutionBoundary(parentSessionId),
    ]);
    this.assertActiveParentRun(parentSessionId, parentRun, input.spawnedBy.parentTurnId);

    const definition = requireBuiltinAgentDefinitionByProfile(input.agentProfile);
    const availableChildTools = await this.childToolsForSession(parentSessionId);
    assertAgentDefinitionRunnable({
      definition,
      tools: availableChildTools,
      worktreeChildExecutorAvailable: await this.isWorktreeChildExecutorAvailable(parentHeader),
    });
    const resolvedToolNames = buildToolsForAgentDefinition(availableChildTools, definition).map(
      (tool) => tool.name,
    );

    const proposedTurnId = input.turnId ?? this.deps.newId();
    const proposedRunId = input.runId ?? this.deps.newId();
    const workspace = await this.provisionChildWorkspace(
      parentHeader,
      definition,
      requestFingerprint,
    );
    const creation = await this.deps.store.createSubagent(
      {
        cwd: workspace?.worktreePath ?? parentHeader.cwd,
        ...(parentHeader.projectId !== undefined ? { projectId: parentHeader.projectId } : {}),
        name: input.name ?? input.resolvedPreset?.name ?? definition.name,
        backend: parentHeader.backend,
        llmConnectionSlug: input.resolvedPreset?.connectionSlug ?? parentHeader.llmConnectionSlug,
        model: input.resolvedPreset?.model ?? parentHeader.model,
        ...(input.resolvedPreset
          ? input.resolvedPreset.thinkingLevel !== undefined
            ? { thinkingLevel: input.resolvedPreset.thinkingLevel }
            : {}
          : parentHeader.thinkingLevel !== undefined
            ? { thinkingLevel: parentHeader.thinkingLevel }
            : {}),
        permissionMode: definition.permissionMode,
        collaborationMode: 'agent',
        orchestrationMode: 'default',
        subagentParent: {
          kind: 'subagent',
          parentSessionId,