[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7AQP3MFH3FQGRAZVCD5FXDP":3,"skill-same:01M7AQP3MFH3FQGRAZVCD5FXDP":44},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":14,"repositoryHtmlUrl":27,"repositoryHomepageUrl":6,"ownerHtmlUrl":28,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":29,"install":30,"resources":43},"01M7AQP3MFH3FQGRAZVCD5FXDP","claive-routing-codex",null,"Codex-specific delegation through Claive. Launch, supervise, and reuse Muse, Pi, Claude, or Codex workers when authorized; use Codex managed terminals, worktree\u002Fread-only controls, and verification without changing task scope.","ham-zax\u002Fwebharness","ham-zax","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F81289670?v=4","01M7AQGHAV4TPYCAZY23S7SVSC","Ahmed Hamza","01M7AQGHBCFJYE7KWZ34W9HEGH",0,"MIT","https:\u002F\u002Fgithub.com\u002Fham-zax\u002Fwebharness\u002Fblob\u002Fmain\u002Fskill-library\u002Fpacks\u002Factive\u002Fclaive-routing-codex\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: claive-routing-codex\ndescription: Codex-specific delegation through Claive. Launch, supervise, and reuse Muse, Pi, Claude, or Codex workers when authorized; use Codex managed terminals, worktree\u002Fread-only controls, and verification without changing task scope.\n---\n\n# Claive routing — Codex host\n\nMuse Code is the default engine; Pi is available explicitly with `--engine pi` through `opencode2api`. Follow the global AGENTS.md delegation criteria; complete small or tightly coupled tasks directly when delegation would add overhead. The parent owns synthesis, integration, and final verification.\n\nThe maintained source is `$HOME\u002Frepo\u002Fclaive\u002Fskills\u002Fclaive-routing-codex\u002FSKILL.md`. Skillshare owns the live copy at `~\u002F.config\u002Fskillshare\u002Fskills\u002Fclaive-routing-codex\u002F`; update both, then `skillshare sync`. Do not run the legacy skill installer over Skillshare links. `reference\u002Fglobal-AGENTS.md` is a snapshot, not a replacement for global instructions.\n\nFor a task with an executable check, prefer the verifier-gated ladder in the `claive-orchestration` skill (`claive-orch`: Muse implements, a cross-family Pi critic reviews, and the arbiter accepts or reverts each round). This skill governs Codex launch mechanics; the experimental `ttc-experiment` skill is archived and must not be auto-loaded or reinstalled.\n\n## Current engine boundaries (Claive main, October 2026)\n\nThe general `claive` worker manager supports **four engines**; the optional\n`claive-orch` verifier-driven arbiter currently selects **Muse\u002FPi** candidates.\nDo not confuse the arbiter's model policy with a limitation of the worker manager.\nSelect an engine deliberately and follow the parent's current authorization policy.\n\n| Engine | Runtime contract |\n| --- | --- |\n| `muse` (default) | Pinned `muse-spark-1.3-contributor`; usual substantive effort `xhigh`; supports managed worktrees and read-only isolation |\n| `pi` | `--engine pi --provider opencode2api`; models selected explicitly or inherited; no managed worktree, `--web`, or model-step cap |\n| `claude` | `--engine claude`; pinned `claude-haiku-5-5`; headless and isolated from user settings, hooks, MCP, and skills; no managed worktree, output schema, or model-step cap |\n| `codex` | `--engine codex`; pinned `gpt-6-luna`, effort `max`; writer defaults to workspace-write sandbox, read-only uses the read-only sandbox; no managed worktree, output schema, or model-step cap |\n\nClaude\u002FCodex workers are **available**, not automatically authorized as a\nfallback or as critics for the Muse\u002FPi arbiter. Do not silently switch engines,\nrelax sandboxing, or assume another model's worker permissions carry over.\nFor a Codex worker, `CLAIVE_CODEX_USE_USER_CONFIG=1` explicitly opts into that\nworker's existing Codex user MCP\u002Fskill configuration; the default is isolated.\n`CLAIVE_CODEX_YOLO=1` explicitly bypasses the sandbox for a writing worker:\n**do not set it without task-specific authorization**. Neither setting installs\nnew MCP servers. Consult `docs\u002Fharness-integration.md` for the runtime protocol.\n\nFor routine work from the Codex parent, favor `claive-worker` in Codex's managed\nshell so its session remains visible in `\u002Fps`; use `claive start` or\n`claive open --detach` only when genuinely detached execution is needed.\nKeep the terminal session ID, Claive worker ID, and engine session UUID distinct.\n\n## Model and reasoning\n\nUse **only `muse-spark-1.3-contributor`** for Muse workers. The launcher pins this model rather than inheriting another default. Do not substitute a different Muse model\u002Fprovider or route through agy\u002FOpenCode's historical defaults without explicit fallback authorization below. Their relay copies in `reference\u002F` are archival. Native host subagents require an explicit request.\n\n- **`xhigh`: default for normal implementation, investigation, review, and other substantive work** (the Muse engine default).\n- **`max`: very complicated work**, difficult fixes, or consequential reasoning.\n- **`high`\u002F`medium`: rarely**, only for trivial mechanical work such as generating a commit message.\n- **Pi workers: always `max`** (the Pi engine default). They are free; Pi clamps `max` to each model's highest supported level.\n- **Pi models:** prefer `mimo-v2.6-flash-free`, `big-pickle`, `space-bunny-free`; `longcat-2.5-preview-free` only rarely. Do not use `nemotron-*` or `ling-3.1-flash-free`.\n\nThe orchestrator can select effort per turn or change an existing worker's future default at any time. Changes apply to the next request; they cannot change an in-flight API call. Muse defaults to 100 model steps; Pi rejects `--max-model-steps`. Set a cap suitable for the assignment, including a higher cap when needed; a step cap is not a monetary budget or timeout.\n\n## Prepare the assignment\n\nWrite one narrow task to an absolute scratch prompt-file path. Include:\n\n`mission | inputs | authorized scope | write ownership | required output | stopping condition`\n\nSupply the absolute repository path, relevant files and symbols, existing evidence, constraints, and acceptance criteria. Workers do not automatically inherit the conversation or MCP access. Pass relevant graph findings and coverage gaps when the assignment relies on them.\n\nTell the worker it is not alone in the codebase: preserve other edits and accommodate them. Restrict writes to its assigned files. Forbid recursive delegation, commits, pushes, and other external writes unless the assignment explicitly authorizes them. Workers may make local, reversible implementation choices; they must report a blocker rather than expand scope or make a consequential decision outside the assignment.\n\nRequest a concise report: outcome, files changed, checks with results, supporting evidence, local decisions, uncertainty, blockers, and actual worktree path when isolated. Use exact check commands when known and appropriate to the authorized task. Avoid raw context dumps.\n\n## Launch and observe workers\n\nDefault to `\"$HOME\"\u002F.local\u002Fbin\u002Fclaive-worker` inside Codex's managed shell tool. The launcher opens a reusable worker and remains alive between related turns, so a yielded shell call is a managed background terminal and appears in the native running-terminal indicator and `\u002Fps`. The installed manager is `\"$HOME\"\u002F.local\u002Fbin\u002Fclaive`; its generic supervisor owns state, follow-ups, cancellation, and logs, while each engine adapter builds its commands and interprets its events and usage. Private logs are retained under `${XDG_STATE_HOME:-$HOME\u002F.local\u002Fstate}\u002Fclaive`. `CLAIVE_DIR` can select another absolute registry directory. The custom dashboard and tmux pane are optional additional views.\n\n```bash\nexec \"$HOME\"\u002F.local\u002Fbin\u002Fclaive-worker \\\n  --workspace \"$task_workspace\" \\\n  --prompt-file \"$task_prompt\" \\\n  --label \"Implement assigned feature\" \\\n  --reasoning-effort xhigh \\\n  --max-model-steps 100\n```\n\nFor a Muse worker that needs isolation, add `--worktree`; `--worktree-base` selects a base commit (default `HEAD`; uncommitted parent edits are not included). claive creates the worktree itself (Muse 1.4.3's `-w create` fails under its sandbox) at `$CLAIVE_DIR\u002F\u003Cid>\u002Fworktree`, detached for `--read-only`, on branch `claive\u002F\u003Cid>` for writers, and it lasts across a reusable worker's follow-ups. When the worker ends, claive removes it unless a writer changed it; then the worktree and branch are kept, `show --json` lists `retained_worktree`, and you review and integrate from there. For a worktree you manage yourself, pass `--worktree-existing \u002Fabsolute\u002Fworktree`. For enforced read-only workers add `--read-only` (both write and shell are disabled). Web tools are disabled unless `--web` is supplied. The Muse engine accepts only the pinned model. `--output-schema` is forwarded. Reusable workers require session logging; `--no-session-log` is rejected by this launcher. `--provider echo` is for local transport checks, not evidence that the live model works.\n\nUse `exec_command` with a short initial `yield_time_ms` (for example 1000). A returned `session_id` means the shell command is still running: retain it and use `write_stdin` to collect output and final exit status. Independent workers can each have their own managed session; shell yielding lets the parent continue working without detaching the worker. After a turn, the reusable worker remains idle and available in the managed terminal until closed. An idle supervisor makes no model requests.\n\nFor Pi, use the same launcher with `--engine pi --provider opencode2api` and omit `--max-model-steps`. Omit `--model` to inherit the last selected Pi model from its global settings; the initial model is `muse-spark-1.3-contributor-free`. An explicit `--model ID` becomes the shared selection after launch-option validation, even if the subsequent model request fails; role models, batch stage models and timeout fallbacks do not. Existing workers and their follow-ups retain their launch model. This preference is separate from Muse's pinned model and never switches engines automatically. Pi supports only `opencode2api` here. Use `--workspace` for an externally retained worktree; Pi rejects worktree-management, `--web`, and `--output-schema`. Pi read-only tools are `read,grep,find,ls`, with extensions disabled; Pi has no Muse OS sandbox. See `$HOME\u002Frepo\u002Fclaive\u002Fdocs\u002Fpi-engine.md` for the verified runtime contract.\n\nThe shell session ID and the 12-character worker ID printed by `claive-worker` identify different objects; the retained worker `session_id` (a Muse session UUID for this engine) is a third identifier. Report both when a session is yielded. Keep ownership through the related task chain and final closure. Do not append `&`, use `nohup`\u002F`disown`, or replace the default with `claive start`: those detach the worker from Codex's managed terminal. `start` is available for deliberately detached jobs and returns immediately; such jobs remain visible in the registry dashboard but not in Codex's terminal indicator.\n\nAsync options (host-neutral; full protocol in `$HOME\u002Frepo\u002Fclaive\u002Fdocs\u002Fharness-integration.md`). When several workers run at once, or a worker would outlive the shell session, use `claive open --detach` (reusable, returns at once) or `claive start`, then `claive wait ID1 ID2 --any --timeout S` (first worker to settle; exit 124 means still running), with `S` below the tool's time limit. At the start of each turn, and after context compaction, run `claive inbox --consumer codex` to see finished turns since the last read; `ASK` lines carry a worker's question (answer with `claive answer ID --message ...`; exit 3 means the same). Parallel staged work: `claive batch start \u002Fabs\u002Fplan.json`, then `claive batch wait ID`. Multi-turn efforts: `claive mission new --title T --goal-file F`, `export CLAIVE_MISSION=\u003Cid>`, record decisions with `claive mission note`, and resume with `claive mission show ID` (its `Next:` line). Unattended server queue: `claive goal add` plus `claive serve`; answer parked goals with `claive goal answer ID --message ...`. Name a reusable worker with `claive alias set NAME ID` (`@NAME` then replaces the ID in worker commands). Workers can talk to each other: `claive conversation start @a @b --message-file \u002Fabs\u002Ftopic.md --rounds 2 --timeout 300 --json` runs a bounded exchange between existing idle reusable workers and forwards each reply to the next (exit 3 = a question, 124\u002F130 = inspect `pending_request.response_file` first; see `claive-orchestration`). Workers cannot launch workers or start conversations.\n\nFor cancellation use `claive cancel WORKER_ID`, then collect the managed session's final output. Forcibly killing a terminal can bypass supervisor cleanup; if interrupted, inspect the registry and stop any surviving worker. Use:\n\n```text\nclaive watch                 # live view; Ctrl-C closes only the view\nclaive list                 # active jobs and recent results\nclaive show ID --json       # status, progress, exit code, log paths\nclaive logs ID              # recent JSONL events\nclaive logs ID --stderr     # diagnostic output\nclaive wait ID              # wait for assigned turns; idle means ready, not closed\nclaive followup ID --prompt-file \u002Fabsolute\u002Fnext.md --reasoning-effort xhigh\nclaive effort ID --reasoning-effort max # future default; current call unchanged\nclaive usage ID             # retained session provider token\u002Fcache counters\nclaive close ID             # drain queued turns, close supervisor, retain history\nclaive cancel ID            # stop the worker process group\nclaive status-line          # one-line counts for a shell\u002Fstatus bar\nclaive-codex [codex options] # Codex + live pane + tmux status bar\n```\n\nReport the task, worker ID, and managed shell session ID at launch and report its outcome at completion. Codex's terminal view tracks the managed command and its output; it does not read the registry's detailed engine lifecycle. The optional custom monitor shows jobs launched through `claive`; raw Muse, agy, native agents, and OpenCode invocations are not automatically discovered. A completed CLI run does not establish that the assigned work passed verification. Task failures remain visible as warnings even when the run completes. Unexpected supervisor exits are shown as interrupted, not successful. Closing the monitor does not cancel workers; end jobs explicitly when their purpose ends.\n\nThe manager keeps Codex's existing internal status-line configuration intact. Its tmux view adds an outer status bar and live pane in a separate session; it does not change other tmux sessions. No always-running monitor daemon is installed.\n\n### Underlying Muse flags\n\nAlways set all four options:\n\n```text\n--workspace \u003Cabsolute-repo-path>\n--trust-workspace\n--disable-approval\n--json\n```\n\nPrefer `--prompt-file` over a positional prompt for more than a few lines. Write prompt contents with a file tool or a safely quoted literal heredoc; never interpolate untrusted text into shell code. Quote every path expansion. Capture stdout JSONL and stderr separately in scratch files.\n\nUse the tracked launcher above for routine work. If a task requires a Muse option the manager does not expose, extend the manager within authorized scope or report the limitation; do not silently bypass monitoring. This underlying invocation documents the manager's contract. It assumes `task_workspace`, `task_prompt`, and `task_logs` already contain absolute paths and `task_session` is the retained UUID for this lane, the prompt exists, and the log directory exists:\n\n```bash\nif \"$HOME\"\u002F.local\u002Fbin\u002Fmuse exec \\\n  --workspace \"$task_workspace\" \\\n  --trust-workspace \\\n  --disable-approval \\\n  --json \\\n  --model muse-spark-1.3-contributor \\\n  --session-id \"$task_session\" \\\n  --reasoning-effort xhigh \\\n  --max-model-steps 100 \\\n  --user-input-auto-resolve \\\n  --prompt-file \"$task_prompt\" \\\n  > \"$task_logs\u002Fevents.jsonl\" 2> \"$task_logs\u002Fstderr.log\"\nthen\n  task_rc=0\nelse\n  task_rc=$?\nfi\n```\n\n- Pin `--model muse-spark-1.3-contributor`. Use `xhigh` for normal tasks and `max` for very complicated work; `high`\u002F`medium` only rarely for trivial chores. The orchestrator chooses per turn.\n- Set `--max-model-steps` to fit the assignment; the default 100 is not a required ceiling.\n- `--user-input-auto-resolve` cancels interactive questions automatically. A worker that needs an answer must report a blocker; cancellation is not authorization.\n- For enforced read-only work add **both** `--disable-write --disable-shell`. The first disables only non-shell filesystem writes; leaving shell enabled permits writes through commands. Run any necessary verification commands in the parent or an isolated workspace.\n- Add `--disable-web-tools` when web access is unnecessary.\n- `--output-schema \u002Fabsolute\u002Fschema.json` shapes the final answer for the meta provider; stdout remains a JSONL event stream.\n- Preserve session logging for related follow-ups. `--no-session-log` disables durable history and local messaging, and is allowed only for deliberate single-turn runs.\n\n## Reuse and prompt caching\n\nKeep one worker and durable Muse session for a related task chain. Keep it idle when a specific related follow-up is expected in the active workflow. If no further use is planned, close it and collect the managed terminal output; retained history can be reopened later. Do not leave an idle worker running indefinitely for hypothetical future tasks. Read `show ID --json` for `session_id`; send a narrow `followup` instead of launching a new session. A per-turn effort override does not change the future default; `effort ID` does. Follow-ups can also override `--max-model-steps`. The worker appends JSONL\u002Fstderr logs and keeps each answer in `turn-000N.txt`. Queued follow-ups run sequentially. `close ID` finishes assigned turns before ending; `cancel ID` stops immediately. After closure, resuming with `--session-id UUID` restores retained history; preserve workspace and tool policy. A `--worktree` worktree is created by claive and lasts for all turns of the worker; it is removed when the worker ends unless a writer left changes or commits (then `retained_worktree` in `show --json` names it). To resume a closed session on the same files, pass that worktree with `--worktree-existing`. Do not retire solely after two or four tasks. Start fresh for unrelated work or an actual context\u002Fquality limit.\n\nEach underlying `muse exec` child exits after its turn; the supervisor stays alive and the same UUID reloads history next turn. This preserves conversation context across process exits. It is not a persistent model connection or proof of a cache hit.\n\nMeta [prompt caching](https:\u002F\u002Fdev.meta.ai\u002Fdocs\u002Fprompt-caching) automatically reuses matching token prefixes on the server. Terminal exit does not itself clear that cache; eviction and inactivity can still cause misses. Keeping an idle process open cannot keep a server entry warm. Preserve stable leading instructions, tools, and history; put changing task details last, as in the [cookbook](https:\u002F\u002Fdev.meta.ai\u002Fdocs\u002Fcookbook\u002Fprompt-caching). Changing rules, model, reasoning, or compaction may change the rendered prefix; preserve the session when adjusting effort and measure the result rather than promising a hit.\n\nUse `claive usage ID` (or `--json`) for provider-reported usage from Muse's retained session export. It counts each `model_completed` once, excluding repeated attribution records; no exposed usage means unknown, not zero. `cached_tokens > 0` proves reuse, and its ratio to reported input measures the observed hit rate. Totals include all recorded model calls in the retained session, including internal calls. These are accounting counters, not current context occupancy or an invoice; see [token usage](https:\u002F\u002Fdev.meta.ai\u002Fdocs\u002Ftoken-counting#usage). Do not add cached tokens again to input totals.\n\nThe API optionally exposes `prompt_cache_key` and Responses retention hints; this installed Muse exec CLI exposes neither. Do not invent CLI flags, set a new per-session cache key, change endpoints, or bypass Muse authentication to enable them. Automatic caching needs no extra flag. The current cache price and contributor quota effects are not established by a session UUID or these counters.\n\n## Isolation and limits\n\n- Concurrent Muse writers can each use `--worktree`; read-only workers may share a workspace. A writer's changed worktree is kept on branch `claive\u002F\u003Cid>` after the worker ends. File ownership must remain disjoint even when worktrees are isolated.\n- Worktree creation defaults to `HEAD`. Uncommitted parent edits will not automatically be present. Choose a suitable `--worktree-base` or explicitly transfer the required patch before dependent work. A `--worktree` worktree survives across the worker's reusable turns; use `--worktree-existing` for one you manage yourself or to continue a retained one.\n- Give other shell workers their own isolated worktrees before concurrent writes; their relay scripts do not create them.\n- Run heavy builds or test suites one at a time because this WSL environment has limited shared RAM. Independent light workers may run concurrently.\n- The standard flags disable approval prompts but keep Muse's filesystem\u002Fnetwork sandbox enabled; network defaults to `proxy-only`. Diagnose access failures from stderr and terminal events. Do not silently add `--yolo` or change sandbox permissions. Any exception must fit the task's authorization and host policy.\n- Use managed shell sessions for long runs, retain their IDs, and poll with short waits while keeping the user informed. A yielded command is still running. Close workers when their related task chain ends and collect the managed terminal output; retain isolated changes until integration is complete.\n\n## Validate and integrate\n\nFor a reusable worker, use `wait ID` to obtain the assigned turns' outcome without ending its session. On final closure, collect the managed process exit status too. For a direct single-turn invocation, wait for process completion and inspect `task_rc`. A non-zero exit code is failure even if an answer appeared. Do not hide failures behind a pipeline that only reports the parser's exit code.\n\nParse terminal events, not the last physical line or a partial output delta. The observed Muse schema uses `payload_type` beginning with `run.terminal.`, with status in `payload.terminal` and final answer in `payload.text`:\n\n```bash\njq -es '\n  [.[] | select((.payload_type? \u002F\u002F \"\") | startswith(\"run.terminal.\"))]\n  | last\n  | select(.payload.terminal == \"completed\")\n  | .payload\n' \"$task_logs\u002Fevents.jsonl\"\n```\n\nRequire both exit code zero and a completed terminal event. Missing, malformed, failed, or cancelled results are failures. If schema changes, inspect the local event shape before changing the parser. A completed run can still report a blocker or incomplete work; evaluate the answer against the acceptance criteria. Inspect tool\u002Ftask failures and stderr even when the terminal event reports completion.\n\nVerify consequential claims against source. Inspect tracked and untracked changes in the actual worker workspace, preserve unrelated edits, and perform checks appropriate to the changed behavior. For isolated workers, review and integrate only authorized changes into the parent workspace, then verify the integrated result. A worker's report alone is not proof of completion.\n\nOn failure, retry only with a changed hypothesis or clearer assignment. Report access or backend limitations honestly. Do not silently relax restrictions, change providers, or delegate recursively to get around a failure.\n\n## Five-hour quota and fallback\n\nWhen Muse explicitly reports `Subscription quota exhausted`, stop sending assignments against that quota. Hamza has pre-approved one fallback: Pi `muse-spark-1.3-contributor-free` (`--engine pi --provider opencode2api`, effort `max`) for the affected lane. Switch to it, report the reset time if present, and tell Hamza the fallback is in use. Any other fallback model or subagent still needs his explicit choice. Return to Muse after the reset. Do not run repeated same-quota retries or treat every generic 429 as the five-hour subscription limit.\n\nThe manager records `quota_exhausted`, `quota_reset_at` when provided, and `fallback_requires_user_approval`; `show`\u002F`wait` print the fallback notice. It never launches an alternate provider itself. When switching to the fallback, preserve the original assignment's scope, write ownership, isolation, monitoring, and result checks with the chosen worker. The fallback does not alter Muse's pinned model or its xhigh normal default. Do not offer the broken OpenCode relay until repaired and verified. Close the Muse supervisor when no further use is planned; retained history can be resumed after reset.\n","# Claive routing — Codex host\n\nMuse Code is the default engine; Pi is available explicitly with `--engine pi` through `opencode2api`. Follow the global AGENTS.md delegation criteria; complete small or tightly coupled tasks directly when delegation would add overhead. The parent owns synthesis, integration, and final verification.\n\nThe maintained source is `$HOME\u002Frepo\u002Fclaive\u002Fskills\u002Fclaive-routing-codex\u002FSKILL.md`. Skillshare owns the live copy at `~\u002F.config\u002Fskillshare\u002Fskills\u002Fclaive-routing-codex\u002F`; update both, then `skillshare sync`. Do not run the legacy skill installer over Skillshare links. `reference\u002Fglobal-AGENTS.md` is a snapshot, not a replacement for global instructions.\n\nFor a task with an executable check, prefer the verifier-gated ladder in the `claive-orchestration` skill (`claive-orch`: Muse implements, a cross-family Pi critic reviews, and the arbiter accepts or reverts each round). This skill governs Codex launch mechanics; the experimental `ttc-experiment` skill is archived and must not be auto-loaded or reinstalled.\n\n## Current engine boundaries (Claive main, October 2026)\n\nThe general `claive` worker manager supports **four engines**; the optional\n`claive-orch` verifier-driven arbiter currently selects **Muse\u002FPi** candidates.\nDo not confuse the arbiter's model policy with a limitation of the worker manager.\nSelect an engine deliberately and follow the parent's current authorization policy.\n\n| Engine | Runtime contract |\n| --- | --- |\n| `muse` (default) | Pinned `muse-spark-1.3-contributor`; usual substantive effort `xhigh`; supports managed worktrees and read-only isolation |\n| `pi` | `--engine pi --provider opencode2api`; models selected explicitly or inherited; no managed worktree, `--web`, or model-step cap |\n| `claude` | `--engine claude`; pinned `claude-haiku-5-5`; headless and isolated from user settings, hooks, MCP, and skills; no managed worktree, output schema, or model-step cap |\n| `codex` | `--engine codex`; pinned `gpt-6-luna`, effort `max`; writer defaults to workspace-write sandbox, read-only uses the read-only sandbox; no managed worktree, output schema, or model-step cap |\n\nClaude\u002FCodex workers are **available**, not automatically authorized as a\nfallback or as critics for the Muse\u002FPi arbiter. Do not silently switch engines,\nrelax sandboxing, or assume another model's worker permissions carry over.\nFor a Codex worker, `CLAIVE_CODEX_USE_USER_CONFIG=1` explicitly opts into that\nworker's existing Codex user MCP\u002Fskill configuration; the default is isolated.\n`CLAIVE_CODEX_YOLO=1` explicitly bypasses the sandbox for a writing worker:\n**do not set it without task-specific authorization**. Neither setting installs\nnew MCP servers. Consult `docs\u002Fharness-integration.md` for the runtime protocol.\n\nFor routine work from the Codex parent, favor `claive-worker` in Codex's managed\nshell so its session remains visible in `\u002Fps`; use `claive start` or\n`claive open --detach` only when genuinely detached execution is needed.\nKeep the terminal session ID, Claive worker ID, and engine session UUID distinct.\n\n## Model and reasoning\n\nUse **only `muse-spark-1.3-contributor`** for Muse workers. The launcher pins this model rather than inheriting another default. Do not substitute a different Muse model\u002Fprovider or route through agy\u002FOpenCode's historical defaults without explicit fallback authorization below. Their relay copies in `reference\u002F` are archival. Native host subagents require an explicit request.\n\n- **`xhigh`: default for normal implementation, investigation, review, and other substantive work** (the Muse engine default).\n- **`max`: very complicated work**, difficult fixes, or consequential reasoning.\n- **`high`\u002F`medium`: rarely**, only for trivial mechanical work such as generating a commit message.\n- **Pi workers: always `max`** (the Pi engine default). They are free; Pi clamps `max` to each model's highest supported level.\n- **Pi models:** prefer `mimo-v2.6-flash-free`, `big-pickle`, `space-bunny-free`; `longcat-2.5-preview-free` only rarely. Do not use `nemotron-*` or `ling-3.1-flash-free`.\n\nThe orchestrator can select effort per turn or change an existing worker's future default at any time. Changes apply to the next request; they cannot change an in-flight API call. Muse defaults to 100 model steps; Pi rejects `--max-model-steps`. Set a cap suitable for the assignment, including a higher cap when needed; a step cap is not a monetary budget or timeout.\n\n## Prepare the assignment\n\nWrite one narrow task to an absolute scratch prompt-file path. Include:\n\n`mission | inputs | authorized scope | write ownership | required output | stopping condition`\n\nSupply the absolute repository path, relevant files and symbols, existing evidence, constraints, and acceptance criteria. Workers do not automatically inherit the conversation or MCP access. Pass relevant graph findings and coverage gaps when the assignment relies on them.\n\nTell the worker it is not alone in the codebase: preserve other edits and accommodate them. Restrict writes to its assigned files. Forbid recursive delegation, commits, pushes, and other external writes unless the assignment explicitly authorizes them. Workers may make local, reversible implementation choices; they must report a blocker rather than expand scope or make a consequential decision outside the assignment.\n\nRequest a concise report: outcome, files changed, checks with results, supporting evidence, local decisions, uncertainty, blockers, and actual worktree path when isolated. Use exact check commands when known and appropriate to the authorized task. Avoid raw context dumps.\n\n## Launch and observe workers\n\nDefault to `\"$HOME\"\u002F.local\u002Fbin\u002Fclaive-worker` inside Codex's managed shell tool. The launcher opens a reusable worker and remains alive between related turns, so a yielded shell call is a managed background terminal and appears in the native running-terminal indicator and `\u002Fps`. The installed manager is `\"$HOME\"\u002F.local\u002Fbin\u002Fclaive`; its generic supervisor owns state, follow-ups, cancellation, and logs, while each engine adapter builds its commands and interprets its events and usage. Private logs are retained under `${XDG_STATE_HOME:-$HOME\u002F.local\u002Fstate}\u002Fclaive`. `CLAIVE_DIR` can select another absolute registry directory. The custom dashboard and tmux pane are optional additional views.\n\n```bash\nexec \"$HOME\"\u002F.local\u002Fbin\u002Fclaive-worker \\\n  --workspace \"$task_workspace\" \\\n  --prompt-file \"$task_prompt\" \\\n  --label \"Implement assigned feature\" \\\n  --reasoning-effort xhigh \\\n  --max-model-steps 100\n```\n\nFor a Muse worker that needs isolation, add `--worktree`; `--worktree-base` selects a base commit (default `HEAD`; uncommitted parent edits are not included). claive creates the worktree itself (Muse 1.4.3's `-w create` fails under its sandbox) at `$CLAIVE_DIR\u002F\u003Cid>\u002Fworktree`, detached for `--read-only`, on branch `claive\u002F\u003Cid>` for writers, and it lasts across a reusable worker's follow-ups. When the worker ends, claive removes it unless a writer changed it; then the worktree and branch are kept, `show --json` lists `retained_worktree`, and you review and integrate from there. For a worktree you manage yourself, pass `--worktree-existing \u002Fabsolute\u002Fworktree`. For enforced read-only workers add `--read-only` (both write and shell are disabled). Web tools are disabled unless `--web` is supplied. The Muse engine accepts only the pinned model. `--output-schema` is forwarded. Reusable workers require session logging; `--no-session-log` is rejected by this launcher. `--provider echo` is for local transport checks, not evidence that the live model works.\n\nUse `exec_command` with a short initial `yield_time_ms` (for example 1000). A returned `session_id` means the shell command is still running: retain it and use `write_stdin` to collect output and final exit status. Independent workers can each have their own managed session; shell yielding lets the parent continue working without detaching the worker. After a turn, the reusable worker remains idle and available in the managed terminal until closed. An idle supervisor makes no model requests.\n\nFor Pi, use the same launcher with `--engine pi --provider opencode2api` and omit `--max-model-steps`. Omit `--model` to inherit the last selected Pi model from its global settings; the initial model is `muse-spark-1.3-contributor-free`. An explicit `--model ID` becomes the shared selection after launch-option validation, even if the subsequent model request fails; role models, batch stage models and timeout fallbacks do not. Existing workers and their follow-ups retain their launch model. This preference is separate from Muse's pinned model and never switches engines automatically. Pi supports only `opencode2api` here. Use `--workspace` for an externally retained worktree; Pi rejects worktree-management, `--web`, and `--output-schema`. Pi read-only tools are `read,grep,find,ls`, with extensions disabled; Pi has no Muse OS sandbox. See `$HOME\u002Frepo\u002Fclaive\u002Fdocs\u002Fpi-engine.md` for the verified runtime contract.\n\nThe shell session ID and the 12-character worker ID printed by `claive-worker` identify different objects; the retained worker `session_id` (a Muse session UUID for this engine) is a third identifier. Report both when a session is yielded. Keep ownership through the related task chain and final closure. Do not append `&`, use `nohup`\u002F`disown`, or replace the default with `claive start`: those detach the worker from Codex's managed terminal. `start` is available for deliberately detached jobs and returns immediately; such jobs remain visible in the registry dashboard but not in Codex's terminal indicator.\n\nAsync options (host-neutral; full protocol in `$HOME\u002Frepo\u002Fclaive\u002Fdocs\u002Fharness-integration.md`). When several workers run at once, or a worker would outlive the shell session, use `claive open --detach` (reusable, returns at once) or `claive start`, then `claive wait ID1 ID2 --any --timeout S` (first worker to settle; exit 124 means still running), with `S` below the tool's time limit. At the start of each turn, and after context compaction, run `claive inbox --consumer codex` to see finished turns since the last read; `ASK` lines carry a worker's question (answer with `claive answer ID --message ...`; exit 3 means the same). Parallel staged work: `claive batch start \u002Fabs\u002Fplan.json`, then `claive batch wait ID`. Multi-turn efforts: `claive mission new --title T --goal-file F`, `export CLAIVE_MISSION=\u003Cid>`, record decisions with `claive mission note`, and resume with `claive mission show ID` (its `Next:` line). Unattended server queue: `claive goal add` plus `claive serve`; answer parked goals with `claive goal answer ID --message ...`. Name a reusable worker with `claive alias set NAME ID` (`@NAME` then replaces the ID in worker commands). Workers can talk to each other: `claive conversation start @a @b --message-file \u002Fabs\u002Ftopic.md --rounds 2 --timeout 300 --json` runs a bounded exchange between existing idle reusable workers and forwards each reply to the next (exit 3 = a question, 124\u002F130 = inspect `pending_request.response_file` first; see `claive-orchestration`). Workers cannot launch workers or start conversations.\n\nFor cancellation use `claive cancel WORKER_ID`, then collect the managed session's final output. Forcibly killing a terminal can bypass supervisor cleanup; if interrupted, inspect the registry and stop any surviving worker. Use:\n\n```text\nclaive watch                 # live view; Ctrl-C closes only the view\nclaive list                 # active jobs and recent results\nclaive show ID --json       # status, progress, exit code, log paths\nclaive logs ID              # recent JSONL events\nclaive logs ID --stderr     # diagnostic output\nclaive wait ID              # wait for assigned turns; idle means ready, not closed\nclaive followup ID --prompt-file \u002Fabsolute\u002Fnext.md --reasoning-effort xhigh\nclaive effort ID --reasoning-effort max # future default; current call unchanged\nclaive usage ID             # retained session provider token\u002Fcache counters\nclaive close ID             # drain queued turns, close supervisor, retain history\nclaive cancel ID            # stop the worker process group\nclaive status-line          # one-line counts for a shell\u002Fstatus bar\nclaive-codex [codex options] # Codex + live pane + tmux status bar\n```\n\nReport the task, worker ID, and managed shell session ID at launch and report its outcome at completion. Codex's terminal view tracks the managed command and its output; it does not read the registry's detailed engine lifecycle. The optional custom monitor shows jobs launched through `claive`; raw Muse, agy, native agents, and OpenCode invocations are not automatically discovered. A completed CLI run does not establish that the assigned work passed verification. Task failures remain visible as warnings even when the run completes. Unexpected supervisor exits are shown as interrupted, not successful. Closing the monitor does not cancel workers; end jobs explicitly when their purpose ends.\n\nThe manager keeps Codex's existing internal status-line configuration intact. Its tmux view adds an outer status bar and live pane in a separate session; it does not change other tmux sessions. No always-running monitor daemon is installed.\n\n### Underlying Muse flags\n\nAlways set all four options:\n\n```text\n--workspace \u003Cabsolute-repo-path>\n--trust-workspace\n--disable-approval\n--json\n```\n\nPrefer `--prompt-file` over a positional prompt for more than a few lines. Write prompt contents with a file tool or a safely quoted literal heredoc; never interpolate untrusted text into shell code. Quote every path expansion. Capture stdout JSONL and stderr separately in scratch files.\n\nUse the tracked launcher above for routine work. If a task requires a Muse option the manager does not expose, extend the manager within authorized scope or report the limitation; do not silently bypass monitoring. This underlying invocation documents the manager's contract. It assumes `task_workspace`, `task_prompt`, and `task_logs` already contain absolute paths and `task_session` is the retained UUID for this lane, the prompt exists, and the log directory exists:\n\n```bash\nif \"$HOME\"\u002F.local\u002Fbin\u002Fmuse exec \\\n  --workspace \"$task_workspace\" \\\n  --trust-workspace \\\n  --disable-approval \\\n  --json \\\n  --model muse-spark-1.3-contributor \\\n  --session-id \"$task_session\" \\\n  --reasoning-effort xhigh \\\n  --max-model-steps 100 \\\n  --user-input-auto-resolve \\\n  --prompt-file \"$task_prompt\" \\\n  > \"$task_logs\u002Fevents.jsonl\" 2> \"$task_logs\u002Fstderr.log\"\nthen\n  task_rc=0\nelse\n  task_rc=$?\nfi\n```\n\n- Pin `--model muse-spark-1.3-contributor`. Use `xhigh` for normal tasks and `max` for very complicated work; `high`\u002F`medium` only rarely for trivial chores. The orchestrator chooses per turn.\n- Set `--max-model-steps` to fit the assignment; the default 100 is not a required ceiling.\n- `--user-input-auto-resolve` cancels interactive questions automatically. A worker that needs an answer must report a blocker; cancellation is not authorization.\n- For enforced read-only work add **both** `--disable-write --disable-shell`. The first disables only non-shell filesystem writes; leaving shell enabled permits writes through commands. Run any necessary verification commands in the parent or an isolated workspace.\n- Add `--disable-web-tools` when web access is unnecessary.\n- `--output-schema \u002Fabsolute\u002Fschema.json` shapes the final answer for the meta provider; stdout remains a JSONL event stream.\n- Preserve session logging for related follow-ups. `--no-session-log` disables durable history and local messaging, and is allowed only for deliberate single-turn runs.\n\n## Reuse and prompt caching\n\nKeep one worker and durable Muse session for a related task chain. Keep it idle when a specific related follow-up is expected in the active workflow. If no further use is planned, close it and collect the managed terminal output; retained history can be reopened later. Do not leave an idle worker running indefinitely for hypothetical future tasks. Read `show ID --json` for `session_id`; send a narrow `followup` instead of launching a new session. A per-turn effort override does not change the future default; `effort ID` does. Follow-ups can also override `--max-model-steps`. The worker appends JSONL\u002Fstderr logs and keeps each answer in `turn-000N.txt`. Queued follow-ups run sequentially. `close ID` finishes assigned turns before ending; `cancel ID` stops immediately. After closure, resuming with `--session-id UUID` restores retained history; preserve workspace and tool policy. A `--worktree` worktree is created by claive and lasts for all turns of the worker; it is removed when the worker ends unless a writer left changes or commits (then `retained_worktree` in `show --json` names it). To resume a closed session on the same files, pass that worktree with `--worktree-existing`. Do not retire solely after two or four tasks. Start fresh for unrelated work or an actual context\u002Fquality limit.\n\nEach underlying `muse exec` child exits after its turn; the supervisor stays alive and the same UUID reloads history next turn. This preserves conversation context across process exits. It is not a persistent model connection or proof of a cache hit.\n\nMeta [prompt caching](https:\u002F\u002Fdev.meta.ai\u002Fdocs\u002Fprompt-caching) automatically reuses matching token prefixes on the server. Terminal exit does not itself clear that cache; eviction and inactivity can still cause misses. Keeping an idle process open cannot keep a server entry warm. Preserve stable leading instructions, tools, and history; put changing task details last, as in the [cookbook](https:\u002F\u002Fdev.meta.ai\u002Fdocs\u002Fcookbook\u002Fprompt-caching). Changing rules, model, reasoning, or compaction may change the rendered prefix; preserve the session when adjusting effort and measure the result rather than promising a hit.\n\nUse `claive usage ID` (or `--json`) for provider-reported usage from Muse's retained session export. It counts each `model_completed` once, excluding repeated attribution records; no exposed usage means unknown, not zero. `cached_tokens > 0` proves reuse, and its ratio to reported input measures the observed hit rate. Totals include all recorded model calls in the retained session, including internal calls. These are accounting counters, not current context occupancy or an invoice; see [token usage](https:\u002F\u002Fdev.meta.ai\u002Fdocs\u002Ftoken-counting#usage). Do not add cached tokens again to input totals.\n\nThe API optionally exposes `prompt_cache_key` and Responses retention hints; this installed Muse exec CLI exposes neither. Do not invent CLI flags, set a new per-session cache key, change endpoints, or bypass Muse authentication to enable them. Automatic caching needs no extra flag. The current cache price and contributor quota effects are not established by a session UUID or these counters.\n\n## Isolation and limits\n\n- Concurrent Muse writers can each use `--worktree`; read-only workers may share a workspace. A writer's changed worktree is kept on branch `claive\u002F\u003Cid>` after the worker ends. File ownership must remain disjoint even when worktrees are isolated.\n- Worktree creation defaults to `HEAD`. Uncommitted parent edits will not automatically be present. Choose a suitable `--worktree-base` or explicitly transfer the required patch before dependent work. A `--worktree` worktree survives across the worker's reusable turns; use `--worktree-existing` for one you manage yourself or to continue a retained one.\n- Give other shell workers their own isolated worktrees before concurrent writes; their relay scripts do not create them.\n- Run heavy builds or test suites one at a time because this WSL environment has limited shared RAM. Independent light workers may run concurrently.\n- The standard flags disable approval prompts but keep Muse's filesystem\u002Fnetwork sandbox enabled; network defaults to `proxy-only`. Diagnose access failures from stderr and terminal events. Do not silently add `--yolo` or change sandbox permissions. Any exception must fit the task's authorization and host policy.\n- Use managed shell sessions for long runs, retain their IDs, and poll with short waits while keeping the user informed. A yielded command is still running. Close workers when their related task chain ends and collect the managed terminal output; retain isolated changes until integration is complete.\n\n## Validate and integrate\n\nFor a reusable worker, use `wait ID` to obtain the assigned turns' outcome without ending its session. On final closure, collect the managed process exit status too. For a direct single-turn invocation, wait for process completion and inspect `task_rc`. A non-zero exit code is failure even if an answer appeared. Do not hide failures behind a pipeline that only reports the parser's exit code.\n\nParse terminal events, not the last physical line or a partial output delta. The observed Muse schema uses `payload_type` beginning with `run.terminal.`, with status in `payload.terminal` and final answer in `payload.text`:\n\n```bash\njq -es '\n  [.[] | select((.payload_type? \u002F\u002F \"\") | startswith(\"run.terminal.\"))]\n  | last\n  | select(.payload.terminal == \"completed\")\n  | .payload\n' \"$task_logs\u002Fevents.jsonl\"\n```\n\nRequire both exit code zero and a completed terminal event. Missing, malformed, failed, or cancelled results are failures. If schema changes, inspect the local event shape before changing the parser. A completed run can still report a blocker or incomplete work; evaluate the answer against the acceptance criteria. Inspect tool\u002Ftask failures and stderr even when the terminal event reports completion.\n\nVerify consequential claims against source. Inspect tracked and untracked changes in the actual worker workspace, preserve unrelated edits, and perform checks appropriate to the changed behavior. For isolated workers, review and integrate only authorized changes into the parent workspace, then verify the integrated result. A worker's report alone is not proof of completion.\n\nOn failure, retry only with a changed hypothesis or clearer assignment. Report access or backend limitations honestly. Do not silently relax restrictions, change providers, or delegate recursively to get around a failure.\n\n## Five-hour quota and fallback\n\nWhen Muse explicitly reports `Subscription quota exhausted`, stop sending assignments against that quota. Hamza has pre-approved one fallback: Pi `muse-spark-1.3-contributor-free` (`--engine pi --provider opencode2api`, effort `max`) for the affected lane. Switch to it, report the reset time if present, and tell Hamza the fallback is in use. Any other fallback model or subagent still needs his explicit choice. Return to Muse after the reset. Do not run repeated same-quota retries or treat every generic 429 as the five-hour subscription limit.\n\nThe manager records `quota_exhausted`, `quota_reset_at` when provided, and `fallback_requires_user_approval`; `show`\u002F`wait` print the fallback notice. It never launches an alternate provider itself. When switching to the fallback, preserve the original assignment's scope, write ownership, isolation, monitoring, and result checks with the chosen worker. The fallback does not alter Muse's pinned model or its xhigh normal default. Do not offer the broken OpenCode relay until repaired and verified. Close the Muse supervisor when no further use is planned; retained history can be resumed after reset.\n",{"name":5,"description":7},"main","59ee67804bc373a9bd079a3a27f47277a6efe564","skill-library\u002Fpacks\u002Factive\u002Fclaive-routing-codex","https:\u002F\u002Fgithub.com\u002Fham-zax\u002Fwebharness","https:\u002F\u002Fgithub.com\u002Fham-zax","2026-11-15 01:18:51",{"source":8,"skillName":5,"commands":31,"prompt":41,"zipAvailable":42},[32,35,38],{"tool":33,"command":34},"npx","npx skills add ham-zax\u002Fwebharness --skill claive-routing-codex",{"tool":36,"command":37},"bunx","bunx skills add ham-zax\u002Fwebharness --skill claive-routing-codex",{"tool":39,"command":40},"pnpm","pnpm dlx skills add ham-zax\u002Fwebharness --skill claive-routing-codex","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fham-zax\u002Fwebharness\u002Fblob\u002Fmain\u002Fskill-library\u002Fpacks\u002Factive\u002Fclaive-routing-codex\u002FSKILL.md",true,[],[45,52,59,66,75,82],{"skillNo":46,"name":47,"nameZh":6,"description":48,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":49,"categories":50,"keywords":51,"publishedAt":19},"01M7AS6BAQQ2WQJYS3WBNJPB2G","x-content","Create, rewrite, critique, select formats for, discover opportunities for, and learn from X\u002FTwitter content and X Articles for a technical AI-native developer\u002Fbuilder account. Use when turning ideas, source posts, releases, benchmarks, results, conversations, authenticated For You or creator-watch opportunities, or project evidence into an Original, Quote, Thread, Reply, or Article; reviewing article titles\u002Foutlines\u002Fvisual briefs\u002Flaunch hooks; improving drafts; choosing additive contributions from live X context; or learning from own-account outcomes. Own content intelligence only; compose with agent-browser for live X state and Growth OS for discovery provenance, approvals, measurement, and publication.","https:\u002F\u002Fgithub.com\u002Fham-zax\u002Fwebharness\u002Fblob\u002Fmain\u002Fskills\u002Fx-content\u002FSKILL.md",[],[],{"skillNo":53,"name":54,"nameZh":6,"description":55,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":56,"categories":57,"keywords":58,"publishedAt":19},"01M7AS66FXQR8FEQYW8G8RJB2N","writing-plans","Create detailed implementation plans for multi-step software work before editing code. Use when requirements or a specification must become concrete file-level tasks, interfaces, acceptance criteria, risks, rollout, or explicitly required validation. Default to no test creation, test modification, test execution, TDD, regression-test, or coverage work unless the user, authoritative specification, or mandatory repository policy explicitly requires testing.","https:\u002F\u002Fgithub.com\u002Fham-zax\u002Fwebharness\u002Fblob\u002Fmain\u002Fskills\u002Fwriting-plans\u002FSKILL.md",[],[],{"skillNo":60,"name":61,"nameZh":6,"description":62,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":63,"categories":64,"keywords":65,"publishedAt":19},"01M7AS5ZCJX21NF2RESA2QDWPP","systematic-debugging","Root-cause debugging for concrete technical failures including bugs, failing builds or tests, integration issues, performance regressions, and unexpected behavior. Use before proposing or implementing a repair when diagnosis is required. Reproduce the symptom, trace the responsible owner, maintain one leading causal hypothesis, and falsify it with the smallest direct evidence. Compose with Causal Coding for source mutation; testing is opt-in and requires independent authorization.","https:\u002F\u002Fgithub.com\u002Fham-zax\u002Fwebharness\u002Fblob\u002Fmain\u002Fskills\u002Fsystematic-debugging\u002FSKILL.md",[],[],{"skillNo":67,"name":68,"nameZh":6,"description":69,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":70,"licenseFileUrl":71,"sourceHtmlUrl":72,"categories":73,"keywords":74,"publishedAt":19},"01M7AS548FQ63SAB9G0X81VPGJ","skill-creator","Guide for creating and updating high-quality skills by translating workflows, conventions, and reusable processes into well-structured skills. Includes context, use case examples and spec for skills. Use this skill whenever a user asks to create, update, edit, improve, package, or troubleshoot a skill, and also for conversational questions about skills in ChatGPT (e.g., \"What are skills?\", \"What can I use skills for?\", \"What are the best skill use cases for me?\", \"Where can I find my skills?\").","Apache-2.0","https:\u002F\u002Fgithub.com\u002Fham-zax\u002Fwebharness\u002Fblob\u002Fmain\u002Fskills\u002Fskill-creator\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fham-zax\u002Fwebharness\u002Fblob\u002Fmain\u002Fskills\u002Fskill-creator\u002FSKILL.md",[],[],{"skillNo":76,"name":77,"nameZh":6,"description":78,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":79,"categories":80,"keywords":81,"publishedAt":19},"01M7AS4XD121Q85Y06EXRGYS4F","reflexion","Self-refinement, multi-perspective critique, verification, and durable lesson curation adapted from NeoLabHQ Reflexion. Use when the user asks to reflect, self-review, critique, double-check, verify and improve prior work, run a rigorous review, memorize lessons, or says \"then reflect\" after a coding, analysis, or writing task. Supports repository-aware evidence gathering and works without subagents or Claude hooks.","https:\u002F\u002Fgithub.com\u002Fham-zax\u002Fwebharness\u002Fblob\u002Fmain\u002Fskills\u002Freflexion\u002FSKILL.md",[],[],{"skillNo":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":88,"publishedAt":19},"01M7AS4RN5TYMA4P6SK6K7NVSR","ponytail","Enforce Ponytail's lazy-senior-developer approach for coding, fixing, refactoring, design, dependency choices, and explicit Ponytail modes such as review, audit, debt, gain, and help. Prefer YAGNI, existing code, standard library, native platform features, existing dependencies, low reader load, and the smallest correct diff. For source mutation, keep Causal Coding authoritative for scope, testing authorization, verification cadence, and stopping. On connected WSL\u002FLinux targets, compose with MCP Harness Router and use `wsl-web-harness` for authoritative repository work.","https:\u002F\u002Fgithub.com\u002Fham-zax\u002Fwebharness\u002Fblob\u002Fmain\u002Fskills\u002Fponytail\u002FSKILL.md",[],[]]