oh-my-opencode 4.19.1 → 4.19.3

package/packages/omo-codex/plugin/shared/test/config-loader.test.ts

@@ -1,9 +1,14 @@
 import { afterEach, describe, expect, it } from "bun:test"
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs"
 import { tmpdir } from "node:os"
-import { join } from "node:path"
+import { join, posix } from "node:path"
 
-import { getCodexOmoConfig } from "../src/config-loader.ts"
+import { parse } from "jsonc-parser"
+
+import { runMigrations, type MigrationBoundary } from "../../../../omo-config-core/src/index.ts"
+import { createLegacyConfigMigrationPlans } from "../../../../omo-opencode/src/config-migration/index.ts"
+
+import { getCodexOmoConfig, runCodexStartupMigration } from "../src/config-loader.ts"
 
 const temporaryDirectories: string[] = []
 
@@ -14,11 +19,51 @@ function createTemporaryDirectory(prefix: string): string {
 }
 
 function writeOmoConfig(homeDir: string, content: string): void {
+	const configDir = join(homeDir, ".omo")
+	mkdirSync(configDir, { recursive: true })
+	writeFileSync(join(configDir, "omo.jsonc"), content)
+}
+
+function writeLegacyOmoConfig(homeDir: string, content: string): void {
 	const configDir = join(homeDir, ".omo")
 	mkdirSync(configDir, { recursive: true })
 	writeFileSync(join(configDir, "config.jsonc"), content)
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function readOmoJson(homeDir: string): Record<string, unknown> {
+	const value: unknown = parse(readFileSync(join(homeDir, ".omo", "omo.jsonc"), "utf-8"))
+	if (!isRecord(value)) throw new Error("Expected an omo JSONC object")
+	return value
+}
+
+function writeOpenCodeConfig(homeDir: string): void {
+	const configDir = join(homeDir, ".config", "opencode")
+	mkdirSync(configDir, { recursive: true })
+	writeFileSync(join(configDir, "oh-my-openagent.jsonc"), '{"agents":{"finder":{"model":"provider/finder"}}}')
+}
+
+function runOpenCodeMigration(homeDir: string, cwd: string, onBoundary?: (boundary: MigrationBoundary) => void): void {
+	runMigrations({
+		discover: () => createLegacyConfigMigrationPlans({
+			cwd,
+			environment: { HOME: homeDir, XDG_CONFIG_HOME: join(homeDir, ".config") },
+			homeDir,
+			pathOperations: posix,
+		}),
+		env: { HOME: homeDir },
+		...(onBoundary === undefined ? {} : { onBoundary }),
+	})
+}
+
+function migrationIds(homeDir: string): readonly string[] {
+	const migrations = readOmoJson(homeDir)["_migrations"]
+	return Array.isArray(migrations) ? migrations.filter((entry): entry is string => typeof entry === "string") : []
+}
+
 afterEach(() => {
 	for (const directory of temporaryDirectories.splice(0)) {
 		rmSync(directory, { recursive: true, force: true })
@@ -45,6 +90,7 @@ describe("getCodexOmoConfig", () => {
 		// then
 		expect(result.codegraph).toEqual({
 			auto_provision: true,
+			daemon: true,
 			enabled: false,
 			install_dir: "/base",
 			telemetry: false,
@@ -85,7 +131,21 @@ describe("getCodexOmoConfig", () => {
 		expect(result.codegraph?.excluded_roots).toEqual(["/tmp/omo-research", "/private/tmp/omo-research"])
 	})
 
-	it("#given no codegraph.daemon key #when loading config #then daemon defaults to off", () => {
+	it("#given codex SOT sets the SessionStart cooldown #when loading config #then the configured base interval is returned", () => {
+		// given
+		const homeDir = createTemporaryDirectory("omo-codex-shared-cooldown-home-")
+		const cwd = createTemporaryDirectory("omo-codex-shared-cooldown-project-")
+		writeOmoConfig(homeDir, JSON.stringify({ "[codex]": { codegraph: { session_start_cooldown_ms: 900_000 } } }))
+
+		// when
+		const result = getCodexOmoConfig({ cwd, homeDir, env: {} })
+
+		// then
+		expect(result.codegraph?.session_start_cooldown_ms).toBe(900_000)
+		expect(result.warnings).toEqual([])
+	})
+
+	it("#given no codegraph.daemon key #when loading config #then daemon defaults to on", () => {
 		// given
 		const homeDir = createTemporaryDirectory("omo-codex-shared-daemon-default-home-")
 		const cwd = createTemporaryDirectory("omo-codex-shared-daemon-default-project-")
@@ -95,22 +155,21 @@ describe("getCodexOmoConfig", () => {
 		const result = getCodexOmoConfig({ cwd, homeDir, env: {} })
 
 		// then
-		expect(result.codegraph?.daemon).toBeUndefined()
-		expect(result.codegraph?.daemon === true).toBe(false)
+		expect(result.codegraph?.daemon).toBe(true)
 		expect(result.warnings).toEqual([])
 	})
 
-	it("#given codex SOT sets codegraph.daemon=true #when loading config #then daemon opt-in is returned", () => {
+	it("#given codex SOT sets codegraph.daemon=false #when loading config #then daemon opt-out is returned", () => {
 		// given
-		const homeDir = createTemporaryDirectory("omo-codex-shared-daemon-on-home-")
-		const cwd = createTemporaryDirectory("omo-codex-shared-daemon-on-project-")
-		writeOmoConfig(homeDir, JSON.stringify({ "[codex]": { codegraph: { daemon: true } } }))
+		const homeDir = createTemporaryDirectory("omo-codex-shared-daemon-off-home-")
+		const cwd = createTemporaryDirectory("omo-codex-shared-daemon-off-project-")
+		writeOmoConfig(homeDir, JSON.stringify({ "[codex]": { codegraph: { daemon: false } } }))
 
 		// when
 		const result = getCodexOmoConfig({ cwd, homeDir, env: {} })
 
 		// then
-		expect(result.codegraph?.daemon).toBe(true)
+		expect(result.codegraph?.daemon).toBe(false)
 		expect(result.warnings).toEqual([])
 	})
 
@@ -124,25 +183,25 @@ describe("getCodexOmoConfig", () => {
 		const result = getCodexOmoConfig({ cwd, homeDir, env: {} })
 
 		// then
-		expect(result.codegraph?.daemon).toBeUndefined()
-		expect(result.warnings).toContain("config.[codex].codegraph.daemon must be a boolean")
+		expect(result.codegraph?.daemon).toBe(true)
+		expect(result.warnings).toContain(`Invalid omo config at ${join(homeDir, ".omo", "omo.jsonc")}: [codex].codegraph.daemon`)
 	})
 
 	it("#given legacy env override and SOT value #when loading config #then env wins over the SOT", () => {
 		// given
 		const homeDir = createTemporaryDirectory("omo-codex-shared-env-")
 		const cwd = createTemporaryDirectory("omo-codex-project-env-")
-		writeOmoConfig(homeDir, JSON.stringify({ codegraph: { enabled: true } }))
+		writeOmoConfig(homeDir, JSON.stringify({ codegraph: { enabled: false } }))
 
 		// when
 		const result = getCodexOmoConfig({
 			cwd,
 			homeDir,
-			env: { CODEX_CODEGRAPH_ENABLED: "0" },
+			env: { CODEX_CODEGRAPH_ENABLED: "1" },
 		})
 
 		// then
-		expect(result.codegraph?.enabled).toBe(false)
+		expect(result.codegraph?.enabled).toBe(true)
 	})
 
 	it("#given no SOT files #when loading config #then returns built-in defaults and missing global source", () => {
@@ -156,14 +215,15 @@ describe("getCodexOmoConfig", () => {
 		// then
 		expect(result.codegraph).toEqual({
 			auto_provision: true,
+			daemon: true,
 			enabled: true,
 			telemetry: false,
 		})
 		expect(result.sources).toContainEqual({
 			exists: false,
 			loaded: false,
-			path: join(homeDir, ".omo", "config.jsonc"),
-			scope: "global",
+			path: join(homeDir, ".omo", "omo.jsonc"),
+			scope: "user",
 		})
 	})
 
@@ -179,4 +239,122 @@ describe("getCodexOmoConfig", () => {
 		// then
 		expect(result.warnings).toContain("codegraph.watch_debounce_ms is not supported for harness codex")
 	})
+
+	it("#given only legacy config.jsonc #when codex starts #then migrates once with a backup before loading the unified codex view", () => {
+		// given
+		const homeDir = createTemporaryDirectory("omo-codex-legacy-upgrade-")
+		writeLegacyOmoConfig(homeDir, JSON.stringify({ "[codex]": { codegraph: { daemon: false } } }))
+		const legacyPath = join(homeDir, ".omo", "config.jsonc")
+
+		// when
+		const first = getCodexOmoConfig({ cwd: homeDir, homeDir, env: {} })
+		const backupDirectories = readdirSync(join(homeDir, ".omo")).filter((entry) => entry.startsWith("migration-backup-"))
+		const second = getCodexOmoConfig({ cwd: homeDir, homeDir, env: {} })
+
+		// then
+		expect(first.codegraph?.daemon).toBe(false)
+		expect(first.warnings.some((warning) => warning.startsWith("omo-codex: migrated legacy configuration from ")
+			&& warning.endsWith("/.omo/config.jsonc"))).toBe(true)
+		expect(readOmoJson(homeDir)["_migrations"]).toEqual(["2026-07-codex-config-jsonc"])
+		expect(existsSync(legacyPath)).toBe(false)
+		expect(backupDirectories).toHaveLength(1)
+		expect(existsSync(join(homeDir, ".omo", backupDirectories[0] ?? "", ".omo", "config.jsonc"))).toBe(true)
+		expect(second.warnings.some((warning) => warning.startsWith("omo-codex: migrated legacy configuration from "))).toBe(false)
+		expect(readdirSync(join(homeDir, ".omo")).filter((entry) => entry.startsWith("migration-backup-"))).toEqual(backupDirectories)
+	})
+
+	it("#given a legacy migration conflict #when codex starts #then exposes the migration summary and conflict through loader warnings", () => {
+		// given
+		const homeDir = createTemporaryDirectory("omo-codex-legacy-conflict-")
+		writeOmoConfig(homeDir, JSON.stringify({ codegraph: { enabled: true } }))
+		writeLegacyOmoConfig(homeDir, JSON.stringify({ codegraph: { enabled: false } }))
+
+		// when
+		const result = getCodexOmoConfig({ cwd: homeDir, homeDir, env: {} })
+
+		// then
+		expect(result.warnings.some((warning) => warning.startsWith("omo-codex: migrated legacy configuration from ")
+			&& warning.endsWith("/.omo/config.jsonc"))).toBe(true)
+		expect(result.warnings).toContain("omo-codex: configuration migration: skipped: codegraph.enabled legacy=false kept=true")
+	})
+
+	it("#given overlapping [omo] and [senpi] blocks in legacy config #when Codex migrates #then the transform conflict is reported", () => {
+		// given
+		const homeDir = createTemporaryDirectory("omo-codex-legacy-senpi-conflict-")
+		writeLegacyOmoConfig(homeDir, JSON.stringify({
+			"[omo]": { agents: { oracle: { model: "legacy" } } },
+			"[senpi]": { agents: { oracle: { model: "current" } } },
+		}))
+
+		// when
+		const result = runCodexStartupMigration({ cwd: homeDir, environment: { HOME: homeDir }, homeDir })
+
+		// then
+		expect(result.results[0]?.diagnostics).toContain("conflict: [senpi] legacy [omo] kept [senpi]")
+	})
+
+	it("#given a malformed migration journal #when codex starts #then exposes the recovery failure through loader warnings", () => {
+		// given
+		const homeDir = createTemporaryDirectory("omo-codex-recovery-warning-")
+		const migrationDir = join(homeDir, ".omo")
+		mkdirSync(migrationDir, { recursive: true })
+		writeFileSync(join(migrationDir, ".migration-journal.json"), "not-json")
+
+		// when
+		const result = getCodexOmoConfig({ cwd: homeDir, homeDir, env: {} })
+
+		// then
+		expect(result.warnings.some((warning) => warning.startsWith("omo-codex: configuration migration: "))).toBe(true)
+	})
+
+	it("#given codex starts before opencode #when both legacy source groups exist #then each distinct migration id is applied once", () => {
+		// given
+		const homeDir = createTemporaryDirectory("omo-codex-order-codex-first-")
+		writeLegacyOmoConfig(homeDir, JSON.stringify({ "[codex]": { codegraph: { daemon: false } } }))
+		writeOpenCodeConfig(homeDir)
+		const openCodeSource = join(homeDir, ".config", "opencode", "oh-my-openagent.jsonc")
+
+		// when
+		getCodexOmoConfig({ cwd: homeDir, homeDir, env: {} })
+		const remainsAfterCodexStartup = existsSync(openCodeSource)
+		runOpenCodeMigration(homeDir, homeDir)
+
+		// then
+		expect(remainsAfterCodexStartup).toBe(true)
+		expect(existsSync(openCodeSource)).toBe(false)
+		expect(migrationIds(homeDir)).toEqual(["2026-07-codex-config-jsonc", "2026-07-opencode-config-unification"])
+	})
+
+	it("#given opencode starts before codex #when both legacy source groups exist #then each distinct migration id is applied once", () => {
+		// given
+		const homeDir = createTemporaryDirectory("omo-codex-order-opencode-first-")
+		writeLegacyOmoConfig(homeDir, JSON.stringify({ "[codex]": { codegraph: { daemon: false } } }))
+		writeOpenCodeConfig(homeDir)
+
+		// when
+		runOpenCodeMigration(homeDir, homeDir)
+		getCodexOmoConfig({ cwd: homeDir, homeDir, env: {} })
+
+		// then
+		expect(migrationIds(homeDir)).toEqual(["2026-07-opencode-config-unification", "2026-07-codex-config-jsonc"])
+	})
+
+	it("#given concurrent codex and opencode starts #when opencode owns the shared lock #then both migration ids are applied exactly once", () => {
+		// given
+		const homeDir = createTemporaryDirectory("omo-codex-order-concurrent-")
+		writeLegacyOmoConfig(homeDir, JSON.stringify({ "[codex]": { codegraph: { daemon: false } } }))
+		writeOpenCodeConfig(homeDir)
+		let codexResult: ReturnType<typeof runCodexStartupMigration> | undefined
+
+		// when
+		runOpenCodeMigration(homeDir, homeDir, (boundary) => {
+			if (boundary !== "journal-written" || codexResult !== undefined) return
+			codexResult = runCodexStartupMigration({ cwd: homeDir, homeDir })
+		})
+
+		// then
+		if (codexResult === undefined) throw new Error("Expected concurrent Codex migration attempt")
+		expect(codexResult.error).toBe("Configuration migration is already running")
+		expect(migrationIds(homeDir)).toEqual(["2026-07-opencode-config-unification", "2026-07-codex-config-jsonc"])
+	})
 })

package/packages/omo-codex/plugin/skills/coding-agent-sessions/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: coding-agent-sessions
-description: "MUST USE when asked to find, read, list, search, inspect, fetch, export, or reconstruct coding-agent sessions across Codex, Claude Code/Desktop, OpenCode, Senpi/pi, OpenClaw, Factory Droid, Amp, Gemini/Kimi/Qwen CLIs, Codebuff, Roo/Kilo/Cline, Kodu, Cursor CLI, Aider, or unknown local agent logs. Covers transcripts, session IDs, rollout JSONL, state SQLite, Claude projects/pre-compact histories, OpenCode messages/parts, child/subagent linkage, cwd/model/time/token filters, archives, and cost clues. Expands fuzzy recall into parallel query lanes and first probes known stores so absent platforms are skipped cheaply. Triggers: coding agent sessions, Codex/Claude/OpenCode/Senpi/pi/OpenClaw/Droid/Amp/Kodu/Cursor/Aider sessions, transcript search, session history, session ID, read transcript, token usage, subagent sessions, what did I do yesterday, did we already do this."
+description: "MUST USE when asked to find, read, list, search, inspect, fetch, export, or reconstruct coding-agent sessions across Codex, Claude Code/Desktop, OpenCode, Senpi/pi, oh-my-pi (omp), gajae-code (gjc), OpenClaw, Factory Droid, Amp, Gemini/Kimi/Qwen CLIs, Codebuff, Roo/Kilo/Cline, Kodu, Cursor CLI, Aider, or unknown local agent logs. Covers transcripts, session IDs, rollout JSONL, state SQLite, Claude projects/pre-compact histories, OpenCode messages/parts, child/subagent linkage, cwd/model/time/token filters, archives, and cost clues. Expands fuzzy recall into parallel query lanes and first probes known stores so absent platforms are skipped cheaply. Triggers: coding agent sessions, Codex/Claude/OpenCode/Senpi/pi/oh-my-pi/omp/gajae-code/gjc/OpenClaw/Droid/Amp/Kodu/Cursor/Aider sessions, transcript search, session history, session ID, read transcript, token usage, subagent sessions, what did I do yesterday, did we already do this."
 ---
 
 # Coding Agent Sessions
@@ -16,6 +16,7 @@ Find local coding-agent sessions across agent products before answering from mem
    | Codex / OpenAI Codex CLI | `references/codex.md` |
    | Claude Code / Claude Desktop histories | `references/claude.md` |
    | Senpi / pi coding-agent logs | `references/senpi.md` |
+   | oh-my-pi (`omp`, `~/.omp`) and gajae-code (`gjc`, `~/.gjc`) logs | `references/senpi.md` |
    | OpenCode / oh-my-openagent (formerly oh-my-opencode) storage | `references/opencode.md` |
    | OpenClaw, Droid, Amp, Gemini, Kimi, Qwen, Codebuff, Roo/Kilo/Cline, Kodu, Cursor CLI, Aider, Kiro, Goose, Hermes, Crush, Zed | `references/all-platforms.md` |
    | Unknown / "any session" / cross-agent search | `references/all-platforms.md` |
@@ -28,6 +29,7 @@ When the user remembers a task vaguely ("that OpenCode bug", "the dashboard PR",
 python3 scripts/find-agent-sessions.py list --limit 20
 python3 scripts/find-agent-sessions.py find "commit" --from 7d --platform senpi --platform opencode
 python3 scripts/find-agent-sessions.py find "proxy" --platform openclaw --platform droid --platform amp
+python3 scripts/find-agent-sessions.py find "refactor" --platform oh-my-pi --platform gajae-code
 python3 scripts/find-agent-sessions.py find --query "deploy" --query "token usage" --workers 64
 python3 scripts/find-agent-sessions.py find --query "opencode bug" --query "fix opencode" --query "OpenCode parent session" --include-subagents --workers 64
 python3 scripts/find-agent-sessions.py read <session-id>
@@ -49,7 +51,7 @@ The finder prints JSON for stdout and `jq`. Every result includes:
 
 | Field | Meaning |
 |---|---|
-| `platform` | Registered platform key such as `codex`, `claude`, `opencode`, `openclaw`, `droid`, `amp`, `kodu`, `cursor-cli`, `aider`, `roo-code`, `kilo-code`, `kilo-cli`, or `kiro` |
+| `platform` | Registered platform key such as `codex`, `claude`, `senpi`, `oh-my-pi`, `gajae-code`, `opencode`, `openclaw`, `droid`, `amp`, `kodu`, `cursor-cli`, `aider`, `roo-code`, `kilo-code`, `kilo-cli`, or `kiro` |
 | `id` | Session ID or stable file-derived ID |
 | `path` | Raw transcript/index file |
 | `cwd` | Working directory when recoverable |
@@ -117,6 +119,7 @@ Use `references/codex.md` for Codex storage details.
 | Problem | Fix |
 |---|---|
 | Missing Codex sessions | Set `CODEX_HOME` or pass `--root /path/to/.codex`. |
+| Missing oh-my-pi / gajae-code sessions | Those stores live in `~/.omp/agent/sessions` and `~/.gjc/agent/sessions`. For a custom `PI_CONFIG_DIR` / `PI_CODING_AGENT_DIR`, pass that agent dir with `--root`. |
 | Missing OpenCode sessions | Pass the data dir that contains `messages/` and `parts/`, often `~/.opencode` or `~/.local/share/opencode`. |
 | Missing Claude sessions | Search `~/.claude/projects`, `~/.claude/transcripts`, and `~/.claude/pre-compact-session-histories`; use `--root` for nonstandard config dirs. |
 | Missing optional platform sessions | Check `references/all-platforms.md` for the exact local store. For project-local tools such as Aider, pass `--root /path/to/workspace` if the repo is outside the bounded default roots. |

package/packages/omo-codex/plugin/skills/coding-agent-sessions/references/all-platforms.md

@@ -4,13 +4,15 @@
 
 Search these first, then add user-supplied roots with `--root`:
 
-Registered platform keys: `codex`, `claude`, `senpi`, `opencode`, `openclaw`, `droid`, `amp`, `gemini`, `kimi`, `qwen`, `codebuff`, `roo-code`, `kilo-code`, `cline`, `kodu`, `cursor-cli`, `aider`, `kilo-cli`, `hermes`, `goose`, `crush`, `zed`, `kiro`.
+Registered platform keys: `codex`, `claude`, `senpi`, `oh-my-pi`, `gajae-code`, `opencode`, `openclaw`, `droid`, `amp`, `gemini`, `kimi`, `qwen`, `codebuff`, `roo-code`, `kilo-code`, `cline`, `kodu`, `cursor-cli`, `aider`, `kilo-cli`, `hermes`, `goose`, `crush`, `zed`, `kiro`.
 
 | Platform | Unix/macOS | Windows |
 |---|---|---|
 | Codex | `$CODEX_HOME`, `~/.codex` | `%CODEX_HOME%`, `%USERPROFILE%\.codex` |
 | Claude | `~/.claude` | `%USERPROFILE%\.claude`, `%APPDATA%\Claude` |
 | Senpi / pi | `~/.senpi/agent`, `~/.pi/agent` | `%USERPROFILE%\.senpi\agent`, `%USERPROFILE%\.pi\agent` |
+| oh-my-pi (`omp`) | `~/.omp/agent`, `~/.omp/profiles/*/agent`, `$XDG_DATA_HOME/omp` | `%USERPROFILE%\.omp\agent` |
+| gajae-code (`gjc`) | `~/.gjc/agent`, `~/.gjc/profiles/*/agent`, `$XDG_DATA_HOME/gjc` | `%USERPROFILE%\.gjc\agent` |
 | OpenCode | `$OPENCODE_HOME`, `~/.opencode`, `~/.local/share/opencode` | `%OPENCODE_HOME%`, `%APPDATA%\opencode`, `%USERPROFILE%\.opencode` |
 | OpenClaw | `~/.openclaw/agents/*/sessions`, `~/.openclaw/session-backups` | pass `--root` |
 | Factory Droid | `~/.factory/sessions/*/*.jsonl` | pass `--root` |

package/packages/omo-codex/plugin/skills/coding-agent-sessions/references/senpi.md

@@ -1,10 +1,20 @@
-# Senpi / pi Coding-Agent Sessions
+# Senpi / pi Family Coding-Agent Sessions
 
-Observed Senpi layout:
+The pi family (Senpi, oh-my-pi, gajae-code) shares one session format, so one scanner serves all three under separate platform keys.
 
-- `~/.senpi/agent/sessions/<encoded-cwd>/<timestamp>_<uuid>.jsonl`
-- `~/.senpi/agent/settings.json`, `models.json`, and `auth.json` provide environment context.
-- `~/.pi/agent/sessions/**` can use the same family of JSONL formats.
+| Platform key | Aliases | Config root | Sessions |
+|---|---|---|---|
+| `senpi` | - | `~/.senpi`, `~/.pi` | `<root>/agent/sessions/<encoded-cwd>/<timestamp>_<uuid>.jsonl` |
+| `oh-my-pi` | `omp`, `ohmypi` | `~/.omp` | `~/.omp/agent/sessions/<encoded-cwd>/<timestamp>_<uuid>.jsonl` |
+| `gajae-code` | `gjc`, `gajae` | `~/.gjc` | `~/.gjc/agent/sessions/<encoded-cwd>/<timestamp>_<uuid>.jsonl` |
+
+Extra roots scanned for every pi-family platform:
+
+- Named profiles: `<config-root>/profiles/<profile>/agent/sessions/**`.
+- XDG stores (macOS/Linux, default profile): `$XDG_DATA_HOME/<app>/sessions/**` and `$XDG_DATA_HOME/<app>/profiles/<profile>/sessions/**`, where `<app>` is `senpi`, `omp`, or `gjc`. XDG flattens the `agent/` path segment.
+- A custom `PI_CONFIG_DIR` / `PI_CODING_AGENT_DIR` / `GJC_CONFIG_DIR` store: pass that agent directory with `--root`.
+
+`~/.senpi/agent/settings.json`, `models.json`, and `auth.json` provide environment context; oh-my-pi and gajae-code keep the same files plus `config.yml` and `models.yml` next to their sessions directory.
 
 Common event types:
 

package/packages/omo-codex/plugin/skills/coding-agent-sessions/scripts/agent_sessions/pi_family.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from .transcript import env_path, existing, jsonl_parallel, recent, stem_id
+from .types import Session
+
+SENPI_CONFIG_DIRS = (".senpi", ".pi")
+OH_MY_PI_CONFIG_DIRS = (".omp",)
+GAJAE_CODE_CONFIG_DIRS = (".gjc",)
+
+__all__ = ["scan_gajae_code", "scan_oh_my_pi", "scan_senpi"]
+
+
+def scan_senpi(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    return _scan_pi_family("senpi", SENPI_CONFIG_DIRS, "senpi", extra_roots, workers)
+
+
+def scan_oh_my_pi(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    return _scan_pi_family("oh-my-pi", OH_MY_PI_CONFIG_DIRS, "omp", extra_roots, workers)
+
+
+def scan_gajae_code(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    return _scan_pi_family("gajae-code", GAJAE_CODE_CONFIG_DIRS, "gjc", extra_roots, workers)
+
+
+def _scan_pi_family(platform: str, config_dirs: tuple[str, ...], xdg_app: str, extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    roots = _pi_family_roots(config_dirs, xdg_app, extra_roots)
+    paths = [path for root in roots for path in (root / "sessions").rglob("*.jsonl")]
+    return jsonl_parallel(recent(paths), workers, platform, lambda path: stem_id(path, "_"))
+
+
+def _pi_family_roots(config_dirs: tuple[str, ...], xdg_app: str, extra_roots: tuple[Path, ...]) -> list[Path]:
+    home = Path.home()
+    roots: list[Path] = []
+    for config_dir in config_dirs:
+        base = home / config_dir
+        roots.append(base / "agent")
+        roots.extend(sorted(base.glob("profiles/*/agent")))
+    xdg_data = env_path("XDG_DATA_HOME")
+    if xdg_data is not None:
+        app_root = xdg_data / xdg_app
+        roots.append(app_root)
+        roots.extend(sorted(app_root.glob("profiles/*")))
+    roots.extend(extra_roots)
+    return existing(roots)

package/packages/omo-codex/plugin/skills/coding-agent-sessions/scripts/agent_sessions/scanners.py

@@ -21,9 +21,9 @@ from .file_scanners import (
 )
 from .kiro_scanner import scan_kiro
 from .opencode import scan_opencode
+from .pi_family import scan_gajae_code, scan_oh_my_pi, scan_senpi
 from .sqlite_optional_scanners import scan_crush, scan_goose, scan_hermes, scan_kilo_cli, scan_zed
 from .sqlite_scanners import scan_cursor_cli, scan_kodu
-from .transcript import existing, jsonl_parallel, recent, stem_id
 from .types import Session
 
 Scanner: TypeAlias = Callable[[tuple[Path, ...], int], list[Session]]
@@ -31,7 +31,9 @@ Scanner: TypeAlias = Callable[[tuple[Path, ...], int], list[Session]]
 PLATFORM_SCANNERS: dict[str, Scanner] = {
     "codex": scan_codex,
     "claude": scan_claude,
-    "senpi": lambda roots, workers: scan_senpi(roots, workers),
+    "senpi": scan_senpi,
+    "oh-my-pi": scan_oh_my_pi,
+    "gajae-code": scan_gajae_code,
     "opencode": scan_opencode,
     "openclaw": scan_openclaw,
     "droid": scan_droid,
@@ -54,9 +56,22 @@ PLATFORM_SCANNERS: dict[str, Scanner] = {
     "kiro": scan_kiro,
 }
 DEFAULT_PLATFORMS = frozenset(PLATFORM_SCANNERS)
-PLATFORM_ALIASES = {"cursor": "cursor-cli", "factory": "droid", "roo": "roo-code", "roocode": "roo-code", "kilocode": "kilo-code", "kilo": "kilo-cli"}
+PLATFORM_ALIASES = {
+    "cursor": "cursor-cli",
+    "factory": "droid",
+    "roo": "roo-code",
+    "roocode": "roo-code",
+    "kilocode": "kilo-code",
+    "kilo": "kilo-cli",
+    "omp": "oh-my-pi",
+    "ohmypi": "oh-my-pi",
+    "oh_my_pi": "oh-my-pi",
+    "gjc": "gajae-code",
+    "gajae": "gajae-code",
+    "gajaecode": "gajae-code",
+}
 
-__all__ = ["DEFAULT_PLATFORMS", "PLATFORM_SCANNERS", "scan", "scan_claude", "scan_codex", "scan_opencode", "scan_senpi"]
+__all__ = ["DEFAULT_PLATFORMS", "PLATFORM_SCANNERS", "scan", "scan_claude", "scan_codex", "scan_gajae_code", "scan_oh_my_pi", "scan_opencode", "scan_senpi"]
 
 
 def scan(platforms: frozenset[str], roots: tuple[Path, ...], workers: int) -> list[Session]:
@@ -72,12 +87,6 @@ def scan(platforms: frozenset[str], roots: tuple[Path, ...], workers: int) -> li
     return _dedupe(sessions)
 
 
-def scan_senpi(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
-    roots = existing([Path.home() / ".senpi" / "agent", Path.home() / ".pi" / "agent", *extra_roots])
-    paths = [path for root in roots for path in (root / "sessions").rglob("*.jsonl")]
-    return jsonl_parallel(recent(paths), workers, "senpi", lambda path: stem_id(path, "_"))
-
-
 def _dedupe(sessions: list[Session]) -> list[Session]:
     found: dict[tuple[str, str], Session] = {}
     for session in sessions:

package/packages/omo-codex/plugin/skills/debugging/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: debugging
-description: "MUST USE for any real runtime debugging across ANY language or binary — crashes, silent failures, wrong responses, stuck processes, memory leaks, async misbehavior, unexplained timing, reverse engineering. Runs a hypothesis-driven loop: form ≥3 hypotheses, investigate in parallel, after 2 failed rounds spawn Oracles from orthogonal angles, confirm root cause, lock with a failing test, fix minimally, QA by actually USING the system, scrub artifacts. The actual HOW lives in `references/` — READ THEM. Triggers: 'debug this', 'why is X not working', 'hanging', 'attach a debugger', 'reverse engineer', 'pwndbg', 'gdb', 'lldb', 'node inspect', 'tsx debug', 'pdb', 'dlv', 'delve', 'rust-gdb', 'set a breakpoint', 'context window exploded', 'why is the response empty', 'attach the debugger', 'debug it', 'why is this happening', 'trace this bug', 'reproduce and fix', 'silent failure', 'HTTP 200 but empty', 'why did it stop', 'inspect the binary', 'reverse engineering', 'playwright'."
+description: "MUST USE for any real runtime debugging across ANY language or binary — crashes, silent failures, wrong responses, stuck processes, memory leaks, async misbehavior, unexplained timing, reverse engineering. Runs a hypothesis-driven loop: form ≥3 hypotheses, investigate in parallel, after 2 failed rounds spawn Oracles from orthogonal angles, confirm root cause, lock with a failing test, fix minimally, QA by actually USING the system, scrub artifacts. The actual HOW lives in `references/` — READ THEM. Triggers: 'debug this', 'why is X not working', 'hanging', 'attach a debugger', 'reverse engineer', 'pwndbg', 'gdb', 'lldb', 'node inspect', 'tsx debug', 'pdb', 'dlv', 'delve', 'rust-gdb', 'set a breakpoint', 'context window exploded', 'why is the response empty', 'why is this happening', 'trace this bug', 'reproduce and fix', 'silent failure', 'HTTP 200 but empty', 'why did it stop', 'inspect the binary', 'playwright', 'flaky test', 'fails intermittently', 'passes in isolation', 'only fails in CI'."
 ---
 
 # Debugging
@@ -84,6 +84,7 @@ These are not phases — read them when the situation calls for them:
 
 | Situation | Reference |
 |---|---|
+| The failure is intermittent — fails sometimes, a different test each run, passes in isolation, or only fails in CI | 📖 **[references/methodology/03-flaky-triage.md](references/methodology/03-flaky-triage.md)** — read BEFORE Phase 2; the failure signature usually collapses the search space in one round |
 | You cannot run the actual operation (paid API, blocked network, missing hardware) but still need runtime evidence | 📖 **[references/methodology/partial-runtime-evidence.md](references/methodology/partial-runtime-evidence.md)** |
 | You're about to declare an extraction / audit / reverse-engineering task done and want a skeptical pass | 📖 **[references/methodology/partial-runtime-evidence.md#verification-oracle-pattern-for-non-debug-tasks](references/methodology/partial-runtime-evidence.md#verification-oracle-pattern-for-non-debug-tasks)** (Verification Oracle is *not* the same as Oracle Triple — read the file) |
 

package/packages/omo-codex/plugin/skills/debugging/references/methodology/03-flaky-triage.md

@@ -0,0 +1,47 @@
+# Intermittent / Flaky Failure Triage
+
+Read this when a failure does not reproduce on every run — "fails sometimes", "a different test each run", "passes in isolation", "only fails in CI". Do not enter the hypothesis loop blind: **intermittence itself is evidence.** This triage usually collapses the search space in one round, before Phase 2 hypothesis formation.
+
+---
+
+## Step 1 — Capture the failure signature (three cheap reruns)
+
+Run these before forming any hypothesis. Journal each result.
+
+| Rerun | Command shape | Question it answers |
+|---|---|---|
+| Same scope, same command | exactly what just failed | Does the SAME test fail again, or a different one? |
+| Failing test in isolation | single file / test filter | Does it pass alone? |
+| Full scope on a quiet machine | stop concurrent builds, suites, background agents first | Does the whole suite go green when nothing else runs? |
+| (When order is suspect) shuffled | `-shuffle=on` / `pytest-randomly` / runner's random seed | Does a specific order reproduce it? Record the seed. |
+
+## Step 2 — Read the signature
+
+| Signature | Dominant hypothesis | Next move |
+|---|---|---|
+| Same test fails intermittently, everywhere | Real race in the code under test, or an async test bug (fixed sleep, unawaited promise, poll-for-time) | Standard phase loop from `02-investigate.md`; reproduce deterministically by subscribing to the completion event or injecting a clock |
+| **A different test/file each run; each passes in isolation; quiet machine is green** | **Environment contention between concurrent runs — not the code** | Step 3 checklist |
+| Always the same test, but only in the full suite; isolation green | Test-order dependence / fixture leak (unreset module state, leaked env var, shared singleton) | Bisect with the shuffle seed; find the test that leaks, fix its teardown |
+| Fails only on CI, never locally | Resource ceilings (slower disk/CPU → timeouts), different parallelism defaults, container clock | Reproduce locally under constraint (`taskset`, low `--maxWorkers`); raise the *signal* not the sleep |
+| Green on plain rerun of the same commit | Still a flake — classify it with this table before ignoring it; an unclassified flake is a hidden bug report | Step 1 again with journaling |
+
+## Step 3 — Concurrent-run contention checklist
+
+The classic modern cause: **two checkouts or worktrees of the same repo — or one checkout plus a background agent — running suites at the same time while sharing a global mutable resource.** Multi-agent workstations make this the default failure mode, not an exotic one. Check each:
+
+- **Shared tmp roots** — a sandbox/cache dir derived from a *fixed* tmpdir path (`$TMPDIR/<project>-fixed-name`) instead of a per-run `mktemp`. Both runs read/write the same tree; the loser sees half-deleted state.
+- **Fixed ports** — hardcoded listen ports in test servers. Two suites race to bind; the loser gets 404/ECONNREFUSED mid-run, in whichever file happened to be running.
+- **Global env / config mutation** — tests writing process-external state (dotfiles, shared config, global env) the other run reads.
+- **Shared containers / databases** — same-named containers, same schema, same volume.
+- **Caches and locks** — package-manager caches, lockfiles, `.git` index contention.
+
+Evidence to capture while it is live: `lsof -i :<port>` during the failure window, a listing of the shared tmp path, a process list showing the concurrent runners.
+
+## Step 4 — Fix policy
+
+- **Environment contention** → fix the **test infrastructure**, never the individual test: namespace every suite-global resource per run — `mktemp` for roots, port `0`/ephemeral allocation, unique container names. The bar: *two checkouts of this repo running the suite concurrently must not interfere.* (The programming skill's test-isolation rules own this bar.)
+- **Order dependence** → find the leaking fixture via the recorded shuffle seed; reset at teardown; re-run shuffled until the seed class is clean.
+- **Real race** → normal phase loop (`02-investigate.md` onward); the fix ships with a failing-first test that reproduces deterministically.
+- **Forbidden regardless of cause**: retry wrappers around the test, enlarged sleeps, `.retry(N)`, quarantining, or deleting the test. Each one buries a bug report.
+
+A flake you classified but did not fix is a **finding to report**, not to hide: journal the signature, the evidence, and the classification, and say it in your final report.

package/packages/omo-codex/plugin/skills/frontend/ATTRIBUTION.md

@@ -210,6 +210,13 @@ no Lazyweb source, documentation text, or screenshot content is vendored. Lazywe
 remain the property of their owner, and the guide grants no license to ship, trace, or
 commit reference screenshots harvested through it.
 
+`frontend/references/design/interaction-skill.md` is a project-original, curl-only
+operating guide for consulting the beui.dev animated-component registry during interaction
+and motion work, written from live endpoint verification; no beui.dev source code,
+documentation text, or component implementations are vendored. beui.dev names remain the
+property of their owner, and the guide instructs reading component source for mechanism
+extraction only, not vendoring it into references or projects.
+
 `frontend/references/design/clone-from-url.md` is a project-original runtime-extraction
 workflow guide. Its browser + `getComputedStyle` clone approach follows the same
 MIT-licensed `JCodesMore/ai-website-cloner-template` clone-website workflow that `aside.md`

package/packages/omo-codex/plugin/skills/frontend/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: frontend
-description: "MUST USE for frontend/web UI/UX/visual work: building, styling, redesigning pages/components, React setup, performance audits, visual QA, taste, and polish. Routes four rulesets: design taste router and brand references; perfection for Playwright/Chromium Lighthouse/Core Web Vitals; ui-ux-db palettes/fonts/guidelines; designpowers personas/accessibility/critique/handoff; plus curl-only lazyweb real-app-screen research for design direction. Triggers: frontend, UI, UX, design, redesign, styling, layout, animation, motion, premium, luxury, minimal, brutalist, Awwwards, DESIGN.md, mockup, React, Lighthouse, accessibility, WCAG, Core Web Vitals, looks generic, make it pretty, like X brand, lazyweb, design research."
+description: "MUST USE for frontend/web UI/UX/visual work: building, styling, redesigning pages/components, React setup, performance audits, visual QA, taste, and polish. Routes four rulesets: design taste router and brand references; perfection for Playwright/Chromium Lighthouse/Core Web Vitals; ui-ux-db palettes/fonts/guidelines; designpowers personas/accessibility/critique/handoff; plus curl-only lazyweb real-app-screen research and the beui.dev interaction catalog. Triggers: frontend, UI, UX, design, redesign, styling, layout, animation, motion, interaction, micro-interaction, make it feel alive, premium, luxury, minimal, brutalist, Awwwards, DESIGN.md, mockup, React, Lighthouse, accessibility, WCAG, Core Web Vitals, looks generic, make it pretty, like X brand, lazyweb, design research."
 ---
 
 # Frontend
@@ -14,6 +14,7 @@ This file is a router, not a rulebook. The rules live in four rulesets under `re
 | Request involves… | Read |
 |---|---|
 | ANY UI implementation, styling, redesign, mockup, or visual decision | `references/design/README.md` FIRST. It enforces two mandatory gates — the Design System Gate (a `DESIGN.md` must exist before any component is written) and the React Dev Tooling Gate (react-grab / react-scan / react-doctor installed by default) — then routes to the taste and brand references below. |
+| Interaction or motion work — micro-interactions, animated components, transitions, gestures, hover/press/state feedback, "make it feel alive" | ALSO `references/design/interaction-skill.md`. The beui.dev catalog is the mandatory interaction reference: find the nearest pattern, read its real source through the file's curl recipe, and adapt the mechanism to `DESIGN.md` motion tokens. It stacks on the routed style skill — never replaces it. |
 | Writing or modifying frontend code, OR auditing performance / SEO / accessibility / quality | ALSO `references/perfection/README.md`. Lighthouse 100 in every category, measured on real Playwright Chromium (never the `lighthouse` CLI), achieved through architecture — never by dropping animations or hiding content. |
 | Looking up a concrete style, color palette, font pairing, chart type, landing-page structure, or UX guideline — or generating a project design system from keywords | `references/ui-ux-db/README.md`. A searchable CSV database with a CLI; a lookup tool, not a posture. Load on demand; `design` stays the source of truth for taste and the `DESIGN.md` contract. |
 | ANY implementation or redesign that creates or updates `DESIGN.md` — plus explicit operating-layer asks (personas, critique, debt, handoff, synthetic user testing) | `references/designpowers/README.md` + `references/designpowers/lane-c-review.md`. An internal frontend ruleset, not a separate skill: lane-c is the Phase Final flatness/critique reviewer, and its accessibility-constraints and accepted-debt language fills the required `DESIGN.md` sections. Load other lanes only when their phase applies. |
@@ -61,6 +62,7 @@ The reference library has one architecture file, 12 taste skills (Layer A — *h
 | `image-to-code-skill.md` | "Generate the design first, then code it." Pair with one imagegen file below. |
 | `output-skill.md` | Stacks on any style skill when output is incomplete — placeholders, `// TODO`, half-done components. |
 | `stitch-skill.md` | Stacks on any style skill for Google Stitch compatibility or a `DESIGN.md` doc export. A complete worked export ships as `stitch-design-example.md`. |
+| `interaction-skill.md` | Stacks on any style skill when work adds or changes interaction or motion. beui.dev-anchored: read the mapped component's source before designing an interaction; reduced motion always. |
 | `imagegen-frontend-web.md` / `imagegen-frontend-mobile.md` / `imagegen-brandkit.md` | Image-only output (mockup, app-screen concepts, brand board). These NEVER write code — switch to `image-to-code-skill.md` if code is wanted. |
 
 ### Layer B — brand design systems (orthogonal to Layer A; stack freely)
@@ -113,6 +115,7 @@ Domains: `product` `style` `typography` `color` `landing` `chart` `ux` `react` `
 | "Linear-style landing page" | `design/README.md` + `design/linear.app.md` + `design/taste-skill.md` + `perfection/README.md` |
 | "Premium SaaS hero like Stripe" | `design/README.md` + `design/stripe.md` + `design/soft-skill.md` + `perfection/README.md` |
 | "Improve this existing dashboard" | `design/README.md` + `design/redesign-skill.md` + `perfection/README.md` |
+| "Add micro-interactions" / "animate this" / "make it feel alive" / "polish the interactions" | `design/README.md` + `design/interaction-skill.md` on top of the current style skill + `perfection/README.md` |
 | "Build this screenshot / Imagen mock / Stitch output exactly" | `design/README.md` + `design/image-to-code-skill.md` + `perfection/README.md` + `/visual-qa` reference-fidelity mode |
 | "Audit my site" / "make this page faster" | `perfection/README.md` (+ `perfection/react-perf-tooling.md` if React) |
 | "Mockup image of a fintech app" — no code | `design/imagegen-frontend-mobile.md` (+ a Layer B brand if named) |