oh-my-opencode 4.19.2 → 4.19.4

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

@@ -2,45 +2,194 @@ import { homedir } from "node:os"
 
 import {
 	loadOmoConfig,
+	mergeOmoConfigRecords,
+	OmoConfigSchema,
 	type LoadOmoConfigOptions,
-} from "../../../../utils/src/omo-config/loader.ts"
-import type { OmoConfig } from "../../../../utils/src/omo-config.ts"
-import type { OmoConfigSource } from "../../../../utils/src/omo-config/resolve.ts"
+	type MigrationEnvironment,
+	type MigrationFileSystem,
+	type OmoConfig,
+	type OmoConfigEnv,
+	type OmoConfigSource,
+} from "../../../../omo-config-core/src/index.ts"
 
-export type CodexOmoConfigOptions = Omit<LoadOmoConfigOptions, "harness">
+import {
+	runCodexConfigMigration,
+	type CodexConfigMigrationOptions,
+	type CodexConfigMigrationResult,
+} from "./config-migration.ts"
+
+export type CodexOmoConfigOptions = Omit<LoadOmoConfigOptions, "fileSystem" | "harness"> & {
+	readonly fileSystem?: MigrationFileSystem
+	readonly homeDir?: string
+}
+
+export type CodexStartupMigrationOptions = CodexConfigMigrationOptions
+export type CodexStartupMigrationResult = CodexConfigMigrationResult
+
+type CodexCodegraphConfig = {
+	readonly auto_provision?: boolean
+	readonly daemon?: boolean
+	readonly enabled?: boolean
+	readonly excluded_roots?: readonly string[]
+	readonly install_dir?: string
+	readonly session_start_cooldown_ms?: number
+	readonly telemetry?: boolean
+	readonly watch_debounce_ms?: number
+}
 
