claudecode-omc 4.3.4

package/skills/project-session-manager/templates/feature.md

@@ -0,0 +1,56 @@
+# Feature Development Context
+
+You are developing feature: **{{FEATURE_NAME}}**
+
+## Details
+
+- **Branch**: `{{BRANCH_NAME}}`
+- **Base**: `{{BASE_BRANCH}}`
+- **Project**: {{PROJECT}}
+
+## Feature Scope
+
+{{FEATURE_DESCRIPTION}}
+
+## Development Approach
+
+1. **Plan**
+   - Define requirements
+   - Break into subtasks
+   - Identify dependencies
+
+2. **Implement**
+   - Follow project patterns
+   - Write clean, testable code
+   - Commit incrementally
+
+3. **Test**
+   - Unit tests for new code
+   - Integration tests if needed
+   - Manual testing
+
+4. **Document**
+   - Update relevant docs
+   - Add code comments where needed
+   - Update CHANGELOG if applicable
+
+## Commands
+
+```bash
+# Run tests
+npm test  # or appropriate test command
+
+# Check build
+npm run build  # or appropriate build command
+
+# Create PR when ready
+gh pr create --title "Feature: {{FEATURE_NAME}}" --body "## Summary\n\n<description>\n\n## Changes\n\n- <change 1>\n- <change 2>"
+```
+
+## Feature Checklist
+
+- [ ] Requirements understood
+- [ ] Implementation complete
+- [ ] Tests written and passing
+- [ ] Documentation updated
+- [ ] Ready for PR

package/skills/project-session-manager/templates/issue-fix.md

@@ -0,0 +1,57 @@
+# Issue Fix Context
+
+You are fixing Issue #{{ISSUE_NUMBER}}: **{{ISSUE_TITLE}}**
+
+## Issue Details
+
+- **URL**: {{ISSUE_URL}}
+- **Labels**: {{ISSUE_LABELS}}
+- **Branch**: `{{BRANCH_NAME}}`
+
+## Description
+
+{{ISSUE_BODY}}
+
+## Approach
+
+1. **Understand the Issue**
+   - Reproduce the problem if applicable
+   - Identify root cause
+   - Consider edge cases
+
+2. **Plan the Fix**
+   - Minimal changes to fix the issue
+   - Don't introduce regressions
+   - Consider backwards compatibility
+
+3. **Implement**
+   - Write the fix
+   - Add/update tests
+   - Update documentation if needed
+
+4. **Verify**
+   - Run existing tests
+   - Test the specific fix
+   - Check for regressions
+
+## Commands
+
+```bash
+# Run tests
+npm test  # or appropriate test command
+
+# Check build
+npm run build  # or appropriate build command
+
+# Create PR when done
+gh pr create --title "Fix #{{ISSUE_NUMBER}}: <description>" --body "Fixes #{{ISSUE_NUMBER}}"
+```
+
+## Fix Checklist
+
+- [ ] Root cause identified
+- [ ] Fix implemented
+- [ ] Tests added/updated
+- [ ] All tests pass
+- [ ] No regressions introduced
+- [ ] Ready for PR

package/skills/project-session-manager/templates/pr-review.md

@@ -0,0 +1,65 @@
+# PR Review Context
+
+You are reviewing PR #{{PR_NUMBER}}: **{{PR_TITLE}}**
+
+## PR Details
+
+- **Author**: @{{PR_AUTHOR}}
+- **Branch**: `{{HEAD_BRANCH}}` → `{{BASE_BRANCH}}`
+- **URL**: {{PR_URL}}
+
+## Description
+
+{{PR_BODY}}
+
+## Changed Files
+
+{{CHANGED_FILES}}
+
+## Review Focus
+
+1. **Code Quality**
+   - Follow existing patterns and conventions
+   - Clean, readable, maintainable code
+   - Appropriate abstractions
+
+2. **Correctness**
+   - Does it do what it claims?
+   - Edge cases handled?
+   - Error handling appropriate?
+
+3. **Security**
+   - Input validation
+   - No hardcoded secrets
+   - Safe dependencies
+
+4. **Testing**
+   - Adequate test coverage
+   - Tests are meaningful
+   - Edge cases tested
+
+5. **Documentation**
+   - Code is self-documenting
+   - Complex logic explained
+   - API changes documented
+
+## Commands
+
+```bash
+# View diff
+git diff {{BASE_BRANCH}}...HEAD
+
+# Run tests
+npm test  # or appropriate test command
+
+# Check build
+npm run build  # or appropriate build command
+```
+
+## Review Checklist
+
+- [ ] Code follows project style
+- [ ] No obvious bugs or logic errors
+- [ ] Security concerns addressed
+- [ ] Tests pass and cover changes
+- [ ] Documentation updated if needed

