wei-wuwei 0.1.0 → 0.2.1

package/CHANGELOG.md

@@ -4,6 +4,33 @@ 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.1
+
+- `wuwei review-collect`: finds the latest Claude Code session that
+  dispatched a wuwei lens, copies each lens's transcript and report into
+  the review bundle's `reports/`, and prints what each one spent — turns,
+  context built, cached re-reads, and where the reading went. wuwei-review
+  §7 uses it instead of the collator re-typing each report.
+
+## 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,13 +59,15 @@ 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
 node bin/wuwei.js update             # git pull if behind, diff against what install wrote, apply on yes
 node bin/wuwei.js review-prep <base>  # wuwei-review's prep: dispatcher checks + scan bundle (or --pr <n>)
 node bin/wuwei.js claim [stream] [NN] # list eligible phases, or claim one: cut, claim, push
+node bin/wuwei.js review-collect     # each lens's transcript + report into the bundle, and what each one spent
 node bin/wuwei.js digest-check <f>   # a review digest's arithmetic before it is published
 node bin/wuwei.js plan-check [stream] # plan-phases step 11's checkable half, before sign-off
 node bin/wuwei.js worktree <lens> <sha> # a throwaway worktree no other lens shares (--prune)
@@ -91,8 +93,16 @@ npm in the background, and when a newer version is out it says so on stderr
 (at most hourly; never from a clone or in CI; `WUWEI_NO_UPDATE_CHECK=1` turns
 it off).
 
-Releasing: bump `package.json`, add its `## <version>` section to
-`CHANGELOG.md` (`wuwei check` fails without one), push a `v<version>` tag.
+Releasing is merging. Every merge to main that changes what the package ships
+(`bin`, `skills`, `agents`, `templates`, `wuwei.config.json`) is released by
+`.github/workflows/publish.yml`: the version is bumped by the merged commits'
+Conventional Commit types — `feat` minor, `type!:` or a `BREAKING CHANGE:`
+footer major (minor while under 1.0), anything else patch — `CHANGELOG.md`
+gains a section from the merged PR titles, and the release commit, the
+`v<version>` tag, the npm publish and the GitHub Release follow. A docs- or
+tests-only merge releases nothing; *Run workflow* (`workflow_dispatch`) with a
+bump releases now. A version already set in `package.json` that npm has not
+seen goes out as is.
 
 ## Daily use
 
@@ -188,7 +198,7 @@ wuwei/
 ├── agents/            # canonical subagent definitions
 │   └── _template/
 ├── templates/         # PR / review templates, installed per-repo
-├── bin/wuwei.js       # CLI: build · check · list · init · install · update · status · review-prep · claim · digest-check · plan-check · worktree · mutate · sites · verify · uninstall
+├── bin/wuwei.js       # CLI: build · check · list · init · install · update · status · review-prep · review-collect · claim · digest-check · plan-check · worktree · mutate · sites · verify · uninstall
 │                      #   the per-tool emitters live here too, not in adapters/
 ├── adapters/          # notes only — see bin/wuwei.js for the actual emitters
 ├── docs/

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

@@ -22,6 +22,8 @@
  *   wuwei claim [<stream>] [<phase>] [--take-over] [--by <id>] [--dry]
  *                              wuwei-execute-phase step 1: list what is eligible,
  *                              or claim one — cut, claim, push
+ *   wuwei review-collect [--session <id>]  each subagent's transcript and report into
+ *                              the bundle's reports/, and what each one spent
  *   wuwei digest-check <file>  wuwei-review §7's arithmetic before publishing: count,
  *                              rows, credits, file:line, Action names, redaction
  *   wuwei worktree <lens> [<sha>]  a throwaway worktree no other lens shares; --prune
@@ -187,10 +189,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 +536,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 +707,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 +1168,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 +1236,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 +1348,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)
 
@@ -1777,6 +1844,90 @@ async function cmdVerify(argv) {
   console.log('\nflags are leads, not findings: open the shot, and confirm against the spec what the page should say')
 }
 