-export type CodexOmoConfig = OmoConfig & {
+type CodexResolvedConfig = Omit<OmoConfig, "codegraph"> & {
+	readonly codegraph?: CodexCodegraphConfig
+}
+
+export type CodexOmoConfig = CodexResolvedConfig & {
 	readonly sources: readonly OmoConfigSource[]
 	readonly trustedCodegraphInstallDir?: string
 	readonly warnings: readonly string[]
 }
 
+const ENV_BOOLEAN_SETTINGS = [
+	["auto_provision", "AUTO_PROVISION"],
+	["enabled", "ENABLED"],
+	["telemetry", "TELEMETRY"],
+] as const
+
+function resolveHomeDir(options: CodexOmoConfigOptions): string {
+	const env = options.env ?? process.env
+	return options.homeDir ?? env.HOME ?? env.USERPROFILE ?? homedir()
+}
+
+function environmentWithHome(env: OmoConfigEnv, homeDir: string): OmoConfigEnv {
+	return { ...env, HOME: homeDir }
+}
+
+function migrationEnvironment(homeDir: string, env: OmoConfigEnv): MigrationEnvironment {
+	return {
+		HOME: homeDir,
+		...(env.USERPROFILE === undefined ? {} : { USERPROFILE: env.USERPROFILE }),
+	}
+}
+
+/** Runs only the legacy config.jsonc transaction before Codex reads omo.jsonc. */
+export function runCodexStartupMigration(options: CodexStartupMigrationOptions): CodexStartupMigrationResult {
+	return runCodexConfigMigration(options)
+}
+
+function parseBoolean(value: string): boolean | undefined {
+	const normalized = value.trim().toLowerCase()
+	if (["1", "true", "yes", "on"].includes(normalized)) return true
+	if (["0", "false", "no", "off"].includes(normalized)) return false
+	return undefined
+}
+
+function envOverrides(env: OmoConfigEnv, warnings: string[]): Record<string, unknown> {
+	const codegraph: Record<string, unknown> = {}
+	for (const prefix of ["OMO", "CODEX"]) {
+		for (const [setting, suffix] of ENV_BOOLEAN_SETTINGS) {
+			const name = `${prefix}_CODEGRAPH_${suffix}`
+			const rawValue = env[name]
+			if (rawValue === undefined) continue
+			const value = parseBoolean(rawValue)
+			if (value === undefined) warnings.push(`${name} has invalid boolean value "${rawValue}"`)
+			else codegraph[setting] = value
+		}
+
+		const installDir = env[`${prefix}_CODEGRAPH_INSTALL_DIR`]
+		if (installDir !== undefined) codegraph["install_dir"] = installDir
+		const cooldown = env[`${prefix}_CODEGRAPH_SESSION_START_COOLDOWN_MS`]
+		if (cooldown !== undefined) {
+			const value = Number(cooldown)
+			if (!Number.isFinite(value) || value < 60_000) {
+				warnings.push(`${prefix}_CODEGRAPH_SESSION_START_COOLDOWN_MS has invalid number value "${cooldown}"`)
+			} else codegraph["session_start_cooldown_ms"] = value
+		}
+		const debounce = env[`${prefix}_CODEGRAPH_WATCH_DEBOUNCE_MS`]
+		if (debounce !== undefined) {
+			const value = Number(debounce)
+			if (!Number.isFinite(value) || value < 0) warnings.push(`${prefix}_CODEGRAPH_WATCH_DEBOUNCE_MS has invalid number value "${debounce}"`)
+			else codegraph["watch_debounce_ms"] = value
+		}
+	}
+	return Object.keys(codegraph).length === 0 ? {} : { codegraph }
+}
+
+function migrationWarnings(result: CodexStartupMigrationResult): readonly string[] {
+	const warnings: string[] = []
+	if (result.error !== undefined) warnings.push(`omo-codex: configuration migration: ${result.error}`)
+	if (result.journalResumed) warnings.push("omo-codex: recovered an interrupted configuration migration")
+	if (result.migratedFrom.length > 0) {
+		warnings.push(`omo-codex: migrated legacy configuration from ${result.migratedFrom.join(", ")}`)
+	}
+	for (const migration of result.results) {
+		for (const diagnostic of migration.diagnostics) {
+			warnings.push(`omo-codex: configuration migration: ${diagnostic}`)
+		}
+	}
+	return warnings
+}
+
+function applicabilityWarnings(config: OmoConfig): readonly string[] {
+	return config.codegraph?.watch_debounce_ms === undefined
+		? []
+		: ["codegraph.watch_debounce_ms is not supported for harness codex"]
+}
+
+function codexCodegraphConfig(value: OmoConfig["codegraph"]): CodexCodegraphConfig | undefined {
+	if (value === undefined) return undefined
+	return {
+		auto_provision: value.auto_provision,
+		daemon: value.daemon,
+		enabled: value.enabled,
+		telemetry: value.telemetry,
+		...(value.excluded_roots === undefined ? {} : { excluded_roots: value.excluded_roots }),
+		...(value.install_dir === undefined ? {} : { install_dir: value.install_dir }),
+		...(value.session_start_cooldown_ms === undefined ? {} : { session_start_cooldown_ms: value.session_start_cooldown_ms }),
+		...(value.watch_debounce_ms === undefined ? {} : { watch_debounce_ms: value.watch_debounce_ms }),
+	}
+}
+
 export function getCodexOmoConfig(options: CodexOmoConfigOptions = {}): CodexOmoConfig {
 	const env = options.env ?? process.env
 	const homeDir = resolveHomeDir(options)
+	const environment = environmentWithHome(env, homeDir)
+	const migration = runCodexStartupMigration({
+		cwd: options.cwd ?? process.cwd(),
+		environment,
+		env: migrationEnvironment(homeDir, environment),
+		...(options.fileSystem === undefined ? {} : { fileSystem: options.fileSystem }),
+		...(options.platform === undefined ? {} : { platform: options.platform }),
+	})
 	const result = loadOmoConfig({
 		...(options.cwd === undefined ? {} : { cwd: options.cwd }),
-		env,
-		homeDir,
+		env: environment,
+		...(options.fileSystem === undefined ? {} : { fileSystem: options.fileSystem }),
 		harness: "codex",
+		...(options.platform === undefined ? {} : { platform: options.platform }),
+		...(options.profile === undefined ? {} : { profile: options.profile }),
 	})
 	const trustedConfig = loadOmoConfig({
 		cwd: homeDir,
-		env,
-		homeDir,
+		env: environment,
+		...(options.fileSystem === undefined ? {} : { fileSystem: options.fileSystem }),
 		harness: "codex",
+		...(options.platform === undefined ? {} : { platform: options.platform }),
+		...(options.profile === undefined ? {} : { profile: options.profile }),
 	})
+	const envWarnings: string[] = []
+	const config = OmoConfigSchema.parse(mergeOmoConfigRecords(result.config, envOverrides(env, envWarnings)))
 	const trustedCodegraphInstallDir = trustedConfig.config.codegraph?.install_dir
+	const { codegraph, ...resolvedConfig } = config
+	const codexCodegraph = codexCodegraphConfig(codegraph)
 
 	return {
-		...result.config,
+		...resolvedConfig,
+		...(codexCodegraph === undefined ? {} : { codegraph: codexCodegraph }),
 		sources: result.sources,
 		...(trustedCodegraphInstallDir === undefined ? {} : { trustedCodegraphInstallDir }),
-		warnings: result.warnings,
+		warnings: [
+			...migrationWarnings(migration),
+			...result.diagnostics.map((diagnostic) => diagnostic.message),
+			...envWarnings,
+			...applicabilityWarnings(config),
+		],
 	}
 }
-
-function resolveHomeDir(options: CodexOmoConfigOptions): string {
-	const env = options.env ?? process.env
-	return options.homeDir ?? env["HOME"] ?? env["USERPROFILE"] ?? homedir()
-}

package/packages/omo-codex/plugin/shared/src/config-migration.ts

@@ -0,0 +1,162 @@
+import { existsSync } from "node:fs"
+import { posix, win32 } from "node:path"
+
+import {
+	runMigrations,
+	type LoadedMigrationSource,
+	type MigrationBoundary,
+	type MigrationClock,
+	type MigrationEnvironment,
+	type MigrationFileSystem,
+	type MigrationPlan,
+	type MigrationRunResult,
+	type MigrationTransformResult,
+} from "../../../../omo-config-core/src/index.ts"
+
+const MIGRATION_ID = "2026-07-codex-config-jsonc"
+const OMO_SCHEMA_URL = "https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/dev/assets/omo.schema.json"
+
+type DiscoveryFileSystem = {
+	readonly existsSync: (path: string) => boolean
+}
+
+type PathOperations = {
+	readonly join: (...paths: string[]) => string
+}
+
+export type CodexConfigMigrationOptions = {
+	readonly backupTimestamp?: string
+	readonly clock?: MigrationClock
+	readonly cwd: string
+	readonly discoveryFileSystem?: DiscoveryFileSystem
+	readonly env?: MigrationEnvironment
+	readonly environment?: Readonly<Record<string, string | undefined>>
+	readonly fileSystem?: MigrationFileSystem
+	readonly homeDir?: string
+	readonly isProcessAlive?: (pid: number) => boolean
+	readonly onBoundary?: (boundary: MigrationBoundary) => void
+	readonly pathOperations?: PathOperations
+	readonly pid?: number
+	readonly platform?: NodeJS.Platform
+}
+
+export type CodexConfigMigrationResult = {
+	readonly error?: string
+	readonly journalResumed: boolean
+	readonly migratedFrom: readonly string[]
+	readonly results: readonly MigrationRunResult[]
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function recordAt(value: Readonly<Record<string, unknown>>, key: string): Record<string, unknown> | undefined {
+	const candidate = value[key]
+	return isRecord(candidate) ? candidate : undefined
+}
+
+function migrationHistory(sources: readonly LoadedMigrationSource[], configPath: string): Record<string, readonly string[]> {
+	const history: string[] = []
+	for (const source of sources) {
+		if (!isRecord(source.value)) continue
+		for (const key of ["_migrations", "appliedMigrations"]) {
+			const values = source.value[key]
+			if (!Array.isArray(values)) continue
+			for (const value of values) {
+				if (typeof value === "string" && !history.includes(value)) history.push(value)
+			}
+		}
+	}
+	return history.length === 0 ? {} : { [configPath]: history }
+}
+
+function transformConfigJsonc(configPath: string, sources: readonly LoadedMigrationSource[]): MigrationTransformResult {
+	const config = sources.find((source) => source.path === configPath)
+	const legacy = config === undefined || !isRecord(config.value) ? {} : config.value
+	const omo = recordAt(legacy, "[omo]")
+	const senpi = recordAt(legacy, "[senpi]")
+	const history = migrationHistory(sources, configPath)
+	return {
+		diagnostics: omo !== undefined && senpi !== undefined
+			? ["conflict: [senpi] legacy [omo] kept [senpi]"]
+			: [],
+		document: {
+			$schema: OMO_SCHEMA_URL,
+			...(recordAt(legacy, "codegraph") === undefined ? {} : { codegraph: recordAt(legacy, "codegraph") }),
+			...(recordAt(legacy, "[opencode]") === undefined ? {} : { "[opencode]": recordAt(legacy, "[opencode]") }),
+			...(recordAt(legacy, "[codex]") === undefined ? {} : { "[codex]": recordAt(legacy, "[codex]") }),
+			...(senpi === undefined && omo === undefined ? {} : { "[senpi]": senpi ?? omo }),
+			...(Object.keys(history).length === 0 ? {} : { legacy_migrations: history }),
+		},
+	}
+}
+
+function timestamp(value: string | undefined): string {
+	return value ?? new Date().toISOString().replace(/[:.]/g, "-")
+}
+
+function sourceExists(options: CodexConfigMigrationOptions, path: string): boolean {
+	return (options.discoveryFileSystem ?? options.fileSystem ?? { existsSync }).existsSync(path)
+}
+
+function migrationPlan(homeDir: string, options: CodexConfigMigrationOptions): MigrationPlan | undefined {
+	const platform = options.platform ?? process.platform
+	const paths = options.pathOperations ?? (platform === "win32" ? win32 : posix)
+	const configPath = paths.join(homeDir, ".omo", "config.jsonc")
+	const sidecarPath = `${configPath}.migrations.json`
+	const sourcePaths = [configPath, sidecarPath].filter((path) => sourceExists(options, path))
+	if (sourcePaths.length === 0) return undefined
+	const backupRoot = paths.join(homeDir, ".omo", `migration-backup-${timestamp(options.backupTimestamp)}-opencode-config`, ".omo")
+	return {
+		id: MIGRATION_ID,
+		sources: sourcePaths.map((path) => ({
+			backupPath: paths.join(backupRoot, path === configPath ? "config.jsonc" : "config.jsonc.migrations.json"),
+			path,
+		})),
+		targetPath: paths.join(homeDir, ".omo", "omo.jsonc"),
+		transform: (sources) => transformConfigJsonc(configPath, sources),
+	}
+}
+
+function migratedSources(results: readonly MigrationRunResult[]): readonly string[] {
+	return [...new Set(results.flatMap((result) => result.status === "migrated"
+		? result.preview?.backupMoves.map((move) => move.from) ?? []
+		: []))].sort()
+}
+
+export function runCodexConfigMigration(options: CodexConfigMigrationOptions): CodexConfigMigrationResult {
+	const environment = options.environment ?? process.env
+	const homeDir = options.homeDir ?? environment["HOME"] ?? environment["USERPROFILE"]
+	if (homeDir === undefined || homeDir.length === 0) {
+		return { error: "Cannot migrate configuration because no home directory is available", journalResumed: false, migratedFrom: [], results: [] }
+	}
+
+	try {
+		const batch = runMigrations({
+			...(options.clock === undefined ? {} : { clock: options.clock }),
+			discover: () => {
+				const plan = migrationPlan(homeDir, options)
+				return plan === undefined ? [] : [plan]
+			},
+			...(options.env === undefined ? { env: { HOME: homeDir } } : { env: options.env }),
+			...(options.fileSystem === undefined ? {} : { fileSystem: options.fileSystem }),
+			...(options.isProcessAlive === undefined ? {} : { isProcessAlive: options.isProcessAlive }),
+			...(options.onBoundary === undefined ? {} : { onBoundary: options.onBoundary }),
+			...(options.pid === undefined ? {} : { pid: options.pid }),
+		})
+		return {
+			...(batch.status === "locked" ? { error: "Configuration migration is already running" } : {}),
+			journalResumed: batch.journalResumed,
+			migratedFrom: migratedSources(batch.results),
+			results: batch.results,
+		}
+	} catch (error) {
+		return {
+			error: error instanceof Error ? error.message : String(error),
+			journalResumed: false,
+			migratedFrom: [],
+			results: [],
+		}
+	}
+}

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 })
@@ -86,6 +131,20 @@ describe("getCodexOmoConfig", () => {
 		expect(result.codegraph?.excluded_roots).toEqual(["/tmp/omo-research", "/private/tmp/omo-research"])
 	})
 
