@trac3er/oh-my-god 2.0.7 → 2.0.8

package/artifacts/release/plugins/advanced/commands/OMG:handoff.md

@@ -0,0 +1,115 @@
+---
+description: Intelligent session transfer — captures WHAT was done, HOW it was done, and WHY decisions were made. Works across platforms (Claude Code → Claude.ai).
+allowed-tools: Read, Write, Edit, MultiEdit, Bash(git:*), Bash(cat:*), Bash(wc:*), Bash(find:*), Bash(mkdir:*), Bash(tee:*), Grep, Glob
+argument-hint: "[optional: --portable for cross-platform, or reason for handoff]"
+---
+
+# /OMG:handoff — Intelligent Session Transfer
+
+## Size Budget (CRITICAL)
+- handoff.md: **≤ 60 lines** (briefing, not data dump)
+- handoff-portable.md: **≤ 100 lines** (fits most context windows)
+- If a section grows too long, SUMMARIZE — don't truncate mid-sentence
+
+## Philosophy
+A handoff is NOT a data dump. It's a **briefing** for the next session.
+The next Claude (in ANY platform) should read this and know EXACTLY:
+1. What was the goal
+2. What was accomplished (with evidence)
+3. What decisions were made and WHY
+4. What failed and WHY (so it doesn't repeat)
+5. The single most important next action
+
+## Step 1: Gather Intelligence
+
+Read these (silently, don't dump to user):
+- .omg/state/profile.yaml or project.md (project identity)
+- .omg/state/working-memory.md or _plan.md + _checklist.md (task state)
+- .omg/state/ledger/failure-tracker.json (what failed)
+- .omg/state/ledger/tool-ledger.jsonl (last 20 entries for activity summary)
+- git diff --stat + git log --oneline -5 (what changed)
+
+## Step 2: Synthesize — Write .omg/state/handoff.md
+
+DO NOT copy-paste raw data. SYNTHESIZE into this structure (≤ 60 lines total):
+
+```markdown
+# Handoff — [date]
+
+## Goal
+[1 sentence: what we're trying to achieve]
+
+## What Was Done (with evidence)
+- [action]: [result] (verified: [command, exit code])
+Total: [N] files changed, [M] lines
+
+## Key Decisions (preserve these)
+- Chose [X] over [Y] because [reason]
+
+## What Failed (don't repeat these)
+- [Approach A]: failed because [root cause]
+
+## Current State
+Branch: [name] | Uncommitted: [N files]
+Checklist: [done]/[total] steps
+
+## Exact Next Step
+[Single most important action with specific instructions]
+Read [specific file] first, then [specific action]
+
+## Files to Read on Resume
+1. .omg/state/profile.yaml (project identity)
+2. .omg/state/handoff.md (this file)
+3. [specific file relevant to next step]
+```
+
+## Step 3: Generate Portable Version (≤ 100 lines)
+
+ALWAYS also generate `.omg/state/handoff-portable.md` — a **self-contained** version that works
+when pasted into Claude.ai, ChatGPT, or any AI chat without file access.
+
+Portable version differences:
+- **Include** project identity inline (language, framework, key conventions) — no file references
+- **Include** the relevant code context (key interfaces, schemas, or config) — the next AI can't Read files
+- **Replace** "Read file X" with actual excerpts of the critical parts
+- **Total ≤ 100 lines** (fits in most context windows)
+
+## Step 4: Write Files
+
+**IMPORTANT: File write method — prevents "Error writing file".**
+
+First ensure directory exists:
+```
+mkdir -p .omg/state
+```
+
+Then write with `Write` tool. **If Write fails** (file already exists), use Bash heredoc:
+```bash
+cat > .omg/state/handoff.md << 'HANDOFF_EOF'
+[content here]
+HANDOFF_EOF
+```
+
+Do the same for handoff-portable.md.
+
+## Step 5: Present BOTH Versions
+
+```
+Handoff ready:
+  📁 .omg/state/handoff.md ([N] lines) — for Claude Code sessions
+  📋 .omg/state/handoff-portable.md ([N] lines) — for Claude.ai / other platforms
+
+To continue in Claude Code:
+  "Read .omg/state/profile.yaml and .omg/state/handoff.md, continue where I left off."
+
+To continue in Claude.ai (copy-paste the portable version):
+  [Show the user the full content of handoff-portable.md so they can copy it]
+```
+
+## Anti-patterns
+- Don't dump raw file contents into handoff (synthesize)
+- Don't list every tool call (summarize activity)
+- Don't include full error output (root cause only)
+- Don't make the portable version reference files it can't access
+- Don't exceed 60 lines / 100 lines budget
+- Don't use Write tool alone if the file already exists — fallback to Bash heredoc

package/artifacts/release/plugins/advanced/commands/OMG:learn.md

@@ -0,0 +1,110 @@
+---
+description: Create a reusable skill from a pattern you just did. Auto-detects repetitive work and offers to skill-ify it.
+allowed-tools: Read, Write, Edit, MultiEdit, Bash(git:*), Bash(cat:*), Bash(find:*), Bash(ls:*), Bash(mkdir:*), Bash(tee:*), Grep, Glob
+argument-hint: "[skill name] or 'auto' to detect from recent work"
+---
+
+# /OMG:learn — Auto-Skill Creator
+
+## What This Does
+Takes something you just did (test pattern, implementation approach, debugging method)
+and turns it into a reusable Claude Code skill that activates automatically next time.
+
+## Usage
+
+### Manual: /OMG:learn [skill-name]
+Claude asks you what the pattern is and creates a skill.
+
+### Auto: /OMG:learn auto
+Claude analyzes recent tool-ledger entries to detect repetitive patterns.
+
+## Step 1: Detect Pattern
+
+### If "auto":
+Read .omg/state/ledger/tool-ledger.jsonl (last 50 entries).
+Look for:
+- Same file types being created repeatedly (e.g., always creating .test.ts with same structure)
+- Same command sequences repeated (e.g., lint → typecheck → test → format)
+- Same file reading patterns (e.g., always reading ARCHITECTURE_TOC.md before edits)
+- Same error→fix sequences (e.g., import error → add import → retry)
+
+Present findings: "I noticed you repeatedly [pattern]. Want me to make this a skill?"
+
+### If manual:
+Ask: "Describe the pattern you want to save. What triggers it? What should happen?"
+
+## Step 2: Create Skill
+
+Skills live in: ~/.config/omg/skills/ (personal) or .omg/skills/ (project)
+
+```
+~/.config/omg/skills/[skill-name]/
+├── SKILL.md          # Instructions Claude follows
+├── templates/        # Template files (optional)
+└── scripts/          # Helper scripts (optional)
+```
+
+### SKILL.md Format:
+```markdown
+# [Skill Name]
+
+## When to activate
+[Trigger conditions — what keywords, file types, or situations activate this]
+
+## Steps
+1. [Step 1]
+2. [Step 2]
+...
+
+## Templates
+[If the skill creates files, include template content or reference templates/]
+
+## Quality check
+[How to verify the skill worked correctly]
+
+## Examples
+[1-2 examples of good output]
+```
+
+## Step 3: Register
+
+Add skill to .omg/skills-index.json:
+```json
+{
+  "skills": [
+    {
+      "name": "api-test-pattern",
+      "trigger": ["test", "api", "endpoint"],
+      "path": "~/.config/omg/skills/api-test-pattern/SKILL.md",
+      "description": "Creates API endpoint tests with auth, validation, edge cases"
+    }
+  ]
+}
+```
+
+## Step 4: Verify
+- Create a test invocation
+- Confirm the skill produces correct output
+- Tell user: "Skill '[name]' saved. It'll activate when you [trigger condition]."
+
+## Built-in Skill Candidates (suggest these)
+When detecting patterns, especially look for:
+- **Test patterns**: How tests are structured for this project
+- **Component patterns**: How new React/Vue/etc components are created
+- **API patterns**: How new endpoints are added (route + handler + validation + test)
+- **Migration patterns**: How DB migrations are created and verified
+- **PR patterns**: How PRs are structured (description, checklist, labels)
+- **Debug patterns**: Project-specific debugging steps (log locations, common fixes)
+
+## Aggregated Patterns (Auto)
+When you run `/OMG:learn auto`, OMG reads all learning files from `.omg/state/learnings/` and generates `.omg/knowledge/critical-patterns.md` with your top tool and file patterns.
+
+Run: `python3 -c "import sys; sys.path.insert(0,'hooks'); from _learnings import save_critical_patterns; save_critical_patterns('.')"`
+## File Write Fallback
+If `Write` fails (file exists), use `Edit` or Bash heredoc:
+```bash
+cat > path/to/skill.md << 'SKILLEOF'
+[content]
+SKILLEOF
+```
+Always READ the file after writing to verify changes.

package/artifacts/release/plugins/advanced/commands/OMG:maintainer.md

@@ -0,0 +1,31 @@
+---
+description: Open-source maintainer workflow — issue triage, release notes, review assistance, impact evidence pack
+allowed-tools: Read, Write, Edit, MultiEdit, Grep, Glob, Bash(git:*), Bash(rg:*), Bash(find:*), Bash(cat:*), Bash(ls:*)
+argument-hint: "[triage|release|review|impact]"
+---
+
+# /OMG:maintainer — OSS Maintainer Kit
+
+## Modes
+1. `triage`: summarize new issues, propose labels/priority/owner.
+2. `release`: draft release notes from recent commits and notable changes.
+3. `review`: review open changes with risk tags and test gaps.
+4. `impact`: generate Ecosystem Impact evidence draft.
+
+## Ecosystem Impact Evidence Pack
+Create `.omg/evidence/oss-impact.json` with:
+- `activity`: commits/reviews/releases in recent window
+- `dependents`: direct/transitive usage indicators (if available)
+- `stability`: test pass/fail trend and security findings
+- `adoption_signals`: downloads/stars/changelog cadence (factual only)
+- `summary_500_words`: draft narrative for application forms
+
+## Integrity Policy
+- Never fabricate stats.
+- Never suggest metric manipulation (stars/download inflation).
+- Mark unknown metrics as `unverified`.
+
+## Output format
+- Findings first
+- Risks and unknowns
+- Actionable next 3 maintainer tasks

package/artifacts/release/plugins/advanced/commands/OMG:ralph-start.md

@@ -0,0 +1,43 @@
+---
+description: "Start Ralph autonomous loop — continues working until all tasks complete or max iterations reached."
+allowed-tools: Read, Write, Edit, Bash, Grep, Glob
+argument-hint: "[goal description]"
+---
+
+# /OMG:ralph-start — Start Ralph Autonomous Loop
+
+## Purpose
+Starts a Ralph loop that autonomously continues working until all tasks in the goal are complete or max iterations reached.
+
+## Usage
+```
+/OMG:ralph-start [goal description]
+```
+
+## How it Works
+1. Ask the user for a goal description if not provided
+2. Create `.omg/state/ralph-loop.json` with:
+   - `active: true`
+   - `iteration: 0`
+   - `max_iterations: 50`
+   - `original_prompt: [goal]`
+   - `started_at: [ISO8601 timestamp]`
+   - `checklist_path: ".omg/state/_checklist.md"` (if exists)
+3. Confirm: "Ralph loop started. Will continue working on: [goal]"
+
+## State File Format
+```json
+{
+  "active": true,
+  "iteration": 0,
+  "max_iterations": 50,
+  "original_prompt": "fix all failing tests",
+  "started_at": "2026-02-28T10:00:00Z",
+  "checklist_path": ".omg/state/_checklist.md"
+}
+```
+
+## Stop Condition
+- Reaches max_iterations (50 by default)
+- User runs `/OMG:ralph-stop`
+- User deletes `.omg/state/ralph-loop.json`

package/artifacts/release/plugins/advanced/commands/OMG:ralph-stop.md

@@ -0,0 +1,23 @@
+---
+description: "Stop Ralph autonomous loop — deactivates the state file."
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: ""
+---
+
+# /OMG:ralph-stop — Stop Ralph Autonomous Loop
+
+## Purpose
+Stops an active Ralph loop by deactivating the state file.
+
+## Usage
+```
+/OMG:ralph-stop
+```
+
+## How it Works
+1. Read `.omg/state/ralph-loop.json`
+2. Set `active: false` in the state file (preserve iteration count for review)
+3. Report: "Ralph loop stopped after N iterations. Gomg was: [original_prompt]"
+
+## If No Active Loop
+Report: "No active Ralph loop found. Nothing to stop."

package/artifacts/release/plugins/advanced/commands/OMG:security-review.md

@@ -0,0 +1,16 @@
+---
+description: Deprecated alias to OMG's canonical security-check pipeline.
+allowed-tools: Read, Grep, Glob, Bash(python3:*), Bash(rg:*)
+argument-hint: "[path or '.' for the current project]"
+---
+
+# /OMG:security-review — Deprecated Alias
+
+`/OMG:security-review` remains available only for compatibility.
+
+Use `/OMG:security-check` instead. The canonical pipeline now owns:
+
+- normalized security findings
+- dependency and AST enrichment
+- evidence-ready provenance and trust scores
+- reuse across CLI, compat routing, control plane, MCP, and ship flows

package/artifacts/release/plugins/advanced/commands/OMG:sequential-thinking.md

@@ -0,0 +1,20 @@
+---
+description: Structured multi-step reasoning using sequential-thinking tool for complex debugging and planning.
+allowed-tools: sequential-thinking_sequentialthinking, Read, Grep, Glob
+argument-hint: "[problem statement to reason through]"
+---
+
+# /OMG:sequential-thinking
+
+Use the sequential-thinking tool when the task needs explicit step-by-step reasoning,
+branching, and hypothesis verification.
+
+Execution contract:
+- Start with an initial thought budget
+- Revise or branch when new evidence appears
+- End only when a verified conclusion is reached
+
+Output contract:
+- Return final conclusion
+- Return key assumptions
+- Return verification steps used

package/artifacts/release/plugins/advanced/commands/OMG:ship.md

@@ -0,0 +1,46 @@
+---
+description: Ship pipeline — Idea -> Plan -> Execute -> Evidence -> PR-ready summary
+allowed-tools: Read, Write, Edit, MultiEdit, Grep, Glob, Bash(git:*), Bash(rg:*), Bash(find:*), Bash(cat:*), Bash(python3:*), Bash(pytest:*), Bash(npm test:*), Bash(go test:*), Bash(cargo test:*), Bash(jest:*), Bash(vitest:*)
+argument-hint: "[goal or optional path to .omg/idea.yml]"
+---
+
+# /OMG:ship — Idea -> Evidence -> PR
+
+## Step 1: Load idea contract
+- Prefer `.omg/idea.yml`.
+- If missing, scaffold from `~/.claude/templates/omg/idea.yml` and ask user for minimum fields:
+  - `goal`, `constraints`, `acceptance`, `risk`, `evidence_required`.
+
+## Step 2: Convert idea to execution plan
+- Consume plan artifacts generated by `/OMG:deep-plan`.
+- Require `.omg/plans/deep-plan.md` and `.omg/plans/deep-plan.json` to already encode the business workflow contract.
+- If missing, invoke `/OMG:deep-plan` first and return after those artifacts are created.
+- Use the deep-plan workflow path and task metadata as the execution source of truth.
+
+## Step 3: Execute with Shadow + Evidence discipline
+- Implement changes.
+- Run verification commands.
+- Build an evidence pack at `.omg/evidence/<run-id>.json` containing:
+  - `tests[]`, `security_scans[]`, `diff_summary`, `reproducibility`, `unresolved_risks[]`.
+
+## Step 4: Security and trust checks
+- Run `/OMG:security-check` for auth/payment/database/sensitive changes.
+- If config/hook/MCP changes are involved, ensure trust manifest is updated at `.omg/trust/manifest.lock.json`.
+
+## Step 5: PR-ready output
+Return:
+1. Goal and scope delivered
+2. Files changed
+3. Verification evidence (command + exit code)
+4. Risks/unknowns
+5. Suggested PR title + body
+
+## Full-power sub-agent protocol
+- Prefer parallel background sub-agent launches for independent workstreams.
+- Do not finalize until every launched track is collected via `background_output`.
+- Use `sequential-thinking` to reconcile conflicts and enforce execution order.
+
+## Anti-patterns
+- Do not claim done without evidence.
+- Do not edit tests to hide product bugs.
+- Do not skip trust review for `.claude/.omg` or MCP changes.

package/artifacts/release/plugins/advanced/plugin.json

@@ -0,0 +1,87 @@
+{
+  "name": "omg-advanced",
+  "version": "2.0.8",
+  "description": "Advanced OMG commands - deep planning, learning, code review, and specialized workflows",
+  "type": "omg-plugin",
+  "commands": {
+    "deep-plan": {
+      "path": "commands/OMG:deep-plan.md",
+      "description": "Deep strategic planning with domain awareness",
+      "category": "planning"
+    },
+    "learn": {
+      "path": "commands/OMG:learn.md",
+      "description": "Create reusable skills from patterns",
+      "category": "knowledge"
+    },
+    "code-review": {
+      "path": "commands/OMG:code-review.md",
+      "description": "Deep code review with line-by-line analysis",
+      "category": "quality"
+    },
+    "ship": {
+      "path": "commands/OMG:ship.md",
+      "description": "Ship pipeline - idea to PR-ready summary",
+      "category": "delivery"
+    },
+    "handoff": {
+      "path": "commands/OMG:handoff.md",
+      "description": "Intelligent session transfer",
+      "category": "collaboration"
+    },
+    "maintainer": {
+      "path": "commands/OMG:maintainer.md",
+      "description": "Open-source maintainer workflows",
+      "category": "oss"
+    },
+    "sequential-thinking": {
+      "path": "commands/OMG:sequential-thinking.md",
+      "description": "Structured multi-step reasoning",
+      "category": "thinking"
+    },
+    "ralph-start": {
+      "path": "commands/OMG:ralph-start.md",
+      "description": "Start Ralph autonomous loop",
+      "category": "automation"
+    },
+    "ralph-stop": {
+      "path": "commands/OMG:ralph-stop.md",
+      "description": "Stop Ralph autonomous loop",
+      "category": "automation"
+    }
+  },
+  "categories": {
+    "planning": {
+      "description": "Strategic planning and architecture",
+      "commands": ["deep-plan"]
+    },
+    "quality": {
+      "description": "Code quality and review",
+      "commands": ["code-review"]
+    },
+    "knowledge": {
+      "description": "Learning and skill creation",
+      "commands": ["learn"]
+    },
+    "delivery": {
+      "description": "Shipping and release workflows",
+      "commands": ["ship"]
+    },
+    "collaboration": {
+      "description": "Team collaboration and handoff",
+      "commands": ["handoff"]
+    },
+    "automation": {
+      "description": "Autonomous execution modes",
+      "commands": ["ralph-start", "ralph-stop"]
+    },
+    "thinking": {
+      "description": "Structured thinking tools",
+      "commands": ["sequential-thinking"]
+    },
+    "oss": {
+      "description": "Open source maintainer tools",
+      "commands": ["maintainer"]
+    }
+  }
+}

package/artifacts/release/registry/bundles/algorithms.yaml

@@ -1,6 +1,6 @@
 id: algorithms
 kind: domain-pack
-version: 2.0.5
+version: 2.0.8
 title: OMG Algorithms Pack
 description: Determinism and benchmark attachments for algorithm-heavy work.
 hosts:

package/artifacts/release/registry/bundles/api-twin.yaml

@@ -1,6 +1,6 @@
 id: api-twin
 kind: simulation
-version: 2.0.5
+version: 2.0.8
 title: OMG API Twin
 description: Versioned endpoint cassette replay with latency, drift, and cost reporting.
 hosts:

package/artifacts/release/registry/bundles/claim-judge.yaml

@@ -0,0 +1,49 @@
+id: claim-judge
+kind: proof
+version: 2.0.8
+title: OMG Claim Judge
+description: Evidence-backed claim validator for structured release and completion claims.
+hosts:
+  - claude
+  - codex
+assets:
+  references:
+    - runtime/claim_judge.py
+invocation_policy:
+  user_invocable: true
+  model_invocable: true
+  allow_implicit_invocation: false
+tool_policy:
+  side_effect_level: low
+  allowed_tools:
+    claude:
+      - Read
+      - Grep
+      - Bash(python3:*)
+    codex:
+      - Read
+      - Grep
+      - Bash(python3:*)
+lifecycle_hooks:
+  native:
+    - PostToolUse
+  emulated:
+    - TaskCompleted
+mcp_contract:
+  servers:
+    - omg-control
+lsp_contract:
+  languages:
+    - python
+evidence_outputs:
+  artifacts:
+    - .omg/evidence/claim-judge-*.json
+execution_contract:
+  modes:
+    - embedded
+    - local_supervisor
+channel_overrides:
+  public:
+    posture: self-serve
+  enterprise:
+    posture: managed

package/artifacts/release/registry/bundles/control-plane.yaml

@@ -1,6 +1,6 @@
 id: control-plane
 kind: skill
-version: 2.0.5
+version: 2.0.8
 title: OMG Control Plane
 description: Canonical production control plane bundle for Claude and Codex.
 hosts:

package/artifacts/release/registry/bundles/data-lineage.yaml

@@ -1,6 +1,6 @@
 id: data-lineage
 kind: provenance
-version: 2.0.5
+version: 2.0.8
 title: OMG Data Lineage
 description: Provenance and privacy tracking for traces, fixtures, examples, and synthetic artifacts.
 hosts:

package/artifacts/release/registry/bundles/delta-classifier.yaml

@@ -1,6 +1,6 @@
 id: delta-classifier
 kind: routing
-version: 2.0.5
+version: 2.0.8
 title: OMG Delta Classifier
 description: Change classifier that attaches risk-aware checks, approvals, and packs.
 hosts:

package/artifacts/release/registry/bundles/eval-gate.yaml

@@ -1,6 +1,6 @@
 id: eval-gate
 kind: evaluation
-version: 2.0.5
+version: 2.0.8
 title: OMG Eval Gate
 description: Reproducible evaluation gate that blocks regressions before release.
 hosts:

package/artifacts/release/registry/bundles/health.yaml

@@ -1,6 +1,6 @@
 id: health
 kind: domain-pack
-version: 2.0.5
+version: 2.0.8
 title: OMG Health Pack
 description: Health-sensitive approvals, provenance, and replay attachments.
 hosts:

package/artifacts/release/registry/bundles/hook-governor.yaml

@@ -1,6 +1,6 @@
 id: hook-governor
 kind: governance
-version: 2.0.5
+version: 2.0.8
 title: OMG Hook Governor
 description: Canonical hook ordering, policy reinjection, and protected-path governance.
 hosts:

package/artifacts/release/registry/bundles/incident-replay.yaml

@@ -1,6 +1,6 @@
 id: incident-replay
 kind: debugging
-version: 2.0.5
+version: 2.0.8
 title: OMG Incident Replay
 description: Replayable bug packs built from logs, failing tests, traces, and diffs.
 hosts:

package/artifacts/release/registry/bundles/lsp-pack.yaml

@@ -1,6 +1,6 @@
 id: lsp-pack
 kind: diagnostics
-version: 2.0.5
+version: 2.0.8
 title: OMG LSP Pack
 description: Optional LSP-backed diagnostics and navigation bundle for production verification.
 hosts:

package/artifacts/release/registry/bundles/mcp-fabric.yaml

@@ -1,6 +1,6 @@
 id: mcp-fabric
 kind: mcp
-version: 2.0.5
+version: 2.0.8
 title: OMG MCP Fabric
 description: Tools, prompts, resources, and server instructions for the OMG control plane.
 hosts: