repository

type ACPProbeCacheRepo interface {
	Load(ctx context.Context) (*model.ACPProbeCacheSnapshot, error)
	Save(ctx context.Context, snapshot *model.ACPProbeCacheSnapshot) error
}

type AgentCatalogRepo interface {
	Load(ctx context.Context) (*model.AgentCatalogSnapshot, error)
	Save(ctx context.Context, snapshot *model.AgentCatalogSnapshot) error
}

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

type ChatContextRepo interface {
	LoadAllMessages(ctx context.Context) ([]*schema.Message, error)
	CountMessage(ctx context.Context) (int, error)
	// MessagesFingerprint returns a content-aware identifier for the
	// current state of messages.jsonl. Used by the ACP drift check to
	// detect cross-path mutations that count alone misses (in-place row
	// rewrites — e.g. ReplacePlaceholderToolResult — or hand edits that
	// keep the row count stable but change content). The returned hash
	// is FNV-64 over the on-disk file contents, which is reproducible
	// when nothing has changed and changes whenever any byte does. Empty
	// / missing file yields a zero-valued fingerprint.
	MessagesFingerprint(ctx context.Context) (MessagesFingerprint, error)
	// AppendMessages appends the chat messages to the file.
	AppendMessages(ctx context.Context, msgs []*schema.Message) error
	// ReplaceMessages rewrites the full message history.
	ReplaceMessages(ctx context.Context, msgs []*schema.Message) error
	// ReplacePlaceholderToolResult swaps a previously-persisted placeholder
	// tool_result (matching toolCallID and carrying the placeholder flag)
	// with the real tool result. Used by the round builder when a terminal
	// event arrives AFTER an eager-flush already wrote a [placeholder]
	// superseded row: without this stitch, the placeholder would stay on
	// disk forever and pollute both the history view and the next round's
	// LLM context.
	//
	// Returns stitched=true iff a matching placeholder row was found and
	// replaced. Returns stitched=false (no error) when the placeholder is
	// gone — e.g. a concurrent orphan-tail truncate already cut the row.
	// Errors surface I/O failures only.
	ReplacePlaceholderToolResult(ctx context.Context, toolCallID string, real *schema.Message) (bool, error)
	// WithLock acquires the per-session write lock and runs fn with a
	// LockedRepo handle whose methods bypass the per-call locking. Used
	// by callers that need a multi-step compound operation (e.g.
	// BeginRun's truncate-then-append) to be atomic across other
	// ChatContextRepo instances pointed at the same session directory.
	// Calling the regular ChatContextRepo methods inside fn would
	// deadlock — use the LockedRepo handle.
	//
	// ctx gates the lock acquisition: a Run whose persist deadline has
	// already expired observes ctx.Err() instead of blocking on a
	// contended lock. Once fn starts running, ctx cancellation no
	// longer interrupts the in-flight critical section — fn is
	// expected to honour ctx itself for its own per-step IO.
	WithLock(ctx context.Context, fn func(tx LockedRepo) error) error
}

type CodexAccountBackup struct {
	Files         CodexAccountFiles `json:"files"`
	ManagedID     string            `json:"managed_id"`
	ConfigApplied bool              `json:"config_applied"`
}

type CodexAccountFiles struct {
	Home   string  `json:"home"`
	Auth   *string `json:"auth"`
	Config *string `json:"config"`
}

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

type CodexAccountStore struct {
	Version         int                           `json:"version"`
	Revision        uint64                        `json:"revision"`
	Accounts        []StoredCodexAccount          `json:"accounts"`
	ActiveID        string                        `json:"active_id"`
	ActiveHome      string                        `json:"active_home"`
	ConfigApplied   bool                          `json:"config_applied"`
	Backup          *CodexAccountBackup           `json:"backup,omitempty"`
	Pending         *CodexAccountTransaction      `json:"pending,omitempty"`
	Operations      []model.CodexAccountOperation `json:"operations"`
	OperationHashes map[string]string             `json:"operation_hashes,omitempty"`
}

