pg push service (#547)

## Problem

I track token usage across AI tools with agentsview, and lately I've
been
running more remote agent tools on machines other than my primary dev
box.
Each of those machines records its own sessions locally. The Postgres
support
(`pg push` / `pg serve`) already lets me review everything together, but
keeping the shared database current meant either remembering to run `pg
push`
by hand on each machine or wiring up a bespoke cron job per host. I
wanted a
touchless way to sync data from multiple machines into one place so
remote
agent token usage shows up in my primary dashboard automatically,
without
  maintaining custom cron entries everywhere.

I also made some updates to hermes specific code because although tokens
were being passed through, the associated costs were not being
aggregated
  properly.

  ## pg push service 

A long-running auto-push daemon and a first-class way to install it as
an OS
service, so a recorder machine keeps the shared Postgres current on its
own.

**`agentsview pg push --watch`** start a foreground daemon that pushes
to Postgres
  shortly after sessions change, with a periodic floor as a safety net:

- A file watcher (reusing the same machinery as `serve`) coalesces
change
events over a debounce window (`--debounce`, default 30s) and triggers a
    local sync + incremental push.
- A periodic floor (`--interval`, default 15m) pushes regardless of file
    events and covers any directories the watch budget couldn't cover.
- Pushes are serialized by a single goroutine and connect to Postgres
lazily,
reconnecting on error. A transiently unreachable database is logged and
    retried on the next trigger rather than crashing the daemon.
  - A single-instance lock prevents two watchers from racing on the push
watermarks. On shutdown (SIGINT/SIGTERM) it performs one bounded final
flush.
- It reads the same `[pg]` config and project filters as `pg push`, and
honors `result_content_blocked_categories` so the push path no longer
    diverges from `serve`.
  
  **`agentsview pg service install|uninstall|status|start|stop|logs`**
  installs and manages the daemon as a per-user OS service:

- launchd LaunchAgent on macOS, `systemd --user` unit on Linux, behind a
small
    platform abstraction with pure (golden-tested) unit-file rendering.
- `install` validates that the Postgres DSN is resolvable before
creating the
service, and surfaces the systemd linger requirement so the service
keeps
    running on headless boxes after logout.
- `status` reports the manager state plus the last successful push time;
    `logs -f` tails the daemon log and survives log rotation.

The daemon reads the DSN from the existing config file (no credentials
are
  copied into unit files), so protecting `config.toml` is sufficient.

  ## Notes

- Platform support targets macOS (launchd) and Linux (`systemd --user`);
the
    daemon command itself is cross-platform Go.
- The generated unit always pins `AGENTSVIEW_DATA_DIR` to the
install-time data
dir, so the service resolves the same config regardless of the
environment it
    starts in.
- The watch daemon's initial resync is push-oriented and skips the
serve-side
`Vacuum`/`BackfillSignals` steps, since signal recomputation happens on
the
    serve side.
- A windows service was not added because I don't currently have access
to a
     windows machine that I could use for testing.

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: mxfeinberg

.gitignore

@@ -63,4 +63,7 @@ html/
 
 # Antigravity CLI session dir created when AGY runs inside this repo
 .antigravitycli/
+
+# graphify knowledge-graph output (local analysis)
+graphify-out/
 .kata.local.toml

README.md

@@ -283,6 +283,45 @@ agentsview pg push       # push local data to PG
 agentsview pg serve      # serve web UI from PG (read-only)
 ```
 
+### Automatic push (background service)
+
+To keep a shared PostgreSQL database current without running `pg push` by
+hand, run the auto-push daemon. It watches your session directories and
+pushes shortly after new sessions are recorded, with a periodic floor as a
+safety net:
+
+```bash
+agentsview pg push --watch                 # foreground, Ctrl-C to stop
+agentsview pg push --watch --debounce 1m   # custom coalesce window
+agentsview pg push --watch --interval 5m   # custom floor interval
+```
+
+The daemon reads the same `[pg]` config as `pg push`, so the PostgreSQL
+DSN must be set in your config file (or an environment variable it
+expands). Protect the config file, since it holds credentials:
+
+```bash
+chmod 600 ~/.agentsview/config.toml
+```
+
+To run it unattended as an OS service (launchd on macOS,
+`systemd --user` on Linux):
+
+```bash
+agentsview pg service install     # generate the unit, enable + start it
+agentsview pg service status      # show manager status
+agentsview pg service logs -f     # follow the service log
+agentsview pg service uninstall   # stop and remove
+```
+
+**Linux headless machines:** systemd `--user` services stop at logout and
+do not start at boot unless lingering is enabled for your user. `install`
+detects this and prints the command; you can also run it yourself:
+
+```bash
+loginctl enable-linger "$USER"
+```
+
 See [PostgreSQL docs](https://agentsview.io/postgresql/) for setup and
 configuration.
 

cmd/agentsview/cli.go

@@ -350,6 +350,7 @@ func newPGCommand() *cobra.Command {
 	cmd.AddCommand(newPGPushCommand())
 	cmd.AddCommand(newPGStatusCommand())
 	cmd.AddCommand(newPGServeCommand())
+	cmd.AddCommand(newPGServiceCommand())
 	return cmd
 }
 
@@ -361,13 +362,24 @@ func newPGPushCommand() *cobra.Command {
 		SilenceUsage: true,
 		Args:         cobra.NoArgs,
 		Run: func(cmd *cobra.Command, args []string) {
+			if cfg.Watch {
+				runPGPushWatch(cfg)
+				return
+			}
+			if cmd.Flags().Changed("debounce") || cmd.Flags().Changed("interval") {
+				fmt.Fprintln(os.Stderr,
+					"warning: --debounce and --interval have no effect without --watch")
+			}
 			runPGPush(cfg)
 		},
 	}
 	cmd.Flags().BoolVar(&cfg.Full, "full", false, "Force full local resync and PG push")
 	cmd.Flags().StringVar(&cfg.ProjectsFlag, "projects", "", "Comma-separated list of projects to push (inclusive)")
 	cmd.Flags().StringVar(&cfg.ExcludeProjects, "exclude-projects", "", "Comma-separated list of projects to exclude from push")
 	cmd.Flags().BoolVar(&cfg.AllProjects, "all-projects", false, "Ignore configured project filters for this run")
+	cmd.Flags().BoolVar(&cfg.Watch, "watch", false, "Run continuously, pushing on change plus a periodic floor")
+	cmd.Flags().DurationVar(&cfg.Debounce, "debounce", defaultWatchDebounce, "Coalesce window after a change before pushing (--watch only)")
+	cmd.Flags().DurationVar(&cfg.Interval, "interval", defaultWatchInterval, "Periodic floor push interval (--watch only)")
 	return cmd
 }
 

cmd/agentsview/main.go

@@ -253,7 +253,11 @@ func runServe(cfg config.Config) {
 	fmt.Printf("Database: %s\n", cfg.DBPath)
 
 	if engine != nil {
-		stopWatcher, unwatchedDirs := startFileWatcher(cfg, engine)
+		stopWatcher, unwatchedDirs := startFileWatcher(
+			cfg, engine, func(paths []string) {
+				engine.SyncPaths(paths)
+			},
+		)
 		defer stopWatcher()
 		if len(unwatchedDirs) > 0 {
 			go startUnwatchedPoll(engine)
@@ -281,7 +285,13 @@ func mustLoadConfig(cmd *cobra.Command) config.Config {
 const maxLogSize = 10 * 1024 * 1024 // 10 MB
 
 func setupLogFile(dataDir string) {
-	logPath := filepath.Join(dataDir, "debug.log")
+	setupLogFileNamed(dataDir, "debug.log")
+}
+
+// setupLogFileNamed redirects the standard logger to the named file
+// in dataDir, truncating it first if it exceeds maxLogSize.
+func setupLogFileNamed(dataDir, name string) {
+	logPath := filepath.Join(dataDir, name)
 	truncateLogFile(logPath, maxLogSize)
 	f, err := os.OpenFile(
 		logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644,
@@ -443,12 +453,9 @@ func printSyncProgress(p sync.Progress) {
 }
 
 func startFileWatcher(
-	cfg config.Config, engine *sync.Engine,
+	cfg config.Config, engine *sync.Engine, onChange func(paths []string),
 ) (stopWatcher func(), unwatchedDirs []string) {
 	t := time.Now()
-	onChange := func(paths []string) {
-		engine.SyncPaths(paths)
-	}
 	watcher, err := sync.NewWatcher(watcherDebounce, onChange, cfg.WatchExcludePatterns)
 	if err != nil {
 		log.Printf(

cmd/agentsview/pg.go

@@ -24,19 +24,12 @@ type PGPushConfig struct {
 	ProjectsFlag    string
 	ExcludeProjects string
 	AllProjects     bool
+	Watch           bool
+	Debounce        time.Duration
+	Interval        time.Duration
 }
 
 func runPGPush(cfg PGPushConfig) {
-	if cfg.ProjectsFlag != "" && cfg.ExcludeProjects != "" {
-		fatal("pg push: --projects and --exclude-projects " +
-			"are mutually exclusive")
-	}
-	if cfg.AllProjects &&
-		(cfg.ProjectsFlag != "" || cfg.ExcludeProjects != "") {
-		fatal("pg push: --all-projects cannot be combined " +
-			"with --projects or --exclude-projects")
-	}
-
 	appCfg, err := config.LoadMinimal()
 	if err != nil {
 		log.Fatalf("loading config: %v", err)
@@ -54,28 +47,9 @@ func runPGPush(cfg PGPushConfig) {
 		fatal("pg push: url not configured")
 	}
 
-	// CLI flags override config values entirely. When either
-	// flag is set, clear both config-derived lists so a CLI
-	// include can override a config exclude (and vice versa).
-	// --all-projects clears both lists for an unfiltered push.
-	projects := pgCfg.Projects
-	excludeProjects := pgCfg.ExcludeProjects
-	if cfg.AllProjects {
-		projects = nil
-		excludeProjects = nil
-	}
-	if cfg.ProjectsFlag != "" {
-		projects = splitProjectList(cfg.ProjectsFlag)
-		excludeProjects = nil
-	}
-	if cfg.ExcludeProjects != "" {
-		excludeProjects = splitProjectList(cfg.ExcludeProjects)
-		projects = nil
-	}
-
-	if len(projects) > 0 && len(excludeProjects) > 0 {
-		fatal("pg push: projects and exclude_projects " +
-			"are mutually exclusive")
+	projects, excludeProjects, err := resolvePushProjects(pgCfg, cfg)
+	if err != nil {
+		fatal("pg push: %v", err)
 	}
 
 	applyClassifierConfig(appCfg)
@@ -363,6 +337,47 @@ func runPGServe(appCfg config.Config, basePath string) {
 	}
 }
 
+// resolvePushProjects merges configured project filters with CLI
+// flag overrides. A CLI include or exclude flag fully replaces the
+// configured lists; --all-projects clears both. Include and exclude
+// are mutually exclusive.
+func resolvePushProjects(
+	pgCfg config.PGConfig, cfg PGPushConfig,
+) (projects, exclude []string, err error) {
+	if cfg.ProjectsFlag != "" && cfg.ExcludeProjects != "" {
+		return nil, nil, fmt.Errorf(
+			"--projects and --exclude-projects are mutually exclusive",
+		)
+	}
+	if cfg.AllProjects &&
+		(cfg.ProjectsFlag != "" || cfg.ExcludeProjects != "") {
+		return nil, nil, fmt.Errorf(
+			"--all-projects cannot be combined with " +
+				"--projects or --exclude-projects",
+		)
+	}
+	projects = pgCfg.Projects
+	exclude = pgCfg.ExcludeProjects
+	if cfg.AllProjects {
+		projects = nil
+		exclude = nil
+	}
+	if cfg.ProjectsFlag != "" {
+		projects = splitProjectList(cfg.ProjectsFlag)
+		exclude = nil
+	}
+	if cfg.ExcludeProjects != "" {
+		exclude = splitProjectList(cfg.ExcludeProjects)
+		projects = nil
+	}
+	if len(projects) > 0 && len(exclude) > 0 {
+		return nil, nil, fmt.Errorf(
+			"projects and exclude_projects are mutually exclusive",
+		)
+	}
+	return projects, exclude, nil
+}
+
 // splitProjectList splits a comma-separated string into trimmed,
 // non-empty project names.
 func splitProjectList(s string) []string {