wei-wuwei 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -4,6 +4,25 @@ One section per published version, newest first. `wuwei update` prints the
 sections between the installed version and the new one before it asks;
 `wuwei check` fails when package.json's version has no section here.
 
+## 0.2.0
+
+Execute runs at a fixed tier; the model policy now covers review only.
+
+- `wuwei-execute-phase` runs at `sonnet` / `xhigh` under every policy: its
+  own frontmatter sets the tier for the turn it runs in, and step 2 always
+  dispatches the new `wuwei-implementer` agent (pinned `sonnet` / `xhigh`)
+  with no model or effort on the call. A stop names `/wuwei-execute-phase`,
+  since a reply in chat continues on the session's model.
+- **Changed:** `model policy` under `## Sign-off` is `inherit` | `roles` for
+  the review tier (`roles` sends `review:design` and `review:defects` on
+  opus). `implementation=…` is refused by `plan-check` and `claim`.
+- `wuwei claim` prints how steps 2 and 5 dispatch, and for Codex how to
+  start the session; `wuwei check` ties the skill's and the agent's tier to
+  `modelRoles` in `wuwei.config.json`.
+- Codex: `## Sign-off` takes `codex: <model> / <effort>`; `wuwei init`
+  offers a `[profiles.wuwei-execute]` in `$CODEX_HOME/config.toml` (removed
+  by `wuwei uninstall`); `claim` prints `codex --profile wuwei-execute`.
+
 ## 0.1.0
 
 First release.

package/README.md

@@ -59,7 +59,8 @@ cd wuwei
 npm run check                        # lint frontmatter
 npm run build                        # emit repo-local artifacts (.claude/, .agents/, AGENTS.md, CLAUDE.md)
 node bin/wuwei.js init <project>     # repo scope: templates + .wuwei/ skeleton, then
-                                     #   offers the tools below and names the next step
+                                     #   offers the tools below (and, with Codex, an execute
+                                     #   profile in $CODEX_HOME/config.toml) and names the next step
 node bin/wuwei.js install            # user scope: skills/agents → ~/.claude, rules → ~/.claude/CLAUDE.md;
                                      #   Codex: skills → ~/.agents/skills, rules → $CODEX_HOME/AGENTS.md
 node bin/wuwei.js status <project>   # read-only: streams/claims from .wuwei, drift vs STATE.md flagged

package/agents/wuwei-implementer/agent.md

@@ -0,0 +1,34 @@
+---
+name: wuwei-implementer
+description: >-
+  The implementation subagent of wuwei-execute-phase step 2, under every model
+  policy: one task of a phase, dispatched fresh with SPEC, the phase context,
+  the ladder and step 4's floor. Exists so implementation runs at sonnet /
+  xhigh — a dispatch alone can set a model but not an effort.
+model: sonnet
+effort: xhigh
+version: 0.1.0
+targets: [claude-code]
+---
+
+# wuwei-implementer
+
+## Mandate
+
+Implement the one task you were dispatched with, inside the phase you were
+given, and nothing beyond it. What arrives with the dispatch governs: SPEC,
+the phase context, the ladder (climb it before writing), and step 4's floor.
+`wuwei-tdd` governs the task; commit as `wuwei-commit-hygiene` says — one
+concern per commit, the why in the body.
+
+## Out of scope
+
+- Another task, or the phase's next step — hand back instead.
+- A planning defect (a missing `depends-on`, an interface not there yet):
+  report it; do not work around it.
+- Review of your own work — a fresh subagent does that.
+
+## Output contract
+
+What landed (commit shas, one line each), the tests that ran and their
+result, and anything you stopped short of — with why.

package/bin/wuwei.js

