antidrift/internal/store/store.go

// Package store persists and restores the daemon's current state as a single
// JSON snapshot. It is the M0 source of durability; the hash-chained audit log
// arrives in a later milestone.
package store

import (
	"encoding/json"
	"errors"
	"os"
	"path/filepath"

	"keel/internal/mode/focus/domain"
)

// Snapshot is the persisted current state of the daemon.
type Snapshot struct {
	RuntimeState     domain.RuntimeState `json:"runtime_state"`
	Commitment       *domain.Commitment  `json:"commitment,omitempty"`
	DeadlineUnixSecs int64               `json:"deadline_unix_secs,omitempty"`
	SessionID        string              `json:"session_id,omitempty"`
	OutcomePending   string              `json:"outcome_pending,omitempty"`

	AllowedWindowClasses []string `json:"allowed_window_classes,omitempty"`

	ReflectionStatus string `json:"reflection_status,omitempty"`
	ReflectionRecap  string `json:"reflection_recap,omitempty"`
	CarryForward     string `json:"carry_forward,omitempty"`

	EnforcementLevel domain.EnforcementLevel `json:"enforcement_level,omitempty"`
}

// DefaultPath returns ~/.keel/state.json.
func DefaultPath() (string, error) {
	home, err := os.UserHomeDir()
	if err != nil {
		return "", err
	}
	return filepath.Join(home, ".keel", "state.json"), nil
}

// Load reads a snapshot. A missing file yields a default Locked snapshot.
func Load(path string) (Snapshot, error) {
	data, err := os.ReadFile(path)
	if errors.Is(err, os.ErrNotExist) {
		return Snapshot{RuntimeState: domain.RuntimeLocked}, nil
	}
	if err != nil {
		return Snapshot{}, err
	}
	var s Snapshot
	if err := json.Unmarshal(data, &s); err != nil {
		return Snapshot{}, err
	}
	return s, nil
}

// Save writes a snapshot atomically (temp file + rename), creating the
// directory if needed.
func Save(path string, s Snapshot) error {
	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
		return err
	}
	data, err := json.MarshalIndent(s, "", "  ")
	if err != nil {
		return err
	}
	tmp := path + ".tmp"
	if err := os.WriteFile(tmp, data, 0o644); err != nil {
		return err
	}
	return os.Rename(tmp, path)
}