package/skills/project-session-manager/templates/projects.json

@@ -0,0 +1,19 @@
+{
+  "aliases": {
+    "omc": {
+      "repo": "Yeachan-Heo/oh-my-claudecode",
+      "local": "~/Workspace/oh-my-claudecode",
+      "default_base": "main"
+    },
+    "cc": {
+      "repo": "anthropics/claude-code",
+      "local": "~/Workspace/claude-code",
+      "default_base": "main"
+    }
+  },
+  "defaults": {
+    "worktree_root": "~/.psm/worktrees",
+    "cleanup_after_days": 14,
+    "auto_cleanup_merged": true
+  }
+}

package/skills/ralph/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: ralph
+description: Self-referential loop until task completion with architect verification
+---
+
+[RALPH + ULTRAWORK - ITERATION {{ITERATION}}/{{MAX}}]
+
+Your previous attempt did not output the completion promise. Continue working on the task.
+
+<Purpose>
+Ralph is a persistence loop that keeps working on a task until it is fully complete and architect-verified. It wraps ultrawork's parallel execution with session persistence, automatic retry on failure, and mandatory verification before completion.
+</Purpose>
+
+<Use_When>
+- Task requires guaranteed completion with verification (not just "do your best")
+- User says "ralph", "don't stop", "must complete", "finish this", or "keep going until done"
+- Work may span multiple iterations and needs persistence across retries
+- Task benefits from parallel execution with architect sign-off at the end
+</Use_When>
+
+<Do_Not_Use_When>
+- User wants a full autonomous pipeline from idea to code -- use `autopilot` instead
+- User wants to explore or plan before committing -- use `plan` skill instead
+- User wants a quick one-shot fix -- delegate directly to an executor agent
+- User wants manual control over completion -- use `ultrawork` directly
+</Do_Not_Use_When>
+
+<Why_This_Exists>
+Complex tasks often fail silently: partial implementations get declared "done", tests get skipped, edge cases get forgotten. Ralph prevents this by looping until work is genuinely complete, requiring fresh verification evidence before allowing completion, and using tiered architect review to confirm quality.
+</Why_This_Exists>
+
+<Execution_Policy>
+- Fire independent agent calls simultaneously -- never wait sequentially for independent work
+- Use `run_in_background: true` for long operations (installs, builds, test suites)
+- Always pass the `model` parameter explicitly when delegating to agents
+- Read `docs/shared/agent-tiers.md` before first delegation to select correct agent tiers
+- Deliver the full implementation: no scope reduction, no partial completion, no deleting tests to make them pass
+</Execution_Policy>
+
+<Steps>
+1. **Review progress**: Check TODO list and any prior iteration state
+2. **Continue from where you left off**: Pick up incomplete tasks
+3. **Delegate in parallel**: Route tasks to specialist agents at appropriate tiers
+   - Simple lookups: LOW tier (Haiku) -- "What does this function return?"
+   - Standard work: MEDIUM tier (Sonnet) -- "Add error handling to this module"
+   - Complex analysis: HIGH tier (Opus) -- "Debug this race condition"
+4. **Run long operations in background**: Builds, installs, test suites use `run_in_background: true`
+5. **Verify completion with fresh evidence**:
+   a. Identify what command proves the task is complete
+   b. Run verification (test, build, lint)
+   c. Read the output -- confirm it actually passed
+   d. Check: zero pending/in_progress TODO items
+6. **Architect verification** (tiered):
+   - <5 files, <100 lines with full tests: STANDARD tier minimum (architect-medium / Sonnet)
+   - Standard changes: STANDARD tier (architect-medium / Sonnet)
+   - >20 files or security/architectural changes: THOROUGH tier (architect / Opus)
+   - Ralph floor: always at least STANDARD, even for small changes
+7. **On approval**: Run `/oh-my-claudecode:cancel` to cleanly exit and clean up all state files
+8. **On rejection**: Fix the issues raised, then re-verify at the same tier
+</Steps>
+
+<Tool_Usage>
+- Before first MCP tool use, run the 3-step discovery: (1) `ToolSearch("mcp")`, (2) select the full name from results (e.g., `mcp__x__ask_codex`), (3) fall back to the equivalent Claude agent only if step 1 returns empty. Never use `ToolSearch("ask_codex")` as the primary search -- it can return false negatives even when MCP tools are present.
+- Use `ask_codex` with `agent_role: "architect"` for verification cross-checks when changes are security-sensitive, architectural, or involve complex multi-system integration
+- Skip Codex consultation for simple feature additions, well-tested changes, or time-critical verification
+- If ToolSearch finds no MCP tools or Codex is unavailable, proceed with architect agent verification alone -- never block on external tools
+- Use `state_write` / `state_read` for ralph mode state persistence between iterations
+</Tool_Usage>
+
+<Examples>
+<Good>
+Correct parallel delegation:
+```
+Task(subagent_type="oh-my-claudecode:executor-low", model="haiku", prompt="Add type export for UserConfig")
+Task(subagent_type="oh-my-claudecode:executor", model="sonnet", prompt="Implement the caching layer for API responses")
+Task(subagent_type="oh-my-claudecode:executor-high", model="opus", prompt="Refactor auth module to support OAuth2 flow")
+```
+Why good: Three independent tasks fired simultaneously at appropriate tiers.
+</Good>
+
+<Good>
+Correct verification before completion:
+```
+1. Run: npm test           → Output: "42 passed, 0 failed"
+2. Run: npm run build      → Output: "Build succeeded"
+3. Run: lsp_diagnostics    → Output: 0 errors
+4. Spawn architect-medium  → Verdict: "APPROVED"
+5. Run /oh-my-claudecode:cancel
+```
+Why good: Fresh evidence at each step, architect verification, then clean exit.
+</Good>
+
+<Bad>
+Claiming completion without verification:
+"All the changes look good, the implementation should work correctly. Task complete."
+Why bad: Uses "should" and "look good" -- no fresh test/build output, no architect verification.
+</Bad>
+
+<Bad>
+Sequential execution of independent tasks:
+```
+Task(executor-low, "Add type export") → wait →
+Task(executor, "Implement caching") → wait →
+Task(executor-high, "Refactor auth")
+```
+Why bad: These are independent tasks that should run in parallel, not sequentially.
+</Bad>
+</Examples>
+
+<Escalation_And_Stop_Conditions>
+- Stop and report when a fundamental blocker requires user input (missing credentials, unclear requirements, external service down)
+- Stop when the user says "stop", "cancel", or "abort" -- run `/oh-my-claudecode:cancel`
+- Continue working when the hook system sends "The boulder never stops" -- this means the iteration continues
+- If architect rejects verification, fix the issues and re-verify (do not stop)
+- If the same issue recurs across 3+ iterations, report it as a potential fundamental problem
+</Escalation_And_Stop_Conditions>
+
+<Final_Checklist>
+- [ ] All requirements from the original task are met (no scope reduction)
+- [ ] Zero pending or in_progress TODO items
+- [ ] Fresh test run output shows all tests pass
+- [ ] Fresh build output shows success
+- [ ] lsp_diagnostics shows 0 errors on affected files
+- [ ] Architect verification passed (STANDARD tier minimum)
+- [ ] `/oh-my-claudecode:cancel` run for clean state cleanup
+</Final_Checklist>
+
+<Advanced>
+## PRD Mode (Optional)
+
+When the user provides the `--prd` flag, initialize a Product Requirements Document before starting the ralph loop.
+
+### Detecting PRD Mode
+Check if `{{PROMPT}}` contains `--prd` or `--PRD`.
+
+### PRD Workflow
+1. Create `.omc/prd.json` and `.omc/progress.txt`
+2. Parse the task (everything after `--prd` flag)
+3. Break down into user stories:
+
+```json
+{
+  "project": "[Project Name]",
+  "branchName": "ralph/[feature-name]",
+  "description": "[Feature description]",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "[Short title]",
+      "description": "As a [user], I want to [action] so that [benefit].",
+      "acceptanceCriteria": ["Criterion 1", "Typecheck passes"],
+      "priority": 1,
+      "passes": false
+    }
+  ]
+}
+```
+
+4. Create `progress.txt` with timestamp and empty patterns section
+5. Guidelines: right-sized stories (one session each), verifiable criteria, independent stories, priority order (foundational work first)
+6. Proceed to normal ralph loop using user stories as the task list
+
+### Example
+User input: `--prd build a todo app with React and TypeScript`
+Workflow: Detect flag, extract task, create `.omc/prd.json`, create `.omc/progress.txt`, begin ralph loop.
+
+## Background Execution Rules
+
+**Run in background** (`run_in_background: true`):
+- Package installation (npm install, pip install, cargo build)
+- Build processes (make, project build commands)
+- Test suites
+- Docker operations (docker build, docker pull)
+
+**Run blocking** (foreground):
+- Quick status checks (git status, ls, pwd)
+- File reads and edits
+- Simple commands
+</Advanced>
+
+Original task:
+{{PROMPT}}

