oh-my-opencode 4.7.5 → 4.8.1

package/packages/omo-codex/plugin/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/omo-codex/plugin/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/omo-codex/plugin/skills/init-deep/SKILL.md

@@ -8,15 +8,17 @@ This skill may include examples copied from the OpenCode harness. In Codex, do n
 
 | OpenCode example | Codex tool to use |
 | --- | --- |
-| `call_omo_agent(subagent_type="explore", ...)` | `spawn_agent(agent_type="explorer", task_name="...", message="...", fork_turns="none")` |
-| `call_omo_agent(subagent_type="librarian", ...)` | `spawn_agent(agent_type="librarian", task_name="...", message="...", fork_turns="none")` |
-| `task(subagent_type="plan", ...)` | `spawn_agent(agent_type="plan", task_name="...", message="...", fork_turns="none")` |
-| `task(subagent_type="oracle", ...)` for final verification | `spawn_agent(agent_type="codex-ultrawork-reviewer", task_name="...", message="...", fork_turns="none")` |
-| `task(category="...", ...)` for implementation or QA | `spawn_agent(agent_type="worker", task_name="...", message="...", fork_turns="none")` |
-| `background_output(task_id="...")` | `wait_agent(...)` to wait for subagent completion and mailbox updates |
+| `call_omo_agent(subagent_type="explore", ...)` | `spawn_agent({"task_name":"...","message":"TASK: act as an explorer. ...","fork_turns":"none"})` |
+| `call_omo_agent(subagent_type="librarian", ...)` | `spawn_agent({"task_name":"...","message":"TASK: act as a librarian. ...","fork_turns":"none"})` |
+| `task(subagent_type="plan", ...)` | `spawn_agent({"task_name":"...","message":"TASK: act as a planning agent. ...","fork_turns":"none"})` |
+| `task(subagent_type="oracle", ...)` for final verification | `spawn_agent({"task_name":"...","message":"TASK: act as a rigorous reviewer. ...","fork_turns":"none"})` |
+| `task(category="...", ...)` for implementation or QA | `spawn_agent({"task_name":"...","message":"TASK: act as an implementation or QA worker. ...","fork_turns":"none"})` |
+| `background_output(task_id="...")` | `wait_agent(...)` for mailbox signals; after a timeout, run one `list_agents` check for the named child if reassurance is needed |
 | `team_*(...)` | Use Codex native subagents plus `send_message`, `followup_task`, `wait_agent`, and `close_agent` |
 
-Codex full-history forks inherit the parent agent type, model, and reasoning effort, so role-specific spawns with `agent_type` must use a non-full-history fork mode such as `fork_turns="none"`. 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.
+Codex full-history forks inherit parent context, so role-specific behavior must be described in a self-contained `message` and usually should use a non-full-history fork mode such as `fork_turns="none"`. 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.
+
+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 `wait_agent` timeout only means no new mailbox update arrived. Treat a running child or latest `WORKING:` message as alive. Do not use `list_agents` as a polling loop. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running.
 
 # /init-deep
 

package/packages/omo-codex/plugin/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/omo-codex/plugin/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/omo-codex/plugin/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();
+}

package/packages/omo-codex/plugin/skills/lcx-report-bug/SKILL.md

@@ -1,21 +1,25 @@
 ---
 name: lcx-report-bug
-description: "Create a high-signal LazyCodex bug report for code-yeongyu/lazycodex. Use this whenever the user asks to report, file, open, or triage a LazyCodex, lazycodex-ai, omo-codex, or Codex plugin bug, especially when they need root cause, reproduction steps, expected fix guidance, and a GitHub issue."
+description: "Create a high-signal bug issue or PR in the repo that owns the defect. Use this whenever the user asks to report, file, open, or triage a LazyCodex, lazycodex-ai, omo-codex, Codex plugin, or upstream Codex CLI bug, especially when they need source-backed root cause, reproduction steps, fix guidance, and GitHub routing."
 metadata:
-  short-description: Report LazyCodex bugs with debugging evidence
+  short-description: Route LazyCodex or Codex bugs with source evidence
 ---
 
 # lcx-report-bug
 
-You are a LazyCodex bug reporter. Produce one useful GitHub issue in English for `code-yeongyu/lazycodex`, backed by runtime evidence rather than guesses.
+You are a LazyCodex bug router and reporter. Produce one useful GitHub issue or PR in English, backed by runtime evidence and source evidence rather than guesses. Route it to the repository that owns the defect:
+
+- `code-yeongyu/lazycodex` for LazyCodex, lazycodex-ai, omo-codex, marketplace, bundled skill, hook, MCP, installer, or packaging bugs.
+- `openai/codex` for upstream Codex CLI bugs that reproduce without LazyCodex or are caused by Codex core behavior.
 
 Use GPT-5.5 style: outcome first, concise, evidence-bound. Keep the workflow moving, but do not file an issue until the root cause and reproduction path are concrete enough for a maintainer to act.
 
 ## Goal
 
