derive

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

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"`

	// Upserted/Pruned are filled by the store after the write pass.
	Upserted int `json:"upserted"`
	Pruned   int `json:"pruned"`

	// 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 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

	// 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

	Report SpanReport
}

type SpanSource struct {
	RawTurnID  int64
	RequestID  string
	CapturedAt time.Time
	Kind       string
	ThreadID   string
	Session    SessionKey

	// 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

	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 TranscriptFile struct {
	Session     SessionKey
	AgentID     string // "" for the main transcript
	AgentType   string
	Description string
	ToolUseID   string
	// contains filtered or unexported fields
}

type VerifyResult struct {
	// RawTurns is the number of raw rows scanned.
	RawTurns int `json:"raw_turns"`

	// ParsedTurns is how many raw rows parsed cleanly into a
	// request/response pair.
	ParsedTurns int `json:"parsed_turns"`

	// ParseFailures lists raw rows whose request or response no longer
	// parses (capped). Non-empty means a provider parser regressed OR
	// a raw row predates a parser fix — either way the raw row is
	// intact and re-derivable later.
	ParseFailures []string `json:"parse_failures,omitempty"`

	// RawOnlyTurns counts raw rows whose response fails the same
	// validation ingest applies (missing role/content — error
	// captures, aborted streams). Ingest never derived nodes for
	// these, so neither does the verifier; the raw row is their only
	// representation, by design.
	RawOnlyTurns int `json:"raw_only_turns"`

	// DerivedNodes is the number of distinct node hashes produced by
	// re-deriving every parsed raw turn.
	DerivedNodes int `json:"derived_nodes"`

	// PresentNodes is how many derived hashes exist in the node store.
	PresentNodes int `json:"present_nodes"`

	// MissingNodes samples derived hashes absent from the node store
	// (capped at 20). Empty means the round-trip reproduces the
	// captured nodes exactly.
	MissingNodes []string `json:"missing_nodes,omitempty"`
}