+// ── review-collect: the lenses' own record, from Claude Code's transcripts ──
+// Claude Code keeps every subagent's transcript under ~/.claude/projects/<cwd,
+// non-alphanumerics as '-'>/<session>/subagents/agent-<id>.jsonl, its type in
+// the .meta.json beside it. §7 used to have the collator re-type each report
+// into the bundle — skipped in practice, and paid for in tokens when not. This
+// copies them, and reads what each one spent
+function transcriptStats(file) {
+  const usage = new Map(), uses = new Map(), reads = new Map()
+  const t = { turns: 0, built: 0, reread: 0, input: 0, output: 0, first: null, last: null, report: '' }
+  const kind = (name, inp = {}) => name === 'Read' ? (/\.wuwei-cache/.test(inp.file_path ?? '') ? 'Read:bundle' : 'Read:tree')
+    : name === 'Bash' ? (/codegraph/.test(inp.command ?? '') ? 'Bash:codegraph' : /\b(git )?grep\b|\brg\b/.test(inp.command ?? '') ? 'Bash:grep' : 'Bash:other') : name
+  for (const line of readFileSync(file, 'utf8').split('\n')) {
+    let d; try { d = JSON.parse(line) } catch { continue }
+    if (d.timestamp) { t.first ??= d.timestamp; t.last = d.timestamp }
+    const m = d.message
+    if (!m || typeof m !== 'object') continue
+    // one message arrives as several lines while it streams: its last usage is its total
+    if (d.type === 'assistant' && m.usage) usage.set(m.id, m.usage)
+    for (const x of Array.isArray(m.content) ? m.content : []) {
+      if (x.type === 'tool_use') {
+        uses.set(x.id, kind(x.name, x.input))
+        if (x.name === 'SubagentHandback' && x.input?.message) t.report = x.input.message
+      } else if (x.type === 'tool_result') {
+        const k = uses.get(x.tool_use_id) ?? '?', r = reads.get(k) ?? { n: 0, tokens: 0 }
+        r.n++; r.tokens += Math.round(JSON.stringify(x.content ?? '').length / 4); reads.set(k, r)
+      } else if (x.type === 'text' && d.type === 'assistant' && x.text?.trim()) t.lastText = x.text
+    }
+  }
+  for (const u of usage.values()) {
+    t.turns++; t.built += u.cache_creation_input_tokens ?? 0; t.reread += u.cache_read_input_tokens ?? 0
+    t.input += u.input_tokens ?? 0; t.output += u.output_tokens ?? 0
+  }
+  t.report ||= t.lastText ?? ''
+  t.reads = [...reads].sort((a, b) => b[1].tokens - a[1].tokens)
+  return t
+}
+
+function cmdReviewCollect(argv) {
+  const flag = name => { const i = argv.indexOf(name); return i === -1 ? null : argv[i + 1] }
+  const projects = join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'), 'projects')
+  const projDir = join(projects, process.cwd().replace(/[^A-Za-z0-9]/g, '-'))
+  if (!existsSync(projDir)) { console.error(`✗ no Claude Code sessions recorded for ${process.cwd()} (${projDir}) — run it where the review ran (Codex has no subagent transcripts)`); process.exit(1) }
+  const sessions = readdirSync(projDir, { withFileTypes: true }).filter(d => d.isDirectory() && existsSync(join(projDir, d.name, 'subagents')))
+    .map(d => {
+      const dir = join(projDir, d.name, 'subagents')
+      const agents = readdirSync(dir).filter(f => f.endsWith('.meta.json')).map(f => {
+        let meta = {}; try { meta = JSON.parse(readFileSync(join(dir, f), 'utf8')) } catch {}
+        const jsonl = join(dir, f.replace(/\.meta\.json$/, '.jsonl'))
+        return { meta, jsonl, mtime: existsSync(jsonl) ? statSync(jsonl).mtimeMs : 0 }
+      }).filter(a => a.mtime)
+      return { id: d.name, agents, wuwei: agents.some(a => /^wuwei-/.test(a.meta.agentType ?? '')), latest: Math.max(0, ...agents.map(a => a.mtime)) }
+    })
+  const session = flag('--session') ? sessions.find(s => s.id.startsWith(flag('--session')))
+    : sessions.filter(s => s.wuwei).sort((a, b) => b.latest - a.latest)[0]
+  if (!session) { console.error(`✗ ${flag('--session') ? `no session ${flag('--session')}` : 'no session here dispatched a wuwei lens'} under ${projDir}`); process.exit(1) }
+
+  const sha = flag('--sha') ?? quiet('git', ['rev-parse', '--verify', '--quiet', 'HEAD']).stdout?.trim().slice(0, 12) ?? 'nogit'
+  const out = join(process.cwd(), '.wuwei-cache', 'review', sha, 'reports')
+  mkdirSync(out, { recursive: true })
+  const rows = [], used = new Map()
+  for (const a of session.agents.map(a => ({ ...a, s: transcriptStats(a.jsonl) })).sort((x, y) => (x.s.first ?? '').localeCompare(y.s.first ?? ''))) {
+    const type = a.meta.agentType ?? 'agent'
+    const base = (type === 'general-purpose' && a.meta.description ? a.meta.description.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 30) : type).replace(/^wuwei-/, '')
+    const n = (used.get(base) ?? 0) + 1; used.set(base, n)
+    const name = n === 1 ? base : `${base}-${n}`
+    writeFileSync(join(out, `${name}.jsonl`), readFileSync(a.jsonl))
+    if (a.s.report) writeFileSync(join(out, `${name}.md`), a.s.report.trimEnd() + '\n')
+    rows.push({ name, ...a.s })
+  }
+  const k = x => x >= 1e6 ? `${(x / 1e6).toFixed(1)}M` : x >= 1e3 ? `${Math.round(x / 1e3)}k` : String(x)
+  const total = rows.reduce((t, r) => ({ built: t.built + r.built, reread: t.reread + r.reread }), { built: 0, reread: 0 })
+  console.log(`session ${session.id} · ${rows.length} subagent(s) → ${out}\n`)
+  // output tokens are left out: the transcript records a streaming chunk's count, not the message's
+  console.log('| agent | turns | context built | re-read (cached) | where the reading went |\n|---|---|---|---|---|')
+  for (const r of [...rows].sort((a, b) => (b.built + b.reread / 10) - (a.built + a.reread / 10)))
+    console.log(`| ${r.name} | ${r.turns} | ${k(r.built)} | ${k(r.reread)} | ${r.reads.slice(0, 4).map(([kk, v]) => `${kk} ${v.n}× ≈${k(v.tokens)}`).join(' · ') || '—'} |`)
+  console.log(`| **total** | | ${k(total.built)} | ${k(total.reread)} | |`)
+  const byKind = new Map()
+  for (const r of rows) for (const [kk, v] of r.reads) byKind.set(kk, (byKind.get(kk) ?? 0) + v.tokens)
+  const top = [...byKind].sort((a, b) => b[1] - a[1]).slice(0, 3)
+  if (top.length) console.log(`\nmost read, across the lenses: ${top.map(([kk, v]) => `${kk} ≈${k(v)}`).join(' · ')}`)
+  console.log('re-read is billed at about a tenth of context built; a lens with many turns pays its context again on each')
+}
+
 // ── digest-check: wuwei-review §7's arithmetic, before publishing ─────
 // what the collator re-derives by hand: the header count against the table,
 // reporter credits, every file:line against the reviewed tree, every
