@windyroad/architect 0.20.0-preview.946 → 0.20.1

package/.agents/plugins/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "windyroad-architect-local",
+  "interface": { "displayName": "Windy Road Architect" },
+  "plugins": [
+    {
+      "name": "wr-architect",
+      "source": { "source": "local", "path": "." },
+      "policy": { "installation": "AVAILABLE", "authentication": "ON_INSTALL" },
+      "category": "Developer Tools"
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -123,5 +123,5 @@
     }
   },
   "name": "wr-architect",
-  "version": "0.20.0"
+  "version": "0.20.1"
 }

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wr-architect",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "description": "Architecture decision enforcement for AI coding agents",
   "author": {
     "name": "Windy Road Technology",

package/agents/test/architect-codex-eval-contract.bats

@@ -17,13 +17,17 @@ setup() {
   [ "$status" -eq 0 ]
 }
 
-@test "architect Codex agent eval runner uses codex exec and local plugin install" {
-  run grep -n "codex plugin marketplace add" "$EVAL_DIR/run-codex-agent-eval.sh"
+@test "architect Codex agent eval runner uses packed install and exact custom agent" {
+  run grep -n 'npm pack' "$EVAL_DIR/run-codex-agent-eval.sh"
   [ "$status" -eq 0 ]
-  run grep -n "codex plugin add wr-architect@windyroad-local" "$EVAL_DIR/run-codex-agent-eval.sh"
+  run grep -n 'windyroad-architect --runtime codex --scope user' "$EVAL_DIR/run-codex-agent-eval.sh"
   [ "$status" -eq 0 ]
   run grep -n "codex exec" "$EVAL_DIR/run-codex-agent-eval.sh"
   [ "$status" -eq 0 ]
-  run grep -n ".codex/agents/wr-architect.toml" "$EVAL_DIR/run-codex-agent-eval.sh"
+  run grep -n 'agents/wr-architect-agent.toml' "$EVAL_DIR/run-codex-agent-eval.sh"
+  [ "$status" -eq 0 ]
+  run grep -n 'wr-architect:agent' "$EVAL_DIR/run-codex-agent-eval.sh"
+  [ "$status" -eq 0 ]
+  run grep -n 'git -C "$TMP_REPO" init' "$EVAL_DIR/run-codex-agent-eval.sh"
   [ "$status" -eq 0 ]
 }

package/bin/install.mjs

@@ -1,16 +1,31 @@
 #!/usr/bin/env node
 
-import { resolve, dirname } from "node:path";
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const utils = await import(resolve(__dirname, "../lib/install-utils.mjs"));
-
+const agents = await import(resolve(__dirname, "../scripts/codex-agent.mjs"));
 const PLUGIN = "wr-architect";
-const DEPS = [];
+const CODEX_MARKETPLACE = "windyroad-architect-local";
+const PACKAGE_ROOT = resolve(__dirname, "..");
+const PACKAGE_VERSION = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8")).version;
+
+function marketplaceRoot() {
+  const home = process.env.CODEX_HOME || join(homedir(), ".codex");
+  return join(home, ".tmp", "marketplaces", `wr-architect-${PACKAGE_VERSION}`);
+}
 
 const flags = utils.parseStandardArgs(process.argv);
 
+if (flags.runtime === "codex" || flags.runtime === "both") {
+  const bundled = "/Applications/ChatGPT.app/Contents/Resources/codex";
+  const binary = process.env.CODEX_BINARY || (existsSync(bundled) ? bundled : null);
+  if (binary?.includes("/")) process.env.PATH = `${dirname(binary)}:${process.env.PATH || ""}`;
+}
+
 if (flags.help) {
   console.log(`
 Usage: npx @windyroad/architect [options]
@@ -32,13 +47,47 @@ if (flags.dryRun) {
   utils.setDryRun(true);
   console.log("[dry-run mode — no commands will be executed]\n");
 }
-
 utils.checkPrerequisites({ runtime: flags.runtime });
 
+function codexInstall() {
+  const root = marketplaceRoot();
+  if (!flags.dryRun) {
+    rmSync(root, { recursive: true, force: true });
+    mkdirSync(dirname(root), { recursive: true });
+    cpSync(PACKAGE_ROOT, root, { recursive: true });
+  }
+  if (!utils.run(`codex plugin marketplace add ${JSON.stringify(root)}`, `Codex marketplace: ${CODEX_MARKETPLACE}`)) return false;
+  if (!utils.run(`codex plugin add ${PLUGIN}@${CODEX_MARKETPLACE}`, PLUGIN)) return false;
+  if (!flags.dryRun) agents.installArchitectAgent(agents.agentDir(flags.scope));
+  return true;
+}
+
+function codexUninstall() {
+  const removed = utils.run(`codex plugin remove ${PLUGIN}@${CODEX_MARKETPLACE}`, `Removing ${PLUGIN}`);
+  utils.run(`codex plugin marketplace remove ${CODEX_MARKETPLACE}`, `Removing ${CODEX_MARKETPLACE}`);
+  if (!flags.dryRun) {
+    for (const target of new Set([agents.agentDir(flags.scope), agents.agentDir("user")])) {
+      agents.uninstallArchitectAgent(target);
+    }
+    rmSync(marketplaceRoot(), { recursive: true, force: true });
+  }
+  return removed;
+}
+
 if (flags.uninstall) {
-  utils.uninstallPackage(PLUGIN, { runtime: flags.runtime });
+  if (flags.runtime === "claude" || flags.runtime === "both") utils.uninstallPackage(PLUGIN, { runtime: "claude" });
+  if ((flags.runtime === "codex" || flags.runtime === "both") && !codexUninstall()) process.exit(1);
 } else if (flags.update) {
-  utils.updatePackage(PLUGIN, { scope: flags.scope, runtime: flags.runtime });
+  if (flags.runtime === "claude" || flags.runtime === "both") utils.updatePackage(PLUGIN, { scope: flags.scope, runtime: "claude" });
+  if ((flags.runtime === "codex" || flags.runtime === "both") && !codexInstall()) process.exit(1);
+} else if (flags.runtime === "codex") {
+  console.log(`\nInstalling @windyroad/architect (${flags.scope} scope)...\n`);
+  if (!codexInstall()) process.exit(1);
+  console.log("\nDone! Restart Codex to activate.\n");
+} else if (flags.runtime === "both") {
+  utils.installPackage(PLUGIN, { scope: flags.scope, runtime: "claude" });
+  if (!codexInstall()) process.exit(1);
+  console.log("\nDone! Restart Claude Code and Codex to activate.\n");
 } else {
-  utils.installPackage(PLUGIN, { deps: DEPS, scope: flags.scope, runtime: flags.runtime });
+  utils.installPackage(PLUGIN, { scope: flags.scope, runtime: "claude" });
 }

package/hooks/architect-mark-reviewed.sh

@@ -49,10 +49,7 @@ case "$SUBAGENT" in
     # per 3-filing session).
     MARKER="/tmp/architect-reviewed-${SESSION_ID}"
     case "$VERDICT" in
-      PASS|"")
-        # PASS or unparseable verdict — allow with marker (the empty case
-        # preserves the pre-amendment "could not parse verdict" backward-
-        # compat allow-with-marker behaviour to avoid lockout).
+      PASS)
         if [ -d "$PROJECT_DIR/docs/decisions" ]; then
           HASH=$(_substance_hash_path "$PROJECT_DIR/docs/decisions")
         else
@@ -62,13 +59,12 @@ case "$SUBAGENT" in
           echo "WARN: architect-mark-reviewed atomic marker-write failed for ${MARKER}" >&2
         fi
         ;;
-      FAIL)
-        # Do NOT create marker — review found issues
+      FAIL|"")
+        # Fail closed: issues and unparseable output do not unlock edits.
         ;;
     esac
 
-    # Plan review marker
-    touch "/tmp/architect-plan-reviewed-${SESSION_ID}"
+    [ "$VERDICT" = "PASS" ] && touch "/tmp/architect-plan-reviewed-${SESSION_ID}"
     ;;
 esac
 

package/hooks/codex-agent-completion.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const hookDir = dirname(fileURLToPath(import.meta.url));
+const role = "wr-architect:agent";
+
+function response(input) {
+  if (typeof input.tool_response === "object" && input.tool_response) return input.tool_response;
+  try { return JSON.parse(input.tool_response); } catch { return {}; }
+}
+
+function riskDir(sessionId) {
+  return join(process.env.TMPDIR || "/tmp", `claude-risk-${sessionId}`);
+}
+
+function statePath(input, target) {
+  return join(riskDir(input.session_id), `codex-architect-${Buffer.from(target).toString("base64url")}`);
+}
+
+function remember(input) {
+  const target = response(input).agent_id ?? response(input).task_name;
+  if (typeof target !== "string" || !target) return;
+  mkdirSync(riskDir(input.session_id), { recursive: true });
+  rmSync(statePath(input, target), { force: true });
+  if (input.tool_input?.agent_type === role) writeFileSync(statePath(input, target), role, "utf8");
+}
+
+function complete(input) {
+  const target = input.tool_input?.target;
+  const output = response(input).previous_status?.completed;
+  if (typeof target !== "string" || typeof output !== "string") return;
+  const state = statePath(input, target);
+  if (!existsSync(state) || readFileSync(state, "utf8") !== role) return;
+  rmSync(state, { force: true });
+  const synthetic = {
+    ...input,
+    tool_name: "Agent",
+    tool_input: { subagent_type: role },
+    tool_response: { content: [{ type: "text", text: output }] },
+  };
+  spawnSync(join(hookDir, "architect-mark-reviewed.sh"), {
+    cwd: input.cwd || process.cwd(),
+    env: process.env,
+    input: JSON.stringify(synthetic),
+    encoding: "utf8",
+  });
+}
+
+let body = "";
+process.stdin.setEncoding("utf8");
+for await (const chunk of process.stdin) body += chunk;
+let input;
+try { input = JSON.parse(body); } catch { process.exit(0); }
+if (!/^[A-Za-z0-9-]+$/.test(input.session_id || "")) process.exit(0);
+
+if (["collaborationspawn_agent", "spawn_agent", "multi_agent_v1__spawn_agent"].includes(input.tool_name)) remember(input);
+if (["collaborationinterrupt_agent", "close_agent", "multi_agent_v1__close_agent"].includes(input.tool_name)) complete(input);

package/hooks/hooks.json

@@ -1,7 +1,10 @@
 {
   "hooks": {
     "SessionStart": [
-      { "matcher": "startup", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/architect-oversight-nudge.sh" }] }
+      { "matcher": "startup", "hooks": [
+        { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/scripts/codex-agent.mjs --session-start" },
+        { "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/architect-oversight-nudge.sh" }
+      ] }
     ],
     "UserPromptSubmit": [
       { "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/architect-detect.sh" }] },
@@ -15,6 +18,7 @@
     ],
     "PostToolUse": [
       { "matcher": "Agent", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/architect-mark-reviewed.sh" }] },
+      { "matcher": "collaborationspawn_agent|collaborationinterrupt_agent|spawn_agent|close_agent|multi_agent_v1__spawn_agent|multi_agent_v1__close_agent", "hooks": [{ "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/codex-agent-completion.mjs" }] },
       { "matcher": "Edit|Write", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/architect-refresh-hash.sh" }] },
       { "matcher": "Edit|Write", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/architect-compendium-update-entry.sh" }] },
       { "matcher": "Agent|Bash|Skill", "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/architect-slide-marker.sh" }] }

package/hooks/test/architect-mark-reviewed-verdict-grep.bats

@@ -78,22 +78,13 @@ No conflicts with existing decisions.")
 # P181 bug-fix cases: substring-anywhere false-positive FAIL
 # ---------------------------------------------------------------------------
 
-@test "verdict-grep: marker drops when no canonical heading + body mentions 'ISSUES FOUND' inline (P181)" {
-  # Agent emits prose without a canonical heading but the narrative discusses
-  # the concept of ISSUES FOUND. Current substring grep falsely classifies
-  # this as FAIL → no marker. After fix: anchored regex doesn't match → falls
-  # through to default branch → marker drops (lockout-avoidance).
+@test "verdict-grep: no marker without a canonical heading" {
   INPUT=$(_make_input "I reviewed the change. The previous review surfaced ISSUES FOUND that have since been addressed; the current proposed change is fine.")
   echo "$INPUT" | "$HOOK"
-  [ -f "$REVIEW_MARKER" ]
+  [ ! -f "$REVIEW_MARKER" ]
 }
 
-@test "verdict-grep: marker drops on NEEDS DIRECTION heading even if body prose mentions 'ISSUES FOUND' (P181)" {
-  # NEEDS DIRECTION is one of three canonical verdicts (agent.md line 137).
-  # It currently falls through to the default branch (creates marker for
-  # backward-compat lockout-avoidance). The bug: if the body narratively
-  # references the ISSUES FOUND verdict shape, substring grep fires FAIL.
-  # After fix: neither anchored regex matches → fallback creates marker.
+@test "verdict-grep: NEEDS DIRECTION does not unlock edits" {
   INPUT=$(_make_input "**Architecture Review: NEEDS DIRECTION**
 
 A decision must be recorded. This differs from an ISSUES FOUND verdict because the option is not pinned.
@@ -101,7 +92,8 @@ A decision must be recorded. This differs from an ISSUES FOUND verdict because t
 - Option A — ...
 - Option B — ...")
   echo "$INPUT" | "$HOOK"
-  [ -f "$REVIEW_MARKER" ]
+  [ ! -f "$REVIEW_MARKER" ]
+  [ ! -f "$PLAN_MARKER" ]
 }
 
 @test "verdict-grep: marker drops when PASS heading present and body also says 'ISSUES FOUND' inline" {
@@ -114,13 +106,8 @@ No conflicts. Note: earlier sessions reported ISSUES FOUND on adjacent files but
   [ -f "$REVIEW_MARKER" ]
 }
 
-@test "verdict-grep: marker drops when body just says 'no issues found' in prose" {
-  # Verbatim substring "issues found" should not satisfy the anchored
-  # ISSUES FOUND regex (which requires the bold heading shape). Old code:
-  # grep -q "ISSUES FOUND" is case-sensitive so 'issues found' lowercase
-  # doesn't match either — this test pins case-sensitivity behaviour so
-  # future regex changes don't accidentally relax it.
+@test "verdict-grep: prose-only approval does not unlock edits" {
   INPUT=$(_make_input "Review complete — no issues found in the diff.")
   echo "$INPUT" | "$HOOK"
-  [ -f "$REVIEW_MARKER" ]
+  [ ! -f "$REVIEW_MARKER" ]
 }

package/hooks/test/codex-agent-completion.bats

@@ -0,0 +1,64 @@
+#!/usr/bin/env bats
+
+setup() {
+  HOOK_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)"
+  TMP="$(mktemp -d)"
+  export TMPDIR="$TMP/runtime"
+  export CLAUDE_PROJECT_DIR="$TMP/project"
+  mkdir -p "$TMPDIR" "$CLAUDE_PROJECT_DIR/docs/decisions"
+  SESSION="architect-codex-$$"
+  TARGET="agent-target"
+  MARKER="/tmp/architect-reviewed-$SESSION"
+  HASH="$MARKER.hash"
+  PLAN="/tmp/architect-plan-reviewed-$SESSION"
+  rm -f "$MARKER" "$HASH" "$PLAN"
+}
+
+teardown() {
+  rm -f "$MARKER" "$HASH" "$PLAN"
+  rm -rf "$TMP"
+}
+
+dispatch() {
+  printf '%s' "$1" | node "$HOOK_DIR/codex-agent-completion.mjs"
+}
+
+spawn() {
+  printf '{"session_id":"%s","cwd":"%s","tool_name":"multi_agent_v1__spawn_agent","tool_input":{"agent_type":"%s"},"tool_response":{"agent_id":"%s"}}' "$SESSION" "$CLAUDE_PROJECT_DIR" "$1" "$TARGET"
+}
+
+close() {
+  printf '{"session_id":"%s","cwd":"%s","tool_name":"multi_agent_v1__close_agent","tool_input":{"target":"%s"},"tool_response":{"previous_status":{"completed":"%s"}}}' "$SESSION" "$CLAUDE_PROJECT_DIR" "$TARGET" "$1"
+}
+
+@test "matched Codex architect PASS creates review markers" {
+  dispatch "$(spawn wr-architect:agent)"
+  dispatch "$(close '**Architecture Review: PASS**')"
+  [ -f "$MARKER" ]
+  [ -f "$HASH" ]
+  [ -f "$PLAN" ]
+}
+
+@test "issues and malformed output fail closed" {
+  dispatch "$(spawn wr-architect:agent)"
+  dispatch "$(close '**Architecture Review: ISSUES FOUND**')"
+  [ ! -e "$MARKER" ]
+  dispatch "$(spawn wr-architect:agent)"
+  dispatch "$(close 'review complete')"
+  [ ! -e "$MARKER" ]
+}
+
+@test "unmatched close and non-architect target do not unlock" {
+  dispatch "$(close '**Architecture Review: PASS**')"
+  [ ! -e "$MARKER" ]
+  dispatch "$(spawn default)"
+  dispatch "$(close '**Architecture Review: PASS**')"
+  [ ! -e "$MARKER" ]
+}
+
+@test "reused target clears stale architect identity" {
+  dispatch "$(spawn wr-architect:agent)"
+  dispatch "$(spawn default)"
+  dispatch "$(close '**Architecture Review: PASS**')"
+  [ ! -e "$MARKER" ]
+}

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@windyroad/architect",
-  "version": "0.20.0-preview.946",
+  "version": "0.20.1",
   "description": "Architecture decision enforcement for AI coding agents",
   "bin": {
     "windyroad-architect": "./bin/install.mjs"
   },
   "type": "module",
+  "scripts": {
+    "prepack": "node scripts/sync-codex-skills.mjs --pack",
+    "postpack": "node scripts/sync-codex-skills.mjs --restore-pack"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -24,6 +28,7 @@
     "hooks/",
     "skills/",
     "scripts/",
+    ".agents/",
     ".claude-plugin/",
     ".codex-plugin/",
     "lib/",

package/scripts/codex-agent.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const source = join(packageRoot, "agents", "agent.md");
+const filename = "wr-architect-agent.toml";
+const owner = "# Generated by @windyroad/architect from agents/agent.md.";
+
+function split(markdown) {
+  const end = markdown.indexOf("\n---\n", 4);
+  return markdown.startsWith("---\n") && end !== -1
+    ? { frontmatter: markdown.slice(4, end), body: markdown.slice(end + 5) }
+    : { frontmatter: "", body: markdown };
+}
+
+function description(frontmatter) {
+  const lines = frontmatter.split(/\r?\n/);
+  const start = lines.findIndex((line) => line.startsWith("description:"));
+  if (start === -1) return "Architecture reviewer for structural and technology decisions.";
+  const value = [lines[start].slice("description:".length).trim()];
+  for (let index = start + 1; index < lines.length && /^\s+/.test(lines[index]); index += 1) {
+    value.push(lines[index].trim());
+  }
+  return value.filter(Boolean).join(" ");
+}
+
+function payload() {
+  const { frontmatter, body } = split(readFileSync(source, "utf8"));
+  return [
+    "# Do not edit by hand; update agents/agent.md and reinstall.",
+    'name = "wr-architect:agent"',
+    `description = ${JSON.stringify(description(frontmatter))}`,
+    'sandbox_mode = "read-only"',
+    'developer_instructions = """',
+    body.replace(/\\/g, "\\\\").replace(/"""/g, '\\"\\"\\"').trimEnd(),
+    '"""',
+    "",
+  ].join("\n");
+}
+
+export function renderArchitectAgent() {
+  const content = payload();
+  const hash = createHash("sha256").update(content).digest("hex");
+  return `${owner}\n# Generated content SHA-256: ${hash}\n${content}`;
+}
+
+function owned(content) {
+  if (!content.startsWith(`${owner}\n`)) return false;
+  const lines = content.split("\n");
+  const match = lines[1]?.match(/^# Generated content SHA-256: ([0-9a-f]{64})$/);
+  return Boolean(match && createHash("sha256").update(lines.slice(2).join("\n")).digest("hex") === match[1]);
+}
+
+export function agentDir(scope, cwd = process.cwd(), env = process.env) {
+  return scope === "user"
+    ? join(env.CODEX_HOME || join(homedir(), ".codex"), "agents")
+    : join(cwd, ".codex", "agents");
+}
+
+export function installArchitectAgent(targetDir, { quiet = false } = {}) {
+  mkdirSync(targetDir, { recursive: true });
+  const target = join(targetDir, filename);
+  const expected = renderArchitectAgent();
+  if (existsSync(target)) {
+    const current = readFileSync(target, "utf8");
+    if (current === expected) return false;
+    if (!owned(current)) {
+      if (!quiet) console.log(`Preserved user-managed Codex agent at ${target}.`);
+      return false;
+    }
+  }
+  writeFileSync(target, expected, "utf8");
+  if (!quiet) console.log(`Codex architect agent installed at ${target}.`);
+  return true;
+}
+
+export function uninstallArchitectAgent(targetDir) {
+  const target = join(targetDir, filename);
+  if (existsSync(target) && owned(readFileSync(target, "utf8"))) rmSync(target);
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  if (process.argv.includes("--session-start") && !process.env.CODEX_THREAD_ID) process.exit(0);
+  const scopeIndex = process.argv.indexOf("--scope");
+  const scope = scopeIndex === -1 ? (process.argv.includes("--session-start") ? "user" : "project") : process.argv[scopeIndex + 1];
+  const target = agentDir(scope);
+  if (process.argv.includes("--uninstall")) uninstallArchitectAgent(target);
+  else {
+    const changed = installArchitectAgent(target, { quiet: process.argv.includes("--session-start") });
+    if (changed && process.argv.includes("--session-start")) {
+      console.log(JSON.stringify({ systemMessage: "wr-architect: Codex agent installed; restart Codex to activate it." }));
+    }
+  }
+}

package/scripts/sync-codex-skills.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+import {
+  cpSync,
+  existsSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const skillsRoot = join(packageRoot, "skills");
+const backupRoot = join(packageRoot, ".pack-claude-skills");
+
+const preamble = `<!-- Generated from the Claude skill source during npm pack. -->
+
+> Codex runtime note: use \`request_user_input\` in Plan Mode for structured
+> questions. Resolve \`<architect-plugin-root>\` from this installed
+> \`SKILL.md\` path: it is two directories above the skill directory. Replace
+> that token with the absolute path before running a bundled script; never
+> search the adopter repository or rely on a \`wr-architect-*\` command being
+> on \`PATH\`. Spawn the installed \`wr-architect:agent\` custom agent with the
+> native Codex subagent tool, wait for it, and close the same agent.
+
+`;
+
+const commands = new Map([
+  ["wr-architect-detect-unoversighted", "bash \"<architect-plugin-root>/scripts/detect-unoversighted.sh\""],
+  ["wr-architect-generate-decisions-compendium", "bash \"<architect-plugin-root>/scripts/generate-decisions-compendium.sh\""],
+  ["wr-architect-is-decision-unconfirmed", "bash \"<architect-plugin-root>/scripts/is-decision-unconfirmed.sh\""],
+  ["wr-architect-mark-oversight-confirmed", "bash \"<architect-plugin-root>/scripts/mark-oversight-confirmed.sh\""],
+]);
+
+function transform(text) {
+  let result = text.replaceAll("AskUserQuestion", "request_user_input");
+  for (const [command, replacement] of commands) {
+    result = result.replaceAll(command, replacement);
+  }
+  result = result.replaceAll("packages/architect/", "<architect-plugin-root>/");
+  result = result.replace(
+    "is a `$PATH`-resolved shim (ADR-049 naming grammar) dispatching `<architect-plugin-root>/scripts/",
+    "is the bundled Codex script at `<architect-plugin-root>/scripts/",
+  );
+  if (!result.startsWith("---\n")) return preamble + result;
+  const end = result.indexOf("\n---\n", 4);
+  return end === -1
+    ? preamble + result
+    : result.slice(0, end + 5) + "\n" + preamble + result.slice(end + 5);
+}
+
+function skillFiles(root) {
+  return readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => join(root, entry.name, "SKILL.md"))
+    .filter(existsSync);
+}
+
+if (process.argv.includes("--restore-pack")) {
+  if (existsSync(backupRoot)) {
+    rmSync(skillsRoot, { recursive: true, force: true });
+    renameSync(backupRoot, skillsRoot);
+    console.log("Restored Claude architect skill source after pack.");
+  }
+  process.exit(0);
+}
+
+if (!process.argv.includes("--pack")) {
+  console.error("Usage: sync-codex-skills.mjs --pack | --restore-pack");
+  process.exit(2);
+}
+
+if (existsSync(backupRoot)) {
+  console.error(`Refusing to pack: backup already exists at ${backupRoot}`);
+  process.exit(1);
+}
+
+renameSync(skillsRoot, backupRoot);
+cpSync(backupRoot, skillsRoot, { recursive: true });
+const files = skillFiles(skillsRoot);
+for (const file of files) writeFileSync(file, transform(readFileSync(file, "utf8")), "utf8");
+console.log(`Packed ${files.length} Codex-facing architect skill file(s).`);

package/scripts/test/codex-pack-and-agent.bats

@@ -0,0 +1,86 @@
+#!/usr/bin/env bats
+
+setup() {
+  unset CODEX_THREAD_ID
+  PACKAGE="$(cd "$(dirname "$BATS_TEST_FILENAME")/../.." && pwd)"
+  TMP="$(mktemp -d)"
+}
+
+@test "agent scope selects project or user directory" {
+  mkdir -p "$TMP/project"
+  (cd "$TMP/project" && node "$PACKAGE/scripts/codex-agent.mjs" --scope project >/dev/null)
+  [ -f "$TMP/project/.codex/agents/wr-architect-agent.toml" ]
+
+  CODEX_HOME="$TMP/home" node "$PACKAGE/scripts/codex-agent.mjs" --scope user >/dev/null
+  [ -f "$TMP/home/agents/wr-architect-agent.toml" ]
+}
+
+@test "SessionStart repairs only Codex user registration" {
+  CODEX_HOME="$TMP/claude-home" node "$PACKAGE/scripts/codex-agent.mjs" --session-start
+  [ ! -d "$TMP/claude-home/agents" ]
+
+  run env CODEX_THREAD_ID=test CODEX_HOME="$TMP/codex-home" node "$PACKAGE/scripts/codex-agent.mjs" --session-start
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"restart Codex"* ]]
+  [ -f "$TMP/codex-home/agents/wr-architect-agent.toml" ]
+
+  run env CODEX_THREAD_ID=test CODEX_HOME="$TMP/codex-home" node "$PACKAGE/scripts/codex-agent.mjs" --session-start
+  [ "$status" -eq 0 ]
+  [ -z "$output" ]
+}
+
+@test "default installer remains Claude-only" {
+  run node "$PACKAGE/bin/install.mjs" --dry-run
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"claude plugin marketplace add"* ]]
+  [[ "$output" != *"codex plugin marketplace add"* ]]
+}
+
+@test "packed installer registers plugin and exact agent in isolated Codex home" {
+  run npm pack "$PACKAGE" --pack-destination "$TMP"
+  [ "$status" -eq 0 ]
+  export CODEX_HOME="$TMP/codex-installed"
+  run npm exec --yes --package "$TMP"/*.tgz -- windyroad-architect --runtime codex --scope user
+  [ "$status" -eq 0 ]
+  [ -f "$CODEX_HOME/agents/wr-architect-agent.toml" ]
+  run codex plugin list
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"wr-architect@windyroad-architect-local"* ]]
+}
+
+teardown() {
+  node "$PACKAGE/scripts/sync-codex-skills.mjs" --restore-pack >/dev/null 2>&1 || true
+  rm -rf "$TMP"
+}
+
+@test "npm pack emits Codex skills and restores Claude sources" {
+  before="$(shasum -a 256 "$PACKAGE"/skills/*/SKILL.md)"
+  run npm pack "$PACKAGE" --pack-destination "$TMP"
+  [ "$status" -eq 0 ]
+  [ "$before" = "$(shasum -a 256 "$PACKAGE"/skills/*/SKILL.md)" ]
+
+  tar -xzf "$TMP"/*.tgz -C "$TMP"
+  run grep -F 'bash "<architect-plugin-root>/scripts/generate-decisions-compendium.sh"' "$TMP/package/skills/review-decisions/SKILL.md"
+  [ "$status" -eq 0 ]
+  run grep -F 'use `request_user_input`' "$TMP/package/skills/review-decisions/SKILL.md"
+  [ "$status" -eq 0 ]
+  run grep -F 'wr-architect-generate-decisions-compendium' "$TMP/package/skills/review-decisions/SKILL.md"
+  [ "$status" -ne 0 ]
+  run grep -F 'packages/architect/' "$TMP/package/skills/create-adr/SKILL.md"
+  [ "$status" -ne 0 ]
+}
+
+@test "Codex agent install is exact, owned, and removable" {
+  export CODEX_HOME="$TMP/codex"
+  run node "$PACKAGE/scripts/codex-agent.mjs" --scope user
+  [ "$status" -eq 0 ]
+  target="$CODEX_HOME/agents/wr-architect-agent.toml"
+  grep -Fq 'name = "wr-architect:agent"' "$target"
+
+  printf '# user managed\n' > "$target"
+  node "$PACKAGE/scripts/codex-agent.mjs" --scope user >/dev/null
+  [ "$(cat "$target")" = "# user managed" ]
+
+  node "$PACKAGE/scripts/codex-agent.mjs" --scope user --uninstall
+  [ -e "$target" ]
+}

package/skills/capture-adr/SKILL.md

@@ -1,9 +1,20 @@
 ---
 name: wr-architect:capture-adr
-description: Lightweight ADR-capture skill for aside-invocation during foreground work — derives full MADR substance (Considered Options / Decision Drivers / Consequences / Confirmation / Reassessment) silently from the in-session decision context, single commit, no inline architect-review handoff, no AskUserQuestion. Lightweight means zero-interaction + single-commit, not skimpy content (RFC-045). Use this when the user (or agent mid-iter) wants to record a decision quickly without the ~10-15 turn ceremony of /wr-architect:create-adr. For interactive full-intake new ADR creation where the user authors the options + drivers + consequences + confirmation, use /wr-architect:create-adr.
+description: Lightweight ADR-capture skill for aside-invocation during foreground work — derives full MADR substance (Considered Options / Decision Drivers / Consequences / Confirmation / Reassessment) silently from the in-session decision context, single commit, no inline architect-review handoff, no request_user_input. Lightweight means zero-interaction + single-commit, not skimpy content (RFC-045). Use this when the user (or agent mid-iter) wants to record a decision quickly without the ~10-15 turn ceremony of /wr-architect:create-adr. For interactive full-intake new ADR creation where the user authors the options + drivers + consequences + confirmation, use /wr-architect:create-adr.
 allowed-tools: Read, Write, Edit, Bash, Grep, Glob
 ---
 
+<!-- Generated from the Claude skill source during npm pack. -->
+
+> Codex runtime note: use `request_user_input` in Plan Mode for structured
+> questions. Resolve `<architect-plugin-root>` from this installed
+> `SKILL.md` path: it is two directories above the skill directory. Replace
+> that token with the absolute path before running a bundled script; never
+> search the adopter repository or rely on a `wr-architect-*` command being
+> on `PATH`. Spawn the installed `wr-architect:agent` custom agent with the
+> native Codex subagent tool, wait for it, and close the same agent.
+
+
 # Capture ADR Skill
 
 Capture an Architecture Decision Record quickly during foreground work. Lightweight aside-invocation surface that complements the heavyweight `/wr-architect:create-adr` flow. See `REFERENCE.md` in this directory for rationale, edge cases, contract trade-offs, and the ADR-032 foreground-lightweight-capture amendment.
@@ -17,13 +28,13 @@ This skill is the foreground-lightweight-capture variant of `/wr-architect:creat
 - **User-driven design conversations**: user resolves options (a)/(b)/(c) during conversational work; today the settlement gets buried in a problem-ticket RCA section instead of codified.
 
 **Use `/wr-architect:create-adr` instead** when:
-- The user wants to walk the full interactive intake flow and author the sections themselves (Considered Options ≥2, Decision Drivers, full Consequences, Confirmation criteria, Pros/Cons of Options via AskUserQuestion).
+- The user wants to walk the full interactive intake flow and author the sections themselves (Considered Options ≥2, Decision Drivers, full Consequences, Confirmation criteria, Pros/Cons of Options via request_user_input).
 - The decision is contested or under-specified in-session — silent derivation needs a real decision context to derive FROM; if the options were never actually weighed, create-adr's interactive intake is the honest surface.
 - The decision needs immediate architect review + acceptance (capture-adr writes `.proposed.md`; acceptance review is a follow-up via `/wr-architect:create-adr` or direct architect-agent review).
 
 ## Rule 6 audit (per ADR-032 + ADR-013)
 
-This skill has **zero AskUserQuestion branches** by design. Each potentially-interactive decision is framework-mediated per ADR-044:
+This skill has **zero request_user_input branches** by design. Each potentially-interactive decision is framework-mediated per ADR-044:
 
 | Decision | Resolution |
 |----------|-----------|
@@ -168,7 +179,7 @@ Single `Write` to `docs/decisions/<NNN>-<kebab-title>.proposed.md`.
 After the ADR lands, regenerate `docs/decisions/README.md` so the architect-agent routine load surface includes the new entry:
 
 ```bash
-wr-architect-generate-decisions-compendium
+bash "<architect-plugin-root>/scripts/generate-decisions-compendium.sh"
 ```
 
 The compendium is the architect agent's primary load surface per ADR-077; capture-adr owns keeping it fresh (skills + agent are PRIMARY; the `architect-compendium-refresh-discipline.sh` hook is the safety-net backstop). The next step stages both files together.
@@ -206,21 +217,21 @@ The trailing pointer is **not optional** — it is the user-visible signal that
 
 **Confirm-every-ADR gate (ADR-064):** a capture-adr ADR is recorded `proposed` with derived substance but WITHOUT human review of that substance. It must NOT be promoted to `accepted` until a human has ratified the derived content via `/wr-architect:review-decisions` (or a `/wr-architect:create-adr` review-and-confirm pass). Capture records the decision quickly; the ratification — not the capture — is what gives it human oversight. This is prong 1 of P283 (lift auto-/quick-recorded decisions to human-confirmed before they stand).
 
-**Oversight marker discipline (ADR-066 amendment 2026-06-02 / P348).** A capture-adr ADR MUST be born `human-oversight: unconfirmed` — NOT `confirmed`. Capture is the AFK-friendly aside surface; there is no substance-confirm `AskUserQuestion` pass in this flow, so `confirmed` would be a hollow marker (the P348 bug class). The `architect-oversight-marker-discipline.sh` PreToolUse hook will DENY any Edit/Write that introduces `human-oversight: confirmed` without a matching session-scoped evidence marker. The frontmatter (Step 3 above) MUST include `human-oversight: unconfirmed` so the ADR enters the world honestly self-identified as needing user confirmation. The drain (`/wr-architect:review-decisions`) and a `/wr-architect:create-adr <NNN>` review pass are the surfaces that legitimately promote it to `confirmed` via `wr-architect-mark-oversight-confirmed` + the gated marker write.
+**Oversight marker discipline (ADR-066 amendment 2026-06-02 / P348).** A capture-adr ADR MUST be born `human-oversight: unconfirmed` — NOT `confirmed`. Capture is the AFK-friendly aside surface; there is no substance-confirm `request_user_input` pass in this flow, so `confirmed` would be a hollow marker (the P348 bug class). The `architect-oversight-marker-discipline.sh` PreToolUse hook will DENY any Edit/Write that introduces `human-oversight: confirmed` without a matching session-scoped evidence marker. The frontmatter (Step 3 above) MUST include `human-oversight: unconfirmed` so the ADR enters the world honestly self-identified as needing user confirmation. The drain (`/wr-architect:review-decisions`) and a `/wr-architect:create-adr <NNN>` review pass are the surfaces that legitimately promote it to `confirmed` via `bash "<architect-plugin-root>/scripts/mark-oversight-confirmed.sh"` + the gated marker write.
 
 ## Composition with create-adr
 
 | Concern | create-adr | capture-adr |
 |---------|------------|-------------|
-| Considered Options | AskUserQuestion gathering ≥2 options + pros/cons (user authors) | Silent derivation of chosen + actually-rejected alternatives (agent authors, human ratifies at drain) |
-| Decision Drivers | AskUserQuestion gathering | Silent derivation from decision context |
-| Consequences | AskUserQuestion gathering Good/Neutral/Bad | Silent derivation — real Good/Neutral/Bad trade-off analysis at capture |
-| Confirmation | AskUserQuestion gathering testable criteria | Silent derivation of testable criteria |
-| Reassessment criteria | AskUserQuestion gathering | Silent derivation + 3-month default date |
+| Considered Options | request_user_input gathering ≥2 options + pros/cons (user authors) | Silent derivation of chosen + actually-rejected alternatives (agent authors, human ratifies at drain) |
+| Decision Drivers | request_user_input gathering | Silent derivation from decision context |
+| Consequences | request_user_input gathering Good/Neutral/Bad | Silent derivation — real Good/Neutral/Bad trade-off analysis at capture |
+| Confirmation | request_user_input gathering testable criteria | Silent derivation of testable criteria |
+| Reassessment criteria | request_user_input gathering | Silent derivation + 3-month default date |
 | Frontmatter | Full populated frontmatter | Derived values (git user.name etc.) — no sentinels |
-| Decision-boundary check (Step 2b) | Multi-decision split via AskUserQuestion | Out of scope (one ADR per invocation) |
+| Decision-boundary check (Step 2b) | Multi-decision split via request_user_input | Out of scope (one ADR per invocation) |
 | Supersession (Step 6) | Handles `git mv .accepted.md → .superseded.md` | Out of scope (capture is creation only) |
-| Confirm-with-user (Step 5) | AskUserQuestion review pass at intake | Deferred to the self-firing oversight drain (`human-oversight: unconfirmed` → SessionStart nudge → `/wr-architect:review-decisions`) |
+| Confirm-with-user (Step 5) | request_user_input review pass at intake | Deferred to the self-firing oversight drain (`human-oversight: unconfirmed` → SessionStart nudge → `/wr-architect:review-decisions`) |
 | Commit grain | One commit per intake | One commit per capture |
 | Use case | Full-intake new ADR; user wants to author the flow interactively | Aside-invocation; capture-and-continue |
 
@@ -237,7 +248,7 @@ The two skills share the `docs/decisions/*.proposed.md` directory and the next-I
 - **ADR-044** — decision-delegation contract (framework-mediated mechanical-stage carve-outs).
 - **ADR-049** — bin/ on PATH (capture-adr is self-contained; no shim required, same as create-adr).
 - **ADR-052** — behavioural-tests-default for skill testing.
-- `packages/architect/skills/create-adr/SKILL.md` — heavyweight intake counterpart.
-- `packages/architect/agents/agent.md` — wr-architect:agent review surface; reviews `.proposed.md` ADRs at acceptance delegation.
+- `<architect-plugin-root>/skills/create-adr/SKILL.md` — heavyweight intake counterpart.
+- `<architect-plugin-root>/agents/agent.md` — wr-architect:agent review surface; reviews `.proposed.md` ADRs at acceptance delegation.
 
 $ARGUMENTS

package/skills/create-adr/SKILL.md

@@ -1,16 +1,27 @@
 ---
 name: wr-architect:create-adr
 description: Create a new Architecture Decision Record (MADR 4.0) in docs/decisions/. Examines existing decisions, asks about the problem and options, and writes a properly formatted ADR.
-allowed-tools: Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, request_user_input
 ---
 
+<!-- Generated from the Claude skill source during npm pack. -->
+
+> Codex runtime note: use `request_user_input` in Plan Mode for structured
+> questions. Resolve `<architect-plugin-root>` from this installed
+> `SKILL.md` path: it is two directories above the skill directory. Replace
+> that token with the absolute path before running a bundled script; never
+> search the adopter repository or rely on a `wr-architect-*` command being
+> on `PATH`. Spawn the installed `wr-architect:agent` custom agent with the
+> native Codex subagent tool, wait for it, and close the same agent.
+
+
 # Architecture Decision Record Generator
 
 Create a new ADR in `docs/decisions/` following MADR 4.0 format. The wr-architect:agent reviews these files to enforce architectural compliance.
 
 ## Needs-Direction handoff + confirm-every-ADR (ADR-064)
 
-When a `wr-architect:agent` review returns a **NEEDS DIRECTION** verdict (a new decision with 2+ viable options and no pinned direction, per ADR-064), the option choice is the user's, not the agent's — this skill is the translation surface. The architect's named question + options become the Step 2 cat-1 `AskUserQuestion` calls (Considered Options / Decision Outcome), and the Step 5 confirm is the load-bearing **review-and-confirm-every-ADR** gate: an ADR must not stand as a human-oversighted decision (reach `accepted`) without that confirm pass. A `/wr-architect:capture-adr` ADR — zero-ask, with its decision pre-pinned in `$ARGUMENTS` and its remaining sections silently DERIVED at capture per the ADR-032 derived-substance amendment (RFC-045) — must still have its derived substance human-ratified (via `/wr-architect:review-decisions` or this skill's confirm) before promotion to `accepted`. When direction IS already pinned (same-turn / same-session / accepted ADR / RISK-POLICY.md / CLAUDE.md mandatory rule), act on it — do not re-ask (P132 inverse-P078 guard).
+When a `wr-architect:agent` review returns a **NEEDS DIRECTION** verdict (a new decision with 2+ viable options and no pinned direction, per ADR-064), the option choice is the user's, not the agent's — this skill is the translation surface. The architect's named question + options become the Step 2 cat-1 `request_user_input` calls (Considered Options / Decision Outcome), and the Step 5 confirm is the load-bearing **review-and-confirm-every-ADR** gate: an ADR must not stand as a human-oversighted decision (reach `accepted`) without that confirm pass. A `/wr-architect:capture-adr` ADR — zero-ask, with its decision pre-pinned in `$ARGUMENTS` and its remaining sections silently DERIVED at capture per the ADR-032 derived-substance amendment (RFC-045) — must still have its derived substance human-ratified (via `/wr-architect:review-decisions` or this skill's confirm) before promotion to `accepted`. When direction IS already pinned (same-turn / same-session / accepted ADR / RISK-POLICY.md / CLAUDE.md mandatory rule), act on it — do not re-ask (P132 inverse-P078 guard).
 
 ## Steps
 
@@ -24,34 +35,34 @@ Scan for existing ADRs:
 
 ### 2. Gather context (P132 derive-first; ADR-044 category-4 silent-framework on derivable fields; category-1 direction-setting only on user-judgment fields)
 
-**Shared dispatch helper**: this surface invokes `packages/architect/lib/derive-first-dispatch.sh` for the canonical slug derivation (Title) and I2-isomorphic stderr advisory format. The canonical source-of-truth lives at `packages/shared/derive-first-dispatch.sh`; the architect package carries a synced per-package copy at `packages/architect/lib/derive-first-dispatch.sh` per ADR-017 (Shared code duplicated into per-package lib/ kept in sync). The same helper is sourced by `/wr-itil:capture-problem` Step 1.5, `/wr-itil:manage-incident` Step 4, and `/wr-itil:manage-problem` Step 4 (each from its own per-package `packages/itil/lib/` copy); drift in the advisory shape across the four surfaces re-opens P132.
+**Shared dispatch helper**: this surface invokes `<architect-plugin-root>/lib/derive-first-dispatch.sh` for the canonical slug derivation (Title) and I2-isomorphic stderr advisory format. The canonical source-of-truth lives at `packages/shared/derive-first-dispatch.sh`; the architect package carries a synced per-package copy at `<architect-plugin-root>/lib/derive-first-dispatch.sh` per ADR-017 (Shared code duplicated into per-package lib/ kept in sync). The same helper is sourced by `/wr-itil:capture-problem` Step 1.5, `/wr-itil:manage-incident` Step 4, and `/wr-itil:manage-problem` Step 4 (each from its own per-package `packages/itil/lib/` copy); drift in the advisory shape across the four surfaces re-opens P132.
 
-**Derive-first dispatch.** ADR creation is fundamentally user-judgment-bound — only the user knows the decision space, the alternatives considered, and the chosen-option rationale. But the **declaration-skeleton fields** (Title, status, date, reassessment-date, context-and-problem-statement) carry observable evidence in the user's prose, the working tree, and the wall-clock — the framework can resolve them without firing `AskUserQuestion`. The retained `AskUserQuestion` surfaces (Decision Drivers, Considered Options, Decision Outcome, Consequences, Confirmation, decision-makers) are the genuine **category-1 direction-setting** fields.
+**Derive-first dispatch.** ADR creation is fundamentally user-judgment-bound — only the user knows the decision space, the alternatives considered, and the chosen-option rationale. But the **declaration-skeleton fields** (Title, status, date, reassessment-date, context-and-problem-statement) carry observable evidence in the user's prose, the working tree, and the wall-clock — the framework can resolve them without firing `request_user_input`. The retained `request_user_input` surfaces (Decision Drivers, Considered Options, Decision Outcome, Consequences, Confirmation, decision-makers) are the genuine **category-1 direction-setting** fields.
 
 The P132 inverse-P078 trap (`docs/problems/known-error/132-...md`) is the load-bearing motivation. create-adr Step 2 is the **fourth declaration-skill surface** under Phase 2a to ship the derive-first dispatch (after `/wr-itil:capture-problem` Step 1.5, `/wr-itil:manage-incident` Step 4, and `/wr-itil:manage-problem` Step 4). The pattern is I2-isomorphic across all four — the stderr advisory shape `<skill>: derived <field>=<value> from <source>; <reversibility>` is identical beyond substituted values per the helper's `emit_stderr_advisory` function (architect verdict 2026-05-16 P132 Phase 2a-iii-B: pattern lock-in across the 4-surface set).
 
-Resolve each field via the following dispatch. **The order is load-bearing** — every derivable field resolves silently with a stderr advisory citing the source; only user-judgment fields fire `AskUserQuestion`.
+Resolve each field via the following dispatch. **The order is load-bearing** — every derivable field resolves silently with a stderr advisory citing the source; only user-judgment fields fire `request_user_input`.
 
 | Field | Dispatch | ADR-044 category |
 |-------|----------|------------------|
-| **Title** | Derive silently. Kebab-case the first 8-10 non-stopword tokens of the user's prose problem-statement (same slug derivation as `/wr-itil:capture-problem` Step 1.4, `/wr-itil:manage-incident` Step 4, and `/wr-itil:manage-problem` Step 4 — uses the shared helper's `derive_kebab_slug` function). At intake the derived slug typically encodes the **question** (the problem-statement is question-shaped); the title-as-outcome convention in Step 2a below names the GOOD/BAD shapes, and Step 5a's mechanical retitle-after-decision check renames the file to the chosen-option's outcome shape after substance-confirm passes. Emit stderr advisory: `create-adr: derived title='<slug>' from problem-statement; re-invoke with the desired title or rename the file if the slug is wrong`. Do NOT fire AskUserQuestion. | category-4 silent-framework |
+| **Title** | Derive silently. Kebab-case the first 8-10 non-stopword tokens of the user's prose problem-statement (same slug derivation as `/wr-itil:capture-problem` Step 1.4, `/wr-itil:manage-incident` Step 4, and `/wr-itil:manage-problem` Step 4 — uses the shared helper's `derive_kebab_slug` function). At intake the derived slug typically encodes the **question** (the problem-statement is question-shaped); the title-as-outcome convention in Step 2a below names the GOOD/BAD shapes, and Step 5a's mechanical retitle-after-decision check renames the file to the chosen-option's outcome shape after substance-confirm passes. Emit stderr advisory: `create-adr: derived title='<slug>' from problem-statement; re-invoke with the desired title or rename the file if the slug is wrong`. Do NOT fire request_user_input. | category-4 silent-framework |
 | **status** (frontmatter) | Always `proposed` for new ADRs per Step 4 template convention. No ask, no advisory needed — SKILL convention is unambiguous. | category-4 silent-framework |
 | **date** (frontmatter) | Today's date (`date +%Y-%m-%d`) per Step 4 template. No ask, no advisory needed — wall-clock derivation is unambiguous. | category-4 silent-framework |
 | **reassessment-date** (frontmatter) | Today + 3 months (`date -v+3m +%Y-%m-%d` on BSD-date / `date -d '+3 months' +%Y-%m-%d` on GNU-date) per Step 4 template. Emit stderr advisory: `create-adr: derived reassessment-date='<YYYY-MM-DD>' from today+3-months default; re-invoke with --reassessment-date= or edit the frontmatter to override`. | category-4 silent-framework |
-| **Context and Problem Statement** | Pull verbatim from `$ARGUMENTS` prose into the Step 4 template's `## Context and Problem Statement` section. **Fallback**: when `$ARGUMENTS` carries NO problem prose (only flags or empty body), fire AskUserQuestion as the genuine category-1 direction-setting surface — *"only the user knows the problem being solved."* Question text: *"What problem does this ADR solve? Why is a decision needed now?"* This is the prose-fallback path; the typical maintainer invocation carries the problem-statement in arguments. | category-1 direction-setting (fallback only; category-4 silent-framework on the typical path where prose is present) |
-| **decision-makers** | Retain AskUserQuestion. Architect verdict 2026-05-16: silent derivation from `git config user.name` would conflate "who committed the ADR" with "who made the decision" — a multi-party decision is one of the canonical mis-attribution risks ADR-013's identity model rejects. Once-per-ADR ask is low-friction in absolute terms. Question text: *"Who are the decision-makers?"* | category-1 direction-setting |
-| **Decision Drivers** | Retain AskUserQuestion. Only the user knows which factors weighted the decision. This is the create-adr-equivalent of manage-problem Step 4's Description (the user-judgment surface). | category-1 direction-setting |
-| **Considered Options** | Retain AskUserQuestion. Only the user knows the alternatives evaluated. ADR-044 cat-5 (taste) would only apply if the framework could offer 2+ valid options — but the alternative space is genuinely user-knowledge (the framework can offer "do nothing" + a status-quo option but the actual alternatives are the user's). Architect verdict 2026-05-16: confirmed cat-1 over cat-5. Per MADR 4.0: ≥2 alternatives including "do nothing" where applicable. | category-1 direction-setting |
-| **Decision Outcome** / **Rationale** | Retain AskUserQuestion. The chosen option + primary reason for the choice. | category-1 direction-setting |
-| **Consequences** (Good / Neutral / Bad) | Retain AskUserQuestion. Only the user knows the expected consequences of the decision. | category-1 direction-setting |
-| **Confirmation** | Retain AskUserQuestion. Testable verification criteria. | category-1 direction-setting |
-| **consulted** / **informed** (frontmatter) | Default to empty list per Step 4 template; fold into the decision-makers AskUserQuestion call if the user surfaces stakeholders. | category-4 silent-framework (default empty); category-1 (when user cites stakeholders) |
+| **Context and Problem Statement** | Pull verbatim from `$ARGUMENTS` prose into the Step 4 template's `## Context and Problem Statement` section. **Fallback**: when `$ARGUMENTS` carries NO problem prose (only flags or empty body), fire request_user_input as the genuine category-1 direction-setting surface — *"only the user knows the problem being solved."* Question text: *"What problem does this ADR solve? Why is a decision needed now?"* This is the prose-fallback path; the typical maintainer invocation carries the problem-statement in arguments. | category-1 direction-setting (fallback only; category-4 silent-framework on the typical path where prose is present) |
+| **decision-makers** | Retain request_user_input. Architect verdict 2026-05-16: silent derivation from `git config user.name` would conflate "who committed the ADR" with "who made the decision" — a multi-party decision is one of the canonical mis-attribution risks ADR-013's identity model rejects. Once-per-ADR ask is low-friction in absolute terms. Question text: *"Who are the decision-makers?"* | category-1 direction-setting |
+| **Decision Drivers** | Retain request_user_input. Only the user knows which factors weighted the decision. This is the create-adr-equivalent of manage-problem Step 4's Description (the user-judgment surface). | category-1 direction-setting |
+| **Considered Options** | Retain request_user_input. Only the user knows the alternatives evaluated. ADR-044 cat-5 (taste) would only apply if the framework could offer 2+ valid options — but the alternative space is genuinely user-knowledge (the framework can offer "do nothing" + a status-quo option but the actual alternatives are the user's). Architect verdict 2026-05-16: confirmed cat-1 over cat-5. Per MADR 4.0: ≥2 alternatives including "do nothing" where applicable. | category-1 direction-setting |
+| **Decision Outcome** / **Rationale** | Retain request_user_input. The chosen option + primary reason for the choice. | category-1 direction-setting |
+| **Consequences** (Good / Neutral / Bad) | Retain request_user_input. Only the user knows the expected consequences of the decision. | category-1 direction-setting |
+| **Confirmation** | Retain request_user_input. Testable verification criteria. | category-1 direction-setting |
+| **consulted** / **informed** (frontmatter) | Default to empty list per Step 4 template; fold into the decision-makers request_user_input call if the user surfaces stakeholders. | category-4 silent-framework (default empty); category-1 (when user cites stakeholders) |
 
 **Inferred fields (no ask, no advisory needed)**:
 
 - **supersedes** (frontmatter): empty list by default; populated only via Step 6 supersession handling when the user explicitly cites a superseded decision.
 
-**Stderr advisory contract**: each derived field emits a SINGLE line to stderr (NOT stdout, NOT in the ADR body) via the shared helper's `emit_stderr_advisory` function in `packages/architect/lib/derive-first-dispatch.sh`. The canonical format produced by the helper:
+**Stderr advisory contract**: each derived field emits a SINGLE line to stderr (NOT stdout, NOT in the ADR body) via the shared helper's `emit_stderr_advisory` function in `<architect-plugin-root>/lib/derive-first-dispatch.sh`. The canonical format produced by the helper:
 
 ```
 create-adr: derived <field>=<value> from <source>; <reversibility-clause>
@@ -61,11 +72,11 @@ The advisory text shape is I2-isomorphic — same sentence structure across all
 
 **ADR-026 cost-source grounding**: each derived field cites its source in the advisory (problem-statement token sequence for Title; today's date for date / reassessment-date; default convention for status). The `re-invoke or update if mis-rated` clause carries the reversibility marker ADR-026 mandates for ungrounded outputs.
 
-**AFK fail-safe (ADR-013 Rule 6)**: under AFK orchestration, derivable fields (Title / status / date / reassessment-date / Context-when-prose-present) resolve without interactive input. The 6 retained cat-1 AskUserQuestion surfaces (decision-makers / Decision Drivers / Considered Options / Decision Outcome / Consequences / Confirmation) WILL halt AFK execution — that is **correct behaviour** because ADR creation is genuinely user-judgment-bound (the user authors the decision; the framework cannot). JTBD-006 protection: AFK orchestrators that need ADR creation should call `/wr-architect:capture-adr` (the lightweight aside surface), which derives ALL section content silently at capture (ADR-032 derived-substance amendment, RFC-045) and records it `human-oversight: unconfirmed`; the user ratifies or amends the derived substance at the next interactive `/wr-architect:review-decisions` drain (surfaced by the self-firing SessionStart oversight nudge). The cat-1 classification above governs THIS interactive intake surface — on the capture surface the same fields are derived-provisional-then-ratified, not asked (the ADR-067 pattern); the two surfaces do not conflict.
+**AFK fail-safe (ADR-013 Rule 6)**: under AFK orchestration, derivable fields (Title / status / date / reassessment-date / Context-when-prose-present) resolve without interactive input. The 6 retained cat-1 request_user_input surfaces (decision-makers / Decision Drivers / Considered Options / Decision Outcome / Consequences / Confirmation) WILL halt AFK execution — that is **correct behaviour** because ADR creation is genuinely user-judgment-bound (the user authors the decision; the framework cannot). JTBD-006 protection: AFK orchestrators that need ADR creation should call `/wr-architect:capture-adr` (the lightweight aside surface), which derives ALL section content silently at capture (ADR-032 derived-substance amendment, RFC-045) and records it `human-oversight: unconfirmed`; the user ratifies or amends the derived substance at the next interactive `/wr-architect:review-decisions` drain (surfaced by the self-firing SessionStart oversight nudge). The cat-1 classification above governs THIS interactive intake surface — on the capture surface the same fields are derived-provisional-then-ratified, not asked (the ADR-067 pattern); the two surfaces do not conflict.
 
 **Cross-skill consistency note**: this is the **fourth declaration-skill surface** to ship the derive-first dispatch (after `/wr-itil:capture-problem` Step 1.5, `/wr-itil:manage-incident` Step 4, and `/wr-itil:manage-problem` Step 4 in commits b7cc645 / 43255d2 / 30fd22b). Phase 2a-iii-B (2026-05-16) closes Phase 2a's full 4-surface scope — the I2-isomorphic stderr advisory format is now locked-in across `capture-problem`, `manage-incident`, `manage-problem`, AND `create-adr` via the shared helper at `packages/shared/derive-first-dispatch.sh` with synced per-package lib/ copies. Per ADR-017, drift between copies is caught by `npm run check:derive-first-dispatch` in CI.
 
-If the user has already provided context in `$ARGUMENTS` or earlier conversation, use what they've given and only fire AskUserQuestion for the cat-1 fields still missing.
+If the user has already provided context in `$ARGUMENTS` or earlier conversation, use what they've given and only fire request_user_input for the cat-1 fields still missing.
 
 ### 2a. Title-as-outcome convention (P354)
 
@@ -100,14 +111,14 @@ Before writing the ADR file, perform a decision-boundary analysis on the gathere
 - **Single decision** (one coherent question with one chosen option): proceed directly to step 3.
 - **Multiple decisions** (two or more distinct questions, different components, or different decision drivers that do not share the same trade-off): present a split prompt.
 
-**Split prompt** — use `AskUserQuestion`:
+**Split prompt** — use `request_user_input`:
 - `header: "Multi-decision input"`
 - `multiSelect: false`
 - Options:
   1. `Split into separate ADRs (Recommended)` — description: "Create one ADR per distinct decision, with consecutive IDs. Each ADR can be accepted, rejected, or superseded independently."
   2. `Keep as a single ADR` — description: "Create one ADR covering all decisions. Use this only if the decisions are so tightly coupled that they cannot be made independently."
 
-**Non-interactive fallback**: When `AskUserQuestion` is unavailable (e.g., non-interactive/AFK mode), automatically split into separate ADRs with consecutive IDs and note the auto-split in output. Do not block creation.
+**Non-interactive fallback**: When `request_user_input` is unavailable (e.g., non-interactive/AFK mode), automatically split into separate ADRs with consecutive IDs and note the auto-split in output. Do not block creation.
 
 **ADR-013 Rule 6 carve-out audit (P352, 2026-06-06 amendment)**: the universal AFK default is **queue-and-continue**; this site is a documented **AUTO-DEFAULT** carve-out. Authorising principle: policy-authorised safe default per ADR-044 category 4 (silent framework). Splitting is fully reversible (manual combine via supersession), the framework's WSJF / lifecycle model rewards explicit per-decision ranking, and "split when in doubt" is the persona-correct safe heuristic for JTBD-006 (the loop progresses; over-splits are cheap to combine; halt would cost more loop throughput than the over-split risk). Note: the Step 5 substance-confirm HALT below is a separate carve-out authorised by ADR-074 — substance-confirm cannot AUTO-DEFAULT because the dependent work (Decision Outcome / Consequences / Confirmation / Pros and Cons drafting) is built ON the chosen option.
 
@@ -216,28 +227,28 @@ Use today's date for the `date` field. Set `reassessment-date` to 3 months from
 
 ### 5. Confirm with the user — two separate fires (P339 + P340)
 
-Step 5 fires TWO separate `AskUserQuestion` passes, in this order:
+Step 5 fires TWO separate `request_user_input` passes, in this order:
 
 1. **Substance-confirm fire** — the user picks the chosen option from the considered-options set. THIS fire gates the born-confirmed marker write.
 2. **Draft-quality review fire** (optional, after substance-confirm passes) — narrow questions on prose quality, consulted/informed list, edge cases. Does NOT gate the marker.
 
-This split closes the P339 / P340 gap: previously Step 5 fired ONE bundled "review pass" AskUserQuestion ("does the problem statement + Decision Outcome (Option X) capture the situation? — yes/no/edits/different-option"), and the user's "Yes" was treated as substance-ratification when in practice the user was confirming draft quality alone. The bundled answer landed the human-oversight marker on substance the user never explicitly affirmed. ADR-078 commit 5196e3d is the in-session exemplar; user correction 2026-05-31: *"I never approved the scripted extraction. You are supposed to run decisions by me"* + *"the previous iteration of the decision, with the programmatic extraction was not approved. How did that ADR skip ratification?"*. ADR-074 § Enforcement surface 1 is what this step now operationalises at the create-adr surface.
+This split closes the P339 / P340 gap: previously Step 5 fired ONE bundled "review pass" request_user_input ("does the problem statement + Decision Outcome (Option X) capture the situation? — yes/no/edits/different-option"), and the user's "Yes" was treated as substance-ratification when in practice the user was confirming draft quality alone. The bundled answer landed the human-oversight marker on substance the user never explicitly affirmed. ADR-078 commit 5196e3d is the in-session exemplar; user correction 2026-05-31: *"I never approved the scripted extraction. You are supposed to run decisions by me"* + *"the previous iteration of the decision, with the programmatic extraction was not approved. How did that ADR skip ratification?"*. ADR-074 § Enforcement surface 1 is what this step now operationalises at the create-adr surface.
 
 #### 5a. Substance-confirm fire (P340 — load-bearing for the marker write)
 
 The substance-confirm fire MUST satisfy ALL FIVE interaction-pattern requirements pinned by user direction 2026-05-31 (encoded in ADR-064 + ADR-066 amendments + P340 § Root Cause Analysis):
 
-1. **Briefing in main-turn prose** — emit the considered-options + selected-option + rationale as plain main-turn text BEFORE the `AskUserQuestion` fires. The briefing carries the substance-of-the-decision in a form the user can read and reason about. Long AskUserQuestion text is NOT readable on some devices (mobile clients, accessibility tooling, certain notification surfaces); long prose + short question IS readable across the full device matrix. The split is load-bearing — briefing carries the briefing; the AskUserQuestion stays narrow.
+1. **Briefing in main-turn prose** — emit the considered-options + selected-option + rationale as plain main-turn text BEFORE the `request_user_input` fires. The briefing carries the substance-of-the-decision in a form the user can read and reason about. Long request_user_input text is NOT readable on some devices (mobile clients, accessibility tooling, certain notification surfaces); long prose + short question IS readable across the full device matrix. The split is load-bearing — briefing carries the briefing; the request_user_input stays narrow.
 
-2. **AskUserQuestion is option-shaped, NOT yes/no** — the `options:` array MUST contain each considered option as a selectable option (one entry per considered option). The user picks the substantive direction positively (chooses ONE option), not by clicking "yes" on a bundled "is this OK?" question. Yes/no shape is forbidden at this fire.
+2. **request_user_input is option-shaped, NOT yes/no** — the `options:` array MUST contain each considered option as a selectable option (one entry per considered option). The user picks the substantive direction positively (chooses ONE option), not by clicking "yes" on a bundled "is this OK?" question. Yes/no shape is forbidden at this fire.
 
-3. **No IDs as explainers** — neither the briefing prose nor the `AskUserQuestion` text/options/descriptions may use IDs (`ADR-NNN`, `P-NNN`, `JTBD-NNN`, `RFC-NNN`) as the carrier of meaning. The user does NOT have access to those IDs on all devices (mobile clients without the project filesystem; notification surfaces; accessibility readers that can't follow links). Every option's substance MUST be self-contained in the briefing prose + the option label/description. IDs may appear ONLY as audit-trail annotations after a self-contained explanation, never as the explanation itself.
+3. **No IDs as explainers** — neither the briefing prose nor the `request_user_input` text/options/descriptions may use IDs (`ADR-NNN`, `P-NNN`, `JTBD-NNN`, `RFC-NNN`) as the carrier of meaning. The user does NOT have access to those IDs on all devices (mobile clients without the project filesystem; notification surfaces; accessibility readers that can't follow links). Every option's substance MUST be self-contained in the briefing prose + the option label/description. IDs may appear ONLY as audit-trail annotations after a self-contained explanation, never as the explanation itself.
 
-4. **Informed-decision-without-external-document-lookup** — the briefing + question + options is a self-contained surface. If understanding a chosen option requires the user to first read another document, the briefing has failed. The briefing carries enough context that a user reading ONLY the main-turn text and the AskUserQuestion can pick.
+4. **Informed-decision-without-external-document-lookup** — the briefing + question + options is a self-contained surface. If understanding a chosen option requires the user to first read another document, the briefing has failed. The briefing carries enough context that a user reading ONLY the main-turn text and the request_user_input can pick.
 
 5. **Each option's substance is the actual chosen option** — the options array contains the actual considered options from the ADR draft (Option A / Option B / Option C / ... as worded in the Considered Options section), NOT meta-options ("yes accept draft" / "ask differently"). The label is a short readable phrase; the description carries the trade-off. Picking an option IS the substantive choice.
 
-**Suggested AskUserQuestion shape** (each considered option as one selectable option):
+**Suggested request_user_input shape** (each considered option as one selectable option):
 
 ```text
 question: "Which option should this ADR record as the chosen direction?"
@@ -254,7 +265,7 @@ options:
 **Born-confirmed marker write (ADR-066 — tightened by P340 amendment + structurally gated by P348 amendment 2026-06-02).** The marker write fires ONLY when the substance-confirm answer specifies a substantive option from the considered-options set AND that option matches the option the draft was authored against. On a substantive match, IMMEDIATELY call the marker-evidence helper THEN insert the two lines:
 
 ```bash
-wr-architect-mark-oversight-confirmed docs/decisions/<NNN>-<slug>.proposed.md
+bash "<architect-plugin-root>/scripts/mark-oversight-confirmed.sh" docs/decisions/<NNN>-<slug>.proposed.md
 ```
 
 ```yaml
@@ -262,7 +273,7 @@ human-oversight: confirmed
 oversight-date: YYYY-MM-DD   # today
 ```
 
-The `wr-architect-mark-oversight-confirmed` call writes the session-scoped evidence marker (`/tmp/oversight-confirmed-<sha>-<sid>`) that the `architect-oversight-marker-discipline.sh` PreToolUse hook reads to authorise the subsequent Edit/Write — without the helper call, the hook will DENY the marker write. AFK iter subprocesses spawned via `claude -p` have no `AskUserQuestion` access; they MUST write `human-oversight: unconfirmed` instead (the AFK fallback enum value codified in ADR-066 amendment 2026-06-02), which the drain (`/wr-architect:review-decisions`) later promotes interactively. Calling the helper without a real user substance-confirm event is the P348 hollow-marker bug — every legitimate marker write traces back to an `AskUserQuestion` answer in the same turn.
+The `bash "<architect-plugin-root>/scripts/mark-oversight-confirmed.sh"` call writes the session-scoped evidence marker (`/tmp/oversight-confirmed-<sha>-<sid>`) that the `architect-oversight-marker-discipline.sh` PreToolUse hook reads to authorise the subsequent Edit/Write — without the helper call, the hook will DENY the marker write. AFK iter subprocesses spawned via `claude -p` have no `request_user_input` access; they MUST write `human-oversight: unconfirmed` instead (the AFK fallback enum value codified in ADR-066 amendment 2026-06-02), which the drain (`/wr-architect:review-decisions`) later promotes interactively. Calling the helper without a real user substance-confirm event is the P348 hollow-marker bug — every legitimate marker write traces back to an `request_user_input` answer in the same turn.
 
 **ADR-013 Rule 6 carve-out audit (P352, 2026-06-06 amendment)**: the universal AFK default is queue-and-continue. This Step 5 substance-confirm HALT-and-write-`human-oversight: unconfirmed` shape is a documented carve-out, authorised by **ADR-074** (Confirm decision substance before building dependent work). Rationale: an ADR with `human-oversight: confirmed` enters the world born-confirmed (it does not appear in `/wr-architect:review-decisions`' unoversighted set), so dependent work — every implementation that cites this ADR as authority — would be built on substance that was never user-affirmed. AFK writing `human-oversight: unconfirmed` IS the queue-and-continue shape: the loop continues; the substance-confirm decision is queued to the next interactive drain. Persona-correct for JTBD-006 ("queued for my return, not guessed at"); the carve-out is from the auto-confirm shape, not from queue-and-continue itself.
 
@@ -270,7 +281,7 @@ The `wr-architect-mark-oversight-confirmed` call writes the session-scoped evide
 
 - DO NOT write the marker.
 - Re-draft Decision Outcome + Consequences + Confirmation + Pros and Cons (and Reassessment Criteria if affected) against the newly-chosen option.
-- Re-fire the substance-confirm `AskUserQuestion` against the re-drafted text to verify the substance now matches the user's pick.
+- Re-fire the substance-confirm `request_user_input` against the re-drafted text to verify the substance now matches the user's pick.
 - The marker writes ONLY after a substance-confirm pass whose answer matches the draft on disk.
 
 This is NOT a soft "warn and proceed" path — the marker only ever writes when the draft on disk encodes the user's substantive pick. Mismatch is a re-draft trigger, not an override.
@@ -279,7 +290,7 @@ This is NOT a soft "warn and proceed" path — the marker only ever writes when
 
 **Retitle-after-decision check (P354 — ADR-044 category-4 silent-framework).** After the marker write lands, check the on-disk filename slug for a question-shape pattern (`-vs-`, `should-`, `whether-`, `-or-`). If matched, the title was derived at intake against a question-shaped problem-statement and must be retitled to the chosen-option's outcome shape now that the substance is locked in. The convention is named in Step 2a above.
 
-This step is **mechanical — no AskUserQuestion fires** (per P132 inverse-P078 guard). The chosen option is now known from the substance-confirm answer just above; derive the outcome slug from the chosen-option short name via the same `derive_kebab_slug` helper Step 2's Title derivation uses (`packages/architect/lib/derive-first-dispatch.sh`). Sequence (ordered to preserve marker-discipline hook semantics — the marker-introducing Edit must land BEFORE `git mv`):
+This step is **mechanical — no request_user_input fires** (per P132 inverse-P078 guard). The chosen option is now known from the substance-confirm answer just above; derive the outcome slug from the chosen-option short name via the same `derive_kebab_slug` helper Step 2's Title derivation uses (`<architect-plugin-root>/lib/derive-first-dispatch.sh`). Sequence (ordered to preserve marker-discipline hook semantics — the marker-introducing Edit must land BEFORE `git mv`):
 
 1. Derive `new_slug = derive_kebab_slug "<chosen option short name>"`.
 2. Edit the H1 in the on-disk file to the new outcome shape (H1 stays human-readable Title Case; the slug is for the filename). The `human-oversight: confirmed` line is already in `OLD_CONTENT` so `architect-oversight-marker-discipline.sh` allows this Edit per its "old content already had the marker" branch.
@@ -293,7 +304,7 @@ If the on-disk slug does NOT match a question-shape pattern (already outcome-sha
 
 #### 5b. Draft-quality review fire (optional, after 5a passes)
 
-After the substance-confirm fire passes and the marker is written, fire a separate narrow `AskUserQuestion` for draft-quality review:
+After the substance-confirm fire passes and the marker is written, fire a separate narrow `request_user_input` for draft-quality review:
 
 1. Does the problem statement accurately capture the situation?
 2. Are the pros/cons fair and complete?
@@ -305,7 +316,7 @@ Apply any feedback by editing the file. This fire is OPTIONAL — when the agent
 **Refresh the decisions compendium (ADR-077).** After the ADR file is written and any born-confirmed marker is applied, regenerate `docs/decisions/README.md` so the architect-agent routine load surface includes the new entry. Run:
 
 ```bash
-wr-architect-generate-decisions-compendium
+bash "<architect-plugin-root>/scripts/generate-decisions-compendium.sh"
 git add docs/decisions/README.md
 ```
 

package/skills/create-adr/test/create-adr-codex-eval-contract.bats

@@ -14,10 +14,12 @@ setup() {
   [ "$status" -eq 0 ]
 }
 
-@test "create-adr Codex eval runner uses codex exec and plugin marketplace" {
-  run grep -n "codex plugin marketplace add" "$EVAL_DIR/run-codex-skill-eval.sh"
+@test "create-adr Codex eval runner uses packed installer and codex exec" {
+  run grep -n 'npm pack' "$EVAL_DIR/run-codex-skill-eval.sh"
   [ "$status" -eq 0 ]
-  run grep -n "codex plugin add wr-architect@windyroad-local" "$EVAL_DIR/run-codex-skill-eval.sh"
+  run grep -n 'windyroad-architect --runtime codex --scope user' "$EVAL_DIR/run-codex-skill-eval.sh"
+  [ "$status" -eq 0 ]
+  run grep -n 'agents/wr-architect-agent.toml' "$EVAL_DIR/run-codex-skill-eval.sh"
   [ "$status" -eq 0 ]
   run grep -n "codex exec" "$EVAL_DIR/run-codex-skill-eval.sh"
   [ "$status" -eq 0 ]
@@ -27,4 +29,6 @@ setup() {
   [ "$status" -eq 0 ]
   run grep -n -- "--sandbox read-only" "$EVAL_DIR/run-codex-skill-eval.sh"
   [ "$status" -eq 0 ]
+  run grep -n -- '</dev/null' "$EVAL_DIR/run-codex-skill-eval.sh"
+  [ "$status" -eq 0 ]
 }

package/skills/review-decisions/SKILL.md

@@ -1,14 +1,25 @@
 ---
 name: wr-architect:review-decisions
-description: Drain the set of recorded decisions (ADRs) that lack human oversight. Surfaces each unconfirmed ADR's chosen option and alternatives via AskUserQuestion so a human confirms, amends, or rejects the auto-made call, then writes the human-oversight marker. Use when the session-start nudge reports decisions lack oversight, or any time you want to review recorded decisions.
-allowed-tools: Read, Glob, Grep, Bash, Edit, AskUserQuestion
+description: Drain the set of recorded decisions (ADRs) that lack human oversight. Surfaces each unconfirmed ADR's chosen option and alternatives via request_user_input so a human confirms, amends, or rejects the auto-made call, then writes the human-oversight marker. Use when the session-start nudge reports decisions lack oversight, or any time you want to review recorded decisions.
+allowed-tools: Read, Glob, Grep, Bash, Edit, request_user_input
 ---
 
+<!-- Generated from the Claude skill source during npm pack. -->
+
+> Codex runtime note: use `request_user_input` in Plan Mode for structured
+> questions. Resolve `<architect-plugin-root>` from this installed
+> `SKILL.md` path: it is two directories above the skill directory. Replace
+> that token with the absolute path before running a bundled script; never
+> search the adopter repository or rely on a `wr-architect-*` command being
+> on `PATH`. Spawn the installed `wr-architect:agent` custom agent with the
+> native Codex subagent tool, wait for it, and close the same agent.
+
+
 # Review Decisions — human-oversight drain
 
-Lift auto-made architecture decisions to human decisions. Many ADRs were recorded autocratically — the architect proposed an option and it stood without a human picking it. This skill drains the **unoversighted set** (ADRs lacking `human-oversight: confirmed` in frontmatter, per ADR-066): it surfaces each decision's chosen option + the alternatives via `AskUserQuestion`, and writes the oversight marker only when a human confirms.
+Lift auto-made architecture decisions to human decisions. Many ADRs were recorded autocratically — the architect proposed an option and it stood without a human picking it. This skill drains the **unoversighted set** (ADRs lacking `human-oversight: confirmed` in frontmatter, per ADR-066): it surfaces each decision's chosen option + the alternatives via `request_user_input`, and writes the oversight marker only when a human confirms.
 
-This is the P283 prong-2 drain surface. It is the eat-our-own-dogfood loop: confirming a decision is itself a human decision, so it goes through `AskUserQuestion`.
+This is the P283 prong-2 drain surface. It is the eat-our-own-dogfood loop: confirming a decision is itself a human decision, so it goes through `request_user_input`.
 
 ## When to use
 
@@ -26,18 +37,18 @@ Each run drains as many ADRs as the user has appetite for, in topic-clustered ba
 Run the detector (token-cheap — grep over frontmatter, no body reads):
 
 ```bash
-wr-architect-detect-unoversighted docs/decisions
+bash "<architect-plugin-root>/scripts/detect-unoversighted.sh" docs/decisions
 ```
 
-The `wr-architect-detect-unoversighted` command is a `$PATH`-resolved shim (ADR-049 naming grammar) dispatching `packages/architect/scripts/detect-unoversighted.sh`. It prints one unoversighted ADR path per line (superseded ADRs are excluded — a retired decision needs no confirmation). Empty output → the set is fully drained; report "all recorded decisions carry human oversight" and stop.
+The `bash "<architect-plugin-root>/scripts/detect-unoversighted.sh"` command is the bundled Codex script at `<architect-plugin-root>/scripts/detect-unoversighted.sh`. It prints one unoversighted ADR path per line (superseded ADRs are excluded — a retired decision needs no confirmation). Empty output → the set is fully drained; report "all recorded decisions carry human oversight" and stop.
 
 ### Step 2: Cluster + order
 
 Read **only the frontmatter + title + Decision Outcome** of each unoversighted ADR (not full bodies — keep it cheap). Group by topic cluster (e.g. release-cadence, governance-gates, AFK-orchestration, decision-recording) and order **load-bearing first**: ADRs that other ADRs cite as parents, that are `accepted` (already shipped — highest drift cost if the auto-pick was wrong), or that govern a hook/gate the user interacts with daily. Defer narrow / low-coupling ADRs.
 
-### Step 3: Present each decision via AskUserQuestion (batched)
+### Step 3: Present each decision via request_user_input (batched)
 
-For each ADR in the ordered queue, surface the decision as an `AskUserQuestion` (cap **4 ADRs per call** per ADR-013 Rule 1; issue further calls sequentially). For each ADR:
+For each ADR in the ordered queue, surface the decision as an `request_user_input` (cap **4 ADRs per call** per ADR-013 Rule 1; issue further calls sequentially). For each ADR:
 
 - **Question**: the decision the ADR records (its Decision Outcome, in one line).
 - **Context**: the chosen option + the alternatives the ADR considered (grounded in the ADR's Considered Options section per ADR-026), and any cited parent ADRs.
@@ -47,7 +58,7 @@ For each ADR in the ordered queue, surface the decision as an `AskUserQuestion`
   - **Reject / supersede** — the auto-made pick is wrong; capture the supersede ticket (see Step 4) and write the **rejected-pending-supersede** marker so the drain stops re-asking.
   - **Defer** — skip this sitting; leave unoversighted for a later run.
 
-**Presentation rule — lead with the Decision Outcome, never with the meta (P302).** The AskUserQuestion `question` field MUST open with the one-line Decision Outcome — *what the ADR decides* — phrased as `"This ADR decides: <outcome>"`. Sibling-ADR relationships, supersession lineage, and Considered-Options recording-shape (e.g. "separate ADR vs amend ADR-014") are **meta** about *how the decision was recorded*, not what it decides — relegate them to a trailing clause or omit. This is ADR-074's *name the substance, not the grain* principle applied to the confirm surface itself, and ADR-026 grounding extended from the ADR body to the AskUserQuestion `question` text. Burying the substance behind meta forces a clarifying re-ask: the user cannot tell what they are confirming.
+**Presentation rule — lead with the Decision Outcome, never with the meta (P302).** The request_user_input `question` field MUST open with the one-line Decision Outcome — *what the ADR decides* — phrased as `"This ADR decides: <outcome>"`. Sibling-ADR relationships, supersession lineage, and Considered-Options recording-shape (e.g. "separate ADR vs amend ADR-014") are **meta** about *how the decision was recorded*, not what it decides — relegate them to a trailing clause or omit. This is ADR-074's *name the substance, not the grain* principle applied to the confirm surface itself, and ADR-026 grounding extended from the ADR body to the request_user_input `question` text. Burying the substance behind meta forces a clarifying re-ask: the user cannot tell what they are confirming.
 
   *Bad — buries the decision behind meta:*
   - *"a sibling ADR codifying five patterns; ADR-038 governs UserPromptSubmit, ADR-040 governs SessionStart."* (ADR-045 surfaced this way during the 2026-05-25 drain; user replied *"if this decision defers to a sibling decision, what does this decision decide??"*.)
@@ -61,13 +72,13 @@ The trailing clause exists for cross-reference value — it is optional, NOT a r
 
 **Brief-before-ID discipline (P350).** The `question` and `options` text MUST inline what each referenced artefact is and what is at stake before naming it by ID. `ADR-NNN` / `P-NNN` / `JTBD-NNN` / `RFC-NNN` references are audit-trail annotations, NEVER carriers of meaning — the user reads this prompt without project filesystem access (mobile clients, accessibility tooling, notification surfaces) and cannot follow links. Acceptable: *"This ADR decides: five per-tool-call hook patterns + their budget bands (sibling of the UserPromptSubmit-pattern decision and the SessionStart-pattern decision)."* Unacceptable: *"This ADR decides: 5 patterns; sibling to ADR-038 and ADR-040."* The trailing parenthetical IDs are permitted ONLY after a self-contained explanation, never as the explanation itself. Mirrors the canonical `/wr-architect:create-adr` Step 5 § 5a Rule 3 ("No IDs as explainers"). See also session memory `feedback_brief_before_id.md`.
 
-This is a genuine human-decision surface (the whole point of P283) — `AskUserQuestion` is correct here and is NOT over-asking. Do not auto-confirm; do not prose-ask.
+This is a genuine human-decision surface (the whole point of P283) — `request_user_input` is correct here and is NOT over-asking. Do not auto-confirm; do not prose-ask.
 
 ### Step 4: Apply the outcome
 
 - **Confirm / Amend**: write `human-oversight: confirmed` + `oversight-date: <today, YYYY-MM-DD>` into the ADR's frontmatter (insert after the `date:` line if absent; never duplicate). For Amend, apply the directed body change first. Both edits go through the standard architect / JTBD edit gate per ADR-014.
 - **Reject / supersede** (ADR-066 amendment per P316):
-  1. Capture the supersede ticket via a follow-up `AskUserQuestion`: "Which problem ticket tracks the supersede?" — options: existing `P<NNN>` IDs surfaced from `docs/problems/`, **Capture a new ticket** (delegate to `/wr-itil:capture-problem`), or **Defer (leave un-tracked for now)**.
+  1. Capture the supersede ticket via a follow-up `request_user_input`: "Which problem ticket tracks the supersede?" — options: existing `P<NNN>` IDs surfaced from `docs/problems/`, **Capture a new ticket** (delegate to `/wr-itil:capture-problem`), or **Defer (leave un-tracked for now)**.
   2. If a ticket ID is captured, write `human-oversight: rejected-pending-supersede` + `supersede-ticket: P<NNN>` into the ADR's frontmatter. The detector excludes ADRs carrying both, so the drain stops re-asking until either the supersede ADR lands (status flips to `superseded`) or the rejection is revisited.
   3. If the user defers ticket capture, leave the marker absent — the ADR re-surfaces next drain (the un-tracked case is intentionally re-asked so it doesn't silently rot).
 - **Defer**: no write.
@@ -77,7 +88,7 @@ This is a genuine human-decision surface (the whole point of P283) — `AskUserQ
 After the batch's Confirm/Amend/Reject writes land in the working tree, regenerate `docs/decisions/README.md` so the architect-agent routine load surface reflects the new substance and badges:
 
 ```bash
-wr-architect-generate-decisions-compendium
+bash "<architect-plugin-root>/scripts/generate-decisions-compendium.sh"
 ```
 
 The compendium is the architect agent's primary load surface per ADR-077; review-decisions owns keeping it fresh through this drain (skills + agent are PRIMARY; the `architect-compendium-refresh-discipline.sh` hook is the safety-net backstop). Why this matters per disposition:
@@ -108,7 +119,7 @@ Commit the drained batch per ADR-014 (one commit for the sitting's drained batch
 ## Related
 
 - **ADR-066** — the oversight marker + this drain skill + the detector + the nudge.
-- **ADR-064** — the architect Needs-Direction verdict; the main agent owns `AskUserQuestion` (this skill is that ownership applied to the existing set).
+- **ADR-064** — the architect Needs-Direction verdict; the main agent owns `request_user_input` (this skill is that ownership applied to the existing set).
 - **ADR-009** — never-re-ask persistent-marker principle (the marker, not its TTL/drift lifecycle).
 - **ADR-013 / ADR-044** — structured user interaction + decision-delegation taxonomy.
 - **ADR-077** — generated decisions compendium as the architect agent's routine load surface; Step 4.5 + Step 5 keep it fresh through this drain (Confirmation item (f)). Mirrors the same regen + stage-with-commit pattern used by `/wr-architect:create-adr` Step 5 and `/wr-architect:capture-adr` Step 4.5.

package/skills/review-design/SKILL.md

@@ -1,9 +1,20 @@
 ---
 name: wr-architect:review-design
 description: On-demand architecture compliance review. Checks staged changes and recent commits against existing ADRs in docs/decisions/. Use before editing architecture-bearing files or before a release.
-allowed-tools: Read, Glob, Grep, Bash, AskUserQuestion, Skill
+allowed-tools: Read, Glob, Grep, Bash, request_user_input, Skill
 ---
 
+<!-- Generated from the Claude skill source during npm pack. -->
+
+> Codex runtime note: use `request_user_input` in Plan Mode for structured
+> questions. Resolve `<architect-plugin-root>` from this installed
+> `SKILL.md` path: it is two directories above the skill directory. Replace
+> that token with the absolute path before running a bundled script; never
+> search the adopter repository or rely on a `wr-architect-*` command being
+> on `PATH`. Spawn the installed `wr-architect:agent` custom agent with the
+> native Codex subagent tool, wait for it, and close the same agent.
+
+
 # Architecture Compliance Review Skill
 
 Run an architecture compliance review on demand — outside the pre-tool-use hook gate. Reviews staged changes and recent commits against the project's ADRs in `docs/decisions/`.
@@ -49,7 +60,7 @@ Summarise:
 
 ### 3. Resolve ambiguity
 
-If there are no staged changes and no recent unpushed commits, use `AskUserQuestion` to ask:
+If there are no staged changes and no recent unpushed commits, use `request_user_input` to ask:
 
 > "I don't see any staged or unpushed changes. What would you like me to review?
 > (a) A specific set of files — please name them
@@ -87,7 +98,7 @@ agent: wr-architect:agent
 prompt: <constructed review prompt from step 4>
 ```
 
-Codex auto-discovers the agent from the installed plugin's `agents/agent.md` and registers it as `wr-architect:agent` (plugin name + agent frontmatter name). Adopter projects do not need to ship any `.codex/agents/*.toml` themselves — `codex plugin add wr-architect@windyroad` is enough. The repo-local `.codex/agents/wr-architect.toml`, kept in sync from `packages/architect/agents/agent.md` by `scripts/sync-codex-agents.mjs`, only supports in-repo dogfooding before the plugin is installed into `CODEX_HOME`; it registers a short-name alias `wr-architect` for source-repo developers. If a non-interactive `codex exec` validation harness cannot spawn the custom agent directly, perform the review inline using the same generated agent instructions and name that fallback in the output.
+The Codex installer generates `.codex/agents/wr-architect-agent.toml` from the installed plugin's `agents/agent.md` and registers the exact identity `wr-architect:agent`. SessionStart repairs the user-scoped registration when needed. Adopter projects do not need to ship their own agent configuration. Restart Codex if that exact identity is not visible; do not substitute the built-in `default` agent because the review marker consumes the architect identity. The repo-local `.codex/agents/wr-architect.toml`, kept in sync from `<architect-plugin-root>/agents/agent.md` by `scripts/sync-codex-agents.mjs`, remains the short-name `wr-architect` alias for source-repo dogfooding.
 
 Wait for the agent to complete.