package/skills/ralph-init/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: ralph-init
+description: Initialize a PRD (Product Requirements Document) for structured ralph-loop execution
+---
+
+# Ralph Init
+
+Initialize a PRD (Product Requirements Document) for structured ralph-loop execution. Creates a structured requirements document that Ralph can use for goal-driven iteration.
+
+## Usage
+
+```
+/oh-my-claudecode:ralph-init "project or feature description"
+```
+
+## Behavior
+
+1. **Gather requirements** via interactive interview or from the provided description
+2. **Create PRD** at `.omc/plans/prd-{slug}.md` with:
+   - Problem statement
+   - Goals and non-goals
+   - Acceptance criteria (testable)
+   - Technical constraints
+   - Implementation phases
+3. **Link to Ralph** so that `/oh-my-claudecode:ralph` can use the PRD as its completion criteria
+
+## Output
+
+A structured PRD file saved to `.omc/plans/` that serves as the definition of done for Ralph execution.
+
+## Next Steps
+
+After creating the PRD, start execution with:
+```
+/oh-my-claudecode:ralph "implement the PRD"
+```
+
+Ralph will iterate until all acceptance criteria in the PRD are met and architect-verified.

package/skills/ralplan/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: ralplan
+description: Alias for /plan --consensus
+---
+
+# Ralplan (Consensus Planning Alias)
+
+Ralplan is a shorthand alias for `/oh-my-claudecode:plan --consensus`. It triggers iterative planning with Planner, Architect, and Critic agents until consensus is reached.
+
+## Usage
+
+```
+/oh-my-claudecode:ralplan "task description"
+```
+
+## Flags
+
+- `--interactive`: Enables user prompts at key decision points (draft review in step 2 and final approval in step 6). Without this flag the workflow runs fully automated — Planner → Architect → Critic loop — and outputs the final plan without asking for confirmation.
+
+## Usage with interactive mode
+
+```
+/oh-my-claudecode:ralplan --interactive "task description"
+```
+
+## Behavior
+
+This skill invokes the Plan skill in consensus mode:
+
+```
+/oh-my-claudecode:plan --consensus <arguments>
+```
+
+The consensus workflow:
+1. **Planner** creates initial plan
+2. **User feedback** *(--interactive only)*: If `--interactive` is set, use `AskUserQuestion` to present the draft plan before review (Proceed to review / Request changes / Skip review). Otherwise, automatically proceed to review.
+3. **Architect** reviews for architectural soundness — **await completion before step 4**
+4. **Critic** evaluates against quality criteria — run only after step 3 completes
+5. If Critic rejects: iterate with feedback (max 5 iterations)
+6. On Critic approval *(--interactive only)*: If `--interactive` is set, use `AskUserQuestion` to present the plan with approval options (Approve and execute via ralph / Approve and implement via team / Clear context and implement / Request changes / Reject). Otherwise, output the final plan and stop.
+7. *(--interactive only)* User chooses: Approve (ralph or team), Request changes, or Reject
+8. *(--interactive only)* On approval: invoke `Skill("oh-my-claudecode:ralph")` for sequential execution or `Skill("oh-my-claudecode:team")` for parallel team execution -- never implement directly
+
+> **Important:** Steps 3 and 4 MUST run sequentially. Do NOT issue both `ask_codex` calls in the same parallel batch — if one hits a 429 rate-limit error, Claude Code will cancel the sibling call ("Sibling tool call errored"), causing the entire review to fail. On a rate-limit error, retry once after 5–10 s; on second failure fall back to the equivalent Claude agent.
+
+Follow the Plan skill's full documentation for consensus mode details.

