$npx -y skills add levi-qiao/graphkit --skill questCompile a long-horizon coding task into ONE objective prompt for a host that drives a goal to done with its own verifier (grok /goal, a Codex task) — where the host's harness is the acceptance auditor, so no second supervisor loop is needed. Folds the octopus discipline (verifi
| 1 | # quest — one objective, riding the host's own verifier |
| 2 | |
| 3 | ## What it does & why |
| 4 | |
| 5 | Some hosts already drive the graph for you. grok's `/goal` plans acceptance |
| 6 | criteria, works across rounds, and only marks the goal complete after an |
| 7 | **independent adversarial verifier** reproduces the evidence (defaulting to |
| 8 | *refuted* if it can't). A Codex task self-drives an objective to done across rounds. |
| 9 | On such a host, generating a separate executor + supervisor + two loops is |
| 10 | redundant — you'd pay tokens to re-describe what the harness enforces for free. |
| 11 | |
| 12 | The quest arm instead emits **one objective prompt** and lets the host drive it. Its |
| 13 | whole value is that the objective carries the octopus discipline the host's generic |
| 14 | harness doesn't know — verifiable acceptance criteria, no-test-theater, no |
| 15 | speculative building, forced convergence, owner red lines — so the host's verifier |
| 16 | has something real to check against. |
| 17 | |
| 18 | ## When to use quest vs loop-graph |
| 19 | |
| 20 | Use the **quest arm** when *all* hold: |
| 21 | - one self-contained goal (no strict-ordered milestones with a non-skippable gate); |
| 22 | - the host has a goal command that self-drives to done (**grok `/goal`**, a **Codex |
| 23 | task**); |
| 24 | - executor and reviewer live in the **same** run (you're not splitting them across |
| 25 | hosts/models); |
| 26 | - no owner-only decision sits on the goal's critical path. |
| 27 | |
| 28 | Use the **loop-graph arm** (`../loop-graph`) when *any* hold: multi-milestone phases, |
| 29 | executor and supervisor on different hosts/models/cadences, owner red-lines/gates |
| 30 | that must stop the run, cross-session durability, or a host that **only loops** and |
| 31 | has no goal command (**Claude Code**, **Cursor**, shell) — there loop-graph supplies |
| 32 | the verifier as the supervisor node. See `../../lib/host-dialects.md` for which host |
| 33 | has what. |
| 34 | |
| 35 | ## How to run it |
| 36 | |
| 37 | **Step 1 — Interview** (fill the blanks, don't assume; surface tradeoffs, don't |
| 38 | silently pick). Ask in order — skip only if context already answers: |
| 39 | |
| 40 | 1. **Host** — where does the goal run? (**grok `/goal`**, a **Codex task**). This |
| 41 | picks the invocation dialect (`../../lib/host-dialects.md`). If the host has **no** |
| 42 | goal command — Claude Code, Cursor, shell — stop and switch to the loop-graph arm. |
| 43 | 2. **Objective** — the goal in one sentence. |
| 44 | 3. **Acceptance criteria** — the North Star, each as a check the host's verifier can |
| 45 | **reproduce without the agent**: a command that must pass, or an artifact at a |
| 46 | persistent path showing a bar met on a named eval set. Push until every criterion |
| 47 | is checkable ("`make test` green", "scorecard ≥ X on the frozen set"), not "make |
| 48 | it work". This is the single most important step — grok's verifier defaults to |
| 49 | *refuted* on anything it can't reproduce, and a Codex task has no separate refuter |
| 50 | at all, so the criteria are your only guardrail there. |
| 51 | 4. **Red lines** — the non-negotiables that halt the work (push/commit auth, |
| 52 | destructive ops, secrets/real data, frozen contracts, metrics-only-go-up). |
| 53 | 5. **Expensive-op guard** — is there a full-cohort eval / bulk sweep / migration? If |
| 54 | so, it pilots first. |
| 55 | |
| 56 | **Milestone check.** If the answers reveal strict-ordered phases with a gate, or an |
| 57 | owner-only call on the critical path, say so and switch to the loop-graph arm — the |
| 58 | quest arm deliberately has no gate and no owner-stop loop. |
| 59 | |
| 60 | **Step 2 — Fill the template.** Copy `templates/quest.md`, replace every |
| 61 | `{{PLACEHOLDER}}`, delete the guidance comments. Interview in the user's language and |
| 62 | mirror it in the prose; keep structural headings as in the template. |
| 63 | |
| 64 | **Step 3 — Deliver.** Hand the filled objective to the host's goal command, and tell |
| 65 | the user how **in the chat** (print it, don't assume this session is the host): |
| 66 | |
| 67 | - **grok:** `/goal <the filled objective>` — optionally `--budget <tokens>`. Manage |
| 68 | with `/goal status` · `pause` · `resume` · `clear`. |
| 69 | - **Codex:** delegate a task with the filled objective as its brief; it self-drives |
| 70 | across rounds. Since there's no separate refuter, the objective's acceptance |
| 71 | criteria carry the whole verification burden — make them reproducible. |
| 72 | |
| 73 | Optional reliability upgrade on grok (from `../../lib/host-dialects.md`): a `Stop` |
| 74 | hook to hold the turn open until a gate passes; a `Notification` hook to ping the |
| 75 | owner when the goal parks on a real blocker. |
| 76 | |
| 77 | **Durability note.** A goal harness's state is ephemeral (grok's scratch dir is |
| 78 | deleted when th |