type CodexAccountTransaction struct {
	Before    CodexAccountBackup          `json:"before"`
	After     CodexAccountFiles           `json:"after"`
	Operation model.CodexAccountOperation `json:"operation"`
}

type FileShareRepo interface {
	Create(filePath string) (*model.FileShare, error)
	Get(token string) (*model.FileShare, bool)
	GetByPath(filePath string) (*model.FileShare, bool)
	Delete(token string) error
}

type GraphRunRepo interface {
	RegisterRun(ctx context.Context, run *model.GraphRun) error
	RegisterRunLocation(ctx context.Context, runID, workspaceID, jobID string) error
	SaveRun(ctx context.Context, run *model.GraphRun) error
	GetRun(ctx context.Context, runID string) (*model.GraphRun, error)

	SaveInstances(ctx context.Context, runID string, instances map[string]model.GraphInstanceState) error
	GetInstances(ctx context.Context, runID string) (map[string]model.GraphInstanceState, error)

	SaveEdges(ctx context.Context, runID string, edges map[string]model.GraphEdgeState) error
	GetEdges(ctx context.Context, runID string) (map[string]model.GraphEdgeState, error)

	SaveVariables(ctx context.Context, runID string, variables map[string]map[string]string) error
	GetVariables(ctx context.Context, runID string) (map[string]map[string]string, error)

	SaveSessionLineage(ctx context.Context, runID string, lineage map[string]model.GraphSessionLineage) error
	GetSessionLineage(ctx context.Context, runID string) (map[string]model.GraphSessionLineage, error)

	SaveProgress(ctx context.Context, runID string, progress *model.GraphProgress) error
	GetProgress(ctx context.Context, runID string) (*model.GraphProgress, error)

	SaveResume(ctx context.Context, runID string, resume *model.GraphResumeState) error
	GetResume(ctx context.Context, runID string) (*model.GraphResumeState, error)

	AppendEvent(ctx context.Context, runID string, event *model.GraphEvent) error
	ListEvents(ctx context.Context, runID string, startLine int, count *int) ([]model.GraphEvent, error)
	// CountEvents returns the number of persisted event lines without reading
	// their content. Used by GetRunStatus to expose an event count (the SSE
	// resume cursor seed) without serialising the whole event log into the
	// status response. A missing events file yields (0, nil).
	CountEvents(ctx context.Context, runID string) (int, error)

	DeleteRun(ctx context.Context, runID string) error
}

type GraphWorkflowRepo interface {
	Save(ctx context.Context, wf *model.GraphWorkflow) error
	Get(ctx context.Context, id string) (*model.GraphWorkflow, error)
	List(ctx context.Context) ([]*model.GraphWorkflow, []model.GraphWorkflowWarning, error)
	Update(ctx context.Context, id string, wf *model.GraphWorkflow) error
	UpdateIfUnchanged(ctx context.Context, id string, wf *model.GraphWorkflow, expectedUpdatedAt *time.Time) error
	Delete(ctx context.Context, id string, expectedUpdatedAt *time.Time) error
}

type IMJobMappingRepo interface {
	Get(platform, chatID string) (*model.IMJobMapping, error)
	Save(m *model.IMJobMapping) error
}

type IMMessageRepo interface {
	Append(ctx context.Context, msg *model.IMMessage) error
}

type JobRepo interface {
	Save(jobID string, job *model.Job) error
	Load(jobID string) (*model.Job, error)
	ListIDs() ([]string, error)
	LoadAll() ([]*model.Job, error)
	// SweepDeleted removes complete on-disk job directories whose durable job
	// metadata is marked Deleted. It is the startup recovery half of the
	// two-phase Job deletion protocol.
	SweepDeleted() error
}

type LockedRepo interface {
	LoadAllMessages(ctx context.Context) ([]*schema.Message, error)
	AppendMessages(ctx context.Context, msgs []*schema.Message) error
	ReplaceMessages(ctx context.Context, msgs []*schema.Message) error
}

