oh-my-opencode 4.7.4 → 4.8.0

package/packages/omo-codex/scripts/install-project-local-cleanup.test.mjs

@@ -72,7 +72,6 @@ test("#given root and nested project-local Codex configs #when script cleanup ru
 	await mkdir(join(projectRoot, ".git"), { recursive: true });
 	await mkdir(join(projectRoot, ".codex"), { recursive: true });
 	await mkdir(join(projectDirectory, ".codex"), { recursive: true });
-	await mkdir(join(projectDirectory, ".omx"), { recursive: true });
 	await writeFile(join(projectDirectory, ".codex", "hooks.json"), "{}\n");
 	await writeFile(
 		rootConfigPath,
@@ -122,7 +121,7 @@ test("#given root and nested project-local Codex configs #when script cleanup ru
 	assert.match(nestedContent, /job_max_runtime_seconds = 7200/);
 	assert.deepEqual(
 		result.artifacts.map((artifact) => artifact.path).sort(),
-		[join(projectDirectory, ".codex", "hooks.json"), join(projectDirectory, ".omx")],
+		[join(projectDirectory, ".codex", "hooks.json")],
 	);
 });
 
@@ -194,6 +193,78 @@ test("#given project-local config is a symlink to CODEX_HOME #when script cleanu
 	assert.match(content, /max_depth = 4/);
 });
 
