oh-my-customcodex 0.1.0

package/templates/.claude/skills/omcodex-release-notes/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: omcodex-release-notes
+description: Generate structured release notes from git history and closed issues within the GPT Codex + OMX session
+scope: harness
+user-invocable: true
+argument-hint: "<version> [--previous-tag <tag>]"
+---
+
+# Release Notes Generator
+
+Generate structured release notes directly within the GPT Codex + OMX session, using git history and GitHub issues. No external API calls needed — the current harness analyzes and generates the notes.
+
+## Purpose
+
+Replaces the CI-based `release-notes.yml` workflow that previously used Claude API (`ANTHROPIC_API_KEY`). The release notes are now generated in-session and passed directly to `gh release create --notes`.
+
+## Usage
+
+```
+/omcodex-release-notes 0.36.0
+/omcodex-release-notes 0.36.0 --previous-tag v0.35.3
+```
+
+## Workflow
+
+### Phase 1: Gather Context
+
+```bash
+# 1. Determine previous tag
+PREV_TAG=$(git tag --sort=-version:refname | grep -v "^v${VERSION}$" | head -1)
+
+# 2. Get commit history
+git log ${PREV_TAG}..HEAD --pretty=format:"%h %s"
+
+# 3. Get changed files
+git diff --name-status ${PREV_TAG}..HEAD
+
+# 4. Get closed issues since previous tag
+gh issue list --state closed --search "closed:>$(git log -1 --format=%ci ${PREV_TAG} | cut -d' ' -f1)" --json number,title,labels
+```
+
+### Phase 2: Classify Changes
+
+Categorize commits using Conventional Commits:
+
+| Prefix | Category | Emoji |
+|--------|----------|-------|
+| feat: | Features | :rocket: |
+| fix: | Bug Fixes | :bug: |
+| docs: | Documentation | :books: |
+| refactor: | Refactoring | :recycle: |
+| test: | Tests | :test_tube: |
+| chore: | Chores | :wrench: |
+| security | Security | :lock: |
+
+### Phase 3: Generate Notes
+
+Output format:
+
+```markdown
+# Release v{VERSION}
+
+## Highlights
+(1-3 key features/changes)
+
+## :rocket: Features
+- **{title}** (#{issue}): {description}
+
+## :bug: Bug Fixes
+- **{title}** (#{issue}): {description}
+
+## :lock: Security
+- {security changes}
+
+## :books: Documentation
+- {doc changes}
+
+## :recycle: Other Changes
+- {other changes}
+
+## Resource Changes
+| Resource | Before | After | Delta |
+|----------|--------|-------|-------|
+| Rules | {n} | {n} | {delta} |
+| Skills | {n} | {n} | {delta} |
+| Agents | {n} | {n} | {delta} |
+
+## Breaking Changes
+{if any, otherwise omit section}
+
+---
+_Release notes generated with oh-my-customcodex_
+```
+
+### Phase 4: Apply
+
+The generated notes can be:
+1. **Direct**: Passed to `gh release create --notes "{notes}"`
+2. **File**: Written to `release_notes.md` for review before use
+3. **Update**: Used with `gh release edit v{VERSION} --notes "{notes}"`
+
+## Integration
+
+This skill is designed to be used during the release process:
+
+```
+/omcodex:npm-version patch|minor|major  ->  version bump
+/omcodex-release-notes {version}         ->  generate notes
+mgr-gitnerd: gh release create           ->  create release with notes
+```
+
+## Notes
+
+- No external API keys required
+- Uses git history and gh CLI for data gathering
+- The current harness analyzes and generates notes in-context
+- Resource count changes auto-detected from AGENTS.md history

