feat(parser): add Omnigent support (#1284)

Supersedes #1167 — same feature, rebuilt as a lean series on the
capability work that landed in #1282/#1283. The comment on #1167 records
what was cut and why.

## What this does

Adds Omnigent to the supported agents. Omnigent stores every conversation
in one SQLite file (`chat.db`), so this follows the same container model
as Zed: sync watches one file, and the archive holds one session per
conversation (`omnigent:0:<hex>`).

- Scheduled syncs reparse the container when its fingerprint (mtime +
  hash of the db and WAL) changes.
- Watcher events do a bounded, indexed scan of only the members whose
  `updated_at` moved, and retire disappeared members as tombstones. WAL
  `-shm` checkpoint noise is ignored.
- Deleting a conversation (or the whole db) tombstones its sessions;
  nothing is destroyed.

## Notes

- Supports the two schema generations that ship in released Omnigent
  builds, including the current binary-uuid one. The oldest shape is
  reported as unsupported without failing sync; the interim
  `session_overrides` shape is not supported.
- `chat.db` co-locates transcripts with authentication secrets, so
  Omnigent is excluded from remote sync (capability from #1282,
  nested-root enforcement from #1283).
- Validated against a chat.db produced by Omnigent's own store code at
  upstream head, not just fixtures (evidence in
  `docs/internal/session-format-sources.md`).
- Known trade-offs (Zed parity): the scheduled reparse scales with
  container size, and edits that don't bump `updated_at` wait for the
  scheduled pass instead of the watcher.

## Where to look

- `internal/parser/omnigent.go` — schema detection and member queries
- `internal/parser/omnigent_provider.go` — discovery, fingerprinting,
  watcher scan, tombstones
- `internal/sync/engine.go` — container scheduling and the
  persistent-archive audit fallback
- `internal/sync/omnigent_integration_test.go` — end-to-end sync coverage


Co-authored-by: Wes McKinney <wesm@users.noreply.github.com>

Author: wesm

README.md

@@ -22,21 +22,26 @@ func TestScheduledReconcileTargetsSelectsOnlyOptedInProviders(t *testing.T) {
 	aiderDir := filepath.Join(home, "aider")
 	coworkDir := filepath.Join(home, "cowork")
 	claudeDir := filepath.Join(home, "claude")
+	omnigentDir := filepath.Join(home, "omnigent")
 	require.NoError(t, os.MkdirAll(aiderDir, 0o755))
 	require.NoError(t, os.MkdirAll(coworkDir, 0o755))
 	require.NoError(t, os.MkdirAll(claudeDir, 0o755))
+	require.NoError(t, os.MkdirAll(omnigentDir, 0o755))
 
 	cfg := config.Config{
 		AgentDirs: map[parser.AgentType][]string{
-			parser.AgentAider:  {aiderDir},
-			parser.AgentCowork: {coworkDir},
-			parser.AgentClaude: {claudeDir},
+			parser.AgentAider:    {aiderDir},
+			parser.AgentCowork:   {coworkDir},
+			parser.AgentClaude:   {claudeDir},
+			parser.AgentOmnigent: {omnigentDir},
 		},
 	}
 	targets := scheduledReconcileTargets(cfg)
-	require.Len(t, targets, 1, "only the opted-in provider is scheduled")
+	require.Len(t, targets, 2, "only opted-in providers are scheduled")
 	assert.Equal(t, parser.AgentAider, targets[0].Agent)
 	assert.Equal(t, []string{aiderDir}, targets[0].Roots)
+	assert.Equal(t, parser.AgentOmnigent, targets[1].Agent)
+	assert.Equal(t, []string{omnigentDir}, targets[1].Roots)
 }
 
 func TestScheduledReconcileDefersUnavailableOptedInRoots(t *testing.T) {

cmd/agentsview/periodic_sync_test.go

@@ -263,6 +263,7 @@ can still be parsed.
 | OpenClaw              | `~/.openclaw/assets/static/agents/` and `~/.kimi_openclaw/assets/static/agents/` | JSONL per session                                                                                                               |
 | OpenCode              | `~/.local/share/opencode/`                                                       | SQLite DB or `storage/` JSON files                                                                                              |
 | OpenHands CLI         | `~/.openhands/conversations/`                                                    | Per-conversation `base_state.json` + `events/*.json`                                                                            |
+| Omnigent              | `~/.omnigent/`                                                                   | SQLite `chat.db`, one session per conversation                                                                                  |
 | Pi                    | `~/.pi/agent/sessions/`                                                          | JSONL per session                                                                                                               |
 | Poolside              | `~/Library/Application Support/poolside/trajectories/` (macOS), `~/.local/state/poolside/trajectories/` (Linux), `%APPDATA%\\poolside\\trajectories\\` (Windows) | NDJSON trajectory files                                                                                                         |
 | Piebald               | `~/.local/share/piebald/`                                                        | SQLite database (`app.db`)                                                                                                      |
@@ -292,6 +293,16 @@ and tool calls). If `chat_history.jsonl` is missing, AgentsView falls back
 to summary-only mode. Set `GROK_DIR` or `grok_dirs` to override the default
 directory.
 
+Omnigent sessions are read from `~/.omnigent/chat.db`. Set `OMNIGENT_DIR` or
+`omnigent_dirs` to override the default directory. AgentsView creates one
+session per conversation and supports the split text-ID and current
+binary-UUID schema generations; the older single-table schema is detected and
+reported as unsupported without losing sessions already synced from it.
+Remote HTTP and SSH sync stay disabled for Omnigent because `chat.db`
+co-locates transcripts with authentication secrets. A metadata-only edit made
+directly in `chat.db` can be deferred by the immediate filesystem-event sync;
+the next scheduled reconciliation pass or an explicit resync picks it up.
+
 **VS Code Copilot default directories** vary by platform:
 
 - **macOS:** `~/Library/Application Support/Code/User/`

docs/configuration.md

@@ -75,9 +75,9 @@ Grok section and remove the explicit registry exception in the coverage test.
   `attachment.type=queued_command` are written mid-stream, in file order
   between consecutive `assistant` records that share one `message.id`, so a
   queued command can fall inside a streaming run that straddles an incremental
-  sync boundary. Reverified 2026-07-23 against the transcript shape reported in
-  [#1238](https://github.com/kenn-io/agentsview/issues/1238): Claude Code for
-  VS Code writes standalone `user` records wrapped in `ide_opened_file` or
+  sync boundary. Reverified 2026-07-23 against the transcript shape reported
+  in [#1238](https://github.com/kenn-io/agentsview/issues/1238): Claude Code
+  for VS Code writes standalone `user` records wrapped in `ide_opened_file` or
   `ide_selection` tags for editor context rather than operator prompts.
 
 ## OpenClaude (`openclaude`)
@@ -228,11 +228,11 @@ Grok section and remove the explicit registry exception in the coverage test.
   from those tokens rather than consuming a persisted USD total.
 - **Working directory:** SQLite sessions store a per-session `directory` and a
   `project_id`. The synthetic `global` project uses `worktree=/`. Agentsview
-  prefers a concrete `session.directory` over `project.worktree` when resolving
-  cwd/project (verified against live `opencode.db` rows under `project_id=global`
-  on 2026-07-23; see #1236).
-- **Invalid tool calls:** Model calls to unknown or malformed tools are
-  recorded as a synthetic `invalid` tool part whose `execute` succeeds
+  prefers a concrete `session.directory` over `project.worktree` when
+  resolving cwd/project (verified against live `opencode.db` rows under
+  `project_id=global` on 2026-07-23; see #1236).
+- **Invalid tool calls:** Model calls to unknown or malformed tools are recorded
+  as a synthetic `invalid` tool part whose `execute` succeeds
   (`packages/opencode/src/tool/invalid.ts`, registered in
   `packages/opencode/src/tool/registry.ts` at the pinned commit), so
   `state.status` is `completed` with the error text in the output. Agentsview
@@ -247,10 +247,10 @@ Grok section and remove the explicit registry exception in the coverage test.
   failure signal. The tool's own output text carries no `exit status N`
   marker, and the shell is `COMSPEC`/`cmd.exe` on Windows, so text-pattern
   matching alone misses these failures on every platform. Agentsview treats a
-  non-zero `state.metadata.exit` on a `bash` tool part as a failure and attaches
-  an errored result event. Only `bash` parts record `exit`; other tools omit the
-  key. Verified 2026-07-24 against a live `opencode.db` where all 24 bash
-  parts with `exit` in `{1, 127, 128}` had output text without an
+  non-zero `state.metadata.exit` on a `bash` tool part as a failure and
+  attaches an errored result event. Only `bash` parts record `exit`; other
+  tools omit the key. Verified 2026-07-24 against a live `opencode.db` where
+  all 24 bash parts with `exit` in `{1, 127, 128}` had output text without an
   `exit status` marker, and the 81 successful parts recorded `exit=0`. Known
   gaps: a command that legitimately exits non-zero (`grep` with no match)
   counts as a failure, matching the existing `exit status N` heuristic, and a
@@ -294,8 +294,8 @@ Grok section and remove the explicit registry exception in the coverage test.
   OpenCode-based rebuild (public beta 2026-03-10, GA 2026-04-02); new sessions
   stopped appearing around 2026-03-21.
 - **Usage and cost:** `ui_messages.json` carries per-request `api_req_started`
-  metadata with input, output, cache-read, and cache-write tokens, explicit USD
-  cost, and `usageMissing` flag. `task_metadata.json` does not carry the
+  metadata with input, output, cache-read, and cache-write tokens, explicit
+  USD cost, and `usageMissing` flag. `task_metadata.json` does not carry the
   RooCode-style ID/token/cost wiring; token and cost totals are derived from
   the transcript itself.
 - **Agentsview:** `internal/parser/kilo_legacy.go` and
@@ -1124,20 +1124,20 @@ Grok section and remove the explicit registry exception in the coverage test.
 - **Upstream:** The public
   [pool release repository](https://github.com/poolsideai/pool) (README,
   changelog, and third-party notices only; no source code) and the
-  [Poolside Agent CLI documentation](https://docs.poolside.ai/cli/pool)
-  were checked 2026-07-23. Upstream confirms sessions are saved
-  automatically and that per-session trajectory files exist (`pool config`
-  prints the trajectory directory; `pool history trajectories` browses
-  them), but publishes neither the on-disk paths nor the NDJSON event
-  schema. The event format was characterized from real trajectory files.
+  [Poolside Agent CLI documentation](https://docs.poolside.ai/cli/pool) were
+  checked 2026-07-23. Upstream confirms sessions are saved automatically and
+  that per-session trajectory files exist (`pool config` prints the trajectory
+  directory; `pool history trajectories` browses them), but publishes neither
+  the on-disk paths nor the NDJSON event schema. The event format was
+  characterized from real trajectory files.
 - **Usage and cost:** Per-inference token counts (`input_tokens`,
-  `output_tokens`, `cache_read_input_tokens`, `cache_write_input_tokens`)
-  are persisted in `tool_call.inference.end` events. The model is recorded
-  in `tool_call.inference.start` and paired by `step_id`. No authoritative
-  USD cost is persisted; Agentsview computes cost from its pricing catalog.
+  `output_tokens`, `cache_read_input_tokens`, `cache_write_input_tokens`) are
+  persisted in `tool_call.inference.end` events. The model is recorded in
+  `tool_call.inference.start` and paired by `step_id`. No authoritative USD
+  cost is persisted; Agentsview computes cost from its pricing catalog.
 - **Agentsview:** `internal/parser/poolside.go` and
-  `internal/parser/poolside_provider.go`; single-file provider with
-  NDJSON line-by-line parsing.
+  `internal/parser/poolside_provider.go`; single-file provider with NDJSON
+  line-by-line parsing.
 
 ## Reasonix (`reasonix`)
 
@@ -1155,3 +1155,53 @@ Grok section and remove the explicit registry exception in the coverage test.
 - **Agentsview:** `internal/parser/reasonix.go` and
   `internal/parser/reasonix_provider.go`; discovery spans multiple roots and
   uses metadata sidecars for identity.
+
+## Omnigent (`omnigent`)
+
+- **Format:** A shared SQLite `chat.db` containing conversations and ordered
+  conversation items, with session metadata and usage stored alongside each
+  conversation.
+- **Evidence:** `source`.
+- **Upstream:** The first-party
+  [database documentation](https://omnigent.ai/docs/deploy/database)
+  identifies SQLite `chat.db` as the local persistence store and was checked
+  2026-07-27. Clone `https://github.com/omnigent-ai/omnigent.git` at
+  `61fd72350ea4c4aba776fbc01c40774079d352e8`. The pinned
+  [conversation schema](https://github.com/omnigent-ai/omnigent/blob/61fd72350ea4c4aba776fbc01c40774079d352e8/omnigent/db/db_models.py),
+  and
+  [store decoding](https://github.com/omnigent-ai/omnigent/blob/61fd72350ea4c4aba776fbc01c40774079d352e8/omnigent/stores/conversation_store/sqlalchemy_store.py)
+  describe persistence. The current schema indexes conversation changes by
+  `(workspace_id, archived, updated_at, id)` rather than a bare `updated_at`
+  index. `session_usage` lives on `omnigent_conversation_metadata`, and both
+  `set_session_usage` and `increment_session_usage` update that metadata row
+  without changing `conversations.updated_at`. The metadata table has runner
+  and project lookup indexes but no modification timestamp or change index.
+  Consequently, the immediate filesystem-event sync can defer a metadata-only
+  edit. The next scheduled reconciliation pass, an explicit resync, or an
+  archive audit reparses the whole changed container and is not limited to a
+  bounded candidate set, so it picks up the edit regardless of how long ago it
+  was made. The pinned
+  [message entity](https://github.com/omnigent-ai/omnigent/blob/61fd72350ea4c4aba776fbc01c40774079d352e8/omnigent/entities/conversation.py)
+  and
+  [deterministic benchmark seeder](https://github.com/omnigent-ai/omnigent/blob/61fd72350ea4c4aba776fbc01c40774079d352e8/dev/benchmarks/omnigent/seed.py)
+  were inspected. The seeder runs the Alembic lineage to head before
+  inserting model-backed rows. Agentsview supports two schema generations
+  observed at that lineage head: the split text-ID generation (session
+  metadata in `omnigent_conversation_metadata`, model overrides in a separate
+  `agent_configuration` table) and the current split binary-UUID generation
+  (16-byte `BLOB` ids, `session_overrides` JSON on `conversations`). The
+  earlier single-table generation, where session metadata columns (including
+  `kind`) lived directly on `conversations` with no separate metadata table,
+  predates that split and is detected-unsupported: Agentsview fails closed
+  with a nonfatal `ErrOmnigentUnsupportedSchema`, skips the container, and
+  preserves any archive rows already synced from it.
+- **Regeneration:** From that checkout, run
+  `uv run dev/benchmarks/omnigent/seed.py --database-uri sqlite:////absolute/temp/path/chat.db --sessions 3 --items-per-session 4 --projects 1 --filed-fraction 1`,
+  then set `OMNIGENT_SOURCE_DB` to the generated file for the opt-in parser
+  test. Never use a live Omnigent data directory.
+- **Usage and cost:** Session usage can contain input and output tokens,
+  per-model breakdowns, and an optional authoritative USD total. An absent
+  cost remains unset so Agentsview can use catalog pricing.
+- **Agentsview:** `internal/parser/omnigent.go` and
+  `internal/parser/omnigent_provider.go`; fixtures under
+  `internal/parser/testdata/omnigent/` provide observed event-shape evidence.

docs/internal/session-format-sources.md

@@ -49,6 +49,7 @@ describe("KNOWN_AGENTS", () => {
       "posit-assistant",
       "roocode",
       "poolside",
+      "omnigent",
     ]);
   });
 
@@ -124,6 +125,9 @@ describe("agentColor", () => {
     expect(agentColor("roocode")).toBe(
       "var(--accent-rose)",
     );
+    expect(agentColor("omnigent")).toBe(
+      "var(--accent-teal)",
+    );
   });
 
   it("falls back to blue for unknown agents", () => {
@@ -200,6 +204,7 @@ describe("agentLabel", () => {
     expect(agentLabel("deepseek-tui")).toBe("DeepSeek TUI");
     expect(agentLabel("qoder")).toBe("Qoder");
     expect(agentLabel("roocode")).toBe("RooCode");
+    expect(agentLabel("omnigent")).toBe("Omnigent");
   });
 
   it("capitalizes simple agent names", () => {

frontend/src/lib/utils/agents.test.ts

@@ -75,6 +75,7 @@ export const KNOWN_AGENTS: readonly AgentMeta[] = [
   },
   { name: "roocode", color: "var(--accent-rose)", label: "RooCode" },
   { name: "poolside", color: "var(--accent-cyan)", label: "Poolside" },
+  { name: "omnigent", color: "var(--accent-teal)", label: "Omnigent" },
 ];
 
 const agentColorMap = new Map(

frontend/src/lib/utils/agents.ts

@@ -32,6 +32,7 @@ type SessionBatchResult struct {
 	ExcludedSessions int
 	ExcludedIDs      []string
 	FailedSessions   int
+	FailedIDs        []string
 	Errors           []error
 }
 
@@ -109,6 +110,7 @@ func (db *DB) WriteSessionBatch(
 				return result, rerr
 			}
 			result.FailedSessions++
+			result.FailedIDs = append(result.FailedIDs, write.Session.ID)
 			result.Errors = append(result.Errors, err)
 		}
 	}

internal/db/session_batch.go

@@ -2270,6 +2270,85 @@ func (db *DB) ListSessionIDsByFilePath(path, agent string) ([]string, error) {
 	return ids, nil
 }
 
+const descendantSessionRootBatchSize = 100
+
+// ListActiveDescendantSessionSourcePaths returns the source paths of active
+// descendants already linked beneath parentIDs. Both the seed and recursive
+// steps use idx_sessions_parent, so work scales with the affected subagent
+// trees rather than every archived session.
+func (db *DB) ListActiveDescendantSessionSourcePaths(
+	ctx context.Context,
+	machine, agent string,
+	parentIDs []string,
+) ([]string, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	seen := make(map[string]struct{})
+	var paths []string
+	for start := 0; start < len(parentIDs); start += descendantSessionRootBatchSize {
+		end := min(start+descendantSessionRootBatchSize, len(parentIDs))
+		batch := parentIDs[start:end]
+		placeholders := strings.TrimSuffix(strings.Repeat("?,", len(batch)), ",")
+		query := `
+			WITH RECURSIVE descendants(id, file_path) AS (
+				SELECT id, file_path
+				  FROM sessions INDEXED BY idx_sessions_parent
+				 WHERE parent_session_id IS NOT NULL
+				   AND parent_session_id IN (` + placeholders + `)
+				   AND machine = ? AND agent = ? AND deleted_at IS NULL
+				UNION
+				SELECT s.id, s.file_path
+				  FROM sessions AS s INDEXED BY idx_sessions_parent
+				  JOIN descendants AS d ON s.parent_session_id = d.id
+				 WHERE s.parent_session_id IS NOT NULL
+				   AND s.machine = ? AND s.agent = ? AND s.deleted_at IS NULL
+			)
+			SELECT file_path
+			  FROM descendants
+			 WHERE file_path IS NOT NULL AND file_path <> ''
+			 ORDER BY file_path`
+		args := make([]any, 0, len(batch)+4)
+		for _, id := range batch {
+			args = append(args, id)
+		}
+		args = append(args, machine, agent, machine, agent)
+		rows, err := db.getReader().QueryContext(ctx, query, args...)
+		if err != nil {
+			return nil, fmt.Errorf(
+				"listing active descendant session sources: %w", err,
+			)
+		}
+		for rows.Next() {
+			var path string
+			if err := rows.Scan(&path); err != nil {
+				_ = rows.Close()
+				return nil, fmt.Errorf(
+					"scanning active descendant session source: %w", err,
+				)
+			}
+			if _, exists := seen[path]; exists {
+				continue
+			}
+			seen[path] = struct{}{}
+			paths = append(paths, path)
+		}
+		if err := rows.Err(); err != nil {
+			_ = rows.Close()
+			return nil, fmt.Errorf(
+				"iterating active descendant session sources: %w", err,
+			)
+		}
+		if err := rows.Close(); err != nil {
+			return nil, fmt.Errorf(
+				"closing active descendant session sources: %w", err,
+			)
+		}
+	}
+	sort.Strings(paths)
+	return paths, nil
+}
+
 const storedSourcePathHintRootBatchSize = 100
 
 // StoredSourcePathHintScope identifies one affected stored-source prefix.

internal/db/sessions.go

@@ -67,6 +67,11 @@ func TestProviderSyncSemanticsDeclarations(t *testing.T) {
 		AgentIcodemate: {
 			UnchangedResults: UnchangedResultMTimeAndHash,
 		},
+		AgentOmnigent: {
+			FingerprintHashInCacheKey:           true,
+			FingerprintHashRequiredForFreshness: true,
+			UnchangedResults:                    UnchangedResultMTimeAndHash,
+		},
 	}
 
 	for _, factory := range ProviderFactories() {

internal/parser/capabilities_sync_test.go

@@ -611,7 +611,9 @@ func (s kiroSourceSet) Fingerprint(
 		MTimeNS: info.ModTime().UnixNano(),
 	}
 	if src.Kind == kiroSourceSQLiteDB {
-		if compositeMtime, err := sqliteDBCompositeMtime(src.DBPath); err == nil {
+		if compositeMtime, err := sqliteDBCompositeMtime(
+			src.DBPath, sqliteDBJournalSuffixes,
+		); err == nil {
 			fingerprint.MTimeNS = compositeMtime
 		}
 		return fingerprint, nil