dag

type BaseNode struct {
	NodeName         string
	NodeDependencies []string
	NodeTimeout      time.Duration
	NodeRetryable    bool
}

type Builder struct {
	// contains filtered or unexported fields
}

type Checkpoint struct {
	// State is the execution state at checkpoint time.
	State *State `json:"state"`

	// Timestamp is when the checkpoint was created (Unix milliseconds UTC).
	Timestamp int64 `json:"timestamp"`

	// Version is the checkpoint format version.
	Version string `json:"version"`

	// Checksum is the SHA256 of the state for integrity verification.
	Checksum string `json:"checksum"`

	// DAGName is the name of the DAG being executed.
	DAGName string `json:"dag_name"`
}

type CycleError struct {
	Path []string
}

type DAG struct {
	// contains filtered or unexported fields
}

type Edge struct {
	// From is the dependency node name (must complete first).
	From string `json:"from"`

	// To is the dependent node name (waits for From).
	To string `json:"to"`
}

type Executor struct {
	// contains filtered or unexported fields
}

type ExecutorConfig struct {
	// VerificationMode enables lightweight execution for MCTS scoring.
	//
	// When true, the executor:
	//   - Skips setup/initialization nodes (nodes with "setup" or "init" in name)
	//   - Disables detailed per-node tracing spans
	//   - Only runs verification nodes (lint, test, security)
	//   - Returns minimal scoring result instead of full trace
	//
	// This addresses the DAG vs MCTS performance tension where MCTS rollouts
	// need fast leaf verification (<100ms) without full pipeline overhead.
	//
	// Default: false
	VerificationMode bool

	// SkipNodes lists node names to skip in verification mode.
	// These are typically heavy setup nodes that aren't needed for scoring.
	// Default: []string{"PARSE_FILES", "LOAD_CACHE", "BUILD_GRAPH"}
	SkipNodes []string

	// VerificationNodes lists the only nodes to run in verification mode.
	// If empty, runs all nodes except those in SkipNodes.
	// Default: []string{"LINT_CHECK", "TYPE_CHECK", "SECURITY_SCAN"}
	VerificationNodes []string
}

type FuncNode struct {
	BaseNode
	// contains filtered or unexported fields
}

type Node interface {
	// Name returns the unique identifier for this node.
	//
	// Outputs:
	//   string - Unique node name (e.g., "PARSE_FILES", "BUILD_GRAPH").
	Name() string

	// Dependencies returns the names of nodes that must complete first.
	//
	// Outputs:
	//   []string - Names of dependency nodes. Empty if no dependencies.
	Dependencies() []string

	// Execute runs the node's logic.
	//
	// Inputs:
	//   ctx - Context for cancellation and timeout.
	//   inputs - Map of dependency node outputs keyed by node name.
	//
	// Outputs:
	//   any - The node's output, passed to dependent nodes.
	//   error - Non-nil on failure.
	Execute(ctx context.Context, inputs map[string]any) (any, error)

	// Retryable returns true if this node can be retried on failure.
	//
	// Outputs:
	//   bool - True if retryable.
	Retryable() bool

	// Timeout returns the maximum execution time for this node.
	//
	// Outputs:
	//   time.Duration - Maximum execution time. Zero means no timeout.
	Timeout() time.Duration
}

type NodeError struct {
	NodeName string
	Err      error
}

type NodeStatus string

type RehydratableNode interface {
	Node

	// OnResume restores ephemeral state after checkpoint load.
	//
	// Description:
	//
	//   Called after loading a checkpoint, before resuming DAG execution.
	//   Implementations should check if their ephemeral resources still exist
	//   and recreate them if necessary.
	//
	// Inputs:
	//
	//   ctx - Context for cancellation. Must not be nil.
	//   output - The node's output from the checkpoint. May be nil.
	//
	// Outputs:
	//
	//   error - Non-nil if rehydration fails and the node should be re-executed.
	//
	// Example:
	//
	//   func (n *LSPNode) OnResume(ctx context.Context, output any) error {
	//       lspOutput, ok := output.(*LSPSpawnOutput)
	//       if !ok || lspOutput.Manager == nil {
	//           return ErrRehydrationFailed // Will cause re-execution
	//       }
	//       // Check if process is still alive
	//       if !lspOutput.Manager.IsHealthy() {
	//           return n.manager.RespawnAll(ctx)
	//       }
	//       return nil
	//   }
	OnResume(ctx context.Context, output any) error
}

type Result struct {
	// Success indicates if the DAG completed successfully.
	Success bool `json:"success"`

	// SessionID is the execution session ID.
	SessionID string `json:"session_id"`

	// Duration is the total execution time.
	Duration time.Duration `json:"duration"`

	// NodesExecuted is the count of nodes that ran.
	NodesExecuted int `json:"nodes_executed"`

	// Output is the terminal node's output (if successful).
	Output any `json:"output,omitempty"`

	// Error is the error message (if failed).
	Error string `json:"error,omitempty"`

	// FailedNode is the node that caused failure.
	FailedNode string `json:"failed_node,omitempty"`

	// NodeDurations tracks execution time per node.
	NodeDurations map[string]time.Duration `json:"node_durations,omitempty"`
}

type State struct {

	// SessionID is the unique identifier for this execution.
	SessionID string `json:"session_id"`

	// StartedAt is when execution began (Unix milliseconds UTC).
	StartedAt int64 `json:"started_at"`

	// CompletedNodes tracks which nodes have finished.
	CompletedNodes map[string]bool `json:"completed_nodes"`

	// NodeOutputs stores outputs from completed nodes.
	NodeOutputs map[string]any `json:"node_outputs"`

	// NodeStatuses tracks status per node.
	NodeStatuses map[string]NodeStatus `json:"node_statuses"`

	// CurrentNodes is the set of currently executing nodes.
	CurrentNodes []string `json:"current_nodes"`

	// FailedNode is the name of the node that caused failure (if any).
	FailedNode string `json:"failed_node,omitempty"`

	// Error is the error message if failed.
	Error string `json:"error,omitempty"`
	// contains filtered or unexported fields
}