@@ -187,10 +187,8 @@ function validate(items) {
       errs.push(`${it.rel}: description too long (${it.data.description.length} > 400)`)
     if (it.data.mode && !MODES.includes(it.data.mode))
       errs.push(`${it.rel}: mode must be one of ${MODES.join('|')}`)
-    // a skill is not a subagent: these fields would be emitted into SKILL.md
-    // and ignored, so say it at check time instead of shipping dead frontmatter
-    if ((it.data.model || it.data.effort) && it.kind !== 'agents')
-      errs.push(`${it.rel}: model/effort apply to agents only — a skill is not a subagent`)
+    // on a skill, Claude Code applies model/effort to the turn the skill runs
+    // in (and only that turn — the session's resume on the next prompt)
     if (it.data.model && !MODEL_ALIASES.includes(it.data.model)
       && !/^claude-[a-z0-9.-]+$/.test(it.data.model))
       errs.push(`${it.rel}: model must be ${MODEL_ALIASES.join('|')} or a full id (claude-…)`)
@@ -536,6 +534,21 @@ function lint(items) {
   for (const rel of Object.keys(budgets))
     if (!items.some(it => it.rel === rel || (it.refs ?? []).some(r => r.rel === rel)))
       errs.push(`wuwei.config.json: wordBudgets names ${rel}, which is not a definition or reference`)
+  // modelRoles names the tier; the agent file is what dispatch actually reads
+  const impl = CONFIG.modelRoles?.implementation
+  if (impl) {
+    const ag = items.find(it => it.kind === 'agents' && it.data.name === impl.agent)
+    if (!ag) errs.push(`wuwei.config.json: modelRoles.implementation.agent ${impl.agent} is not an agent`)
+    else for (const f of ['model', 'effort']) if (ag.data[f] !== impl[f])
+      errs.push(`${ag.rel}: ${f} ${ag.data[f] ?? '(unset)'} ≠ modelRoles.implementation.${f} ${impl[f]} — the roles tier is what this file pins`)
+  }
+  // the skill that runs implementation runs its own turn at the same tier
+  const sk = impl?.skill && items.find(it => it.kind === 'skills' && it.data.name === impl.skill)
+  if (impl?.skill && !sk) errs.push(`wuwei.config.json: modelRoles.implementation.skill ${impl.skill} is not a skill`)
+  else if (sk) for (const f of ['model', 'effort']) if (sk.data[f] !== impl[f])
+    errs.push(`${sk.rel}: ${f} ${sk.data[f] ?? '(unset)'} ≠ modelRoles.implementation.${f} ${impl[f]} — execute runs at the implementer's tier`)
+  for (const l of CONFIG.modelRoles?.review?.lenses ?? [])
+    if (!items.some(it => it.kind === 'agents' && it.data.name === l)) errs.push(`wuwei.config.json: modelRoles.review.lenses names ${l}, which is not an agent`)
   // update prints this file's sections — a version without one updates in silence
   const changelog = existsSync(join(ROOT, 'CHANGELOG.md')) ? readFileSync(join(ROOT, 'CHANGELOG.md'), 'utf8') : ''
   if (!new RegExp(`^## v?${escapeRe(PKG.version)}\\b`, 'm').test(changelog))
@@ -692,6 +705,7 @@ async function cmdUninstall(target) {
     }
     if (stripManagedBlock(join(codexHome(), 'AGENTS.md')))
       removed.push(join(codexHome(), 'AGENTS.md') + ' (managed block)')
+    if (removeCodexProfile()) removed.push(`${codexConfigPath()} ([profiles.${CODEX_PROFILE}])`)
     if (existsSync(manifestPath())) { rmSync(manifestPath()); removed.push(manifestPath()) }
     console.log(`user scope ← ${base}`)
     for (const r of removed) console.log(`    removed ${r}`)
@@ -1152,6 +1166,51 @@ function claimPhases(dest, stream) {
   return { streamBranch, integration, remote, behind, phases }
 }
 
+// SPEC ## Sign-off's model policy: `inherit` (default, also when the line is
+// absent) or `roles`, for the review tier. Implementation is not on the menu:
+// it is always wuwei-implementer at modelRoles.implementation's tier
+function modelPolicy(spec) {
+  const raw = (signOffField(spec ?? '', 'model policy') ?? 'inherit').trim()
+  const v = (raw.match(/\breview\s*[=:]\s*(\w+)/i)?.[1] ?? raw).toLowerCase()
+  const error = /\bimplementation\b/i.test(raw)
+    ? `model policy '${raw}': implementation is fixed (wuwei-implementer, ${CONFIG.modelRoles?.implementation?.model} / ${CONFIG.modelRoles?.implementation?.effort}) — the policy is inherit or roles, for review`
+    : !['inherit', 'roles'].includes(v) ? `model policy '${raw}': inherit or roles` : null
+  // Codex, when it runs execute: `codex: <model> / <effort>` — the session it is started as
+  const cx = (spec ?? '').split(/^## Sign-off\s*$/m)[1]?.split(/^## /m)[0]?.split('\n').find(l => /^[-*|\s]*codex\s*[:|]/i.test(l))
+  const cv = cx ? (cx.match(/`([^`]+)`/)?.[1] ?? cx.split(/[:|]/).map(x => x.trim()).filter(Boolean).at(-1)) : null
+  const cm = cv?.match(/^(\S+)\s*\/\s*(\S+)$/)
+  const codex = cm ? { model: cm[1], effort: cm[2] } : null
+  const codexError = cx && !cm ? `codex '${cv}': write it as <model> / <effort>`
+    : codex && !CODEX_EFFORTS.includes(codex.effort) ? `codex effort '${codex.effort}': one of ${CODEX_EFFORTS.join('|')}` : null
+  return { raw, tiers: { review: v }, error: error ?? codexError, codex }
+}
+
+function codexLine(want) {
+  const { profile } = codexProfile()
+  if (!want) return profile
+    ? `codex                       start it with \`codex --profile ${CODEX_PROFILE}\` (${profile.model} / ${profile.effort}) — none recorded under ## Sign-off`
+    : 'codex                       the model Codex was started with — no `codex:` under ## Sign-off'
+  return profile?.model === want.model && profile?.effort === want.effort
+    ? `codex                       start it with \`codex --profile ${CODEX_PROFILE}\` (${want.model} / ${want.effort})`
+    : `codex                       start it with \`${codexLaunch(want.model, want.effort)}\`${profile ? ` — profile ${CODEX_PROFILE} is ${profile.model} / ${profile.effort}, not what ## Sign-off says` : ''}`
+}
+
+// what step 2 and step 5 dispatch, from the policy and wuwei.config.json's
+// modelRoles — printed, so the tier is read off the screen, not remembered
+function dispatchLines(policy) {
+  const roles = CONFIG.modelRoles ?? {}
+  const impl = roles.implementation ?? {}, rev = roles.review ?? {}
+  return [
+    `implement (step 2)          subagent_type ${impl.agent}, no model or effort on the call — ${impl.model} / ${impl.effort}, pinned in its agent file`,
+    policy.tiers.review === 'roles'
+      ? `${(rev.lenses ?? []).map(l => l.replace(/^wuwei-review-/, 'review:')).join(', ')} (step 5)  model: ${rev.model} — effort from the agent file`
+      : `${(rev.lenses ?? []).map(l => l.replace(/^wuwei-review-/, 'review:')).join(', ')} (step 5)  no model — the session's model; effort from the agent file`,
+    'other lenses                no model — the session\'s; wuwei-security-auditor stays fable / high (pinned)',
+    'inline (no subagents, Codex)  the session\'s, whatever the policy — say so in the round record',
+    codexLine(policy.codex),
+  ]
+}
+
 function cmdClaim(argv) {
   const flag = name => { const i = argv.indexOf(name); return i === -1 ? null : argv[i + 1] }
   const positional = argv.filter((a, i) => !a.startsWith('--') && argv[i - 1] !== '--by')
@@ -1175,6 +1234,10 @@ function cmdClaim(argv) {
   for (const p of r.phases)
     console.log(`  ${p.name.padEnd(w)}  ${p.state}${p.review === 'human' ? '   ← review: human' : ''}`)
 
+  const policy = modelPolicy(existsSync(join(streamsDir, stream, 'SPEC.md')) ? readFileSync(join(streamsDir, stream, 'SPEC.md'), 'utf8') : '')
+  if (policy.error) { console.error(`\n✗ ${policy.error} — fix ## Sign-off (wuwei plan-check)`); process.exit(1) }
+  console.log(`\ndispatch · model policy: ${policy.raw}\n${dispatchLines(policy).map(l => `  ${l}`).join('\n')}`)
+
   if (!phaseArg) {
     const ready = r.phases.filter(p => p.state === 'ready')
     console.log(ready.length ? `\nclaim one: wuwei claim ${stream} ${ready[0].no}` : '\nnothing ready to claim')
@@ -1283,6 +1346,8 @@ function cmdPlanCheck(argv) {
   const open = signLines.filter(l => /:\s*(\?|tbd|todo|pending|—|-|<[^>]+>)?\s*$/i.test(l) && /\w/.test(l.split(':')[0]) && /^\s*[-*|]/.test(l))
   const auto = signLines.some(l => /\bmode\b[^|\n]*\bauto\b/i.test(l))
   if (auto && open.length) errs.push(`drive mode is auto while ## Sign-off still has open fields: ${open.map(l => l.trim()).join(' / ')} — a partly answered sign-off stays manual`)
+  const policy = spec ? modelPolicy(spec) : null
+  if (policy?.error) errs.push(`## Sign-off: ${policy.error}`)
   const tracker = signLines.find(l => /tracker/i.test(l)) ?? ''
   const linked = tracker && !/\bnone\b/i.test(tracker)
 
@@ -2620,6 +2685,59 @@ async function promptYesNo(question, def = false) {
   }
 }
 
+async function promptText(question, def = '') {
+  if (!isInteractive()) return def
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  try { return (await rl.question(`${question}${def ? ` [${def}]` : ''} `)).trim() || def } catch { return def } finally { rl.close() }
+}
+
+// ── Codex: a skill cannot set its model — the session is started with one.
+// So execute's tier on Codex is a profile in $CODEX_HOME/config.toml that the
+// session is launched under (codex --profile wuwei-execute); init offers to
+// write it, claim prints how to start. Effort values: codex-rs ReasoningEffort
+const CODEX_PROFILE = 'wuwei-execute'
+const CODEX_EFFORTS = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra', 'persistent']
+const CODEX_PROFILE_MARK = '# added by wuwei init — wuwei-execute-phase runs under this profile; `wuwei uninstall` removes it'
+const codexConfigPath = () => join(codexHome(), 'config.toml')
+// [profiles.wuwei-execute]'s model and effort, or null; plus the top-level model
+function codexProfile() {
+  const text = existsSync(codexConfigPath()) ? readFileSync(codexConfigPath(), 'utf8') : ''
+  const sec = text.split(/^(?=\[)/m).find(s => new RegExp(`^\\[profiles\\.(?:"${CODEX_PROFILE}"|${CODEX_PROFILE})\\]`).test(s))
+  const val = (s, k) => s?.match(new RegExp(`^${k}\\s*=\\s*"([^"]*)"`, 'm'))?.[1] ?? null
+  const top = text.split(/^\[/m)[0]
+  return { profile: sec ? { model: val(sec, 'model'), effort: val(sec, 'model_reasoning_effort') } : null, topModel: val(top, 'model') }
+}
+const codexLaunch = (model, effort) => `codex -m ${model} -c model_reasoning_effort=${effort}`
+
+async function offerCodexProfile(dry) {
+  if (!existsSync(codexHome())) return
+  const { profile, topModel } = codexProfile()
+  if (profile) { console.log(`
+codex: profile ${CODEX_PROFILE} — ${profile.model ?? '(model unset)'} / ${profile.effort ?? '(effort unset)'} · start execute with \`codex --profile ${CODEX_PROFILE}\``); return }
+  const snippet = m => [CODEX_PROFILE_MARK, `[profiles.${CODEX_PROFILE}]`, `model = "${m.model}"`, `model_reasoning_effort = "${m.effort}"`].join('\n')
+  console.log(`
+codex: a skill can't choose Codex's model — the session is started with one. wuwei-execute-phase runs under a profile you launch it with.`)
+  if (!isInteractive()) { console.log(`    add to ${codexConfigPath()}:\n${snippet({ model: '<model>', effort: 'xhigh' }).replace(/^/gm, '        ')}`); return }
+  if (!await promptYesNo(`  Add [profiles.${CODEX_PROFILE}] to ${codexConfigPath()}?`, true)) { console.log('  skipped — re-run `wuwei init` anytime'); return }
+  const model = await promptText('  model for execute:', topModel ?? '')
+  let effort = await promptText(`  reasoning effort (${CODEX_EFFORTS.join('|')}):`, 'xhigh')
+  if (!model || !CODEX_EFFORTS.includes(effort)) { console.log(`  ✗ ${!model ? 'no model given' : `effort must be one of ${CODEX_EFFORTS.join('|')}`} — nothing written`); return }
+  if (dry) { console.log(`  [dry] would append:\n${snippet({ model, effort }).replace(/^/gm, '    ')}`); return }
+  const prev = existsSync(codexConfigPath()) ? readFileSync(codexConfigPath(), 'utf8') : ''
+  writeFileSync(codexConfigPath(), (prev ? prev.replace(/\n*$/, '\n\n') : '') + snippet({ model, effort }) + '\n')
+  console.log(`  ✓ written · start execute with \`codex --profile ${CODEX_PROFILE}\`, and write \`codex: ${model} / ${effort}\` under the stream's ## Sign-off`)
+}
+
+// only the section init wrote (its marker line above it), never one you made
+function removeCodexProfile() {
+  if (!existsSync(codexConfigPath())) return false
+  const text = readFileSync(codexConfigPath(), 'utf8')
+  const re = new RegExp(`\\n*${escapeRe(CODEX_PROFILE_MARK)}\\n\\[profiles\\.${CODEX_PROFILE}\\][^\\[]*`)
+  if (!re.test(text)) return false
+  writeFileSync(codexConfigPath(), text.replace(re, '\n').replace(/^\n+/, '').replace(/\n*$/, '\n'))
+  return true
+}
+
 async function cmdInit(target, dry) {
   // bootstrap a project: repo-scope install into the target (default: cwd) —
   // the entrypoint `npx <pkg> init` runs from anywhere, package files as ROOT
@@ -2664,6 +2782,7 @@ async function cmdInit(target, dry) {
 
   await offerCodegraphSetup(dest, dry, existing)
   await offerScannerSetup(dry)
+  await offerCodexProfile(dry)
 
   const installHint = isSkillsInstalled()
     ? ''

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wei-wuwei",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "為無為，則無不治 — a source-of-truth skills & agents framework that compiles to Claude Code and Codex (Cursor and Gemini CLI planned). Write once, run in every agent, govern without forcing.",
   "type": "module",
   "bin": {

package/skills/wuwei-execute-phase/skill.md

@@ -9,6 +9,8 @@ description: >-
   simplify/review/fix → PR — one phase, or a range on request.
 version: 0.2.0
 mode: triggered
+model: sonnet
+effort: xhigh
 targets: [claude-code, codex]
 tags: [execution, workflow]
 ---
@@ -98,9 +100,12 @@ Stopping early is normal — say where, why, and what resumes:
 ```
 stopped at 03-appcheck-wiring · bound e2e red (auth/refresh.spec.ts)
 02 merged. 03 claimed, branch pushed, not merged.
-next invocation resumes at 03.
+next invocation resumes at 03: /wuwei-execute-phase
 ```
 
+Name the invocation: this skill's sonnet / xhigh holds for the turn it runs
+in, and a reply in chat continues on the session's model.
+
 **Scope is distance, never permission.** `mode` is the stream's standing
 authorisation from sign-off; scope is only how far one invocation tries to
 get.
@@ -152,8 +157,9 @@ get.
    context, **the ladder below**, and **step 4's floor** — and nothing else.
    The ladder is a question the subagent writing the helper has to ask; an
    orchestrator holding it while the subagent writes is the same as not having
-   it. Dispatch at the tier in `## Sign-off` (`inherit` by
-   default; `sonnet` / `xhigh` under `roles`). Inline instead → watch for
+   it. Dispatch `wuwei-implementer` with **no `model` or `effort` on the
+   call** — its file pins sonnet / xhigh, and a value on the call beats it.
+   Inline instead → watch for
    drift, keep the phase small, and note that the model policy has nothing to
    attach to.
 
@@ -333,8 +339,7 @@ get.
    `ACCEPTANCE.md`, the **base ref just synced to**, the **tool facts**
    (`wuwei-review` §1, §5), and **the scope** (`wuwei-review` §6) — plus, for the
    document panel, **the intended reader and the facts this phase
-   establishes** (`wuwei-review` §3). Models: the security auditor's pin, the
-   `## Sign-off` policy for design and defects, the session's for the rest
+   establishes** (`wuwei-review` §3). Models: as `wuwei claim` printed them
    (`wuwei-review` §2).
 
    **Round 1 is full scope; every round after it is delta** — dispatched with

package/skills/wuwei-plan-phases/skill.md

@@ -202,15 +202,18 @@ tags: [planning, workflow]
    - **merge method**: unsquashed by default — a merge commit — so ask only
      whether this stream squashes instead, plus which methods the repo allows
      (table below);
-   - **model policy**: `inherit` (default) | `roles` | a mix. Ask only
+   - **model policy** for review: `inherit` (default) | `roles`. Ask only
      whether to change the default;
+   - **Codex**, when it runs execute: the model and effort it is started
+     with — `codex: <model> / <effort>`. A skill cannot set Codex's model;
+     `wuwei claim` prints the launch (`wuwei init` offers the profile);
    - whether the plan goes through **its own PR** first — if so, steps 8–9
      wait for that PR to merge.
 
-   Two tiers are configurable, and both are honoured because both dispatch as
-   subagents: **implementation** (execute step 2, and step 5's
-   `review:defects` lens) and **review** (step 5's `review:design` lens) —
-   confirm both, not one. The panel's other lenses inherit the session's
+   Implementation is not on the menu: execute runs, and dispatches its
+   implementer, at sonnet / xhigh (`wuwei.config.json` `modelRoles`). The
+   policy sets **review** — step 5's `review:design` and `review:defects`,
+   which dispatch as subagents. The panel's other lenses inherit the session's
    model, **except `wuwei-security-auditor`**, which pins `fable` / `high` in
    frontmatter and holds under every policy including `inherit`. Say so,
    rather than letting a `roles` answer imply it was chosen.

package/wuwei.config.json

@@ -16,6 +16,10 @@
     "failOnDrift": true,
     "stampGeneratedHeader": true
   },
+  "modelRoles": {
+    "implementation": { "skill": "wuwei-execute-phase", "agent": "wuwei-implementer", "model": "sonnet", "effort": "xhigh" },
+    "review": { "lenses": ["wuwei-review-design", "wuwei-review-defects"], "model": "opus" }
+  },
   "wordBudgets": {
     "skills/wuwei-brainstorm/skill.md": 500,
     "skills/wuwei-commit-hygiene/skill.md": 200,