-Create or prepare a GitHub issue that includes:
+Create or prepare a GitHub issue or PR that includes:
 
 - clear title
+- target repository decision
 - environment
 - reproducible steps
 - expected behavior
@@ -23,24 +27,66 @@ Create or prepare a GitHub issue that includes:
 - confirmed or strongly evidenced root cause
 - fix approach, including files or components likely involved
 - verification plan
+- `lazycodex-generated` label and footer tag
 
 ## Required Workflow
 
 1. Read the user's bug report and identify the affected surface: LazyCodex installer, Codex plugin, skill, hook, MCP, CLI alias, GitHub marketplace sync, or web/docs.
 2. Invoke `$omo:debugging` for the investigation. If Codex exposes only unqualified skill names in the current session, invoke `$debugging` and state that it is the OMO debugging skill.
-3. Follow the debugging skill far enough to gather runtime evidence:
+3. Materialize upstream Codex source under `/tmp` before deciding ownership:
+
+```bash
+CODEX_SRC="/tmp/openai-codex-source"
+if [ ! -d "$CODEX_SRC/.git" ]; then
+  gh repo clone openai/codex "$CODEX_SRC" -- --depth=1
+else
+  git -C "$CODEX_SRC" fetch --depth=1 origin
+fi
+```
+
+If `gh` is unavailable, use `git clone --depth=1 https://github.com/openai/codex "$CODEX_SRC"`.
+4. Follow the debugging skill far enough to gather runtime evidence:
    - form at least three plausible hypotheses
    - run the smallest reproduction that exercises the real surface
    - confirm the root cause by observing the failing state
    - identify the minimal fix path or maintainer action
-4. Search for an existing issue before creating a new one:
+5. Compare local LazyCodex evidence with `/tmp/openai-codex-source` before choosing the target repo. Cite exact files, commands, logs, or source paths that support the routing decision.
+6. Choose the target repo:
+   - Use `code-yeongyu/lazycodex` when the bug is in LazyCodex integration, distribution, bundled plugin code, skills, hooks, MCP wiring, installer behavior, aliases, marketplace sync, docs, or any behavior that disappears in clean upstream Codex.
+   - Use `openai/codex` when the bug reproduces in clean upstream Codex without LazyCodex, or the failing behavior comes from Codex CLI core, plugin API contracts, sandboxing, approvals, config loading, or built-in tool behavior.
+   - If ownership remains ambiguous after evidence gathering, do not guess. Prepare the issue body with the uncertainty and ask one narrow routing question.
+7. Search for an existing issue in the selected repo before creating a new one. Search the other repo too when the ownership boundary is close:
 
 ```bash
-gh issue list --repo code-yeongyu/lazycodex --search "<short error or symptom>" --state open
+TARGET_REPO="code-yeongyu/lazycodex" # or openai/codex
+gh issue list --repo "$TARGET_REPO" --search "<short error or symptom>" --state open
 ```
 
-5. If a matching open issue exists, add a comment with the new evidence instead of creating a duplicate.
-6. If no matching issue exists, create the issue with `gh`.
+8. If a matching open issue exists, add a comment with the new evidence instead of creating a duplicate.
+9. Ensure the generated label exists in repositories you control:
+
+```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
+```
+
+If the selected repo is `openai/codex` and label management is not available, still include the footer tag in the body and continue without claiming label creation succeeded.
+10. If no matching issue exists, create the issue with `gh` and apply the `lazycodex-generated` label.
+11. Create a PR only when the user asked for a PR, the fix is already implemented on a branch, or the smallest correct fix can be safely made in the selected repo. Apply the `lazycodex-generated` label to every PR created by this skill. Otherwise create an issue with fix guidance.
+
+## Required Label And Footer
+
+Every issue body, evidence comment, and PR body created by this skill must use the GitHub label `lazycodex-generated` when the artifact supports labels. It must also end with this footer. Do not put content after it.
+
+```markdown
+---
+This issue or PR was generated by LazyCodex.
+Tag: lazycodex-generated
+```
 
 ## Issue Body Template
 
@@ -57,6 +103,12 @@ Write the issue body in English and keep it direct:
 - Install method:
 - Relevant config:
 
+## Repository Decision
+- Target repository:
+- Why this belongs there:
+- LazyCodex evidence:
+- Upstream Codex source evidence from `/tmp/openai-codex-source`:
+
 ## Reproduction
 1. [Exact command or UI action]
 2. [Exact next step]
@@ -81,6 +133,40 @@ Write the issue body in English and keep it direct:
 - [Check that reproduces the original failure]
 - [Check that proves the fix]
 - [Regression check for adjacent LazyCodex/Codex plugin behavior]
