Method bootTasks

internal/daemon/task_runtime.go:335–407

(ctx context.Context, state *bootState)

}

func (d *Daemon) bootTasks(ctx context.Context, state *bootState) error {
	if state == nil || state.registry == nil || state.sessions == nil {
		return nil
	}

	store, ok := state.registry.(taskStore)
	if !ok {
		state.logger.Warn("daemon: task runtime skipped because registry does not implement task store")
		return nil
	}

	bridge, err := newTaskSessionBridge(
		state.sessions,
		d.homePaths.HomeDir,
		state.logger,
		withTaskSessionContextOverlay(state.situationContext),
	)
	if err != nil {
		return err
	}
	reentry, err := bootHarnessReentryBridge(ctx, state)
	if err != nil {
		return fmt.Errorf("daemon: create harness reentry bridge: %w", err)
	}
	wakeBridge, err := newTaskWakeBridge(ctx, state.sessions, state.logger)
	if err != nil {
		return fmt.Errorf("daemon: create task wake bridge: %w", err)
	}
	reviewRequests := newRunReviewRequestedForwarder()
	eventObserver, bridgeNotifications, networkTaskStatus := d.composeTaskEventObserver(state, store, reentry)
	manager, err := taskpkg.NewManager(
		taskManagerOptions(
			store,
			bridge,
			wakeBridge,
			eventObserver,
			state.notifier,
			reviewRequests,
			state.cfg.Task.Recovery,
			state.cfg.Autonomy.Scheduler,
			state.cfg.Autonomy.BlockRecurrenceLimit,
		)...,
	)
	if err != nil {
		return fmt.Errorf("daemon: create task manager: %w", err)
	}
	detached, err := newHarnessDetachedWorkBridge(manager, store, state.sessions)
	if err != nil {
		return fmt.Errorf("daemon: create detached harness bridge: %w", err)
	}

	state.tasks = &taskRuntime{
		manager:             manager,
		store:               store,
		detached:            detached,
		reentry:             reentry,
		wakeBridge:          wakeBridge,
		bridgeNotifications: bridgeNotifications,