package/templates/.claude/skills/omcodex-takeover/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: omcodex:takeover
+description: Extract canonical spec from existing agent or skill files
+scope: harness
+user-invocable: true
+argument-hint: "<agent-name>"
+---
+
+# Takeover Skill
+
+Extract a canonical specification from an existing agent or skill file. Inspired by codespeak.dev's reverse compilation concept — deriving specs from existing implementations.
+
+## Purpose
+
+When an agent or skill has evolved organically without a formal spec, `omcodex:takeover` reverse-engineers a structured specification that captures its intent, invariants, workflow contract, and I/O contract.
+
+## Usage
+
+```
+/omcodex:takeover <agent-name>
+/omcodex:takeover <skill-name>
+```
+
+## Workflow
+
+### Phase 1: Read Target
+
+```
+1. Determine target type:
+   - Agent: read .codex/agents/<name>.md
+   - Skill: read .codex/skills/<name>/SKILL.md
+2. Parse frontmatter (YAML metadata)
+3. Parse body (markdown content)
+```
+
+### Phase 2: Extract Spec Components
+
+Extract these components from the target:
+
+| Component | Source | Description |
+|-----------|--------|-------------|
+| `intent` | Description field + first paragraph | One-line purpose statement |
+| `invariants` | Rules referenced, constraints mentioned | Things that must always be true |
+| `workflow_contract` | Workflow/stages sections | Input → processing → output steps |
+| `io_contract` | Tools field, input/output patterns | What the agent consumes and produces |
+| `dependencies` | Skills field, guide references | External knowledge required |
+| `boundaries` | Limitations field, disallowedTools | What the agent explicitly cannot do |
+
+### Phase 3: Generate Spec
+
+Output structured spec to `.codex/specs/<name>.spec.md`:
+
+```markdown
+---
+name: <name>
+type: agent | skill
+source: .codex/agents/<name>.md | .codex/skills/<name>/SKILL.md
+generated: <ISO-8601 timestamp>
+---
+
+# Spec: <name>
+
+## Intent
+<one-line purpose>
+
+## Invariants
+- <rule or constraint that must always hold>
+- ...
+
+## Workflow Contract
+### Input
+<what the agent/skill receives>
+
+### Processing
+1. <step>
+2. <step>
+
+### Output
+<what the agent/skill produces>
+
+## I/O Contract
+### Consumes
+- Tools: [<tools used>]
+- Files: [<files read>]
+- MCP: [<MCP tools if any>]
+
+### Produces
+- Files: [<files created/modified>]
+- Output: [<what is returned>]
+
+## Dependencies
+- Skills: [<referenced skills>]
+- Guides: [<referenced guides>]
+- Rules: [<rules enforced>]
+
+## Boundaries
+- <what the agent explicitly cannot do>
+```
+
+### Phase 4: Report
+
+```
+[Done] Spec extracted: .codex/specs/<name>.spec.md
+├── Intent: <summary>
+├── Invariants: <count> rules
+├── Workflow: <step count> steps
+└── Dependencies: <count> refs
+```
+
+## Notes
+
+- Specs are git-untracked (under `.codex/`)
+- Regenerate anytime with `/omcodex:takeover <name>`
+- Used by `/dev-refactor --spec` for invariant-preserving refactoring
+- Advisory output — human review recommended before using as contract

