oh-my-opencode 4.10.0 → 4.11.0

package/dist/skills/init-deep/SKILL.md

@@ -0,0 +1,309 @@
+---
+name: init-deep
+description: "(builtin) Initialize hierarchical AGENTS.md knowledge base"
+---
+# /init-deep
+
+Generate hierarchical AGENTS.md files. Root + complexity-scored subdirectories.
+
+## Usage
+
+```
+/init-deep                      # Update mode: modify existing + create new where warranted
+/init-deep --create-new         # Read existing → remove all → regenerate from scratch
+/init-deep --max-depth=2        # Limit directory depth (default: 3)
+```
+
+---
+
+## Workflow (High-Level)
+
+1. **Discovery + Analysis** (concurrent)
+   - Fire background explore agents immediately
+   - Main session: bash structure + LSP codemap + read existing AGENTS.md
+2. **Score & Decide** - Determine AGENTS.md locations from merged findings
+3. **Generate** - Root first, then subdirs in parallel
+4. **Review** - Deduplicate, trim, validate
+
+<critical>
+**TodoWrite ALL phases. Mark in_progress → completed in real-time.**
+```
+TodoWrite([
+  { id: "discovery", content: "Fire explore agents + LSP codemap + read existing", status: "pending", priority: "high" },
+  { id: "scoring", content: "Score directories, determine locations", status: "pending", priority: "high" },
+  { id: "generate", content: "Generate AGENTS.md files (root + subdirs)", status: "pending", priority: "high" },
+  { id: "review", content: "Deduplicate, validate, trim", status: "pending", priority: "medium" }
+])
+```
+</critical>
+
+---
+
+## Phase 1: Discovery + Analysis (Concurrent)
+
+**Mark "discovery" as in_progress.**
+
+### Fire Background Explore Agents IMMEDIATELY
+
+Don't wait-these run async while main session works.
+
+```
+// Fire all at once, collect results later
+task(subagent_type="explore", load_skills=[], description="Explore project structure", run_in_background=true, prompt="Project structure: PREDICT standard patterns for detected language → REPORT deviations only")
+task(subagent_type="explore", load_skills=[], description="Find entry points", run_in_background=true, prompt="Entry points: FIND main files → REPORT non-standard organization")
+task(subagent_type="explore", load_skills=[], description="Find conventions", run_in_background=true, prompt="Conventions: FIND config files (.eslintrc, pyproject.toml, .editorconfig) → REPORT project-specific rules")
+task(subagent_type="explore", load_skills=[], description="Find anti-patterns", run_in_background=true, prompt="Anti-patterns: FIND 'DO NOT', 'NEVER', 'ALWAYS', 'DEPRECATED' comments → LIST forbidden patterns")
+task(subagent_type="explore", load_skills=[], description="Explore build/CI", run_in_background=true, prompt="Build/CI: FIND .github/workflows, Makefile → REPORT non-standard patterns")
+task(subagent_type="explore", load_skills=[], description="Find test patterns", run_in_background=true, prompt="Test patterns: FIND test configs, test structure → REPORT unique conventions")
+```
+
+<dynamic-agents>
+**DYNAMIC AGENT SPAWNING**: After bash analysis, spawn ADDITIONAL explore agents based on project scale:
+
+| Factor | Threshold | Additional Agents |
+|--------|-----------|-------------------|
+| **Total files** | >100 | +1 per 100 files |
+| **Total lines** | >10k | +1 per 10k lines |
+| **Directory depth** | ≥4 | +2 for deep exploration |
+| **Large files (>500 lines)** | >10 files | +1 for complexity hotspots |
+| **Monorepo** | detected | +1 per package/workspace |
+| **Multiple languages** | >1 | +1 per language |
+
+```bash
+# Measure project scale first
+total_files=$(find . -type f -not -path '*/node_modules/*' -not -path '*/.git/*' | wc -l)
+total_lines=$(find . -type f \\( -name "*.ts" -o -name "*.py" -o -name "*.go" \\) -not -path '*/node_modules/*' -exec wc -l {} + 2>/dev/null | tail -1 | awk '{print $1}')
+large_files=$(find . -type f \\( -name "*.ts" -o -name "*.py" \\) -not -path '*/node_modules/*' -exec wc -l {} + 2>/dev/null | awk '$1 > 500 {count++} END {print count+0}')
+max_depth=$(find . -type d -not -path '*/node_modules/*' -not -path '*/.git/*' | awk -F/ '{print NF}' | sort -rn | head -1)
+```
+
+Example spawning:
+```
+// 500 files, 50k lines, depth 6, 15 large files → spawn 5+5+2+1 = 13 additional agents
+task(subagent_type="explore", load_skills=[], description="Analyze large files", run_in_background=true, prompt="Large file analysis: FIND files >500 lines, REPORT complexity hotspots")
+task(subagent_type="explore", load_skills=[], description="Explore deep modules", run_in_background=true, prompt="Deep modules at depth 4+: FIND hidden patterns, internal conventions")
+task(subagent_type="explore", load_skills=[], description="Find shared utilities", run_in_background=true, prompt="Cross-cutting concerns: FIND shared utilities across directories")
+// ... more based on calculation
+```
+</dynamic-agents>
+
+### Main Session: Concurrent Analysis
+
+**While background agents run**, main session does:
+
+#### 1. Bash Structural Analysis
+```bash
+# Directory depth + file counts
+find . -type d -not -path '*/\\.*' -not -path '*/node_modules/*' -not -path '*/venv/*' -not -path '*/dist/*' -not -path '*/build/*' | awk -F/ '{print NF-1}' | sort -n | uniq -c
+
+# Files per directory (top 30)
+find . -type f -not -path '*/\\.*' -not -path '*/node_modules/*' | sed 's|/[^/]*$||' | sort | uniq -c | sort -rn | head -30
+
+# Code concentration by extension
+find . -type f \\( -name "*.py" -o -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.go" -o -name "*.rs" \\) -not -path '*/node_modules/*' | sed 's|/[^/]*$||' | sort | uniq -c | sort -rn | head -20
+
+# Existing AGENTS.md / CLAUDE.md
+find . -type f \\( -name "AGENTS.md" -o -name "CLAUDE.md" \\) -not -path '*/node_modules/*' 2>/dev/null
+```
+
+#### 2. Read Existing AGENTS.md
+```
+For each existing file found:
+  Read(filePath=file)
+  Extract: key insights, conventions, anti-patterns
+  Store in EXISTING_AGENTS map
+```
+
+If `--create-new`: Read all existing first (preserve context) → then delete all → regenerate.
+
+#### 3. LSP Codemap (if available)
+```
+LspServers()  # Check availability
+
+# Entry points (parallel)
+LspDocumentSymbols(filePath="src/index.ts")
+LspDocumentSymbols(filePath="main.py")
+
+# Key symbols (parallel)
+LspWorkspaceSymbols(filePath=".", query="class")
+LspWorkspaceSymbols(filePath=".", query="interface")
+LspWorkspaceSymbols(filePath=".", query="function")
+
+# Centrality for top exports
+LspFindReferences(filePath="...", line=X, character=Y)
+```
+
+**LSP Fallback**: If unavailable, use `codegraph_explore` first when codegraph_* tools exist; otherwise rely on explore agents + the ast-grep skill (`sg` CLI).
+
+### Collect Background Results
+
+```
+// After main session analysis done, collect all task results
+for each background task ID (`bg_...`): background_output(task_id="bg_...")
+```
+
+**Merge: bash + LSP + existing + explore findings. Mark "discovery" as completed.**
+
+---
+
+## Phase 2: Scoring & Location Decision
+
+**Mark "scoring" as in_progress.**
+
+### Scoring Matrix
+
+| Factor | Weight | High Threshold | Source |
+|--------|--------|----------------|--------|
+| File count | 3x | >20 | bash |
+| Subdir count | 2x | >5 | bash |
+| Code ratio | 2x | >70% | bash |
+| Unique patterns | 1x | Has own config | explore |
+| Module boundary | 2x | Has index.ts/__init__.py | bash |
+| Symbol density | 2x | >30 symbols | LSP |
+| Export count | 2x | >10 exports | LSP |
+| Reference centrality | 3x | >20 refs | LSP |
+
+### Decision Rules
+
+| Score | Action |
+|-------|--------|
+| **Root (.)** | ALWAYS create |
+| **>15** | Create AGENTS.md |
+| **8-15** | Create if distinct domain |
+| **<8** | Skip (parent covers) |
+
+### Output
+```
+AGENTS_LOCATIONS = [
+  { path: ".", type: "root" },
+  { path: "src/hooks", score: 18, reason: "high complexity" },
+  { path: "src/api", score: 12, reason: "distinct domain" }
+]
+```
+
+**Mark "scoring" as completed.**
+
+---
+
+## Phase 3: Generate AGENTS.md
+
+**Mark "generate" as in_progress.**
+
+<critical>
+**File Writing Rule**: If AGENTS.md already exists at the target path → use `Edit` tool. If it does NOT exist → use `Write` tool.
+NEVER use Write to overwrite an existing file. ALWAYS check existence first via `Read` or discovery results.
+</critical>
+
+### Root AGENTS.md (Full Treatment)
+
+```markdown
+# PROJECT KNOWLEDGE BASE
+
+**Generated:** {TIMESTAMP}
+**Commit:** {SHORT_SHA}
+**Branch:** {BRANCH}
+
+## OVERVIEW
+{1-2 sentences: what + core stack}
+
+## STRUCTURE
+```
+{root}/
+├── {dir}/    # {non-obvious purpose only}
+└── {entry}
+```
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+
+## CODE MAP
+{From LSP - skip if unavailable or project <10 files}
+
+| Symbol | Type | Location | Refs | Role |
+|--------|------|----------|------|------|
+
+## CONVENTIONS
+{ONLY deviations from standard}
+
+## ANTI-PATTERNS (THIS PROJECT)
+{Explicitly forbidden here}
+
+## UNIQUE STYLES
+{Project-specific}
+
+## COMMANDS
+```bash
+{dev/test/build}
+```
+
+## NOTES
+{Gotchas}
+```
+
+**Quality gates**: 50-150 lines, no generic advice, no obvious info.
+
+### Subdirectory AGENTS.md (Parallel)
+
+Launch writing tasks for each location:
+
+```
+for loc in AGENTS_LOCATIONS (except root):
+  task(category="writing", load_skills=[], run_in_background=false, description="Generate AGENTS.md", prompt=`
+    Generate AGENTS.md for: ${loc.path}
+    - Reason: ${loc.reason}
+    - 30-80 lines max
+    - NEVER repeat parent content
+    - Sections: OVERVIEW (1 line), STRUCTURE (if >5 subdirs), WHERE TO LOOK, CONVENTIONS (if different), ANTI-PATTERNS
+  `)
+```
+
+**Wait for all. Mark "generate" as completed.**
+
+---
+
+## Phase 4: Review & Deduplicate
+
+**Mark "review" as in_progress.**
+
+For each generated file:
+- Remove generic advice
+- Remove parent duplicates
+- Trim to size limits
+- Verify telegraphic style
+
+**Mark "review" as completed.**
+
+---
+
+## Final Report
+
+```
+=== init-deep Complete ===
+
+Mode: {update | create-new}
+
+Files:
+  [OK] ./AGENTS.md (root, {N} lines)
+  [OK] ./src/hooks/AGENTS.md ({N} lines)
+
+Dirs Analyzed: {N}
+AGENTS.md Created: {N}
+AGENTS.md Updated: {N}
+
+Hierarchy:
+  ./AGENTS.md
+  └── src/hooks/AGENTS.md
+```
+
+---
+
+## Anti-Patterns
+
+- **Static agent count**: MUST vary agents based on project size/depth
+- **Sequential execution**: MUST parallel (explore + LSP concurrent)
+- **Ignoring existing**: ALWAYS read existing first, even with --create-new
+- **Over-documenting**: Not every dir needs AGENTS.md
+- **Redundancy**: Child never repeats parent
+- **Generic content**: Remove anything that applies to ALL projects
+- **Verbose style**: Telegraphic or die