@@ -2620,6 +2771,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 +2868,7 @@ async function cmdInit(target, dry) {
 
   await offerCodegraphSetup(dest, dry, existing)
   await offerScannerSetup(dry)
+  await offerCodexProfile(dry)
 
   const installHint = isSkillsInstalled()
     ? ''
@@ -2699,6 +2904,7 @@ switch (cmd) {
   case 'update': await cmdUpdate(dry, rest.includes('--no-fetch')); break
   case 'status': cmdStatus(arg); break
   case 'review-prep': cmdReviewPrep(rest); break
+  case 'review-collect': cmdReviewCollect(rest); break
   case 'verify': await cmdVerify(rest); break
   case 'claim': cmdClaim(rest); break
   case 'digest-check': cmdDigestCheck(rest); break
@@ -2708,6 +2914,6 @@ switch (cmd) {
   case 'plan-check': cmdPlanCheck(rest); break
   case 'uninstall': await cmdUninstall(arg); break
   default:
-    console.error(`unknown command '${cmd}'\nusage: wuwei [build|check|list|init [path]|install [path]|update|status [path]|review-prep [base] [--pr n] [--path p]|verify [page] [--phase NN]|claim [stream] [phase]|digest-check <digest.md>|worktree <lens> [sha]|mutate <file>:<line>|sites <pattern>|plan-check [stream]|uninstall [path]|--version] [--dry]`)
+    console.error(`unknown command '${cmd}'\nusage: wuwei [build|check|list|init [path]|install [path]|update|status [path]|review-prep [base] [--pr n] [--path p]|review-collect|verify [page] [--phase NN]|claim [stream] [phase]|digest-check <digest.md>|worktree <lens> [sha]|mutate <file>:<line>|sites <pattern>|plan-check [stream]|uninstall [path]|--version] [--dry]`)
     process.exit(1)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wei-wuwei",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "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/skills/wuwei-review/references/prep.md

@@ -31,5 +31,5 @@ slices they need:
   diff.patch    git diff <base>...HEAD, three dots, verbatim
   symbols.md    definitions the diff references, from `codegraph node` — or "graph absent"
   tools/<tool>.json   each detected tool's read-only output over the change (§5), run once
-  reports/<lens>.md   each lens's raw report, as returned — never the session scratchpad
+  reports/<lens>.md   each lens's raw report — `wuwei review-collect`, or written as returned
 ```

package/skills/wuwei-review/skill.md

@@ -102,7 +102,7 @@ disk**; lenses pull the slices they need:
 ```
 .wuwei-cache/review/<reviewed-sha>/     # gitignored — never inside the reviewed tree
   PREP.md · INDEX.md (kind is a first pass by path — reclassify by content) · diff.patch
-  thread.json · tools/<tool>.json · reports/<lens>.md (each lens's raw report, as returned)
+  thread.json · tools/<tool>.json · reports/<lens>.md + .jsonl (`wuwei review-collect`)
 ```
 
 **No copies of the changed files** — each lens's context holds what it reads
@@ -346,9 +346,9 @@ finding closes.
 
 ## 7. Collate
 
-The collator is the dispatching session. It first writes each lens's report
-into the bundle's `reports/<lens>.md` as returned — the harness's output file,
-copied, not re-typed. Then one digest
+The collator is the dispatching session. **`wuwei review-collect`** first
+copies each lens's transcript and report into the bundle's `reports/` —
+never re-typed (no subagents, as on Codex: write them yourself). Then one digest
 against `.wuwei/templates/code-review.md`, opening with which
 panels ran and why. **Whichever panels ran share one table** — code and
 document on a mixed target, or the stream panel's five reporters plus §2 on

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,