package/templates/.claude/skills/omcodex-web/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: omcodex:web
+description: Control and inspect the built-in Web UI (packages/serve) — start, stop, status, open
+scope: harness
+argument-hint: "[start|stop|status|open]"
+user-invocable: true
+---
+
+# Web UI Control
+
+Interactive control for the built-in Web UI server (packages/serve).
+
+## Arguments
+
+| Argument | Action |
+|----------|--------|
+| `status` (default) | Show server status (PID, port, URL) |
+| `start` | Start the Web UI server in background |
+| `stop` | Stop the running Web UI server |
+| `open` | Open the Web UI in the default browser |
+
+## Workflow
+
+### Step 1: Check Server Status
+
+Run these checks via Bash:
+
+```bash
+PORT=${OMCODEX_PORT:-${OMCUSTOM_PORT:-4321}}
+PID_FILE="$HOME/.omcodex-serve.pid"
+PID=$(cat "$PID_FILE" 2>/dev/null)
+
+# Process alive?
+if [ -n "$PID" ] && kill -0 "$PID" 2>/dev/null; then
+  STATUS="running"
+else
+  STATUS="stopped"
+  # Clean stale PID file
+  [ -f "$PID_FILE" ] && rm "$PID_FILE"
+fi
+
+# Port check
+PORT_PID=$(lsof -ti :$PORT 2>/dev/null | head -1)
+
+echo "STATUS=$STATUS PID=$PID PORT=$PORT PORT_PID=$PORT_PID"
+```
+
+### Step 2: Display Status
+
+```
+Web UI Control
+─────────────
+Status: ● Running (PID {PID})
+URL:    http://localhost:{PORT}
+PID:    ~/.omcodex-serve.pid
+```
+
+or
+
+```
+Web UI Control
+─────────────
+Status: ○ Stopped
+Port:   {PORT} (free)
+```
+
+### Step 3: Execute Subcommand
+
+| Subcommand | Action |
+|------------|--------|
+| `status` | Display status from Step 2, then exit |
+| `start` | If stopped → run `omcodex serve` via Bash. If running → show URL |
+| `stop` | If running → run `omcodex serve-stop` via Bash. If stopped → inform user |
+| `open` | If running → `open http://localhost:{PORT}` (macOS). If stopped → ask to start first |
+
+### Step 4: Port Conflict Detection
+
+Before `start`, check if port is already occupied by another process:
+
+```bash
+PORT_PID=$(lsof -ti :$PORT 2>/dev/null | head -1)
+if [ -n "$PORT_PID" ]; then
+  PROC=$(ps -p $PORT_PID -o comm= 2>/dev/null)
+  echo "Port $PORT is occupied by $PROC (PID $PORT_PID)"
+fi
+```
+
+If occupied by a non-serve process, warn the user and suggest `--port` option.
+
+## No Argument Behavior
+
+When called without arguments (`/omcodex:web`):
+1. Show status
+2. If stopped, suggest: "Run `/omcodex:web start` to start the server"
+3. If running, suggest: "Run `/omcodex:web open` to open in browser"

package/templates/.claude/skills/optimize-analyze/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: optimize-analyze
+description: Analyze bundle size and performance metrics
+scope: core
+argument-hint: "[target] [--verbose]"
+user-invocable: true
+---
+
+# Bundle Analysis Skill
+
+Analyze bundle size and performance metrics for web applications.
+
+## Arguments
+
+```
+target           Build output path or project root (optional, auto-detects)
+```
+
+## Options
+
+```
+--verbose, -v    Show detailed analysis
+```
+
+## Workflow
+
+```
+1. Identify build tool (webpack, vite, rollup, esbuild)
+2. Locate build output
+3. Analyze bundle composition
+4. Calculate size metrics
+5. Identify large dependencies
+6. Detect unused code/exports
+7. Generate analysis report
+```
+
+## Output
+
+- Total bundle size
+- Size breakdown by chunk/module
+- Top dependencies by size
+- Tree-shaking status
+- Dead code detection
+- Optimization recommendations
+
+## Examples
+
+```bash
+# Analyze current project
+optimize-analyze
+
+# Analyze specific output directory
+optimize-analyze ./dist
+
+# Verbose analysis
+optimize-analyze --verbose
+```

package/templates/.claude/skills/optimize-bundle/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: optimize-bundle
+description: Apply bundle size optimizations
+scope: core
+argument-hint: "[--dry-run] [--safe]"
+disable-model-invocation: true
+user-invocable: true
+---
+
+# Bundle Optimization Skill
+
+Apply bundle size optimizations to reduce build output and improve performance.
+
+## Options
+
+```
+--dry-run        Show what would be changed without applying
+--safe           Only apply safe, reversible optimizations
+```
+
+## Workflow
+
+```
+1. Run full bundle analysis
+2. Identify optimization opportunities
+3. Prioritize by impact and risk
+4. Apply recommended changes (or show dry-run)
+5. Rebuild if changes applied
+6. Verify improvements
+7. Report before/after metrics
+```
+
+## Optimization Levels
+
+### Safe
+- Configure code splitting
+- Enable tree-shaking for ESM
+- Add terser/minification
+- Configure chunk optimization
+
+### Moderate
+- Replace heavy dependencies with lighter alternatives
+- Add dynamic imports for routes
+- Configure asset optimization
+
+### Aggressive
+- Remove unused dependencies
+- Inline small modules
+- Configure aggressive minification
+
+## Output
+
+- Applied changes list
+- Before/after size comparison
+- Build time comparison
+- Risk assessment for each change
+
+## Examples
+
+```bash
+# Apply all safe optimizations
+optimize-bundle
+
+# Preview changes without applying
+optimize-bundle --dry-run
+
+# Only apply safe optimizations
+optimize-bundle --safe
+```

