derive

type CallContext struct {
	Provider  string
	AgentName string
	ThreadID  string
	Project   string
}

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

type DerivedNode struct {
	Node       *merkle.Node
	Session    SessionKey
	CapturedAt time.Time
}

type DerivedSet struct {
	// Nodes in capture order (chain order within a turn). Deduplicated
	// by hash — the first capturing call wins, mirroring ingest's
	// ON CONFLICT DO NOTHING semantics.
	Nodes []*DerivedNode

	// Sessions are the harness keys covered by the raw layer. The
	// store prunes stale derived rows only within these sessions.
	Sessions []SessionKey

	// SessionTitles carries the folded title-gen output per session
	// (latest call wins — the harness regenerates titles as the
	// session evolves).
	SessionTitles map[SessionKey]string

	// SpanSources retains one slim record per parsed raw turn so the
	// span emit stage (EmitSpans) can re-walk the capture in call
	// order after the attach/reconcile passes have stamped fork and
	// offshoot anchors. Holds only pointers to retained nodes plus
	// scalar call identity — never payload copies.
	SpanSources []*SpanSource

	Report RederiveReport
}

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

type ModelUsage struct {
	Model        string  `json:"model"`
	Calls        int64   `json:"calls"`
	InputTokens  int64   `json:"input_tokens"`
	OutputTokens int64   `json:"output_tokens"`
	CostUSD      float64 `json:"cost_usd"`
}

type ReconcileStats struct {
	TranscriptFiles  int `json:"transcript_files"`
	SubagentForks    int `json:"subagent_forks"`
	ForkedChains     int `json:"forked_chains"`
	MainChainsJoined int `json:"main_chains_joined"`

	// ConversationJoined / ConversationTotal measure how many
	// conversation-spine nodes' content appears in a transcript — the
	// Go-native version of the prototype's join-rate oracle.
	ConversationJoined int `json:"conversation_joined"`
	ConversationTotal  int `json:"conversation_total"`
}

type RederiveReport struct {
	RawTurns      int            `json:"raw_turns"`
	ParsedTurns   int            `json:"parsed_turns"`
	RawOnlyTurns  int            `json:"raw_only_turns"`
	ParseFailures []string       `json:"parse_failures,omitempty"`
	Nodes         int            `json:"nodes"`
	CallKinds     map[string]int `json:"call_kinds"`
	NodeKinds     map[string]int `json:"node_kinds"`

	// Verdict attach: judged actions grouped across stages, and how
	// many attached one-to-one to a captured tool_use.
	JudgedActions    int `json:"judged_actions"`
	AttachedVerdicts int `json:"attached_verdicts"`

	// UnattachedActions samples judged actions that found no matching
	// tool_use (capped) — expected for non-tool events like subagent
	// handbacks; anything else is matcher signal worth reading.
	UnattachedActions []string `json:"unattached_actions,omitempty"`

	// WebSummaryAttached counts web-summary calls linked back to their
	// WebFetch/WebSearch tool_use.
	WebSummaryAttached int `json:"web_summary_attached"`

	// PlansAttached counts plan-name-gen calls linked to the
	// ExitPlanMode tool_use that accepted the plan.
	PlansAttached int `json:"plans_attached"`

	// Reconcile reports the transcript↔wire fusion when transcript
	// rows are present in the raw layer.
	Reconcile *ReconcileStats `json:"reconcile,omitempty"`
}

type SessionKey struct {
	HarnessID        string
	HarnessSessionID string
}

type SessionStatus struct {
	DerivedStatus   string
	HasGitActivity  bool
	ToolResultCount int
	ToolErrorCount  int
}

type Span struct {
	SpanID       string
	ParentSpanID string
	Kind         string
	Name         string
	Status       string
	StartedAt    time.Time
	DurationNS   int64

	// Seq is the emit ordinal within the trace — presentation order.
	// started_at cannot order spans inside one llm call (a parallel
	// tool batch shares a single instant), so readers sort by seq.
	Seq int64

	// Input: llm — fresh request content blocks; tool — the tool_use
	// input rendered as a single tool_use block.
	Input []llm.ContentBlock
	// Output: llm — response content blocks; tool — the tool_result
	// block, once it arrives.
	Output []llm.ContentBlock

	// CallKind is the §2g taxonomy verbatim ("main", "offshoot:…",
	// "injected:…") on llm and event spans.
	CallKind string
	ThreadID string
	Model    string

	StopReason string
	Usage      *llm.Usage

	// Verdict is the security-monitor disposition on a permission-check
	// span (nil elsewhere), extracted at derive time by ClassifyVerdict.
	Verdict *Verdict

	// RawTurnID is the raw row whose call produced this span (0 for
	// tool/agent spans, which are assembled across calls).
	RawTurnID int64
	// NodeHash joins the span back to the merkle layer node that
	// carries the same content ("" for agent spans).
	NodeHash string
}