+test("#given project-local Codex config is a symlink #when script cleanup runs #then symlink target is not modified", async () => {
+	if (process.platform === "win32") return;
+
+	const projectRoot = await makeTempDir();
+	const codexHome = await makeTempDir();
+	const victimDir = await makeTempDir();
+	const victimConfigPath = join(victimDir, "victim.toml");
+	const projectConfigPath = join(projectRoot, `.codex`, "config.toml");
+	const victimBefore = [
+		"[features.multi_agent_v2]",
+		"enabled=true",
+		"",
+		"[agents]",
+		"max_threads=10",
+		"max_depth=4",
+		"",
+	].join("\n");
+
+	await mkdir(join(projectRoot, ".git"), { recursive: true });
+	await mkdir(join(projectRoot, ".codex"), { recursive: true });
+	await writeFile(victimConfigPath, victimBefore);
+	await symlink(victimConfigPath, projectConfigPath);
+
+	const result = await repairNearestProjectLocalCodexArtifacts({
+		startDirectory: projectRoot,
+		codexHome,
+		now: () => new Date("2026-06-01T00:00:00Z"),
+	});
+
+	assert.equal(result.configPath, null);
+	assert.equal(result.changed, false);
+	assert.equal(result.backupPath, undefined);
+	assert.equal(await pathExists(`${projectConfigPath}.backup-2026-06-01T00-00-00-000Z`), false);
+	assert.equal(await readFile(victimConfigPath, "utf8"), victimBefore);
+});
+
+test("#given project-local .codex directory is a symlink #when script cleanup runs #then symlink target is not modified", async () => {
+	if (process.platform === "win32") return;
+
+	const projectRoot = await makeTempDir();
+	const codexHome = await makeTempDir();
+	const outsideCodexDir = await makeTempDir();
+	const outsideConfigPath = join(outsideCodexDir, "config.toml");
+	const projectCodexPath = join(projectRoot, ".codex");
+	const outsideBefore = [
+		"[features.multi_agent_v2]",
+		"enabled=true",
+		"",
+		"[agents]",
+		"max_threads=10",
+		"max_depth=4",
+		"",
+	].join("\n");
+
+	await mkdir(join(projectRoot, ".git"), { recursive: true });
+	await mkdir(outsideCodexDir, { recursive: true });
+	await writeFile(outsideConfigPath, outsideBefore);
+	await symlink(outsideCodexDir, projectCodexPath);
+
+	const result = await repairNearestProjectLocalCodexArtifacts({
+		startDirectory: projectRoot,
+		codexHome,
+		now: () => new Date("2026-06-01T00:00:00Z"),
+	});
+
+	assert.equal(result.configPath, null);
+	assert.equal(result.changed, false);
+	assert.equal(result.backupPath, undefined);
+	assert.equal(await pathExists(join(projectCodexPath, "config.toml.backup-2026-06-01T00-00-00-000Z")), false);
+	assert.equal(await readFile(outsideConfigPath, "utf8"), outsideBefore);
+});
+
 test("#given malformed project directory from the environment #when script cleanup runs #then it skips project-local cleanup without failing install", async () => {
 	const codexHome = await makeTempDir();
 

package/packages/omo-codex/scripts/sync-telemetry-component.mjs

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
 export const TELEMETRY_SYNC_FILES = [
 	"atomic-write.ts",
 	"data-path.ts",
+	"diagnostics.ts",
 	"env-flags.ts",
 	"posthog-activity-state.ts",
 ];

package/packages/shared-skills/skills/debugging/references/methodology/04-oracle-triple.md

@@ -48,7 +48,7 @@ task(subagent_type="oracle", load_skills=[], run_in_background=true,
      - attached to the wrong instance of the service
      - test harness running different code than the app
      - editing src/ while running dist/
-     
+
      Give me exactly three candidate causes ranked by likelihood, with one sentence each explaining why our evidence is consistent with each.")
 
 task(subagent_type="oracle", load_skills=[], run_in_background=true,
@@ -64,7 +64,7 @@ task(subagent_type="oracle", load_skills=[], run_in_background=true,
      - shared-library version mismatch (system lib vs bundled lib)
      - ABI difference (native addons, glibc versions, musl vs glibc)
      - wrong transport (HTTP/1.1 vs HTTP/2, TLS version negotiation)
-     
+
      Give me three candidate causes, each naming the specific boundary and the specific contract assumption that might be violated.")
 
 task(subagent_type="oracle", load_skills=[], run_in_background=true,
@@ -75,7 +75,7 @@ task(subagent_type="oracle", load_skills=[], run_in_background=true,
      Enumerate the five assumptions most load-bearing to our current hypotheses, then for each:
      - describe the smallest runtime query that would falsify it
      - predict what the observable would be if the invariant holds vs if it fails
-     
+
      We want at least one of these queries to be decisive.")
 ```
 

package/packages/shared-skills/skills/git-master/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: git-master
+description: "MUST USE whenever a task needs a commit or git-history investigation. Covers atomic commits, staging, commit-message style, rebase, squash, fixup/autosquash, blame, bisect, reflog, git log -S/-G, and questions like who wrote this or when was this added. Do not use for ordinary code edits unless the user asks for git work."
+---
+
+# Git Master
+
+Use this skill when the user asks you to operate on Git history or answer a Git-history question. Be exact, conservative, and evidence-led. Read the repository state before you infer anything.
+
+## Mode Gate
+
+Classify the request first:
+
+- `COMMIT`: stage and commit local changes.
+- `REBASE`: rebase, squash, fixup, autosquash, reorder, split, or otherwise rewrite branch history.
+- `HISTORY`: answer when, where, who, why, or which commit changed something.
+- `STATUS`: inspect branch, diff, or working-tree state without changing it.
+
+Do not commit, rebase, push, force-push, reset, stash-pop, or delete anything unless the user explicitly asked for that operation. If the request is only investigative, report findings and stop.
+
+## Ground Truth
+
+Gather independent facts in parallel when the tools allow it:
+
+```bash
+git status --short
+git diff --stat
+git diff --staged --stat
+git branch --show-current
+git log -30 --oneline
+git log -30 --pretty=format:%s
+git rev-parse --abbrev-ref @{upstream}
+git merge-base HEAD origin/main
+git merge-base HEAD origin/master
+```
+
+Missing upstream or missing `main`/`master` is normal. Fall back to the best available branch or report the missing fact. Never treat a failed lookup as proof.
+
+## Commit Mode
+
+Commit only the user's requested changes. Preserve unrelated dirty work.
+
+1. Detect message style from recent history. Use the dominant local pattern, language, and casing. Do not default to Conventional Commits unless the repo uses them.
+2. Inspect the full diff, not only filenames. Separate unrelated user edits from the requested commit.
+3. Build atomic groups by behavior, module, and revertability. Keep implementation and its direct tests together.
+4. Prefer multiple commits for unrelated concerns. A single commit is acceptable only when the changed files form one indivisible behavior or the user explicitly asks for one commit.
+5. Stage by path or hunk so each commit contains only its atomic group.
+6. Before each commit, verify `git diff --staged --stat` and enough staged diff to prove the group is right.
+7. Commit with the detected style. After each commit, verify `git log -1 --oneline`.
+
+Grouping rules:
+
+- Split different features, modules, generated artifacts, config, docs, and test-only changes unless they are inseparable.
+- Keep generated files with the source change that produced them when omitting them would leave the repo inconsistent.
+- Never hide failing or unrelated changes inside a broad commit.
+
+Final report: list commit hashes, messages, and any remaining uncommitted files.
+
+## Rebase Mode
+
+History rewriting is a shared-impact operation.
+
+- Never rebase or rewrite `main`, `master`, `dev`, release branches, or a protected branch unless the user explicitly named that exact operation.
+- If commits may already be pushed, ask before force-pushing. Use `--force-with-lease`, never plain `--force`.
+- If the worktree is dirty, preserve it intentionally before rebasing. Do not stash-pop over conflicts without checking what changed.
+- For fixups, prefer `git commit --fixup=<hash>` followed by `GIT_SEQUENCE_EDITOR=: git rebase -i --autosquash <base>`.
+- For conflicts, read the conflicting files and resolve by intent. Do not choose ours/theirs blindly.
+- If a rebase goes wrong, use `git rebase --abort` first. Use reflog only after explaining the recovery path.
+
+After rewriting, run the relevant tests or at least the project's cheapest smoke check, then show the new branch log from base to HEAD.
+
+## History Mode
+
+Choose the Git tool by the question:
+
+- `git log -S "text"`: when the count of an exact string changed.
+- `git log -G "regex"`: when diffs touched lines matching a pattern.
+- `git blame -L start,end -- file`: who last changed specific lines.
+- `git log --follow -- file`: history across renames for one file.
+- `git show <hash>`: inspect the commit that appears relevant.
+- `git bisect`: find the first bad commit when there is a deterministic pass/fail command and known good/bad bounds.
+- `git reflog`: recover or explain recent local history movement.
+
+Always cite the exact command evidence in the answer: commit hash, subject, file path, and line or diff context when relevant. If the evidence is ambiguous, say what remains unproven.
+
+## Safety Checks
+
+Before any write to Git history:
+
+- Current branch is known.
+- Dirty work is accounted for.
+- Upstream/pushed status is known or explicitly unknown.
+- The operation matches the user's request.
+- Recovery path is known (`rebase --abort`, reflog hash, or untouched worktree).
+
+Before finishing:
+
+- Run the most relevant verification available for the changed behavior or history operation.
+- Report commands that passed and any command you could not run.
+- Leave the worktree state explicit.

package/packages/shared-skills/skills/git-master/agents/openai.yaml

@@ -0,0 +1,13 @@
+interface:
+  display_name: "git-master (omo)"
+  short_description: "Atomic Git commits, history surgery, and source archaeology"
+  search_terms:
+    - "git-master"
+    - "git commit"
+    - "atomic commit"
+    - "rebase"
+    - "squash"
+    - "git blame"
+    - "git bisect"
+    - "history search"
+  default_prompt: "Use $git-master to inspect the repository state, preserve unrelated work, and handle the requested Git operation with atomic grouping, history safety checks, and evidence-backed verification."

package/packages/shared-skills/skills/lcx-contribute-bug-fix/SKILL.md

@@ -0,0 +1,176 @@
+---
+name: lcx-contribute-bug-fix
+description: "Contribute a verified bug-fix PR for LazyCodex, lazycodex-ai, omo-codex, bundled Codex skills, or upstream Codex CLI bugs. Use when the user asks to fix a bug, contribute a bug fix, contribute to fix bug, open a PR for a bug, or debug and PR a LazyCodex/Codex defect."
+metadata:
+  short-description: Contribute verified LazyCodex or Codex bug-fix PRs
+---
+
+# lcx-contribute-bug-fix
+
+Use this skill to debug a concrete LazyCodex or Codex defect, implement the smallest correct fix in a fresh temporary workspace, and open a GitHub PR. Work in English, keep the PR body short, and support every claim with runtime or source evidence.
+
+Route ownership the same way as `$lcx-report-bug`:
+
+- `code-yeongyu/lazycodex` for LazyCodex, lazycodex-ai, omo-codex, bundled skills, hooks, MCP wiring, installer behavior, marketplace sync, docs, or packaging.
+- `openai/codex` for upstream Codex CLI bugs that reproduce without LazyCodex or come from Codex core behavior.
+
+## Required Outcome
+
+Create a PR that includes:
+
+- a focused branch from a fresh `/tmp` clone/worktree
+- reproduction logs from before the fix
+- the smallest implementation that fixes the defect
+- verification logs from after the fix
+- apply `lazycodex-generated` when label management is available
+- the required LazyCodex footer tag `Tag: lazycodex-generated`
+- cleanup of temporary worktrees and clones
+
+## Required Workflow
+
+1. Read the user's bug report and identify the affected surface.
+2. Invoke `$omo:debugging` for the investigation. If only unqualified skill names are exposed, invoke `$debugging` and state that it is the OMO debugging skill.
+3. Decide the target repository. If ownership is close, compare against upstream Codex source under `/tmp/openai-codex-source` before choosing.
+4. Create a fresh temporary clone and branch. Do not modify the user's current repository for the target fix unless the current repository is itself the requested target and the user explicitly asked for local edits.
+
+```bash
+TARGET_REPO="code-yeongyu/lazycodex" # or openai/codex
+WORK_ROOT="$(mktemp -d /tmp/lazycodex-fix-XXXXXX)"
+gh repo clone "$TARGET_REPO" "$WORK_ROOT/repo" -- --depth=1
+cd "$WORK_ROOT/repo"
+BASE_BRANCH="$(git remote show origin | sed -n '/HEAD branch/s/.*: //p')"
+git fetch origin "$BASE_BRANCH" --depth=1
+BRANCH_NAME="lazycodex/bug-fix-<short-slug>"
+git worktree add "$WORK_ROOT/worktree" -b "$BRANCH_NAME" "origin/$BASE_BRANCH"
+cd "$WORK_ROOT/worktree"
+```
+
+If `gh` cannot clone, use `git clone --depth=1 "https://github.com/$TARGET_REPO" "$WORK_ROOT/repo"` and continue with the same worktree flow.
+
+5. Reproduce the bug in the worktree through the real surface. Save exact command output to `/tmp/lazycodex-fix-<short-slug>-repro.log`.
+6. Write or update a failing regression test before production changes. Confirm it fails for the bug, not for a missing fixture or typo.
+7. Implement the smallest correct fix. Avoid refactors unless the fix cannot be made safely without one.
+8. Run the regression test, adjacent tests, and the smallest real-surface QA command that proves the user-visible behavior changed.
+9. Commit the verified fix before pushing. Inspect the status first so the PR cannot be empty or stale:
+
+```bash
+git status --short
+git add -A
+git commit -m "fix: <short bug-fix summary>"
+git log --oneline "origin/$BASE_BRANCH..HEAD"
+```
+
+10. Generate the PR body with `scripts/create-pr-body.mjs`.
+11. Ensure the generated label exists when the target repo allows label management. Keep the footer tag even when label creation is unavailable:
+
+```bash
+LABEL_ARGS=()
+if gh label create lazycodex-generated --repo "$TARGET_REPO" --color "7C3AED" --description "Created by LazyCodex" --force; then
+  LABEL_ARGS=(--label lazycodex-generated)
+else
+  echo "Label management unavailable for $TARGET_REPO; keeping the footer tag only."
+fi
+```
+
+12. Push to a writable remote, then create the PR. For upstream `openai/codex`, fork first and use the fork as the head repository:
+
+```bash
+PUSH_REMOTE="origin"
+PR_HEAD="$BRANCH_NAME"
+if [ "$TARGET_REPO" = "openai/codex" ]; then
+  gh repo fork "$TARGET_REPO" --remote --remote-name fork
+  PUSH_REMOTE="fork"
+  GH_USER="$(gh api user --jq .login)"
+  PR_HEAD="$GH_USER:$BRANCH_NAME"
+fi
+
+git push -u "$PUSH_REMOTE" "$BRANCH_NAME"
+gh pr create --repo "$TARGET_REPO" --base "$BASE_BRANCH" --head "$PR_HEAD" --title "<short fix title>" "${LABEL_ARGS[@]}" --body-file "$PR_BODY"
+```
+
+13. Clean up:
+
+```bash
+cd /
+git -C "$WORK_ROOT/repo" worktree remove "$WORK_ROOT/worktree"
+find "$WORK_ROOT" -mindepth 1 -maxdepth 1 -exec rm -r -- {} +
+rmdir "$WORK_ROOT"
+```
+
+Return the PR URL, the reproduction command, the verification command, and the cleanup receipt.
+
+## PR Body Generator
+
+Use the bundled script to generate the PR body. Create a JSON file with this shape:
+
+```json
+{
+  "title": "Fix short user-visible failure",
+  "targetRepository": "code-yeongyu/lazycodex",
+  "problem": "What is broken for the user.",
+  "reproductionLogs": "Exact failing command, log excerpt, or trace.",
+  "approach": "What changed and why this is the smallest correct fix.",
+  "confidence": "Why the diagnosis and fix are strongly supported.",
+  "risks": "Risk level and what could regress.",
+  "userVisibleBehaviorChanges": "What changes for the user after the PR.",
+  "verification": ["failing test before fix", "passing test after fix", "manual QA command"]
+}
+```
+
+Run:
+
+```bash
+PR_INPUT="/tmp/lazycodex-fix-<short-slug>-pr.json"
+PR_BODY="/tmp/lazycodex-fix-<short-slug>-pr.md"
+node "<skill-root>/scripts/create-pr-body.mjs" "$PR_INPUT" "$PR_BODY"
+```
+
+## PR Body Template
+
+The generated body must follow this structure:
+
+```markdown
+## Problem Situation
+[What failed for the user.]
+
+## Reproduction Logs
+[Exact failing command and relevant log excerpt.]
+
+## Approach
+[What changed and why.]
+
+## Why I Am Confident
+[Evidence that proves the root cause and fix.]
+
+## Risks
+[Risk level and possible regressions.]
+
+## User-Visible Behavior Changes
+[What users experience after this PR.]
+
+## Verification
+- [RED test output or repro before the fix]
+- [GREEN test output after the fix]
+- [Manual QA command and result]
+
+---
+This PR was debugged, implemented, and created with [LazyCodex](https://github.com/code-yeongyu/lazycodex).
+Tag: lazycodex-generated
+```
+
+## Stop Conditions
+
+Stop and ask one narrow question only when:
+
+- the bug cannot be reproduced from available information
+- target repository ownership remains ambiguous after comparing LazyCodex and upstream Codex evidence
+- authentication is missing for pushing or creating the PR
+- the fix requires a product decision rather than a technical correction
+
+Do not open:
+
+- a PR without a failing-before and passing-after test
+- a PR without a real-surface QA command
+- a PR without the `Tag: lazycodex-generated` footer
+- a vague fix that does not identify the root cause
+- a broad refactor disguised as a bug fix

package/packages/shared-skills/skills/lcx-contribute-bug-fix/agents/openai.yaml

@@ -0,0 +1,12 @@
+interface:
+  display_name: "lcx-contribute-bug-fix (omo)"
+  short_description: "Contribute verified LazyCodex or Codex bug-fix PRs"
+  search_terms:
+    - "lcx-contribute-bug-fix"
+    - "contribute a bug fix"
+    - "contribute to fix bug"
+    - "fix bug pr"
+    - "lazycodex fix"
+    - "omo-codex bug fix"
+    - "codex bug fix pr"
+  default_prompt: "Use $lcx-contribute-bug-fix to debug this LazyCodex or Codex bug, work from a fresh /tmp clone and worktree, implement the smallest verified fix, generate the PR body, apply the lazycodex-generated label, open the PR, and clean up."

package/packages/shared-skills/skills/lcx-contribute-bug-fix/scripts/create-pr-body.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import { readFile, writeFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+
+const REQUIRED_STRING_FIELDS = [
+	"title",
+	"targetRepository",
+	"problem",
+	"reproductionLogs",
+	"approach",
+	"confidence",
+	"risks",
+	"userVisibleBehaviorChanges",
+];
+
+function requireRecord(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) {
+		throw new Error("input must be a JSON object");
+	}
+	return value;
+}
+
+function requireStringField(record, field) {
+	const value = record[field];
+	if (typeof value !== "string" || value.trim() === "") {
+		throw new Error(`${field} must be a non-empty string`);
+	}
+	return value.trim();
+}
+
+function requireVerification(record) {
+	const value = record.verification;
+	if (!Array.isArray(value) || value.length === 0) {
+		throw new Error("verification must be a non-empty string array");
+	}
+	return value.map((entry, index) => {
+		if (typeof entry !== "string" || entry.trim() === "") {
+			throw new Error(`verification[${index}] must be a non-empty string`);
+		}
+		return entry.trim();
+	});
+}
+
+function parseInput(value) {
+	const record = requireRecord(value);
+	const strings = Object.fromEntries(REQUIRED_STRING_FIELDS.map((field) => [field, requireStringField(record, field)]));
+	return {
+		title: strings.title,
+		targetRepository: strings.targetRepository,
+		problem: strings.problem,
+		reproductionLogs: strings.reproductionLogs,
+		approach: strings.approach,
+		confidence: strings.confidence,
+		risks: strings.risks,
+		userVisibleBehaviorChanges: strings.userVisibleBehaviorChanges,
+		verification: requireVerification(record),
+	};
+}
+
+function bulletList(items) {
+	return items.map((item) => `- ${item}`).join("\n");
+}
+
+export function createLazyCodexBugFixPrBody(value) {
+	const input = parseInput(value);
+	return `## Problem Situation
+${input.problem}
+
+## Reproduction Logs
+${input.reproductionLogs}
+
+## Approach
+${input.approach}
+
+## Why I Am Confident
+${input.confidence}
+
+## Risks
+${input.risks}
+
+## User-Visible Behavior Changes
+${input.userVisibleBehaviorChanges}
+
+## Verification
+${bulletList(input.verification)}
+
+---
+This PR was debugged, implemented, and created with [LazyCodex](https://github.com/code-yeongyu/lazycodex).
+Tag: lazycodex-generated
+`;
+}
+
+async function main() {
+	const [, , inputPath, outputPath] = process.argv;
+	if (typeof inputPath !== "string" || inputPath.trim() === "") {
+		throw new Error("usage: create-pr-body.mjs <input.json> <output.md>");
+	}
+	if (typeof outputPath !== "string" || outputPath.trim() === "") {
+		throw new Error("usage: create-pr-body.mjs <input.json> <output.md>");
+	}
+	const parsed = JSON.parse(await readFile(inputPath, "utf8"));
+	await writeFile(outputPath, createLazyCodexBugFixPrBody(parsed), "utf8");
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	await main();
+}