axiom-coding-agent-setup 1.0.11 → 1.0.12

package/.agents/skills/skill-creator/scripts/run_loop.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""Run the eval + improve loop until all pass or max iterations reached.
+
+Combines run_eval.py and improve_description.py in a loop, tracking history
+and returning the best description found. Supports train/test split to prevent
+overfitting.
+"""
+
+import argparse
+import json
+import random
+import sys
+import tempfile
+import time
+import webbrowser
+from pathlib import Path
+
+from scripts.generate_report import generate_html
+from scripts.improve_description import improve_description
+from scripts.run_eval import find_project_root, run_eval
+from scripts.utils import parse_skill_md
+
+
+def split_eval_set(eval_set: list[dict], holdout: float, seed: int = 42) -> tuple[list[dict], list[dict]]:
+    """Split eval set into train and test sets, stratified by should_trigger."""
+    random.seed(seed)
+
+    # Separate by should_trigger
+    trigger = [e for e in eval_set if e["should_trigger"]]
+    no_trigger = [e for e in eval_set if not e["should_trigger"]]
+
+    # Shuffle each group
+    random.shuffle(trigger)
+    random.shuffle(no_trigger)
+
+    # Calculate split points
+    n_trigger_test = max(1, int(len(trigger) * holdout))
+    n_no_trigger_test = max(1, int(len(no_trigger) * holdout))
+
+    # Split
+    test_set = trigger[:n_trigger_test] + no_trigger[:n_no_trigger_test]
+    train_set = trigger[n_trigger_test:] + no_trigger[n_no_trigger_test:]
+
+    return train_set, test_set
+
+
+def run_loop(
+    eval_set: list[dict],
+    skill_path: Path,
+    description_override: str | None,
+    num_workers: int,
+    timeout: int,
+    max_iterations: int,
+    runs_per_query: int,
+    trigger_threshold: float,
+    holdout: float,
+    model: str,
+    verbose: bool,
+    live_report_path: Path | None = None,
+    log_dir: Path | None = None,
+) -> dict:
+    """Run the eval + improvement loop."""
+    project_root = find_project_root()
+    name, original_description, content = parse_skill_md(skill_path)
+    current_description = description_override or original_description
+
+    # Split into train/test if holdout > 0
+    if holdout > 0:
+        train_set, test_set = split_eval_set(eval_set, holdout)
+        if verbose:
+            print(f"Split: {len(train_set)} train, {len(test_set)} test (holdout={holdout})", file=sys.stderr)
+    else:
+        train_set = eval_set
+        test_set = []
+
+    history = []
+    exit_reason = "unknown"
+
+    for iteration in range(1, max_iterations + 1):
+        if verbose:
+            print(f"\n{'='*60}", file=sys.stderr)
+            print(f"Iteration {iteration}/{max_iterations}", file=sys.stderr)
+            print(f"Description: {current_description}", file=sys.stderr)
+            print(f"{'='*60}", file=sys.stderr)
+
+        # Evaluate train + test together in one batch for parallelism
+        all_queries = train_set + test_set
+        t0 = time.time()
+        all_results = run_eval(
+            eval_set=all_queries,
+            skill_name=name,
+            description=current_description,
+            num_workers=num_workers,
+            timeout=timeout,
+            project_root=project_root,
+            runs_per_query=runs_per_query,
+            trigger_threshold=trigger_threshold,
+            model=model,
+        )
+        eval_elapsed = time.time() - t0
+
+        # Split results back into train/test by matching queries
+        train_queries_set = {q["query"] for q in train_set}
+        train_result_list = [r for r in all_results["results"] if r["query"] in train_queries_set]
+        test_result_list = [r for r in all_results["results"] if r["query"] not in train_queries_set]
+
+        train_passed = sum(1 for r in train_result_list if r["pass"])
+        train_total = len(train_result_list)
+        train_summary = {"passed": train_passed, "failed": train_total - train_passed, "total": train_total}
+        train_results = {"results": train_result_list, "summary": train_summary}
+
+        if test_set:
+            test_passed = sum(1 for r in test_result_list if r["pass"])
+            test_total = len(test_result_list)
+            test_summary = {"passed": test_passed, "failed": test_total - test_passed, "total": test_total}
+            test_results = {"results": test_result_list, "summary": test_summary}
+        else:
+            test_results = None
+            test_summary = None
+
+        history.append({
+            "iteration": iteration,
+            "description": current_description,
+            "train_passed": train_summary["passed"],
+            "train_failed": train_summary["failed"],
+            "train_total": train_summary["total"],
+            "train_results": train_results["results"],
+            "test_passed": test_summary["passed"] if test_summary else None,
+            "test_failed": test_summary["failed"] if test_summary else None,
+            "test_total": test_summary["total"] if test_summary else None,
+            "test_results": test_results["results"] if test_results else None,
+            # For backward compat with report generator
+            "passed": train_summary["passed"],
+            "failed": train_summary["failed"],
+            "total": train_summary["total"],
+            "results": train_results["results"],
+        })
+
+        # Write live report if path provided
+        if live_report_path:
+            partial_output = {
+                "original_description": original_description,
+                "best_description": current_description,
+                "best_score": "in progress",
+                "iterations_run": len(history),
+                "holdout": holdout,
+                "train_size": len(train_set),
+                "test_size": len(test_set),
+                "history": history,
+            }
+            live_report_path.write_text(generate_html(partial_output, auto_refresh=True, skill_name=name))
+
+        if verbose:
+            def print_eval_stats(label, results, elapsed):
+                pos = [r for r in results if r["should_trigger"]]
+                neg = [r for r in results if not r["should_trigger"]]
+                tp = sum(r["triggers"] for r in pos)
+                pos_runs = sum(r["runs"] for r in pos)
+                fn = pos_runs - tp
+                fp = sum(r["triggers"] for r in neg)
+                neg_runs = sum(r["runs"] for r in neg)
+                tn = neg_runs - fp
+                total = tp + tn + fp + fn
+                precision = tp / (tp + fp) if (tp + fp) > 0 else 1.0
+                recall = tp / (tp + fn) if (tp + fn) > 0 else 1.0
+                accuracy = (tp + tn) / total if total > 0 else 0.0
+                print(f"{label}: {tp+tn}/{total} correct, precision={precision:.0%} recall={recall:.0%} accuracy={accuracy:.0%} ({elapsed:.1f}s)", file=sys.stderr)
+                for r in results:
+                    status = "PASS" if r["pass"] else "FAIL"
+                    rate_str = f"{r['triggers']}/{r['runs']}"
+                    print(f"  [{status}] rate={rate_str} expected={r['should_trigger']}: {r['query'][:60]}", file=sys.stderr)
+
+            print_eval_stats("Train", train_results["results"], eval_elapsed)
+            if test_summary:
+                print_eval_stats("Test ", test_results["results"], 0)
+
+        if train_summary["failed"] == 0:
+            exit_reason = f"all_passed (iteration {iteration})"
+            if verbose:
+                print(f"\nAll train queries passed on iteration {iteration}!", file=sys.stderr)
+            break
+
+        if iteration == max_iterations:
+            exit_reason = f"max_iterations ({max_iterations})"
+            if verbose:
+                print(f"\nMax iterations reached ({max_iterations}).", file=sys.stderr)
+            break
+
+        # Improve the description based on train results
+        if verbose:
+            print(f"\nImproving description...", file=sys.stderr)
+
+        t0 = time.time()
+        # Strip test scores from history so improvement model can't see them
+        blinded_history = [
+            {k: v for k, v in h.items() if not k.startswith("test_")}
+            for h in history
+        ]
+        new_description = improve_description(
+            skill_name=name,
+            skill_content=content,
+            current_description=current_description,
+            eval_results=train_results,
+            history=blinded_history,
+            model=model,
+            log_dir=log_dir,
+            iteration=iteration,
+        )
+        improve_elapsed = time.time() - t0
+
+        if verbose:
+            print(f"Proposed ({improve_elapsed:.1f}s): {new_description}", file=sys.stderr)
+
+        current_description = new_description
+
+    # Find the best iteration by TEST score (or train if no test set)
+    if test_set:
+        best = max(history, key=lambda h: h["test_passed"] or 0)
+        best_score = f"{best['test_passed']}/{best['test_total']}"
+    else:
+        best = max(history, key=lambda h: h["train_passed"])
+        best_score = f"{best['train_passed']}/{best['train_total']}"
+
+    if verbose:
+        print(f"\nExit reason: {exit_reason}", file=sys.stderr)
+        print(f"Best score: {best_score} (iteration {best['iteration']})", file=sys.stderr)
+
+    return {
+        "exit_reason": exit_reason,
+        "original_description": original_description,
+        "best_description": best["description"],
+        "best_score": best_score,
+        "best_train_score": f"{best['train_passed']}/{best['train_total']}",
+        "best_test_score": f"{best['test_passed']}/{best['test_total']}" if test_set else None,
+        "final_description": current_description,
+        "iterations_run": len(history),
+        "holdout": holdout,
+        "train_size": len(train_set),
+        "test_size": len(test_set),
+        "history": history,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run eval + improve loop")
+    parser.add_argument("--eval-set", required=True, help="Path to eval set JSON file")
+    parser.add_argument("--skill-path", required=True, help="Path to skill directory")
+    parser.add_argument("--description", default=None, help="Override starting description")
+    parser.add_argument("--num-workers", type=int, default=10, help="Number of parallel workers")
+    parser.add_argument("--timeout", type=int, default=30, help="Timeout per query in seconds")
+    parser.add_argument("--max-iterations", type=int, default=5, help="Max improvement iterations")
+    parser.add_argument("--runs-per-query", type=int, default=3, help="Number of runs per query")
+    parser.add_argument("--trigger-threshold", type=float, default=0.5, help="Trigger rate threshold")
+    parser.add_argument("--holdout", type=float, default=0.4, help="Fraction of eval set to hold out for testing (0 to disable)")
+    parser.add_argument("--model", required=True, help="Model for improvement")
+    parser.add_argument("--verbose", action="store_true", help="Print progress to stderr")
+    parser.add_argument("--report", default="auto", help="Generate HTML report at this path (default: 'auto' for temp file, 'none' to disable)")
+    parser.add_argument("--results-dir", default=None, help="Save all outputs (results.json, report.html, log.txt) to a timestamped subdirectory here")
+    args = parser.parse_args()
+
+    eval_set = json.loads(Path(args.eval_set).read_text())
+    skill_path = Path(args.skill_path)
+
+    if not (skill_path / "SKILL.md").exists():
+        print(f"Error: No SKILL.md found at {skill_path}", file=sys.stderr)
+        sys.exit(1)
+
+    name, _, _ = parse_skill_md(skill_path)
+
+    # Set up live report path
+    if args.report != "none":
+        if args.report == "auto":
+            timestamp = time.strftime("%Y%m%d_%H%M%S")
+            live_report_path = Path(tempfile.gettempdir()) / f"skill_description_report_{skill_path.name}_{timestamp}.html"
+        else:
+            live_report_path = Path(args.report)
+        # Open the report immediately so the user can watch
+        live_report_path.write_text("<html><body><h1>Starting optimization loop...</h1><meta http-equiv='refresh' content='5'></body></html>")
+        webbrowser.open(str(live_report_path))
+    else:
+        live_report_path = None
+
+    # Determine output directory (create before run_loop so logs can be written)
+    if args.results_dir:
+        timestamp = time.strftime("%Y-%m-%d_%H%M%S")
+        results_dir = Path(args.results_dir) / timestamp
+        results_dir.mkdir(parents=True, exist_ok=True)
+    else:
+        results_dir = None
+
+    log_dir = results_dir / "logs" if results_dir else None
+
+    output = run_loop(
+        eval_set=eval_set,
+        skill_path=skill_path,
+        description_override=args.description,
+        num_workers=args.num_workers,
+        timeout=args.timeout,
+        max_iterations=args.max_iterations,
+        runs_per_query=args.runs_per_query,
+        trigger_threshold=args.trigger_threshold,
+        holdout=args.holdout,
+        model=args.model,
+        verbose=args.verbose,
+        live_report_path=live_report_path,
+        log_dir=log_dir,
+    )
+
+    # Save JSON output
+    json_output = json.dumps(output, indent=2)
+    print(json_output)
+    if results_dir:
+        (results_dir / "results.json").write_text(json_output)
+
+    # Write final HTML report (without auto-refresh)
+    if live_report_path:
+        live_report_path.write_text(generate_html(output, auto_refresh=False, skill_name=name))
+        print(f"\nReport: {live_report_path}", file=sys.stderr)
+
+    if results_dir and live_report_path:
+        (results_dir / "report.html").write_text(generate_html(output, auto_refresh=False, skill_name=name))
+
+    if results_dir:
+        print(f"Results saved to: {results_dir}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

package/.agents/skills/skill-creator/scripts/utils.py

@@ -0,0 +1,47 @@
+"""Shared utilities for skill-creator scripts."""
+
+from pathlib import Path
+
+
+
+def parse_skill_md(skill_path: Path) -> tuple[str, str, str]:
+    """Parse a SKILL.md file, returning (name, description, full_content)."""
+    content = (skill_path / "SKILL.md").read_text()
+    lines = content.split("\n")
+
+    if lines[0].strip() != "---":
+        raise ValueError("SKILL.md missing frontmatter (no opening ---)")
+
+    end_idx = None
+    for i, line in enumerate(lines[1:], start=1):
+        if line.strip() == "---":
+            end_idx = i
+            break
+
+    if end_idx is None:
+        raise ValueError("SKILL.md missing frontmatter (no closing ---)")
+
+    name = ""
+    description = ""
+    frontmatter_lines = lines[1:end_idx]
+    i = 0
+    while i < len(frontmatter_lines):
+        line = frontmatter_lines[i]
+        if line.startswith("name:"):
+            name = line[len("name:"):].strip().strip('"').strip("'")
+        elif line.startswith("description:"):
+            value = line[len("description:"):].strip()
+            # Handle YAML multiline indicators (>, |, >-, |-)
+            if value in (">", "|", ">-", "|-"):
+                continuation_lines: list[str] = []
+                i += 1
+                while i < len(frontmatter_lines) and (frontmatter_lines[i].startswith("  ") or frontmatter_lines[i].startswith("\t")):
+                    continuation_lines.append(frontmatter_lines[i].strip())
+                    i += 1
+                description = " ".join(continuation_lines)
+                continue
+            else:
+                description = value.strip('"').strip("'")
+        i += 1
+
+    return name, description, content

package/README.md

@@ -83,6 +83,7 @@ Domain-specific skills that can be loaded on-demand:
 - `gradio/` — Gradio UI framework guides
 - `mcp-builder/` — MCP server development guide
 - `n8n-patterns/` — n8n workflow automation patterns
+- `project-design/` — Project planning & architecture documentation
 - `ui-ux-pro-max/` — Advanced UI/UX design skill
 
 ## Development

package/bin/cli.js

@@ -41,6 +41,7 @@ const FILES_TO_DOWNLOAD = [
   '.agents/skills/gradio/SKILL.md',
   '.agents/skills/mcp-builder/SKILL.md',
   '.agents/skills/n8n-patterns/SKILL.md',
+  '.agents/skills/project-design/SKILL.md',
   '.agents/skills/ui-ux-pro-max/SKILL.md'
 ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axiom-coding-agent-setup",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "CLI tool to download AXIOM coding agent setup files into your project",
   "main": "bin/cli.js",
   "bin": {

package/plugin/oh-my-openagent.json

@@ -0,0 +1,198 @@
+{
+  "$schema": "https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/dev/assets/oh-my-opencode.schema.json",
+  "agents": {
+    // === ORCHESTRATION CORE ===
+    // Kimi K2.6: #1 open-weight for long-horizon agentic work, 300-subagent swarm,
+    // 12h autonomous sessions, officially omo's top non-Claude fallback for Sisyphus.
+    // Fallback: DeepSeek V4 Pro for its raw SWE-bench muscle when K2.6 is unavailable.
+    "sisyphus": {
+      "model": "opencode-go/kimi-k2.6",
+      "fallback_models": [
+        { "model": "opencode-go/deepseek-v4-pro" }
+      ]
+    },
+
+    // === PLANNING & STRATEGY ===
+    // Prometheus auto-detects model family and switches prompts — Kimi K2.6 fits the
+    // Claude-like instruction-following prompt that omo uses for strategic planning.
+    // Fallback: GLM-5.1 for its independently verified long-horizon execution loop.
+    "prometheus": {
+      "model": "opencode-go/kimi-k2.6",
+      "fallback_models": [
+        { "model": "opencode-go/glm-5.1" }
+      ]
+    },
+
+    // === PLAN REVIEW ===
+    // Metis is the plan reviewer — needs strong reasoning + precision.
+    // Kimi K2.6 excels at catching non-obvious bugs and maintaining architectural integrity
+    // over extended review sessions per enterprise beta feedback.
+    // Fallback: GLM-5.1 which ranked #1 on NL2Repo for codebase structure comprehension.
+    "metis": {
+      "model": "opencode-go/kimi-k2.6",
+      "fallback_models": [
+        { "model": "opencode-go/glm-5.1" }
+      ]
+    },
+
+    // === ARCHITECTURE & DEBUGGING ===
+    // Oracle needs surgical precision in large codebases — Kimi K2.6 won benchmarks
+    // specifically on async/TypeVar edge-case bugs that require multi-cycle inference state.
+    // Fallback: DeepSeek V4 Pro, strongest on SWE-bench Verified (80.6%) and Codeforces (3206).
+    "oracle": {
+      "model": "opencode-go/kimi-k2.6",
+      "fallback_models": [
+        { "model": "opencode-go/deepseek-v4-pro" }
+      ]
+    },
+
+    // === HIGH-ACCURACY REVIEW ===
+    // Momus is the strictness reviewer — prompt is tuned for Claude-like models.
+    // GLM-5.1 promoted to primary: independently verified Code Arena Elo 1530 (#3 globally),
+    // spontaneously applied composition patterns in head-to-head tests vs K2.6.
+    // Fallback: Kimi K2.6 for its 12% improvement in code generation accuracy over K2.5.
+    "momus": {
+      "model": "opencode-go/glm-5.1",
+      "fallback_models": [
+        { "model": "opencode-go/kimi-k2.6" }
+      ]
+    },
+
+    // === TODO ORCHESTRATION ===
+    // Atlas is the task/todo orchestrator — auto-detects model family.
+    // Kimi K2.6 is the best fit for long multi-step coordination (300 sub-agents, 4000 steps).
+    // Fallback: DeepSeek V4 Pro for its $3.48/M cost efficiency at scale.
+    "atlas": {
+      "model": "opencode-go/kimi-k2.6",
+      "fallback_models": [
+        { "model": "opencode-go/deepseek-v4-pro" }
+      ]
+    },
+
+    // === DOCS & CODE SEARCH ===
+    // Librarian does documentation lookup and contextual code search — benefits most from
+    // Qwen3.6 Plus's 1M token context (vs K2.6's 256K ceiling). Handles full repo ingestion
+    // in a single pass. 4-6x cheaper than Claude-class for large-context read-heavy work.
+    // Fallback: DeepSeek V4 Pro — also 1M context, strong on LiveCodeBench (93.5%).
+    "librarian": {
+      "model": "opencode-go/qwen3.6-plus",
+      "fallback_models": [
+        { "model": "opencode-go/deepseek-v4-pro" }
+      ]
+    },
+
+    // === FAST CODEBASE GREP ===
+    // Explore is a fast grep/search agent — speed matters more than raw intelligence here.
+    // Qwen3.6 Plus runs 2-3x faster TPS than Claude Opus and has 1M context for large repos.
+    // Fallback: GLM-5.1 for its 55+ tokens/sec generation speed.
+    "explore": {
+      "model": "opencode-go/qwen3.6-plus",
+      "fallback_models": [
+        { "model": "opencode-go/glm-5.1" }
+      ]
+    },
+
+    // === VISION / SCREENSHOTS ===
+    // Multimodal-looker needs a model with solid vision. Kimi K2.6 has native multimodality
+    // and specifically handles visual-to-code workflows (UI designs → working code).
+    // No fallback: this is the only model in the stack with reliable multimodal support.
+    "multimodal-looker": {
+      "model": "opencode-go/kimi-k2.6"
+    },
+
+    // === JUNIOR WORKER ===
+    // Sisyphus-Junior handles delegated subtasks — Kimi K2.6 maintains session stability
+    // for parallel spawned workers (tool invocation success rate 96.60% per CodeBuddy eval).
+    // Fallback: DeepSeek V4 Pro for cost efficiency on high-volume parallel calls.
+    "sisyphus-junior": {
+      "model": "opencode-go/kimi-k2.6",
+      "fallback_models": [
+        { "model": "opencode-go/deepseek-v4-pro" }
+      ]
+    }
+  },
+
+  "categories": {
+    // === VISUAL / FRONTEND ENGINEERING ===
+    // GLM-5.1 promoted to primary: #3 globally on agentic webdev (Arena.ai Elo 1530),
+    // produced correct Tailwind + TypeScript components on first pass in head-to-head tests.
+    // Kimi K2.6 as fallback — strong on visual-to-code via native multimodal training.
+    "visual-engineering": {
+      "model": "opencode-go/glm-5.1",
+      "fallback_models": [
+        { "model": "opencode-go/kimi-k2.6" }
+      ]
+    },
+
+    // === MAXIMUM REASONING ===
+    // Ultrabrain is the highest-stakes category — Kimi K2.6 leads open-weight AI Index (54).
+    // Fallback: DeepSeek V4 Pro for its Codeforces 3206 and LiveCodeBench 93.5% supremacy.
+    "ultrabrain": {
+      "model": "opencode-go/kimi-k2.6",
+      "fallback_models": [
+        { "model": "opencode-go/deepseek-v4-pro" }
+      ]
+    },
+
+    // === DEEP / COMPLEX WORK ===
+    // Kimi K2.6: best open-source for long-horizon, sustained multi-step execution.
+    // Fallback: GLM-5.1 — demonstrated 655-iteration autonomous optimization loop,
+    // 8h uninterrupted task execution, strongest open-weight for backend deep dives.
+    "deep": {
+      "model": "opencode-go/kimi-k2.6",
+      "fallback_models": [
+        { "model": "opencode-go/glm-5.1" }
+      ]
+    },
+
+    // === CREATIVE / UI ARTISTRY ===
+    // GLM-5.1 as primary: spontaneously applies composition patterns, correct JSX on first
+    // pass, Code Arena voters prefer it for frontend aesthetics in head-to-head evals.
+    // Kimi K2.6 as fallback: Moonshot claims Awwwards-level frontend from single prompts.
+    "artistry": {
+      "model": "opencode-go/glm-5.1",
+      "fallback_models": [
+        { "model": "opencode-go/kimi-k2.6" }
+      ]
+    },
+
+    // === QUICK / TRIVIAL TASKS ===
+    // GLM-5.1: 55+ tokens/sec, HN devs rate it as "actually usable" for piecemeal tasks,
+    // compares well to GPT-5.4 for scoped, well-defined subtasks.
+    // No fallback needed — quick tasks should just pass or skip to the next agent.
+    "quick": {
+      "model": "opencode-go/glm-5.1"
+    },
+
+    // === UNSPECIFIED / MODERATE TASKS ===
+    // Kimi K2.6 is the safest general-purpose choice for ambiguous category routing.
+    // Fallback: Qwen3.6 Plus at $0.50/M input — 30x cheaper than Claude, close in SWE-bench.
+    "unspecified-low": {
+      "model": "opencode-go/kimi-k2.6",
+      "fallback_models": [
+        { "model": "opencode-go/qwen3.6-plus" }
+      ]
+    },
+
+    // === UNSPECIFIED / COMPLEX TASKS ===
+    // Same primary as unspecified-low — Kimi K2.6 handles both well.
+    // Fallback: GLM-5.1 rather than Qwen, for stronger reasoning depth on hard unknowns.
+    "unspecified-high": {
+      "model": "opencode-go/kimi-k2.6",
+      "fallback_models": [
+        { "model": "opencode-go/glm-5.1" }
+      ]
+    },
+
+    // === WRITING / DOCUMENTATION ===
+    // Kimi K2.6: strong instruction-following and consistent output quality.
+    // Fallback: GLM-5.1 — bilingual training (EN/CN) useful for mixed-language codebases
+    // and documentation; Qwen3.6 Plus also strong here but GLM edges it on coherence.
+    "writing": {
+      "model": "opencode-go/kimi-k2.6",
+      "fallback_models": [
+        { "model": "opencode-go/glm-5.1" }
+      ]
+    }
+  }
+}

package/plugin/oh-my-openagent.md

@@ -0,0 +1,49 @@
+Congratulations! 🎉
+You have successfully set up OhMyOpenAgent with your OpenCode Go subscription! Type opencode in your terminal to start using it.
+Your Model Configuration
+All agents have been configured to use your opencode-go/ models:
+Agent Model Role
+Sisyphus opencode-go/kimi-k2.6 Main ultraworker / orchestrator
+Prometheus opencode-go/glm-5.1 Strategic planner
+Metis opencode-go/glm-5.1 Plan reviewer
+Oracle opencode-go/glm-5.1 Architecture / debugging
+Momus opencode-go/glm-5.1 High-accuracy reviewer
+Atlas opencode-go/kimi-k2.6 Todo orchestrator
+Librarian opencode-go/qwen3.5-plus Docs / code search
+Explore opencode-go/qwen3.5-plus Fast codebase grep
+Multimodal Looker opencode-go/kimi-k2.6 Vision / screenshots
+Verification Results
+The doctor found 2 minor non-critical issues:
+
+1.  Comment checker unavailable — Optional. Install @code-yeongyu/comment-checker if you want AI comment quality checks.
+2.  GitHub CLI not authenticated — Only matters if you want GitHub automation. Run gh auth login if needed.
+    Your core setup is healthy! ✅
+    Free Advertising
+    Vercel — The platform for frontend developers. Ship fast, scale faster. Vercel powers some of the most performant web experiences on the internet with their edge network and framework-defined infrastructure. From personal projects to enterprise deployments, Vercel makes frontend teams unstoppable.
+    You can also get free advertising for your company by contributing to oh-my-openagent: https://github.com/code-yeongyu/oh-my-openagent/compare
+    What You Can Do Now
+    Here are some powerful use cases with your setup:
+3.  ultrawork or ulw — Type this in your prompt and Sisyphus will orchestrate multiple agents in parallel to relentlessly execute until your task is done. Refactor an entire codebase, build a feature end-to-end, or fix thousands of lint warnings overnight.
+4.  /start-work — Press Tab to enter Prometheus (Planner) mode. He'll interview you like a senior engineer, identify scope and ambiguities, and build a detailed execution plan before any code is touched.
+5.  /init-deep — Run this to auto-generate hierarchical AGENTS.md files throughout your project. Your agents will instantly understand your codebase structure without you explaining it every time.
+6.  Background Agents — Fire off 5+ specialist agents in parallel. Context stays lean, results come when ready.
+7.  Team Mode — Enable team_mode in your config to run a lead agent + up to 8 parallel members with real-time tmux visualization. Great for security audits or plan critiques.
+    Quick Tips
+8.  Sisyphus agent strongly recommends Opus 4.7 model. Using other models may result in significantly degraded experience. Your current fallback is kimi-k2.6, which is the best available in your OpenCode Go plan.
+9.  Feeling lazy? Just include ultrawork (or ulw) in your prompt. That's it. The agent figures out the rest.
+10. Need precision? Press Tab to enter Prometheus (Planner) mode, create a work plan through an interview process, then run /start-work to execute it with full orchestration.
+11. Want your own agent-catalog setup? I can read the docs (https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/refs/heads/dev/docs/guide/agent-model-matching.md) and set it up for you after interviewing!
+    Authentication Note
+    Your OpenCode Go models (opencode-go/...) should work if your OpenCode Go subscription is active. If opencode prompts you for provider authentication on first use, simply run:
+    opencode auth login
+    and follow the OpenCode provider flow.
+    If you found this helpful, would you like to star the repository? It helps the project grow! ⭐
+    Just say yes and I'll star it for you! 🌟
+
+---
+
+The file I modified is located at:
+C:\Users\Cikal Merdeka\.config\opencode\oh-my-openagent.json
+
+Claude:
+https://claude.ai/chat/3c0c28cf-fc2c-4225-87e1-e5dd3c5cfb38

package/skills-lock.json

@@ -41,6 +41,12 @@
       "skillPath": ".agents/skills/gradio/SKILL.md",
       "computedHash": "5078d8a4cc2b562731620f36f5f0d3ad054bd51f7a98baa547b04b893744823b"
     },
+    "skill-creator": {
+      "source": "anthropics/skills",
+      "sourceType": "github",
+      "skillPath": "skills/skill-creator/SKILL.md",
+      "computedHash": "7e3c9cd74e9e2b4828527a857170e86310f2dab5ea8030a9043df2c7e6c88857"
+    },
     "ui-ux-pro-max": {
       "source": "nextlevelbuilder/ui-ux-pro-max-skill",
       "sourceType": "github",