package/templates/.claude/skills/optimize-report/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: optimize-report
+description: Generate comprehensive optimization report
+scope: core
+argument-hint: "[--baseline <file>] [--format <format>]"
+user-invocable: true
+---
+
+# Optimization Report Skill
+
+Generate comprehensive optimization report with analysis, metrics, and recommendations.
+
+## Options
+
+```
+--baseline       Compare against previous report
+--format         Output format (text, json, markdown)
+                 Default: text
+```
+
+## Workflow
+
+```
+1. Run full analysis
+2. Collect all metrics
+3. Compare against baseline (if provided)
+4. Calculate performance scores
+5. Generate recommendations
+6. Format report
+```
+
+## Report Sections
+
+### Bundle Analysis
+- Total size (raw and gzipped)
+- Chunk breakdown
+- Dependency tree
+
+### Performance Metrics
+- Estimated load times
+- Core Web Vitals impact
+- Build performance
+
+### Code Quality
+- Tree-shaking effectiveness
+- Dead code percentage
+- Duplicate code detection
+
+### Recommendations
+- High impact optimizations
+- Quick wins
+- Long-term improvements
+
+### Comparison (if baseline)
+- Size delta
+- Performance delta
+- Trend analysis
+
+## Output
+
+- Formatted report in requested format
+- Performance grade (A-F)
+- Priority action items
+
+## Examples
+
+```bash
+# Generate current report
+optimize-report
+
+# Compare against previous report
+optimize-report --baseline ./previous-report.json
+
+# Generate markdown report
+optimize-report --format markdown
+```

package/templates/.claude/skills/peer-messaging/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: peer-messaging
+description: Cross-session agent session messaging via claude-peers-mcp broker
+scope: core
+user-invocable: false
+---
+
+# Peer Messaging Skill
+
+## Purpose
+
+Enables cross-session coordination between multiple GPT Codex + OMX sessions through the claude-peers-mcp broker. Complements Agent Teams (R018, intra-session) with inter-session messaging.
+
+## Scope Clarification
+
+| Scope | Mechanism | Tools | Use Case |
+|-------|-----------|-------|----------|
+| Intra-session agents | Agent Teams (R018) | TeamCreate, SendMessage | Single session multi-agent collaboration |
+| Cross-session instances | claude-peers-mcp | list_peers, send_message | Multi-terminal/project real-time coordination |
+| Cross-session memory | claude-mem | save_memory, search | Async memory persistence |
+
+> **Important**: R018's `SendMessage` and claude-peers-mcp's `send_message` are different tools with different scopes. Do not confuse them.
+
+## MCP Tool Mapping
+
+| Tool | Purpose | oh-my-customcodex Scenario |
+|------|---------|---------------------------|
+| `list_peers` | Discover active agent sessions | `omcodex:status` system overview |
+| `send_message` | Send message to peer | Cross-project workflow coordination |
+| `set_summary` | Broadcast current task summary | DAG cross-project step sync |
+| `check_messages` | Read incoming messages | Receive coordination signals |
+
+## Use Cases
+
+### Multi-Project Workflow
+Terminal A runs `auto-dev` on project-1; Terminal B works on dependent project-2. Peers coordinate via messages when blocking dependencies are resolved.
+
+### Cross-Project QA
+Share test infrastructure state between projects running concurrent test suites.
+
+### DAG Bridge
+`dag-orchestration` cross-project steps can use peer messaging for synchronization (currently impossible without this tool).
+
+## Setup
+
+```bash
+# Install broker (optional MCP server)
+npm install -g claude-peers-mcp
+
+# Add to MCP config
+claude mcp add claude-peers-mcp -- npx claude-peers-mcp
+```
+
+## Integration
+
+- Works with R018 Agent Teams (different scope, complementary)
+- Works with claude-mem (async vs sync messaging)
+- Works with `omcodex:status` (peer discovery)
+- Broker runs on localhost:7899 (SQLite-backed)