type MessagePage struct {
	Messages []*schema.Message
	Offsets  []int64
	// StartOffset is the cursor for the next older page. Boundary* identifies
	// the first raw row in this page so the next request can detect a rewrite.
	StartOffset       int64
	BoundaryEndOffset int64
	BoundaryHash      string
	HasMore           bool
}

type MessagePresetRepo interface {
	GetGlobal() (*StoredMessagePresetConfig, error)
	GetWorkspace(workspaceID string) (*StoredMessagePresetConfig, error)
	ListWorkspaceFiles() ([]string, error)
	SaveGlobal(expectedRevision string, config *model.MessagePresetConfig) (*StoredMessagePresetConfig, error)
	SaveWorkspace(workspaceID, expectedRevision string, config *model.MessagePresetConfig) (*StoredMessagePresetConfig, error)
	DeleteWorkspace(workspaceID, expectedRevision string) error
	RebindWorkspace(sourceID, targetID, expectedRevision string, config *model.MessagePresetConfig) error
}

type MessagesFingerprint struct {
	Count int    `json:"count,omitempty"`
	Hash  string `json:"hash,omitempty"`
}

type PagedChatContextRepo interface {
	ChatContextRepo
	// LoadMessagePage reads a reverse page ending immediately before
	// beforeOffset. A zero beforeOffset starts at the current end of file.
	// boundaryEndOffset and boundaryHash validate the first row of the page
	// already returned to the client while still allowing tail appends.
	LoadMessagePage(ctx context.Context, beforeOffset, boundaryEndOffset int64, boundaryHash string, limit int) (*MessagePage, error)
}

type PromptRepo interface {
	Get(ctx context.Context, key string) (string, error)
	Save(ctx context.Context, key string, content string) error
}

type RecentDirs struct {
	Dirs []string `json:"dirs"`
}

type RecentDirsRepo interface {
	Get() (*RecentDirs, error)
	Add(ctx context.Context, dir string) error
}

type ScheduleRepo interface {
	Create(ctx context.Context, task *model.ScheduledTask) error
	SaveDefinition(ctx context.Context, task *model.ScheduledTask) error
	SaveState(ctx context.Context, task *model.ScheduledTask) error
	UpdateActivation(ctx context.Context, id string, enabled *bool, nextRunAt *time.Time) error
	ToggleEnabled(ctx context.Context, id string, nextRunAt *time.Time) error
	Get(ctx context.Context, id string) (*model.ScheduledTask, error)
	List(ctx context.Context) ([]*model.ScheduledTask, error)
	Delete(ctx context.Context, id string) error
}

type SessionRepo interface {
	Save(sessionID string, meta *model.Session) error
	Load(sessionID string) (*model.Session, error)
	ListIDs() ([]string, error)
	LoadAll() ([]*model.Session, error)
}

type SettingsRepo interface {
	Get() (*model.Settings, error)
	Save(s *model.Settings) error
}

type StoredCodexAccount struct {
	Info     model.CodexAccount `json:"info"`
	Identity string             `json:"identity"`
	Auth     string             `json:"auth"`
	Config   *string            `json:"config,omitempty"`
}

type StoredMessagePresetConfig struct {
	Config   *model.MessagePresetConfig
	Revision string
	File     string
}

type UserInputRepo interface {
	Append(ctx context.Context, input *model.UserInput) error
}

type WeChatOutboxRepo interface {
	Save(ctx context.Context, task *model.WeChatOutboxTask) error
	Get(ctx context.Context, id string) (*model.WeChatOutboxTask, error)
	List(ctx context.Context) ([]*model.WeChatOutboxTask, error)
}

type WorkspaceRepo interface {
	Save(id string, ws *model.Workspace) error
	Load(id string) (*model.Workspace, error)
	ListIDs() ([]string, error)
	LoadAll() ([]*model.Workspace, error)
	// SweepDeleted removes on-disk directories for workspaces marked as
	// deleted. Split from LoadAll so the read path has no write side effects.
	SweepDeleted() error
	RemoveDir(id string) error
}