oh-my-opencode 4.13.0 → 4.14.0

package/packages/omo-codex/plugin/scripts/migrate-codex-config/context7-placeholder-guard.mjs

@@ -0,0 +1,131 @@
+const CONTEXT7_HEADER = "[mcp_servers.context7]";
+
+export function removeStaleContext7PlaceholderMcpServer(config) {
+	return removeSections(config, (section) => section.header === CONTEXT7_HEADER && isContext7PlaceholderSection(section.text));
+}
+
+function isContext7PlaceholderSection(sectionText) {
+	const args = readStringArraySetting(sectionText, "args");
+	if (args === null || !args.includes("@upstash/context7-mcp")) return false;
+	const apiKey = valueAfter(args, "--api-key");
+	return apiKey !== null && isPlaceholderApiKey(apiKey);
+}
+
+function valueAfter(values, key) {
+	const index = values.indexOf(key);
+	return index >= 0 ? values[index + 1] ?? null : null;
+}
+
+function isPlaceholderApiKey(value) {
+	return /^your[-_ ]?api[-_ ]?key$/i.test(value);
+}
+
+function readStringArraySetting(sectionText, key) {
+	for (const line of sectionText.split("\n")) {
+		if (!new RegExp(`^\\s*${key}\\s*=`).test(line)) continue;
+		const assignmentIndex = line.indexOf("=");
+		if (assignmentIndex === -1) return null;
+		return parseTomlStringArray(stripUnquotedInlineComment(line.slice(assignmentIndex + 1)).trim());
+	}
+	return null;
+}
+
+function parseTomlStringArray(value) {
+	if (!value.startsWith("[") || !value.endsWith("]")) return null;
+	const items = [];
+	let index = 1;
+	while (index < value.length - 1) {
+		const char = value[index];
+		if (char === "\"" || char === "'") {
+			const parsed = parseTomlString(value, index);
+			if (parsed === null) return null;
+			items.push(parsed.value);
+			index = parsed.nextIndex;
+			continue;
+		}
+		index += 1;
+	}
+	return items;
+}
+
+function parseTomlString(input, startIndex) {
+	const quote = input[startIndex];
+	let value = "";
+	let index = startIndex + 1;
+	while (index < input.length) {
+		const char = input[index];
+		if (quote === "\"" && char === "\\") {
+			const next = input[index + 1];
+			if (next === undefined) return null;
+			value += next;
+			index += 2;
+			continue;
+		}
+		if (char === quote) return { value, nextIndex: index + 1 };
+		value += char;
+		index += 1;
+	}
+	return null;
+}
+
+function stripUnquotedInlineComment(line) {
+	let quote = null;
+	let index = 0;
+	while (index < line.length) {
+		const char = line[index];
+		if (quote === "\"") {
+			if (char === "\\") {
+				index += 2;
+				continue;
+			}
+			if (char === "\"") quote = null;
+			index += 1;
+			continue;
+		}
+		if (quote === "'") {
+			if (char === "'") quote = null;
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			index += 1;
+			continue;
+		}
+		if (char === "#") return line.slice(0, index);
+		index += 1;
+	}
+	return line;
+}
+
+function removeSections(config, shouldRemove) {
+	return splitSections(config)
+		.filter((section) => !shouldRemove(section))
+		.map((section) => section.text)
+		.join("")
+		.replace(/\n{3,}/g, "\n\n");
+}
+
+function splitSections(config) {
+	const lines = config.match(/[^\n]*\n?|$/g) ?? [];
+	const sections = [];
+	let current = { header: null, text: "" };
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const header = tableHeader(line);
+		if (header !== null) {
+			if (current.text.length > 0) sections.push(current);
+			current = { header, text: line };
+		} else {
+			current = { ...current, text: current.text + line };
+		}
+	}
+	if (current.text.length > 0) sections.push(current);
+	return sections;
+}
+
+function tableHeader(line) {
+	const trimmed = stripUnquotedInlineComment(line).trim();
+	if (!trimmed.startsWith("[") || !trimmed.endsWith("]") || trimmed.startsWith("[[")) return null;
+	return trimmed;
+}

package/packages/omo-codex/plugin/scripts/migrate-codex-config/multi-agent-mode-guard.mjs

