maintenance

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

type AssessOptions struct {
	// Batch is how many memory contents go into a single LLM call. 0 falls back
	// to defaultAssessBatch.
	Batch int
	// MaxPerRun caps the rows assessed by one pass, bounding its LLM spend.
	// 0 falls back to defaultAssessMaxPerRun.
	MaxPerRun int
	// MinAge skips memories younger than this, so the sweep never races the
	// write path's own assessment (a fresh write is rated inline by the
	// distill/consolidate call). 0 falls back to defaultAssessMinAge.
	MinAge time.Duration
	// Log receives progress messages; nil falls back to slog.Default().
	Log *slog.Logger
}

type BackfillConfidenceReport struct {
	Inspected int `json:"inspected"`
	Seeded    int `json:"seeded"`
	Skipped   int `json:"skipped"`
}

type ClusterAction struct {
	RepresentativeID string   `json:"representative_id"`
	TombstonedIDs    []string `json:"tombstoned_ids"`
	Size             int      `json:"size"`
}

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

type DedupOptions struct {
	// Similarity is the minimum cosine-like score (the store's vector
	// distance-to-score mapping) for two memories to join a cluster.
	// 0 falls back to defaultDedupSimilarity. Negative disables dedup and
	// the call returns an empty report.
	Similarity float64
	// MinClusterSize is the smallest cluster acted on. A pair of near-
	// duplicates below this is left alone. 0 falls back to
	// defaultDedupMinClusterSize.
	MinClusterSize int
	// Tiers restricts the pass to these tiers; nil/empty means all tiers.
	Tiers []memory.Tier
	// Namespaces restricts the pass to these namespaces; nil/empty means every
	// namespace. Clusters never span namespaces, so scoping the pass to one
	// (the post-import case) is both cheaper and avoids touching other namespaces.
	Namespaces []string
	// NeighboursPerAnchor bounds the per-anchor vector-search fan-out. Larger
	// values tighten clusters at higher vector-search cost. 0 falls back to
	// defaultDedupNeighboursAnchor.
	NeighboursPerAnchor int
	// DryRun reports what would be done without tombstoning anything.
	DryRun bool
	// Now is the instant retention scoring and expiry filtering are evaluated
	// at. Zero means time.Now().UTC().
	Now time.Time
	// Log receives progress messages; nil falls back to slog.Default().
	Log *slog.Logger
	// Merger, when set, merges each cluster's content into a single
	// comprehensive memory before tombstoning the duplicates. When nil, the
	// representative keeps its original content (existing behavior).
	Merger llm.Merger
	// MaxMergeClusterSize bounds the cluster size sent to the LLM (larger
	// clusters would exceed token limits). Clusters larger than this are
	// merged in chunks or skipped. 0 defaults to 10.
	MaxMergeClusterSize int
}

type DedupReport struct {
	Namespaces    int             `json:"namespaces"`
	MemoriesSeen  int             `json:"memories_seen"`
	ClustersFound int             `json:"clusters_found"`
	Tombstoned    int             `json:"tombstoned"`
	DryRun        bool            `json:"dry_run"`
	Actions       []ClusterAction `json:"actions,omitempty"`
}

type ReembedReport struct {
	Namespaces int `json:"namespaces"`
	Total      int `json:"total"`
	Reembedded int `json:"reembedded"`
}

type RenamespaceReport struct {
	Moved   int            `json:"moved"`
	Targets map[string]int `json:"targets,omitempty"` // memories moved into each destination
	Skipped int            `json:"skipped"`           // left in place (no grouping key, or already in place)
	DryRun  bool           `json:"dry_run"`
}

type RepairReport struct {
	Restored   int  `json:"restored"`
	Namespaces int  `json:"namespaces"`
	DryRun     bool `json:"dry_run"`
}

type Report struct {
	ExpiredPurged    int        `json:"expired_purged"`
	ShortTermEvicted int        `json:"short_term_evicted"`
	Namespaces       int        `json:"namespaces"`
	DuplicateGroups  [][]string `json:"duplicate_groups,omitempty"`
}

type ScopeMerge struct {
	From            string `json:"from"`
	To              string `json:"to"`
	Moved           int    `json:"moved"`
	DedupClusters   int    `json:"dedup_clusters,omitempty"`
	DedupTombstoned int    `json:"dedup_tombstoned,omitempty"`
}

type ScopesOptions struct {
	// DryRun reports what would move (and what would be deduped) without
	// writing anything.
	DryRun bool
	// Embedder powers the post-merge dedup pass (gap G14). Required whenever
	// a merge actually happens and DryRun is false; unused in dry-run mode,
	// where no dedup pass runs.
	Embedder embed.Embedder
	// Dedup configures the post-merge dedup pass run against each merge
	// target. Namespaces and DryRun are overridden per call; the caller
	// controls Similarity/MinClusterSize/Tiers/etc. Zero value uses Dedup's
	// own defaults.
	Dedup DedupOptions
}

type ScopesReport struct {
	Merges []ScopeMerge `json:"merges,omitempty"`
	// BareShared lists top-level namespaces literally named "_shared" (no
	// tenant prefix): there is no parent to merge into, so these are left
	// untouched. Reported rather than silently skipped since the operator
	// likely wants it repointed by hand (a home namespace, or a link source).
	BareShared []string `json:"bare_shared,omitempty"`
	// GlobalNamespaceEnv is the raw value of MEMINI_GLOBAL_NAMESPACE when set
	// at run time. Its presence is only ever reported, never acted on: the
	// caller (CLI) prints adoption instructions instead of a silent rewrite.
	GlobalNamespaceEnv string `json:"global_namespace_env,omitempty"`
	DryRun             bool   `json:"dry_run"`
}

type ScrubReport struct {
	LifecycleNoise  int `json:"lifecycle_noise"`
	ExactDuplicates int `json:"exact_duplicates"`
	Namespaces      int `json:"namespaces"`
}

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

type SweeperConfig struct {
	// Interval is how often the sweep runs.
	Interval time.Duration
	// ShortTermCap bounds working+episodic memories per namespace; the lowest-
	// retention ones over the cap are evicted. 0 disables it.
	ShortTermCap int
	// TombstoneTTL hard-deletes superseded memories last updated before now-TTL,
	// reclaiming space. 0 disables it (tombstones are kept indefinitely but stay
	// excluded from recall).
	TombstoneTTL time.Duration
	// DemoteAfter demotes never-recalled, low-importance durable memories older
	// than this to the episodic tier so unused debris ages out. 0 disables it.
	DemoteAfter time.Duration
	// ActivityRetention drops activity-log events older than now-retention.
	// 0 disables age-based pruning.
	ActivityRetention time.Duration
	// ActivityMaxRows caps the activity log, dropping the oldest rows beyond it.
	// 0 disables the cap. With both bounds 0 the log grows without limit.
	ActivityMaxRows int
	// OnDemoted, when non-nil, is called once per memory the demote stage
	// retiers, with the tier it was demoted from (feeds memini_demoted_total).
	OnDemoted func(fromTier string)
}