type SpanLink struct {
	FromTraceID string
	FromSpanID  string
	FromIO      string
	ToTraceID   string
	ToSpanID    string
	ToIO        string
	Kind        string
}

type SpanReport struct {
	Traces       int            `json:"traces"`
	Spans        int            `json:"spans"`
	SpanKinds    map[string]int `json:"span_kinds"`
	CallKinds    map[string]int `json:"call_kinds"`
	LinkKinds    map[string]int `json:"link_kinds"`
	Synthetic    int            `json:"synthetic_traces"`
	OrphanShadow int            `json:"orphan_shadow_calls"`
}

type SpanSet struct {
	Turns []*SpanTurn

	// Links holds CROSS-trace links only (compaction seams, the odd
	// interrupted tool feed); intra-trace links live on their turn.
	Links []*SpanLink

	// ModelUsage is the per-session, per-model spend breakdown folded at
	// derive time across ALL threads (subagent models included). The
	// session detail surfaces it so the UI can show a dominant model and
	// per-model share; the share basis is cost, not call count, so a
	// fan-out of cheap subagent calls never out-votes the expensive
	// main-spine model (#28).
	ModelUsage map[SessionKey][]ModelUsage

	// Tasks is the per-session TaskCreate/TaskUpdate fold, replayed in
	// event order. KindCounts is the per-session tally of span call_kinds.
	// Both are session-rollup facts the deriver owns; the API serves them
	// on the composite traces response without re-folding.
	Tasks      map[SessionKey][]Task
	KindCounts map[SessionKey]map[string]int

	// Status is the per-session chain-aware outcome + signals, folded from
	// the spans at derive time (moved off the ingest hot path).
	Status map[SessionKey]SessionStatus

	Report SpanReport
}

type SpanSource struct {
	RawTurnID  int64
	RequestID  string
	CapturedAt time.Time
	Kind       string
	ThreadID   string
	Session    SessionKey
	// Source is the capture source of the raw turn this call came from
	// ('wire' | 'transcript') — provenance carried onto the trace.
	Source string

	// Chain holds the retained node for every chain position of this
	// call (root → leaf; last is the response). New marks positions
	// first captured by THIS call.
	Chain []*DerivedNode
	New   []bool

	// Anchor is the tool_use id this call attaches to, recorded
	// per-call by the attach passes. Node stamps (ParentToolUseID)
	// cannot carry this: checks share deduped prefix nodes, and a
	// shared node holds only the last writer's edge.
	Anchor string
}

type SpanTurn struct {
	TraceID string
	Session SessionKey

	// UserPrompt is the text of the genuine user prompt that opened
	// the turn ("" for synthetic openers).
	UserPrompt string

	// ResponsePreview is the text the closing conversation-spine llm
	// call answered with, truncated for the turn card — the response
	// counterpart of UserPrompt, folded at derive time so collapsed
	// renderings never need span payloads.
	ResponsePreview string

	// Synthetic marks traces not opened by a human prompt
	// ("post-compaction" for compaction continuations).
	Synthetic string

	// Source is the capture source of the raw turns that produced this
	// trace ('wire' | 'transcript'), promoted from raw_turns.source.
	Source string

	StartedAt time.Time
	EndedAt   time.Time

	// Token totals summed over every llm span in the trace — shadow
	// calls included, because the turn really spent them. The Main*
	// pair counts only call_kind=main spans, so shadow spend is the
	// difference and both numbers are visible to the read layer.
	TotalInputTokens    int64
	TotalOutputTokens   int64
	MainInputTokens     int64
	MainOutputTokens    int64
	CacheReadTokens     int64
	CacheCreationTokens int64

	// TotalCostUSD prices every llm span's usage at derive time, so a
	// re-derive reprices history when the table updates.
	TotalCostUSD float64

	Spans []*Span
	Links []*SpanLink
}

type Task struct {
	ID          string `json:"id"`
	Subject     string `json:"subject"`
	Description string `json:"description,omitempty"`
	Status      string `json:"status"`
	Updates     int    `json:"updates"`
}

type TranscriptFile struct {
	Session     SessionKey
	AgentID     string // "" for the main transcript
	AgentType   string
	Description string
	ToolUseID   string
	// contains filtered or unexported fields
}

type Verdict struct {
	Disposition string `json:"disposition"` // ALLOW | BLOCK
	Stage       int    `json:"stage"`
	Reasoned    bool   `json:"reasoned"`
}