+	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-")
@@ -125,24 +184,24 @@ describe("getCodexOmoConfig", () => {
 
 		// then
 		expect(result.codegraph?.daemon).toBe(true)
-		expect(result.warnings).toContain("config.[codex].codegraph.daemon must be a boolean")
+		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", () => {
@@ -163,8 +222,8 @@ describe("getCodexOmoConfig", () => {
 		expect(result.sources).toContainEqual({
 			exists: false,
 			loaded: false,
-			path: join(homeDir, ".omo", "config.jsonc"),
-			scope: "global",
+			path: join(homeDir, ".omo", "omo.jsonc"),
+			scope: "user",
 		})
 	})
 
@@ -180,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, 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."
+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, Aside browser-agent sessions, 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/Aside 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
@@ -18,7 +18,7 @@ Find local coding-agent sessions across agent products before answering from mem
    | 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` |
+   | OpenClaw, Droid, Amp, Gemini, Kimi, Qwen, Codebuff, Roo/Kilo/Cline, Kodu, Cursor CLI, Aider, Kiro, Goose, Hermes, Crush, Zed, Aside | `references/all-platforms.md` |
    | Unknown / "any session" / cross-agent search | `references/all-platforms.md` |
 
 2. **Run the broad finder first unless the user gave an exact file path. For fuzzy recall, expand the query first.**
@@ -51,7 +51,7 @@ The finder prints JSON for stdout and `jq`. Every result includes:
 
 | Field | Meaning |
 |---|---|
-| `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` |
+| `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`, `kiro`, or `aside` |
 | `id` | Session ID or stable file-derived ID |
 | `path` | Raw transcript/index file |
 | `cwd` | Working directory when recoverable |
@@ -122,6 +122,7 @@ Use `references/codex.md` for Codex storage details.
 | 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 Aside sessions | The Aside browser agent stores per-user data under `~/.aside/u/<n>/` (`sessions/<date>_<id>/messages.jsonl` transcripts + a `state.db` index; `agents/*/sessions/` is just a hardlink mirror). Pass `--root` for a nonstandard `.aside` dir or an exported user dir. |
 | 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. |
 | Date filter misses local sessions | Timestamps are compared as UTC instants when parseable; otherwise file mtime is used. |
 | Search is slow | Narrow with repeated `--platform` flags or date/cwd filters. Optional stores are probed before parsing; avoid passing your whole home as `--root` unless you really want every bounded project-local scan. |