Function bodies 401 total

func AnalysisReportData(r *AnalysisReport, timestamp time.Time) map[string]any {
	data := make(map[string]any)
	data["launch_name"] = r.SourceName
	data["total_cases"] = len(r.CaseResults)
	data["transformer"] = r.Transformer

	headerFields := []map[string]any{}
	if r.SourceName != "" {
		headerFields = append(headerFields, map[string]any{
			"Field": "Launch", "Value": r.SourceName,
		})
	}
	headerFields = append(headerFields,
		map[string]any{"Field": "Analyzed", "Value": timestamp.UTC().Format("2006-01-02 15:04 UTC")},
		map[string]any{"Field": "Transformer", "Value": r.Transformer},
		map[string]any{"Field": "Failures", "Value": r.TotalCases},
	)
	data["header_fields"] = headerFields

	var investigated, skipped, recallHits, cascades int
	compCounts := make(map[string]int)
	defectCounts := make(map[string]int)
	for _, cr := range r.CaseResults {
		if cr.RCAID != 0 {
			investigated++
		}
		if cr.Skip {
			skipped++
		}
		if cr.RecallHit {
			recallHits++
		}
		if cr.Cascade {
			cas

func RenderAnalysisReport(r *AnalysisReport, timestamp time.Time, templateData []byte) (string, error) {
	if r == nil || len(r.CaseResults) == 0 {
		return "# RCA Report\n\nNo failures analyzed.\n", nil
	}
	def, err := cal.ParseReportDef(templateData)
	if err != nil {
		return "", fmt.Errorf("parse RCA report template: %w", err)
	}
	data := AnalysisReportData(r, timestamp)
	return cal.Render(def, data)
}

func BuildCostBill(report *CalibrationReport) *agentport.CostBill {
	if report.Tokens == nil {
		return nil
	}

	caseMap := make(map[string]CaseResult, len(report.CaseResults))
	for _, cr := range report.CaseResults {
		caseMap[cr.CaseID] = cr
	}

	return agentport.BuildCostBill(report.Tokens,
		agentport.WithTitle("TokiMeter"),
		agentport.WithSubtitle(fmt.Sprintf("**%s** | transformer: `%s`", report.Scenario, report.Transformer)),
		agentport.WithStepOrder(asteriskStepOrder),
		agentport.WithStepNames(func(step string) string {
			return vocabNameWithCode(step)
		}),
		agentport.WithCaseLabels(func(id string) string { return id }),
		agentport.WithCaseDetails(func(id string) string {
			cr, ok := caseMap[id]
			if !ok {
				return "-"
			}
			return fmt.Sprintf("%s/%s", cr.Version, cr.Job)
		}),
	)
}

func WeaveTranscripts(calReport *CalibrationReport) ([]RCATranscript, error) {
	if calReport == nil || len(calReport.CaseResults) == 0 {
		return nil, nil
	}

	groups := groupByRCA(calReport.CaseResults)
	var transcripts []RCATranscript

	for rcaID, cases := range groups {
		t := RCATranscript{RCAID: rcaID}

		primary := pickPrimary(cases)
		t.Component = primary.ActualComponent
		t.DefectType = primary.ActualDefectType
		t.RCAMessage = primary.ActualRCAMessage

		ct, err := buildCaseTranscript(calReport, primary)
		if err != nil {
			return nil, fmt.Errorf("weave case %s: %w", primary.CaseID, err)
		}
		t.Primary = ct

		for i := range cases {
			if cases[i].CaseID == primary.CaseID {
				continue
			}
			corr, err := buildCaseTranscript(calReport, &cases[i])
			if err != nil {
				return nil, fmt.Errorf("weave correlated case %s: %w", cases[i].CaseID, err)
			}
			t.Correlated = append(t.Correlated, *corr)
		}

		transcripts = append(transcripts, t)
	}

	return transcripts, nil
}

func TranscriptSlug(t *RCATranscript) string {
	comp := strings.ToLower(strings.ReplaceAll(t.Component, " ", "-"))
	dt := strings.ToLower(t.DefectType)
	if comp == "" {
		comp = "unknown"
	}
	if dt == "" {
		dt = "unknown"
	}
	return fmt.Sprintf("rca-transcript-%s-%s", comp, dt)
}

func TranscriptData(t *RCATranscript) map[string]any {
	data := make(map[string]any)

	data["transcript_title"] = fmt.Sprintf("RCA Transcript — %s: %s",
		t.Component, vocabNameWithCode(t.DefectType))

	caseIDs := []string{t.Primary.CaseID + " (primary)"}
	for _, c := range t.Correlated {
		caseIDs = append(caseIDs, c.CaseID+" (correlated)")
	}
	data["header_fields"] = []map[string]any{
		{"Field": "RCA ID", "Value": fmt.Sprintf("%d", t.RCAID)},
		{"Field": "Component", "Value": t.Component},
		{"Field": "Defect Type", "Value": vocabNameWithCode(t.DefectType)},
		{"Field": "Cases", "Value": strings.Join(caseIDs, ", ")},
		{"Field": "Generated", "Value": time.Now().UTC().Format(time.RFC3339)},
	}

	data["primary_info"] = fmt.Sprintf("**Test:** %s  \n**Path:** %s",
		t.Primary.TestName, vocabStagePath(t.Primary.Path))
	data["primary_entries"] = transcriptEntryData(t.Primary.Entries)

	var correlated []map[string]any
	for _, c := range t.Correlated {
		correlated = append(correlated, map[

func transcriptEntryData(entries []TranscriptEntry) []map[string]any {
	var result []map[string]any
	for i := len(entries) - 1; i >= 0; i-- {
		e := entries[i]
		var body strings.Builder
		if e.Prompt != "" {
			body.WriteString("#### Prompt\n\n")
			for _, line := range strings.Split(e.Prompt, "\n") {
				body.WriteString("> " + line + "\n")
			}
			body.WriteString("\n")
		}
		if e.Response != "" {
			body.WriteString("#### Response\n\n```json\n")
			body.WriteString(e.Response)
			body.WriteString("\n```\n\n")
		}
		body.WriteString(fmt.Sprintf("#### Decision: %s — %s", e.HeuristicID, e.Decision))

		result = append(result, map[string]any{
			"entry_title": fmt.Sprintf("%s %s (%s)", e.Step, e.StepName, e.Timestamp),
			"entry_body":  body.String(),
		})
	}
	return result
}

func RenderTranscript(t *RCATranscript, templateData []byte) (string, error) {
	def, err := cal.ParseReportDef(templateData)
	if err != nil {
		return "", fmt.Errorf("parse transcript template: %w", err)
	}
	data := TranscriptData(t)
	return cal.Render(def, data)
}

func groupByRCA(results []CaseResult) map[int64][]CaseResult {
	groups := make(map[int64][]CaseResult)
	for _, cr := range results {
		key := cr.ActualRCAID
		if key == 0 {
			key = -cr.StoreCaseID
		}
		groups[key] = append(groups[key], cr)
	}
	return groups
}

func pickPrimary(cases []CaseResult) *CaseResult {
	best := &cases[0]
	for i := 1; i < len(cases); i++ {
		if len(cases[i].ActualPath) > len(best.ActualPath) {
			best = &cases[i]
		}
	}
	return best
}

func buildCaseTranscript(calReport *CalibrationReport, cr *CaseResult) (*CaseTranscript, error) {
	ct := &CaseTranscript{
		CaseID:   cr.CaseID,
		TestName: cr.TestName,
		Version:  cr.Version,
		Job:      cr.Job,
		Path:     cr.ActualPath,
	}

	caseDir := CaseDir(calReport.BasePath, calReport.SuiteID, cr.StoreCaseID)

	stateData, stateErr := os.ReadFile(filepath.Join(caseDir, "state.json"))
	if stateErr != nil {
		if os.IsNotExist(stateErr) {
			return ct, nil
		}
		return ct, fmt.Errorf("load state: %w", stateErr)
	}
	var stateVal CaseState
	if err := json.Unmarshal(stateData, &stateVal); err != nil {
		return ct, fmt.Errorf("parse state: %w", err)
	}
	state := &stateVal

	for _, record := range state.History {
		step := record.Step
		if step == "INIT" || step == "DONE" {
			continue
		}

		entry := TranscriptEntry{
			Step:        step,
			StepName:    vocabName(step),
			HeuristicID: record.HeuristicID,
			Decision:    record.Outcome,
			Timestamp:   record.Timestamp,
		}

		prompt

func groupAnalysisByComponent(cases []AnalysisCaseResult) map[string][]AnalysisCaseResult {
	groups := make(map[string][]AnalysisCaseResult)
	for _, cr := range cases {
		comp := cr.Component
		if comp == "" {
			comp = "unknown"
		}
		groups[comp] = append(groups[comp], cr)
	}
	return groups
}

func collectAnalysisEvidence(cases []AnalysisCaseResult) []string {
	seen := make(map[string]bool)
	var result []string
	for _, cr := range cases {
		for _, ref := range cr.EvidenceRefs {
			if !seen[ref] {
				seen[ref] = true
				result = append(result, ref)
			}
		}
	}
	return result
}

func (t *reportHeuristic) Transform(_ context.Context, tc *engine.TransformerContext) (any, error) {
	fp := failureFromContext(tc.WalkerState)
	caseLabel, _ := tc.WalkerState.Context[KeyCaseLabel].(string)
	return map[string]any{
		"case_id":   caseLabel,
		"test_name": fp.name,
		"summary":   "automated baseline analysis",
	}, nil
}

func (t *resolveHeuristic) Transform(_ context.Context, tc *engine.TransformerContext) (any, error) {
	fp := failureFromContext(tc.WalkerState)
	text := t.ht.textFromFailure(fp)
	component := t.ht.identifyComponent(text)
	var repos []any
	if component != "unknown" {
		repos = append(repos, map[string]any{"name": component, "reason": fmt.Sprintf("keyword-identified component: %s", component)})
	} else {
		for _, name := range t.ht.repos {
			repos = append(repos, map[string]any{"name": name, "reason": "included from workspace (no component identified)"})
		}
	}
	return map[string]any{"selected_repos": repos}, nil
}

func (t *reviewHeuristic) Transform(_ context.Context, _ *engine.TransformerContext) (any, error) {
	return map[string]any{"decision": "approve"}, nil
}

func ResolveRPCases(fetcher rcatype.EnvelopeFetcher, scenario *Scenario) error {
	logger := slog.Default().With("component", "rp-source")
	cache := make(map[int]*rcatype.Envelope)

	for i := range scenario.Cases {
		c := &scenario.Cases[i]
		if c.SourceLaunchID <= 0 {
			continue
		}

		env, ok := cache[c.SourceLaunchID]
		if !ok {
			var err error
			env, err = fetcher.Fetch(fmt.Sprintf("%d", c.SourceLaunchID))
			if err != nil {
				return fmt.Errorf("fetch RP launch %d for case %s: %w", c.SourceLaunchID, c.ID, err)
			}
			cache[c.SourceLaunchID] = env
			logger.Info("fetched RP launch",
				"launch_id", c.SourceLaunchID, "name", env.Name, "failures", len(env.FailureList))
		}

		item := matchFailureItem(env, c)
		if item == nil {
			return fmt.Errorf("case %s: no matching failure item in RP launch %d (test=%q, item_id=%d)",
				c.ID, c.SourceLaunchID, c.TestName, c.SourceItemID)
		}

		logger.Info("matched RP item", "case_id", c.ID, "item_id", item.ID, "item_name", item.Name)

		if

func matchFailureItem(env *rcatype.Envelope, c *GroundTruthCase) *rcatype.FailureItem {
	if c.SourceItemID > 0 {
		want := fmt.Sprintf("%d", c.SourceItemID)
		for i := range env.FailureList {
			if env.FailureList[i].ID == want {
				return &env.FailureList[i]
			}
		}
	}

	if c.TestID != "" {
		tag := "test_id:" + c.TestID
		for i := range env.FailureList {
			if strings.Contains(env.FailureList[i].Name, tag) {
				return &env.FailureList[i]
			}
		}
	}

	testLower := strings.ToLower(c.TestName)
	if testLower != "" {
		for i := range env.FailureList {
			nameLower := strings.ToLower(env.FailureList[i].Name)
			if strings.Contains(nameLower, testLower) {
				return &env.FailureList[i]
			}
			if strings.Contains(testLower, nameLower) {
				return &env.FailureList[i]
			}
		}
	}

	return nil
}

func LoadScenario(fsys fs.FS, name string) (*Scenario, error) {
	data, err := fs.ReadFile(fsys, name+".yaml")
	if err != nil {
		return nil, fmt.Errorf("scenario %q not found (available: %s): %w",
			name, strings.Join(ListScenarios(fsys), ", "), err)
	}
	var s Scenario
	if err := yaml.Unmarshal(data, &s); err != nil {
		return nil, fmt.Errorf("parse scenario %q: %w", name, err)
	}
	if s.Name == "" {
		s.Name = name
	}
	s.ApplyDefaults()
	return &s, nil
}

func ResolveOfflineRP(offlineFS fs.FS, scenario *Scenario) error {
	logger := slog.Default().With("component", "offline-rp")
	cache := make(map[int]*rcatype.Envelope)

	resolve := func(cases []GroundTruthCase) error {
		for i := range cases {
			c := &cases[i]
			if c.SourceLaunchID <= 0 {
				continue
			}
			env, ok := cache[c.SourceLaunchID]
			if !ok {
				path := fmt.Sprintf("rp/%d.json", c.SourceLaunchID)
				data, err := fs.ReadFile(offlineFS, path)
				if err != nil {
					available := listDir(offlineFS, "rp")
					return fmt.Errorf("offline RP launch %d for case %s: %w (available files in rp/: %s)",
						c.SourceLaunchID, c.ID, err, available)
				}
				env = new(rcatype.Envelope)
				if err := json.Unmarshal(data, env); err != nil {
					return fmt.Errorf("parse offline RP launch %d: %w", c.SourceLaunchID, err)
				}
				cache[c.SourceLaunchID] = env
				logger.Info("loaded offline RP launch",
					"launch_id", c.SourceLaunchID, "failures", len(env.FailureList))
			}
			item

func matchOfflineItem(env *rcatype.Envelope, c *GroundTruthCase) *rcatype.FailureItem {
	if c.TestID != "" {
		for i := range env.FailureList {
			if env.FailureList[i].ID == c.TestID {
				return &env.FailureList[i]
			}
			tag := "test_id:" + c.TestID
			if strings.Contains(env.FailureList[i].Name, tag) {
				return &env.FailureList[i]
			}
		}
	}
	if len(env.FailureList) == 1 {
		return &env.FailureList[0]
	}
	return nil
}

func ListScenarios(fsys fs.FS) []string {
	entries, _ := fs.ReadDir(fsys, ".")
	var names []string
	for _, e := range entries {
		if strings.HasSuffix(e.Name(), ".yaml") {
			names = append(names, strings.TrimSuffix(e.Name(), ".yaml"))
		}
	}
	sort.Strings(names)
	return names
}

func listDir(fsys fs.FS, dir string) string {
	entries, err := fs.ReadDir(fsys, dir)
	if err != nil {
		return fmt.Sprintf("<unreadable: %v>", err)
	}
	if len(entries) == 0 {
		return "<empty>"
	}
	var names []string
	for _, e := range entries {
		names = append(names, e.Name())
	}
	sort.Strings(names)
	return strings.Join(names, ", ")
}

func Hooks() engine.SessionHooks {
	return engine.SessionHooks{
		CreateSession: createSession,
		StepSchemas:   RCAStepSchemas(),
		FormatReport: func(result any) (string, any, error) {
			report, ok := result.(*CalibrationReport)
			if !ok {
				return "", nil, nil
			}
			formatted, err := RenderCalibrationReport(report, nil)
			return formatted, report, err
		},
	}
}

func createSession(_ context.Context, params engine.SessionParams) (*engine.SessionConfig, error) {
	// --- Parse domain params from Extra ---
	scenarioName, _ := params.Extra["scenario"].(string)
	if scenarioName == "" {
		scenarioName = "ptp"
	}
	backend, _ := params.Extra["backend"].(string)
	if backend == "" {
		backend = "llm"
	}
	mode, _ := params.Extra["mode"].(string)
	if mode == "" {
		mode = "offline"
	}

	// --- Load scenario from domain FS ---
	if params.DomainFS == nil {
		return nil, fmt.Errorf("DomainFS is nil — fold-generated code must set CircuitConfig.DomainFS")
	}

	scenarioFS, err := fs.Sub(params.DomainFS, "scenarios")
	if err != nil {
		return nil, fmt.Errorf("sub-fs scenarios/: %w", err)
	}
	scenario, err := LoadScenario(scenarioFS, scenarioName)
	if err != nil {
		return nil, fmt.Errorf("load scenario %q: %w", scenarioName, err)
	}

	// --- Resolve RP failure data ---
	if mode == "offline" {
		offlineFS, err := fs.Sub(params.DomainFS, "offline")
		if err == nil 

func RCAStepSchemas() []toolkit.StepSchema {
	return []toolkit.StepSchema{
		{
			Name: "recall",
			Defs: []toolkit.FieldDef{
				{Name: "match", Type: "bool", Required: true, Desc: "true if a prior RCA likely explains this failure"},
				{Name: "prior_rca_id", Type: "int", Required: false, Desc: "matched RCA ID, 0 if no match"},
				{Name: "symptom_id", Type: "int", Required: false, Desc: "matched symptom ID, 0 if no match"},
				{Name: "confidence", Type: "float", Required: true, Desc: "0.0-1.0 (>=0.8 high, 0.4-0.8 uncertain, <0.4 miss)"},
				{Name: "reasoning", Type: "string", Required: true, Desc: "brief explanation of match or mismatch"},
				{Name: "is_regression", Type: "bool", Required: false, Desc: "true if known-resolved symptom reappearing"},
			},
		},
		{
			Name: "triage",
			Defs: []toolkit.FieldDef{
				{Name: "symptom_category", Type: "string", Required: true, Desc: "product, automation, environment, infra, firmware, flake"},
				{Name: "severity", Type: "string", Re

func applyStoreEffects(
	st store.Store,
	caseData *store.Case,
	nodeName string,
	artifact any,
) error {
	switch nodeName {
	case "recall":
		return applyRecallEffects(st, caseData, artifact)
	case "triage":
		return applyTriageEffects(st, caseData, artifact)
	case "investigate":
		return applyInvestigateEffects(st, caseData, artifact)
	case "correlate":
		return applyCorrelateEffects(st, caseData, artifact)
	case "review":
		return applyReviewEffects(st, caseData, artifact)
	}
	return nil
}

func applyRecallEffects(st store.Store, caseData *store.Case, artifact any) error {
	m := asMap(artifact)
	if m == nil || !mapBool(m, "match") {
		return nil
	}
	symptomID := mapInt64(m, "symptom_id")
	if symptomID != 0 {
		if err := st.LinkCaseToSymptom(caseData.ID, symptomID); err != nil {
			return fmt.Errorf("link case to symptom: %w", err)
		}
		caseData.SymptomID = symptomID
		_ = st.UpdateSymptomSeen(symptomID)
	}
	priorRCAID := mapInt64(m, "prior_rca_id")
	if priorRCAID != 0 {
		if err := st.LinkCaseToRCA(caseData.ID, priorRCAID); err != nil {
			return fmt.Errorf("link case to rca: %w", err)
		}
		caseData.RCAID = priorRCAID
	}
	return nil
}

func applyTriageEffects(st store.Store, caseData *store.Case, artifact any) error {
	m := asMap(artifact)
	if m == nil {
		return nil
	}
	triage := &store.Triage{
		CaseID:               caseData.ID,
		SymptomCategory:      mapStr(m, "symptom_category"),
		Severity:             mapStr(m, "severity"),
		DefectTypeHypothesis: mapStr(m, "defect_type_hypothesis"),
		SkipInvestigation:    mapBool(m, "skip_investigation"),
		ClockSkewSuspected:   mapBool(m, "clock_skew_suspected"),
		CascadeSuspected:     mapBool(m, "cascade_suspected"),
		DataQualityNotes:     mapStr(m, "data_quality_notes"),
	}
	if _, err := st.CreateTriage(triage); err != nil {
		slog.Warn("create triage failed", "component", "orchestrate", "error", err)
	}

	fingerprint := ComputeFingerprint(caseData.Name, caseData.ErrorMessage, mapStr(m, "symptom_category"))
	sym, err := st.GetSymptomByFingerprint(fingerprint)
	if err != nil {
		slog.Warn("get symptom by fingerprint failed", "component", "orchestrate", "error", err)
	}

func applyInvestigateEffects(st store.Store, caseData *store.Case, artifact any) error {
	m := asMap(artifact)
	if m == nil {
		return nil
	}
	title := mapStr(m, "rca_message")
	if len(title) > 80 {
		title = title[:80] + "..."
	}
	if title == "" {
		title = "RCA from investigation"
	}
	rca := &store.RCA{
		Title:            title,
		Description:      mapStr(m, "rca_message"),
		DefectType:       mapStr(m, "defect_type"),
		Component:        mapStr(m, "component"),
		ConvergenceScore: mapFloat(m, "convergence_score"),
		Status:           "open",
	}
	rcaID, err := st.SaveRCA(rca)
	if err != nil {
		return fmt.Errorf("save rca: %w", err)
	}

	if err := st.LinkCaseToRCA(caseData.ID, rcaID); err != nil {
		return fmt.Errorf("link case to rca: %w", err)
	}
	if err := st.UpdateCaseStatus(caseData.ID, "investigated"); err != nil {
		return fmt.Errorf("update case status: %w", err)
	}
	caseData.RCAID = rcaID
	caseData.Status = "investigated"

	if caseData.SymptomID != 0 {
		link := &store.Symp

func applyCorrelateEffects(st store.Store, caseData *store.Case, artifact any) error {
	m := asMap(artifact)
	if m == nil || !mapBool(m, "is_duplicate") {
		return nil
	}
	linkedRCAID := mapInt64(m, "linked_rca_id")
	if linkedRCAID == 0 {
		return nil
	}
	if err := st.LinkCaseToRCA(caseData.ID, linkedRCAID); err != nil {
		return fmt.Errorf("link case to shared rca: %w", err)
	}
	caseData.RCAID = linkedRCAID

	if caseData.SymptomID != 0 {
		link := &store.SymptomRCA{
			SymptomID:  caseData.SymptomID,
			RCAID:      linkedRCAID,
			Confidence: mapFloat(m, "confidence"),
			Notes:      "linked from F4 correlation",
		}
		if _, err := st.LinkSymptomToRCA(link); err != nil {
			slog.Warn("link symptom to RCA failed (correlate)", "component", "orchestrate", "error", err)
		}
	}
	return nil
}

func applyReviewEffects(st store.Store, caseData *store.Case, artifact any) error {
	m := asMap(artifact)
	if m == nil {
		return nil
	}
	decision := mapStr(m, "decision")
	if decision == "approve" {
		if err := st.UpdateCaseStatus(caseData.ID, "reviewed"); err != nil {
			return fmt.Errorf("update case after review: %w", err)
		}
		caseData.Status = "reviewed"
	}
	if decision == "overturn" {
		override := mapMap(m, "human_override")
		if override != nil && caseData.RCAID != 0 {
			rca, err := st.GetRCA(caseData.RCAID)
			if err == nil && rca != nil {
				rca.Description = mapStr(override, "rca_message")
				rca.DefectType = mapStr(override, "defect_type")
				if _, err := st.SaveRCA(rca); err != nil {
					slog.Warn("update RCA after overturn failed", "component", "orchestrate", "error", err)
				}
			}
		}
		if err := st.UpdateCaseStatus(caseData.ID, "reviewed"); err != nil {
			return fmt.Errorf("update case after overturn: %w", err)
		}
		caseData.Status = "reviewed"
	}
	return nil

func ComputeFingerprint(testName, errorMessage, component string) string {
	input := testName + "|" + errorMessage + "|" + component
	var h uint64 = 14695981039346656037
	for i := 0; i < len(input); i++ {
		h ^= uint64(input[i])
		h *= 1099511628211
	}
	return fmt.Sprintf("%016x", h)
}

func (s *MemStore) CreateSuite(suite *InvestigationSuite) (int64, error) {
	if suite == nil {
		return 0, fmt.Errorf("suite is nil")
	}
	if suite.Status == "" {
		suite.Status = "open"
	}
	if suite.CreatedAt == "" {
		suite.CreatedAt = now()
	}
	return s.mes.Create("investigation_suites", sqlite.Row{
		"name": suite.Name, "description": suite.Description,
		"status": suite.Status, "created_at": suite.CreatedAt, "closed_at": suite.ClosedAt,
	})
}

func (s *MemStore) GetSuite(id int64) (*InvestigationSuite, error) {
	row, err := s.mes.Get("investigation_suites", id)
	if err != nil || row == nil {
		return nil, err
	}
	return suiteFromRow(row), nil
}

func (s *MemStore) ListSuites() ([]*InvestigationSuite, error) {
	rows, err := s.mes.List("investigation_suites", nil, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, suiteFromRow), nil
}

func (s *MemStore) CloseSuite(id int64) error {
	return s.mes.Update("investigation_suites", id, sqlite.Row{
		"status": "closed", "closed_at": now(),
	})
}

func (s *MemStore) CreateVersion(ver *Version) (int64, error) {
	if ver == nil {
		return 0, fmt.Errorf("version is nil")
	}
	existing, _ := s.mes.GetBy("versions", sqlite.Row{"label": ver.Label})
	if existing != nil {
		return 0, fmt.Errorf("version label %q already exists", ver.Label)
	}
	return s.mes.Create("versions", sqlite.Row{
		"label": ver.Label, "build_id": ver.BuildID,
	})
}

func (s *MemStore) GetVersion(id int64) (*Version, error) {
	row, err := s.mes.Get("versions", id)
	if err != nil || row == nil {
		return nil, err
	}
	return versionFromRow(row), nil
}

func (s *MemStore) GetVersionByLabel(label string) (*Version, error) {
	row, err := s.mes.GetBy("versions", sqlite.Row{"label": label})
	if err != nil || row == nil {
		return nil, err
	}
	return versionFromRow(row), nil
}

func (s *MemStore) ListVersions() ([]*Version, error) {
	rows, err := s.mes.List("versions", nil, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, versionFromRow), nil
}

func (s *MemStore) CreateCircuit(p *Circuit) (int64, error) {
	if p == nil {
		return 0, fmt.Errorf("circuit is nil")
	}
	return s.mes.Create("circuits", sqlite.Row{
		"suite_id": p.SuiteID, "version_id": p.VersionID, "name": p.Name,
		"source_run_id": p.SourceRunID, "status": p.Status,
		"started_at": p.StartedAt, "ended_at": p.EndedAt,
	})
}

func (s *MemStore) GetCircuit(id int64) (*Circuit, error) {
	row, err := s.mes.Get("circuits", id)
	if err != nil || row == nil {
		return nil, err
	}
	return circuitFromRow(row), nil
}

func (s *MemStore) ListCircuitsBySuite(suiteID int64) ([]*Circuit, error) {
	rows, err := s.mes.List("circuits", sqlite.Row{"suite_id": suiteID}, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, circuitFromRow), nil
}

func (s *MemStore) CreateLaunch(l *Launch) (int64, error) {
	if l == nil {
		return 0, fmt.Errorf("launch is nil")
	}
	return s.mes.Create("launches", sqlite.Row{
		"circuit_id": l.CircuitID, "source_run_id": l.SourceRunID,
		"source_run_uuid": l.SourceRunUUID, "name": l.Name,
		"status": l.Status, "started_at": l.StartedAt, "ended_at": l.EndedAt,
		"env_attributes": l.EnvAttributes, "git_branch": l.GitBranch,
		"git_commit": l.GitCommit, "envelope_payload": l.EnvelopePayload,
	})
}

func (s *MemStore) GetLaunch(id int64) (*Launch, error) {
	row, err := s.mes.Get("launches", id)
	if err != nil || row == nil {
		return nil, err
	}
	return launchFromRow(row), nil
}

func (s *MemStore) GetLaunchBySourceRunID(circuitID int64, sourceRunID string) (*Launch, error) {
	row, err := s.mes.GetBy("launches", sqlite.Row{
		"circuit_id": circuitID, "source_run_id": sourceRunID,
	})
	if err != nil || row == nil {
		return nil, err
	}
	return launchFromRow(row), nil
}

func (s *MemStore) ListLaunchesByCircuit(circuitID int64) ([]*Launch, error) {
	rows, err := s.mes.List("launches", sqlite.Row{"circuit_id": circuitID}, "")
	if err != nil {
		return nil, err
	}
	return rowsTo(rows, launchFromRow), nil
}

func (s *MemStore) CreateJob(j *Job) (int64, error) {
	if j == nil {
		return 0, fmt.Errorf("job is nil")
	}
	return s.mes.Create("jobs", sqlite.Row{
		"launch_id": j.LaunchID, "source_item_id": j.SourceItemID,
		"name": j.Name, "clock_type": j.ClockType, "status": j.Status,
		"stats_total": j.StatsTotal, "stats_failed": j.StatsFailed,
		"stats_passed": j.StatsPassed, "stats_skipped": j.StatsSkipped,
		"started_at": j.StartedAt, "ended_at": j.EndedAt,
	})
}

func (s *MemStore) GetJob(id int64) (*Job, error) {
	row, err := s.mes.Get("jobs", id)
	if err != nil || row == nil {
		return nil, err
	}
	return jobFromRow(row), nil
}