package/skills/release/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: release
+description: Automated release workflow for oh-my-claudecode
+---
+
+# Release Skill
+
+Automate the release process for oh-my-claudecode.
+
+## Usage
+
+```
+/oh-my-claudecode:release <version>
+```
+
+Example: `/oh-my-claudecode:release 2.4.0` or `/oh-my-claudecode:release patch` or `/oh-my-claudecode:release minor`
+
+## Release Checklist
+
+Execute these steps in order:
+
+### 1. Version Bump
+Update version in all locations:
+- `package.json`
+- `src/installer/index.ts` (VERSION constant)
+- `src/__tests__/installer.test.ts` (expected version)
+- `.claude-plugin/plugin.json`
+- `README.md` (version badge and title)
+
+### 2. Run Tests
+```bash
+npm run test:run
+```
+All 231+ tests must pass before proceeding.
+
+### 3. Commit Version Bump
+```bash
+git add -A
+git commit -m "chore: Bump version to <version>"
+```
+
+### 4. Create & Push Tag
+```bash
+git tag v<version>
+git push origin main
+git push origin v<version>
+```
+
+### 5. Publish to npm
+```bash
+npm publish --access public
+```
+
+### 6. Create GitHub Release
+```bash
+gh release create v<version> --title "v<version> - <title>" --notes "<release notes>"
+```
+
+### 7. Verify
+- [ ] npm: https://www.npmjs.com/package/oh-my-claudecode
+- [ ] GitHub: https://github.com/Yeachan-Heo/oh-my-claudecode/releases
+
+## Version Files Reference
+
+| File | Field/Line |
+|------|------------|
+| `package.json` | `"version": "X.Y.Z"` |
+| `src/installer/index.ts` | `export const VERSION = 'X.Y.Z'` |
+| `src/__tests__/installer.test.ts` | `expect(VERSION).toBe('X.Y.Z')` |
+| `.claude-plugin/plugin.json` | `"version": "X.Y.Z"` |
+| `README.md` | Title + version badge |
+
+## Semantic Versioning
+
+- **patch** (X.Y.Z+1): Bug fixes, minor improvements
+- **minor** (X.Y+1.0): New features, backward compatible
+- **major** (X+1.0.0): Breaking changes
+
+## Notes
+
+- Always run tests before publishing
+- Create release notes summarizing changes
+- Plugin marketplace syncs automatically from GitHub releases

package/skills/review/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: review
+description: Alias for /plan --review
+---
+
+# Review (Plan Review Alias)
+
+Review is a shorthand alias for `/oh-my-claudecode:plan --review`. It triggers Critic evaluation of an existing plan.
+
+## Usage
+
+```
+/oh-my-claudecode:review
+/oh-my-claudecode:review "path/to/plan.md"
+```
+
+## Behavior
+
+This skill invokes the Plan skill in review mode:
+
+```
+/oh-my-claudecode:plan --review <arguments>
+```
+
+The review workflow:
+1. Read plan file from `.omc/plans/` (or specified path)
+2. Evaluate via Critic agent
+3. Return verdict: APPROVED, REVISE (with specific feedback), or REJECT (replanning required)
+
+Follow the Plan skill's full documentation for review mode details.