package/dist/skills/lcx-contribute-bug-fix/SKILL.md

@@ -0,0 +1,242 @@
+---
+name: lcx-contribute-bug-fix
+description: "Contribute a verified bug fix for LazyCodex, lazycodex-ai, omo-codex, bundled Codex skills, or upstream Codex CLI bugs. Opens a fork PR only for upstream openai/codex; LazyCodex-owned defects become a verified-fix issue on code-yeongyu/lazycodex (never a PR — that repo is a generated distribution mirror). 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 fixes
+---
+
+# 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 deliver it. Work in English, keep the body short, and support every claim with runtime or source evidence.
+
+Route ownership the same way as `$lcx-report-bug`, but the deliverable differs by target:
+
+- `code-yeongyu/lazycodex` for LazyCodex, lazycodex-ai, omo-codex, bundled skills, hooks, MCP wiring, installer behavior, marketplace sync, docs, or packaging. Deliverable: a verified-fix issue with the patch embedded. NEVER open a PR or push a branch against this repo — its contents are regenerated from the source tree on every release, so PRs there cannot be merged and will be closed.
+- `openai/codex` for upstream Codex CLI bugs that reproduce without LazyCodex or come from Codex core behavior. Deliverable: a PR from a fork.
+
+## Required Outcome
+
+For `openai/codex`, create a fork 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
+
+For `code-yeongyu/lazycodex`, create an issue (never a PR) that includes:
+
+- reproduction logs from before the fix
+- the root cause with source evidence
+- the verified patch as a unified diff, produced and tested in a fresh `/tmp` clone/worktree
+- verification logs from after the fix
+- the `lazycodex-generated` label and the 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. Materialize the latest sources, then decide the target repository. Sync both checkouts on every run and compare them before choosing — a stale checkout routes the fix to the wrong repo:
+
+```bash
+sync_latest_source() {
+  REPO="$1"; DEST="$2"
+  if [ ! -d "$DEST/.git" ]; then
+    gh repo clone "$REPO" "$DEST" -- --depth=1 \
+      || git clone --depth=1 "https://github.com/$REPO" "$DEST"
+  fi
+  DEFAULT_BRANCH="$(git -C "$DEST" remote show origin | sed -n '/HEAD branch/s/.*: //p')"
+  git -C "$DEST" fetch --depth=1 origin "$DEFAULT_BRANCH"
+  git -C "$DEST" checkout -B "$DEFAULT_BRANCH" FETCH_HEAD
+}
+sync_latest_source code-yeongyu/lazycodex /tmp/lazycodex-source
+sync_latest_source openai/codex /tmp/openai-codex-source
+```
+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 in the worktree. Inspect the status first so the delivered diff 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. Build the delivery body for the target:
+   - `openai/codex`: generate the PR body with `scripts/create-pr-body.mjs`.
+   - `code-yeongyu/lazycodex`: export the verified patch and write the issue body from the Verified-Fix Issue Template below:
+
+```bash
+PATCH_FILE="/tmp/lazycodex-fix-<short-slug>.patch"
+git diff "origin/$BASE_BRANCH"..HEAD > "$PATCH_FILE"
+```
+
+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. Deliver the fix.
+   - `code-yeongyu/lazycodex`: create the verified-fix issue. Never push a branch to this repo and never run `gh pr create` against it:
+
+```bash
+ISSUE_BODY="/tmp/lazycodex-fix-<short-slug>-issue.md"
+gh issue create --repo code-yeongyu/lazycodex --title "<short fix title>" "${LABEL_ARGS[@]}" --body-file "$ISSUE_BODY"
+```
+
+   - `openai/codex`: fork, push the branch to the fork, and create the PR:
+
+```bash
+gh repo fork openai/codex --remote --remote-name fork
+GH_USER="$(gh api user --jq .login)"
+git push -u fork "$BRANCH_NAME"
+gh pr create --repo openai/codex --base "$BASE_BRANCH" --head "$GH_USER:$BRANCH_NAME" --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 or issue URL, the reproduction command, the verification command, and the cleanup receipt.
+
+## Verified-Fix Issue Template (code-yeongyu/lazycodex)
+
+Write the issue body in English. Embed the patch verbatim so a maintainer can apply it to the source tree:
+
+````markdown
+## Problem Situation
+[What failed for the user.]
+
+## Reproduction Logs
+[Exact failing command and relevant log excerpt.]
+
+## Root Cause
+[Confirmed cause with runtime and source evidence.]
+
+## Verified Fix
+[What changed and why this is the smallest correct fix.]
+
+```diff
+[Contents of $PATCH_FILE.]
+```
+
+## Verification
+- [RED test output or repro before the fix]
+- [GREEN test output after the fix]
+- [Manual QA command and result]
+
+---
+This fix was debugged, implemented, and verified with [LazyCodex](https://github.com/code-yeongyu/lazycodex).
+Tag: lazycodex-generated
+````
+
+## PR Body Generator (openai/codex)
+
+Use the bundled script to generate the PR body. Create a JSON file with this shape:
+
+```json
+{
+  "title": "Fix short user-visible failure",
+  "targetRepository": "openai/codex",
+  "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 (openai/codex)
+
+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 creating the issue or pushing and creating the PR
+- the fix requires a product decision rather than a technical correction
+
+Do not open:
+
+- a PR or pushed branch targeting `code-yeongyu/lazycodex` — deliver the verified-fix issue instead, always
+- a PR or verified-fix issue without a failing-before and passing-after test
+- a PR or verified-fix issue without a real-surface QA command
+- a PR or issue without the `Tag: lazycodex-generated` footer
+- a verified-fix issue without the patch embedded in a `diff` block
+- a vague fix that does not identify the root cause
+- a broad refactor disguised as a bug fix

package/dist/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 fixes"
+  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, apply the lazycodex-generated label, deliver it (verified-fix issue on code-yeongyu/lazycodex — never a PR there; fork PR only for openai/codex), and clean up."

package/dist/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();
+}