Method startReservedAgentTask

src/node/services/taskService.ts:2711–2911

(plan: TaskLaunchPlan)

  }

  private async startReservedAgentTask(plan: TaskLaunchPlan): Promise<void> {
    assert(plan.taskId.length > 0, "startReservedAgentTask requires taskId");
    assert(plan.parentWorkspaceId.length > 0, "startReservedAgentTask requires parentWorkspaceId");
    if (plan.start.kind === "sendMessage") {
      assert(plan.start.prompt.length > 0, "startReservedAgentTask requires prompt");
    }

    const entryAtStart = findWorkspaceEntry(this.config.loadConfigOrDefault(), plan.taskId);
    if (entryAtStart?.workspace.taskStatus !== "starting") {
      return;
    }

    // isolation: "none" tasks were queued pointing at the parent's checkout. When that checkout
    // still exists, materialization reuses it (no fork); if it disappeared, materialization falls
    // back to forking a real workspace and the shared flag must be cleared below.
    const taskWasShared = entryAtStart.workspace.taskIsolation === "none";
    const persistedSharedPath = taskWasShared
      ? coerceNonEmptyString(entryAtStart.workspace.path)
      : undefined;

    const initLogger = this.startWorkspaceInit(plan.taskId, plan.parentMeta.projectPath);
    // Supply the parent's persisted path so override-aware runtimes (worktree/SSH) fork from the
    // parent's REAL checkout when the parent is itself an isolation: "none" task (see create()).
    const parentEntryForLaunch = findWorkspaceEntry(
      this.config.loadConfigOrDefault(),
      plan.parentWorkspaceId
    );
    const runtime = createRuntimeForWorkspace({
      runtimeConfig: plan.taskRuntimeConfig,
      projectPath: plan.parentMeta.projectPath,
      name: plan.parentMeta.name,
      namedWorkspacePath: coerceNonEmptyString(parentEntryForLaunch?.workspace.path),
    });

    let materialized: MaterializedTaskLaunch | null;
    try {
      materialized = await this.materializeReservedTaskWorkspace(plan, runtime, initLogger);
    } catch (error: unknown) {
      initLogger.logComplete(-1);
      throw error;
    }
    if (!materialized) {
      initLogger.logComplete(-1);
      return;
    }

    // Reuse of the persisted shared path means the task still runs in the parent's checkout;
    // any other materialized path means the fork fallback created a real (deletable) workspace.
    const sharesParentCheckout =
      taskWasShared && materialized.workspacePath === persistedSharedPath;

    const entryAfterMaterialize = findWorkspaceEntry(
      this.config.loadConfigOrDefault(),
      plan.taskId
    );
    if (!entryAfterMaterialize) {
      initLogger.logComplete(-1);
      await this.cleanupMaterializedTaskWorkspace(