package/templates/.claude/skills/pipeline/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: pipeline
+description: Invoke and resume YAML-defined pipelines by name — /pipeline auto-dev runs the full release pipeline
+scope: harness
+user-invocable: true
+effort: high
+argument-hint: "<pipeline-name> | resume | (no args to list available)"
+source:
+  type: external
+  origin: github
+  url: https://github.com/baekenough/baekenough-skills
+  version: 1.0.0
+---
+
+# /pipeline — Pipeline Invocation
+
+## Usage
+
+```
+/pipeline auto-dev          # Run the auto-dev pipeline
+/pipeline                   # List available pipelines
+/pipeline resume            # Resume a halted pipeline
+```
+
+## Behavior
+
+### List Mode (no arguments or --list flag)
+
+Execute these steps to display available pipelines:
+
+1. **Scan built-in pipelines**: Use `Glob("workflows/*.yaml")` (NOT templates/) to find all pipeline definitions
+2. **Extract metadata**: For each YAML file found, use `Bash` to extract name and description:
+   ```bash
+   for f in workflows/*.yaml; do
+     name=$(grep -m1 '^name:' "$f" | sed 's/^name: *//' | tr -d '"')
+     desc=$(grep -m1 '^description:' "$f" | sed 's/^description: *//' | tr -d '"')
+     echo "  $name — $desc"
+   done
+   ```
+3. **Scan template pipelines**: Use `Glob("templates/workflows/*.yaml")` for template examples
+4. **Display formatted output**:
+   ```
+   Available pipelines:
+     {name} — {description}
+     {name} — {description}
+
+   Template pipelines (in templates/workflows/):
+     {name} — {description}
+   ```
+5. If no pipelines found, display: "No pipelines found in workflows/ directory."
+6. If YAML parsing fails for a file, skip it and show: `  {filename} — (parse error, skipped)`
+
+### Run Mode (with pipeline name)
+
+1. Validate pipeline exists: `workflows/{name}.yaml`
+2. Load and validate YAML structure:
+   - Required fields: `name`, `description`, `steps[]`
+   - Each step has either `skill:` or `prompt:` (not both)
+   - Referenced skills exist in `.codex/skills/`
+   - Skill names must match `^[a-z0-9-]+$` (kebab-case only) — reject path traversal attempts
+3. Announce: `[Pipeline] Starting {name} — {step_count} steps`
+4. Execute steps top-to-bottom:
+   - **Skill steps** (`skill: name`): Invoke via Skill tool — `Skill(skill: "{name}")`
+   - **Prompt steps** (`prompt: text`): Execute the described action using appropriate agents/tools
+   - **Foreach steps** (`foreach: collection`): Iterate over collection from previous step output
+   - **Permission mode**: When spawning agents, pass `mode: "bypassPermissions"` in the Agent tool call if the session uses bypassPermissions. Without explicit mode, CC defaults to `acceptEdits`.
+5. Report completion or failure
+
+### Resume Mode (/pipeline resume)
+
+1. Scan `/tmp/.codex-pipeline-*-{PPID}.json` for state files
+2. If none found: "No halted pipelines found."
+3. If found: display pipeline name, failed step, error message
+4. Options:
+   - **Retry** — Re-execute the failed step
+   - **Skip** — Mark failed step as skipped, continue to next
+   - **Abort** — Delete state file, cancel pipeline
+5. On resume: execute from the failed step
+
+## State Tracking
+
+Track per-step state:
+```json
+{
+  "pipeline": "{name}",
+  "started": "ISO-8601",
+  "status": "running|completed|halted",
+  "current_step": 0,
+  "steps": [
+    {"name": "triage", "status": "completed", "duration_ms": 5000},
+    {"name": "plan", "status": "running"}
+  ]
+}
+```
+
+State saved to `/tmp/.codex-pipeline-{name}-{PPID}.json` on failure.
+
+## Error Handling
+
+- Pipeline not found → list available pipelines with suggestion
+- YAML parse error → report with line number
+- Step failure (error: halt-and-report) → stop execution, save state, report failure with context
+- All file writes delegated to subagents per R010