@@ -0,0 +1,60 @@
+const MULTI_AGENT_MODE_KEY = "multi_agent_mode";
+
+export function removeUnsupportedRootMultiAgentMode(config) {
+	const lines = config.split(/\n/);
+	const output = [];
+	let inRoot = true;
+	let changed = false;
+	for (const line of lines) {
+		const sectionHeader = isSectionHeader(line);
+		if (inRoot && isRootSetting(line, MULTI_AGENT_MODE_KEY)) {
+			changed = true;
+			continue;
+		}
+		output.push(line);
+		if (sectionHeader) inRoot = false;
+	}
+	return changed ? output.join("\n") : config;
+}
+
+function isSectionHeader(line) {
+	const trimmed = stripUnquotedInlineComment(line).trim();
+	return trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+
+function isRootSetting(line, key) {
+	const trimmed = line.trimStart();
+	if (trimmed.startsWith("#") || trimmed.startsWith("[")) return false;
+	const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+	return match?.[1] === key;
+}
+
+function stripUnquotedInlineComment(line) {
+	let quote = null;
+	let index = 0;
+	while (index < line.length) {
+		const char = line[index];
+		if (quote === "\"") {
+			if (char === "\\") {
+				index += 2;
+				continue;
+			}
+			if (char === "\"") quote = null;
+			index += 1;
+			continue;
+		}
+		if (quote === "'") {
+			if (char === "'") quote = null;
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			index += 1;
+			continue;
+		}
+		if (char === "#") return line.slice(0, index);
+		index += 1;
+	}
+	return line;
+}

package/packages/omo-codex/plugin/scripts/migrate-codex-config/multi-agent-v2-guard.mjs

@@ -24,11 +24,10 @@ const MANAGED_DISABLE_COMMENT = [
 ].join("\n");
 
 export function forceDisableMultiAgentV2(config) {
-	let result = removeEnabledFeaturesShorthand(config);
+	let result = removeFeaturesShorthand(config);
 	const section = findSection(result, "[features.multi_agent_v2]");
 
 	if (!section) {
-		if (hasDisabledFeaturesShorthand(result)) return result;
 		return ensureManagedComment(appendDisabledSection(result));
 	}
 
@@ -53,23 +52,17 @@ function ensureManagedComment(config) {
 	return config.slice(0, section.start) + MANAGED_DISABLE_COMMENT + config.slice(section.start);
 }
 
-function removeEnabledFeaturesShorthand(config) {
+function removeFeaturesShorthand(config) {
 	const section = findSection(config, "[features]");
 	if (!section) return config;
 
-	const shorthandPattern = /^\s*multi_agent_v2\s*=\s*true[ \t]*(?:#[^\n]*)?[ \t]*\n?/m;
+	const shorthandPattern = /^\s*multi_agent_v2\s*=\s*(?:true|false)[ \t]*(?:#[^\n]*)?[ \t]*\n?/m;
 	if (!shorthandPattern.test(section.text)) return config;
 
 	const patched = section.text.replace(shorthandPattern, "");
 	return config.slice(0, section.start) + patched + config.slice(section.end);
 }
 
-function hasDisabledFeaturesShorthand(config) {
-	const section = findSection(config, "[features]");
-	if (!section) return false;
-	return /^\s*multi_agent_v2\s*=\s*false[ \t]*(?:#[^\n]*)?$/m.test(section.text);
-}
-
 function appendDisabledSection(config) {
 	const trimmed = config.trimEnd();
 	const prefix = trimmed.length === 0 ? "" : `${trimmed}\n\n`;

package/packages/omo-codex/plugin/scripts/migrate-codex-config/root-settings.mjs

@@ -62,7 +62,7 @@ function replaceOrInsertRootSetting(config, key, value) {
 }
 
 function isSectionHeader(line) {
-	const trimmed = line.trim();
+	const trimmed = stripUnquotedInlineComment(line).trim();
 	return trimmed.startsWith("[") && trimmed.endsWith("]");
 }
 
@@ -72,3 +72,33 @@ function isRootSetting(line, key) {
 	const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=/);
 	return match?.[1] === key;
 }
+
+function stripUnquotedInlineComment(line) {
+	let quote = null;
+	let index = 0;
+	while (index < line.length) {
+		const char = line[index];
+		if (quote === "\"") {
+			if (char === "\\") {
+				index += 2;
+				continue;
+			}
+			if (char === "\"") quote = null;
+			index += 1;
+			continue;
+		}
+		if (quote === "'") {
+			if (char === "'") quote = null;
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			index += 1;
+			continue;
+		}
+		if (char === "#") return line.slice(0, index);
+		index += 1;
+	}
+	return line;
+}

package/packages/omo-codex/plugin/scripts/migrate-codex-config/subagent-limit-guard.mjs

@@ -0,0 +1,73 @@
+const CODEX_AGENTS_HEADER = "[agents]";
+const CODEX_MULTI_AGENT_V2_HEADER = "[features.multi_agent_v2]";
+const CODEX_SUBAGENT_THREAD_LIMIT = "1000";
+
+export function ensureSubagentConcurrencyLimit(config) {
+	return ensureMultiAgentV2ThreadLimit(ensureAgentsMaxThreads(config));
+}
+
+function ensureAgentsMaxThreads(config) {
+	const section = findSection(config, CODEX_AGENTS_HEADER);
+	if (!section) return appendBlock(config, `${CODEX_AGENTS_HEADER}\nmax_threads = ${CODEX_SUBAGENT_THREAD_LIMIT}\n`);
+	return replaceOrInsertSetting(config, section, "max_threads", CODEX_SUBAGENT_THREAD_LIMIT);
+}
+
+function ensureMultiAgentV2ThreadLimit(config) {
+	const section = findSection(config, CODEX_MULTI_AGENT_V2_HEADER);
+	if (!section) {
+		return appendBlock(
+			config,
+			`${CODEX_MULTI_AGENT_V2_HEADER}\nmax_concurrent_threads_per_session = ${CODEX_SUBAGENT_THREAD_LIMIT}\n`,
+		);
+	}
+	return replaceOrInsertSetting(config, section, "max_concurrent_threads_per_session", CODEX_SUBAGENT_THREAD_LIMIT);
+}
+
+function replaceOrInsertSetting(config, section, key, value) {
+	const pattern = new RegExp(`^(\\s*)${escapeRegExp(key)}\\s*=\\s*[^\\n#]*(#[^\\n]*)?$`, "m");
+	if (pattern.test(section.text)) {
+		const patched = section.text.replace(pattern, (_match, indent, comment) => comment ? `${indent}${key} = ${value} ${comment}` : `${indent}${key} = ${value}`);
+		return config.slice(0, section.start) + patched + config.slice(section.end);
+	}
+
+	const headerEnd = section.text.indexOf("\n");
+	const insertAt = headerEnd === -1 ? section.text.length : headerEnd + 1;
+	const patched = `${section.text.slice(0, insertAt)}${headerEnd === -1 ? "\n" : ""}${key} = ${value}\n${section.text.slice(insertAt)}`;
+	return config.slice(0, section.start) + patched + config.slice(section.end);
+}
+
+function appendBlock(config, block) {
+	const trimmed = config.trimEnd();
+	const prefix = trimmed.length === 0 ? "" : `${trimmed}\n\n`;
+	return `${prefix}${block}`;
+}
+
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function stripTrailingComment(line) {
+	const idx = line.indexOf("#");
+	return idx === -1 ? line : line.slice(0, idx).trim();
+}
+
+function findSection(config, headerLine) {
+	const lines = config.match(/[^\n]*\n?|$/g) ?? [];
+	let offset = 0;
+	let start = -1;
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const trimmed = line.trim();
+		if (start === -1) {
+			if (stripTrailingComment(trimmed) === headerLine) start = offset;
+		} else {
+			const bare = stripTrailingComment(trimmed);
+			if (bare.startsWith("[") && bare.endsWith("]")) {
+				return { start, end: offset, text: config.slice(start, offset) };
+			}
+		}
+		offset += line.length;
+	}
+	if (start === -1) return null;
+	return { start, end: config.length, text: config.slice(start) };
+}

package/packages/omo-codex/plugin/scripts/migrate-codex-config.mjs

@@ -6,9 +6,12 @@ import { pathToFileURL } from "node:url";
 
 import { FALLBACK_CATALOG, readModelCatalog } from "./migrate-codex-config/catalog.mjs";
 import { configPaths } from "./migrate-codex-config/config-paths.mjs";
+import { removeStaleContext7PlaceholderMcpServer } from "./migrate-codex-config/context7-placeholder-guard.mjs";
+import { removeUnsupportedRootMultiAgentMode } from "./migrate-codex-config/multi-agent-mode-guard.mjs";
 import { forceDisableMultiAgentV2 } from "./migrate-codex-config/multi-agent-v2-guard.mjs";
 import { ensureCodexReasoningConfig as applyReasoningProfile, readRootSettings } from "./migrate-codex-config/root-settings.mjs";
 import { readState, resolveStatePath, writeState } from "./migrate-codex-config/state.mjs";
+import { ensureSubagentConcurrencyLimit } from "./migrate-codex-config/subagent-limit-guard.mjs";
 
 export { readModelCatalog } from "./migrate-codex-config/catalog.mjs";
 
@@ -22,6 +25,7 @@ export async function migrateCodexConfig({ env = process.env, cwd = process.cwd(
 	const state = await readState(statePath);
 	const paths = await configPaths({ env, cwd });
 	const changed = [];
+	const modeChanged = [];
 	const nextState = { catalogVersion: catalog.version, files: {} };
 	for (const configPath of paths) {
 		const result = await migrateConfigFile(configPath, {
@@ -29,6 +33,7 @@ export async function migrateCodexConfig({ env = process.env, cwd = process.cwd(
 			previousState: state.files?.[configPath],
 		});
 		if (result.changed) changed.push(configPath);
+		if (result.multiAgentModeChanged) modeChanged.push(configPath);
 		nextState.files[configPath] = {
 			catalogVersion: catalog.version,
 			written: result.written,
@@ -36,7 +41,7 @@ export async function migrateCodexConfig({ env = process.env, cwd = process.cwd(
 		};
 	}
 	await writeState(statePath, nextState);
-	return { changed };
+	return { changed, modeChanged };
 }
 
 export async function migrateConfigFile(configPath, { catalog = FALLBACK_CATALOG, previousState } = {}) {
@@ -55,7 +60,19 @@ export async function migrateConfigFile(configPath, { catalog = FALLBACK_CATALOG
 	const multiAgentChanged = afterMultiAgentGuard !== config;
 	if (multiAgentChanged) config = afterMultiAgentGuard;
 
-	const changed = reasoningApplied || multiAgentChanged;
+	const afterMultiAgentModeGuard = removeUnsupportedRootMultiAgentMode(config);
+	const multiAgentModeChanged = afterMultiAgentModeGuard !== config;
+	if (multiAgentModeChanged) config = afterMultiAgentModeGuard;
+
+	const afterContext7PlaceholderGuard = removeStaleContext7PlaceholderMcpServer(config);
+	const context7PlaceholderChanged = afterContext7PlaceholderGuard !== config;
+	if (context7PlaceholderChanged) config = afterContext7PlaceholderGuard;
+
+	const afterSubagentLimit = ensureSubagentConcurrencyLimit(config);
+	const subagentLimitChanged = afterSubagentLimit !== config;
+	if (subagentLimitChanged) config = afterSubagentLimit;
+
+	const changed = reasoningApplied || multiAgentChanged || multiAgentModeChanged || context7PlaceholderChanged || subagentLimitChanged;
 	if (changed) {
 		await mkdir(dirname(configPath), { recursive: true });
 		await writeFile(configPath, `${config.trimEnd()}\n`);
@@ -63,7 +80,7 @@ export async function migrateConfigFile(configPath, { catalog = FALLBACK_CATALOG
 
 	const written = decision.apply ? catalog.current : readRootSettings(config);
 	const managed = decision.apply ? true : decision.managed;
-	return { changed, written, managed };
+	return { changed, written, managed, multiAgentModeChanged };
 }
 
 function shouldApplyCatalog(config, catalog, previousState) {

package/packages/omo-codex/plugin/scripts/sync-skills.mjs

@@ -8,6 +8,8 @@ const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const sharedSkillsRoot = sharedSkillsRootPath();
 const skillsRoot = join(root, "skills");
 const sourceTestFilePattern = /\.test\.ts$/;
+const ignoredSkillSourceDirNames = new Set([".mypy_cache", ".omo", ".pytest_cache", ".ruff_cache", "__pycache__"]);
+const ignoredSkillSourceFileNames = new Set([".gitignore", ".npmignore", "pyrightconfig.json"]);
 const skillSources = [
 	["comment-checker", "components/comment-checker/skills/comment-checker"],
 	["lsp", "components/lsp/skills/lsp"],
@@ -19,6 +21,17 @@ const skillSources = [
 const componentSkillNames = new Set(skillSources.map(([name]) => name));
 const skillDisplayPrefix = "(OmO) ";
 
+function shouldCopySkillSource(source) {
+	const normalized = source.replaceAll("\\", "/");
+	const segments = normalized.split("/");
+	const name = segments.at(-1) ?? "";
+	if (segments.some((segment) => ignoredSkillSourceDirNames.has(segment))) return false;
+	if (ignoredSkillSourceFileNames.has(name)) return false;
+	if (sourceTestFilePattern.test(name) || name.endsWith(".pyc")) return false;
+	const scriptsIndex = segments.lastIndexOf("scripts");
+	return scriptsIndex === -1 || segments[scriptsIndex + 1] !== "tests";
+}
+
 const opencodeOnlyOrchestrationPattern = /\b(?:call_omo_agent|background_output|team_[a-z_]+|task)\s*\(/;
 
 const codexHarnessToolCompatibility = `## Codex Harness Tool Compatibility
@@ -37,12 +50,17 @@ This skill may include examples copied from the OpenCode harness. In Codex, do n
 
 Role-specific behavior must be described in a self-contained \`message\`. Use \`fork_context: false\` to start the child with only the initial prompt (no parent history); use \`fork_context: true\` only when full parent history is truly required. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's \`message\`. OMO installs these selectable agent roles into \`~/.codex/agents/\`: \`explorer\`, \`librarian\`, \`plan\`, \`momus\`, \`metis\`, \`lazycodex-code-reviewer\`, \`lazycodex-qa-executor\`, and \`lazycodex-gate-reviewer\` - pass the matching name as \`agent_type\` so the child gets that role's model and instructions. If the spawn tool exposes no \`agent_type\` parameter, omit it and describe the role inside \`message\`. If a code block below conflicts with this section, this section wins.
 
+On \`multi_agent_v2\` sessions the same \`agent_type\` applies (the OMO installer exposes it) with \`fork_turns\` instead of \`fork_context\`. If a code block below conflicts with this section, this section wins.
+
+When translating \`load_skills=[...]\`, include the requested skill names in the spawned agent's \`message\`. If a code block below conflicts with this section, this section wins.
+
 For work likely to exceed one wait cycle, require the child to send \`WORKING: <task> - <current phase>\` before long passes and \`BLOCKED: <reason>\` only when progress stops. A \`multi_agent_v1.wait_agent\` timeout only means no new mailbox update arrived. Treat a running child as alive. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly \`BLOCKED:\`, or no longer running.
 
 `;
 
 const codexCompatibilityEndMarkers = [
 	"For work likely to exceed one wait cycle, require the child to send `WORKING: <task> - <current phase>` before long passes and `BLOCKED: <reason>` only when progress stops. A `multi_agent_v1.wait_agent` timeout only means no new mailbox update arrived. Treat a running child as alive. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running.\n\n",
+	"On `multi_agent_v2` sessions the same `agent_type` applies (the OMO installer exposes it) with `fork_turns` instead of `fork_context`. If a code block below conflicts with this section, this section wins.\n\n",
 	"Role-specific behavior must be described in a self-contained `message`. Use `fork_context: false` to start the child with only the initial prompt (no parent history); use `fork_context: true` only when full parent history is truly required. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\n",
 	"When translating `load_skills=[...]`, include the requested skill names in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\n",
 	"When translating `load_skills=[...]`, name the skills inside the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\n",
@@ -103,26 +121,26 @@ export function insertCodexCompatibilityGuidance(content) {
 const startWorkOriginalCompletion = `When all top-level checkboxes in \`## TODOs\` and \`## Final Verification Wave\` are complete:
 
 1. Run the plan's final verification commands.
-2. If worktree mode was used, sync \`.omo/\` state back to the main repo, merge or hand off exactly as requested, and remove the worktree only after successful merge or explicit handoff.
+2. For PR/branch work, finish the lifecycle from the task-owned worktree: sync \`.omo/\` state back to the main repo, create or update the PR, wait for review/verification gates, merge by default unless explicitly opted out, and remove the worktree only after successful merge or explicit handoff.
 3. Remove or mark the Boulder work as completed.
 4. Print an \`ORCHESTRATION COMPLETE\` block with the plan path, verification commands, artifacts, and cleanup receipts.`;
 
 const startWorkCodexCompletion = `When all top-level checkboxes in \`## TODOs\` and \`## Final Verification Wave\` are complete:
 
 1. Run the plan's final verification commands.
-2. Complete the **Global Review and Debugging Gate** before any completion claim, PR handoff, or branch handoff:
+2. Complete the **Global Review and Debugging Gate** before any completion claim, PR creation, PR handoff, branch handoff, or merge:
    - Invoke the \`review-work\` skill with the final diff, changed files, user goal, constraints, run command, and verification evidence. All five review lanes must return PASS. A timeout, missing deliverable, ack-only child, \`BLOCKED:\`, or inconclusive lane is a gate failure, not approval.
    - Run a debugging-oriented runtime audit even when the review passes: name at least three plausible failure hypotheses for the changed surface, run the distinguishing checks against the actual artifact, and append the ruled-out or confirmed result to \`.omo/start-work/ledger.jsonl\`.
    - If any review lane or debugging hypothesis fails, invoke the \`debugging\` skill, confirm root cause with runtime evidence, add the minimal failing test or reproduction, fix it, rerun the affected verification, then rerun the Global Review and Debugging Gate.
    - Evidence hygiene is mandatory: redact or mask secrets and sensitive user data before writing \`.omo/start-work/ledger.jsonl\`, a PR body, or a handoff. Never include raw tokens, credentials, auth headers, cookies, API keys, env dumps, private logs, or PII; use concise summaries, lengths, hashes, or short non-sensitive prefixes instead.
-   - If the work includes creating, updating, or handing off a PR, refresh \`git status\` and the PR/branch state after the gate, and include only redacted review/debugging evidence in the PR body or handoff.
-3. If worktree mode was used, sync \`.omo/\` state back to the main repo, merge or hand off exactly as requested, and remove the worktree only after successful merge or explicit handoff.
+   - If the work includes creating, updating, or handing off a PR, refresh \`git status\` and the PR/branch state from the task-owned worktree after the gate, and include only redacted review/debugging evidence in the PR body or handoff.
+3. Finish the PR/branch lifecycle from its task-owned worktree: sync \`.omo/\` state back to the main repo, create or update the PR when requested, wait for CI/review/Cubic gates, merge by default unless explicitly opted out, and remove the worktree only after successful merge or explicit handoff.
 4. Remove or mark the Boulder work as completed.
 5. Print an \`ORCHESTRATION COMPLETE\` block with the plan path, verification commands, Global Review and Debugging Gate verdict, artifacts, and cleanup receipts.`;
 
-const startWorkOriginalHardRule = "- No completion claim while an applicable ultraqa adversarial class was never probed. Each applicable class needs a captured observable result; each skipped class needs a one-line not-applicable reason in the ledger.\n- No unprefixed session ids in Boulder state. Codex sessions are always `codex:<session_id>`.";
+const startWorkOriginalHardRule = "- No completion claim while an applicable ultraqa adversarial class was never probed. Each applicable class needs a captured observable result; each skipped class needs a one-line not-applicable reason in the ledger.\n- No PR/branch implementation, review, or merge in the main worktree; use the task-owned git worktree.\n- No unprefixed session ids in Boulder state. Codex sessions are always `codex:<session_id>`.";
 
-const startWorkCodexHardRule = "- No completion claim while an applicable ultraqa adversarial class was never probed. Each applicable class needs a captured observable result; each skipped class needs a one-line not-applicable reason in the ledger.\n- No `ORCHESTRATION COMPLETE`, final response, PR creation, or PR handoff before the Global Review and Debugging Gate passes with recorded evidence.\n- No unprefixed session ids in Boulder state. Codex sessions are always `codex:<session_id>`.";
+const startWorkCodexHardRule = "- No completion claim while an applicable ultraqa adversarial class was never probed. Each applicable class needs a captured observable result; each skipped class needs a one-line not-applicable reason in the ledger.\n- No `ORCHESTRATION COMPLETE`, final response, PR creation, PR handoff, or merge before the Global Review and Debugging Gate passes with recorded evidence.\n- No PR/branch implementation or review in the main worktree; create or use a task-owned git worktree first.\n- No unprefixed session ids in Boulder state. Codex sessions are always `codex:<session_id>`.";
 
 const reviewWorkAnchor = "Launch 5 specialized sub-agents in parallel to review completed implementation work from every angle. All 5 must pass for the review to pass. If even ONE fails, the review fails.\n";
 
@@ -132,7 +150,11 @@ gate, it is blocking. A timeout, missing deliverable, ack-only response,
 explicit \`BLOCKED:\`, or inconclusive lane is not a pass. Treat that lane as
 failed, investigate the underlying uncertainty with the \`debugging\` skill when
 runtime behavior may be wrong, fix with evidence, and rerun the affected lane
-before claiming completion or handing off a PR.
+before claiming completion, creating or handing off a PR, or merging.
+
+When reviewing a PR or branch, collect diff, file contents, and verification
+results from a dedicated review worktree attached to that branch. Never
+checkout, test, or edit the review branch in the main worktree.
 
 Review evidence must be safe to share. Redact or mask secrets and sensitive
 user data before including evidence in logs, PR bodies, or handoffs. Never
@@ -215,7 +237,7 @@ async function syncSkills() {
 	for (const skillName of sharedSkillNames) {
 		if (componentSkillNames.has(skillName)) continue;
 		await cp(join(sharedSkillsRoot, skillName), join(skillsRoot, skillName), {
-			filter: (source) => !sourceTestFilePattern.test(source),
+			filter: shouldCopySkillSource,
 			recursive: true,
 		});
 		await adaptSkillForCodex(skillName);

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

@@ -0,0 +1,128 @@
+---
+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."
+---
+
+# Coding Agent Sessions
+
+Find local coding-agent sessions across agent products before answering from memory. Prefer the bundled finder for broad cross-platform search, then read the selected session or raw file when you need exact evidence.
+
+## PHASE 0 - PLATFORM ROUTER
+
+1. **IF the user names a platform, load its reference first.**
+
+   | Platform | Read |
+   |---|---|
+   | Codex / OpenAI Codex CLI | `references/codex.md` |
+   | Claude Code / Claude Desktop histories | `references/claude.md` |
+   | Senpi / pi coding-agent 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` |
+
+2. **Run the broad finder first unless the user gave an exact file path. For fuzzy recall, expand the query first.**
+
+When the user remembers a task vaguely ("that OpenCode bug", "the dashboard PR", "when did we fix X"), derive 3-6 short query lanes before searching: product/tool aliases, repo/package names, exact error text, issue/PR/session IDs, English/Korean phrasing, and likely verbs such as `fix`, `review`, `plan`, `deploy`, or `merge`. Run the lanes together with repeated `--query` so `match_reasons` shows which wording found the hit.
+
+```bash
+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 --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>
+```
+
+Use `python` instead of `python3` on systems where that is the available executable.
+
+3. **Use explorer-style parallel lanes when one query batch is not enough.**
+
+If scope is broad (multi-month, many repos/platforms, or a vague "what happened with X"), split independent searches by names/errors, repos/cwds, platforms/models, and time windows. Use available subagent/delegation tools for these lanes when they exist; otherwise run the finder calls in parallel. Merge candidates by `id`/`path`, then read the most likely sessions.
+
+4. **Read details from search results before ad hoc digging.** Search results include `detail_hint`; run that `read <session-id> --platform <platform>` command to see the first user prompt, last user prompt, events, and child sessions together.
+
+5. **Verify by opening raw transcripts for claims.** The finder normalizes formats; the raw `path` remains the source of truth.
+
+## Output Contract
+
+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` |
+| `id` | Session ID or stable file-derived ID |
+| `path` | Raw transcript/index file |
+| `cwd` | Working directory when recoverable |
+| `created_at`, `updated_at` | ISO-like timestamps when recoverable |
+| `provider`, `model` | Model metadata when recoverable |
+| `first_user_message` | First user prompt preview (for subagents: task description + delegated prompt) |
+| `last_user_message` | Last user prompt preview when recoverable |
+| `usage` | Token/cost clues when present in the platform log |
+| `parent_id` | Parent session/thread ID when this is a subagent or child session, else `null` |
+| `agent` | Subagent label (Claude `agentType`, Codex `nickname (role)`, OpenCode agent name) |
+| `subagent_count` | Number of child sessions spawned by this session |
+| `detail_hint` | Ready-to-run `read` command for detailed inspection |
+| `match_reasons` | Search-only array explaining which field/content matched each query |
+
+Each `match_reasons` entry includes `query`, `platform`, `field`, and `snippet`, so you can tell which platform matched and what content caused the hit without opening every transcript.
+
+## Filters
+
+`list` and `search` share these filters:
+
+| Filter | Meaning |
+|---|---|
+| `--platform` | Repeatable platform filter; pass one platform per flag |
+| `--root` | Extra root to scan, repeatable |
+| `--from`, `--to` | Date bounds: `YYYY-MM-DD`, `YYYY-MM`, `YYYY`, `today`, `yesterday`, `7d` |
+| `--cwd` | Working-directory substring |
+| `--model` | Model substring |
+| `--limit` | Maximum results |
+| `--query` | Repeatable search query; multiple queries return per-query groups plus a de-duplicated merged result list |
+| `--workers` | Parallel worker count for platform scans, transcript parsing, OpenCode message joins, and multi-query matching |
+| `--include-subagents` | Include subagent/child sessions as standalone `list`/`search` results (hidden by default) |
+
+When `--platform` is omitted, the finder searches every registered platform in parallel. Each optional platform first probes fixed, known transcript roots and returns immediately when the product has no local store, so broad default searches stay cheap. Use repeatable flags such as `--platform openclaw --platform droid` only when narrowing. Comma-separated platform values are intentionally unsupported.
+
+For OpenCode, the finder uses `opencode db path` plus direct SQLite queries first, then `opencode session list --format json` as a fallback. It avoids heavy `messages/` or `parts/` scans during normal list/search, and only falls back to file joins when the OpenCode DB/CLI is unavailable or explicit `--root` values request a nonstandard store.
+
+Usage-only sources such as Copilot OTEL, Mux, Antigravity tokscale cache rows, Synthetic provider retagging, and Cursor IDE usage CSV are excluded from default transcript search because they do not reconstruct user prompts.
+
+## Subagent / Child Sessions
+
+`list` and `find`/`search` return main sessions only by default, each annotated with `subagent_count`. `read <main-session-id>` (alias: `get`) always returns a `prompts` object and a `subagents` array containing every child session (id, agent label, parent_id, prompt preview, raw path), so opening a main session reveals its whole delegation tree. `read <child-id>` works too and returns that child's own events.
+
+| Platform | Where children live | Linkage |
+|---|---|---|
+| Claude Code | `projects/<proj>/<session-id>/subagents/agent-*.jsonl` (Task tool) and `.../subagents/workflows/wf_*/agent-*.jsonl` (Workflow) | Directory name = parent session ID; `agent-*.meta.json` holds `agentType` + task description |
+| Codex | Regular threads in `state_*.sqlite` + own rollout JSONL | `thread_spawn_edges` table and `threads.source` / rollout `session_meta.payload.source.subagent.thread_spawn` |
+| OpenCode | Regular sessions in `opencode.db` / `storage/session/` | `session.parent_id` column / `parentID` field; `agent` column names the subagent |
+
+When the user asks whether some specific work was ever done, search with `--include-subagents` — delegated work often lives only in child transcripts, not in the main session. Workflow `journal.jsonl` files are orchestration logs, not sessions.
+
+## Codex Notes
+
+For Codex sessions, use the same broad finder. It reads `state_*.sqlite`, rollout JSONL, and archived rollout files:
+
+```bash
+python3 scripts/find-agent-sessions.py list --platform codex --from 7d
+python3 scripts/find-agent-sessions.py find "deploy" --platform codex
+python3 scripts/find-agent-sessions.py read <session-id> --platform codex
+```
+
+Use `references/codex.md` for Codex storage details.
+
+## Troubleshooting
+
+| Problem | Fix |
+|---|---|
+| Missing Codex sessions | Set `CODEX_HOME` or pass `--root /path/to/.codex`. |
+| 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. |
+| 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. |
+
+## Activation
+
+Use this skill for any request to find, read, or inspect a local coding-agent session, regardless of product name — including memory-recall questions ("what did I work on a few days ago", "did we already migrate X", "when did I fix Y"). If the user only says "that session where we did X", do not rely on one literal query: expand to multiple discriminative terms first, add `--include-subagents` when the work may have been delegated, then narrow by `--platform`, `cwd`, `model`, and time (`--from 7d` for "a few days ago"). Prefer the `detail_hint` from the chosen search result for the next read step. If the first query batch is still ambiguous, use explorer-style lanes by keyword, repo/cwd, platform/model, and time window before summarizing.

package/packages/omo-codex/plugin/skills/coding-agent-sessions/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "(OmO) coding-agent-sessions"
+  short_description: "Find local coding-agent session history"
+  default_prompt: "Use $coding-agent-sessions to find the coding-agent session where I worked on a recent bug."