+
+---
+This issue or PR was generated by LazyCodex.
+Tag: lazycodex-generated
+```
+
+## PR Body Template
+
+Use this when a PR is the right artifact:
+
+```markdown
+## Summary
+[One or two sentences describing the fix and the user-visible failure it resolves.]
+
+## Repository Decision
+- Target repository:
+- Why this belongs there:
+- LazyCodex evidence:
+- Upstream Codex source evidence from `/tmp/openai-codex-source`:
+
+## Root Cause
+[Confirmed cause. Cite runtime evidence and source paths.]
+
+## Fix
+[What changed and why.]
+
+## Verification
+- [Check that reproduced the original failure before the fix]
+- [Check that passes after the fix]
+- [Regression check for adjacent behavior]
+
+---
+This issue or PR was generated by LazyCodex.
+Tag: lazycodex-generated
 ```
 
 ## GitHub Creation Path
@@ -90,18 +176,35 @@ Prefer `gh`:
 ```bash
 ISSUE_BODY="/tmp/lcx-report-bug-$(date +%Y%m%d-%H%M%S).md"
 $EDITOR "$ISSUE_BODY"
-gh issue create --repo code-yeongyu/lazycodex --title "<clear title>" --body-file "$ISSUE_BODY"
+gh issue create --repo "$TARGET_REPO" --title "<clear title>" "${LABEL_ARGS[@]}" --body-file "$ISSUE_BODY"
 ```
 
 If `$EDITOR` is not usable, write the file with the available file-editing tool, then run the same `gh issue create` command.
 
-After creating or commenting, return the issue URL and a short summary of the evidence used.
+For an existing issue:
+
+```bash
+COMMENT_BODY="/tmp/lcx-report-bug-comment-$(date +%Y%m%d-%H%M%S).md"
+gh issue comment "<issue-number>" --repo "$TARGET_REPO" --body-file "$COMMENT_BODY"
+if [ "${#LABEL_ARGS[@]}" -gt 0 ]; then
+  gh issue edit "<issue-number>" --repo "$TARGET_REPO" --add-label lazycodex-generated
+fi
+```
+
+For a PR from a branch pushed to the selected repo or fork:
+
+```bash
+PR_BODY="/tmp/lcx-report-bug-pr-$(date +%Y%m%d-%H%M%S).md"
+gh pr create --repo "$TARGET_REPO" --title "<clear title>" "${LABEL_ARGS[@]}" --body-file "$PR_BODY"
+```
+
+After creating or commenting, return the issue or PR URL and a short summary of the evidence used.
 
 ## Browser use fallback
 
 If `gh` is unavailable, unauthenticated, or blocked, use Browser Use against the real GitHub page:
 
-1. Open `https://github.com/code-yeongyu/lazycodex/issues/new`.
+1. Open the new issue page for the selected repo: `https://github.com/code-yeongyu/lazycodex/issues/new` or `https://github.com/openai/codex/issues/new`.
 2. Fill the title and body from the template.
 3. Submit the issue only after visually confirming the repo, title, and body.
 4. Capture the resulting issue URL.
@@ -110,7 +213,7 @@ If `gh` is unavailable, unauthenticated, or blocked, use Browser Use against the
 
 If Browser Use is unavailable but a desktop browser is open and authenticated, use Computer Use:
 
-1. Navigate to `https://github.com/code-yeongyu/lazycodex/issues/new`.
+1. Navigate to the new issue page for the selected repo: `https://github.com/code-yeongyu/lazycodex/issues/new` or `https://github.com/openai/codex/issues/new`.
 2. Fill the title and body.
 3. Verify the target repository and final text before submission.
 4. Submit and capture the issue URL.
@@ -124,4 +227,6 @@ Do not file:
 - a vague issue without reproduction steps
 - an issue that claims a root cause not supported by runtime evidence
 - a duplicate when commenting on an existing issue is enough
-- a fix PR unless the user separately asks for one
+- an upstream Codex issue without checking `/tmp/openai-codex-source`
+- a LazyCodex issue when the bug is proven to reproduce in clean upstream Codex
+- a fix PR without a concrete branch, implemented fix, and verification result

package/packages/omo-codex/plugin/skills/lcx-report-bug/agents/openai.yaml

@@ -1,9 +1,11 @@
 interface:
   display_name: "lcx-report-bug (omo)"
-  short_description: "Report LazyCodex bugs with debugging evidence"
+  short_description: "Route LazyCodex or Codex bugs with source evidence"
   search_terms:
     - "lcx-report-bug"
     - "lazycodex bug"
     - "lazycodex issue"
     - "omo-codex bug"
-  default_prompt: "Use $lcx-report-bug to investigate this LazyCodex bug and file a clear issue with reproduction, root cause, and fix guidance."
+    - "openai codex bug"
+    - "codex upstream issue"
+  default_prompt: "Use $lcx-report-bug to investigate this LazyCodex or Codex bug, compare LazyCodex evidence with /tmp openai/codex source, choose the correct GitHub repo, and file an issue or PR with reproduction, root cause, fix guidance, and the lazycodex-generated label and footer."