Honor author replies

.gitea/workflows/check.yml

@@ -14,8 +14,4 @@ jobs:
 
       - uses: denoland/setup-deno@v2
 
-      - run: >-
+      - run: deno fmt --check . && deno lint . && deno check run.ts
-          deno fmt --check . &&
-          deno lint . &&
-          deno check run.ts &&
-          deno test

action.yml

@@ -20,11 +20,6 @@ inputs:
   bot-token:
     description: API key or token for the selected bot
     required: false
-  model:
-    description: >-
-      Model for the selected bot. Defaults to `claude-sonnet-5` or
-      `gpt-5.6-terra`, the mid tiers, which cover reviews and fixes.
-    required: false
 
 runs:
   using: composite
@@ -45,7 +40,6 @@ runs:
         ACTION_PATH: ${{ gitea.action_path }}
         BOT_TYPE: ${{ inputs.bot-type }}
         BOT_TOKEN: ${{ inputs.bot-token }}
-        MODEL: ${{ inputs.model }}
         GITEA_API_URL: ${{ gitea.api_url }}
         GITEA_REPOSITORY: ${{ gitea.repository }}
         GITEA_TOKEN: ${{ inputs.author-token }}

auth.ts

@@ -1,12 +0,0 @@
-export async function retryInvalidToken<
-  T extends { status: { success: boolean }; error: string },
->(attempt: () => Promise<T>, relogin: () => Promise<void>): Promise<T> {
-  let result = await attempt();
-  if (
-    !result.status.success && result.error.includes("invalid_refresh_token")
-  ) {
-    await relogin();
-    result = await attempt();
-  }
-  return result;
-}

auth_test.ts

@@ -1,44 +0,0 @@
-import { assertEquals } from "jsr:@std/assert@1";
-import { retryInvalidToken } from "./auth.ts";
-
-Deno.test("retries once after an invalid refresh token", async () => {
-  let attempts = 0;
-  let relogins = 0;
-  const result = await retryInvalidToken(
-    () =>
-      Promise.resolve({
-        status: { success: false },
-        error: attempts++ === 0 ? "invalid_refresh_token" : "still failed",
-      }),
-    () => {
-      relogins++;
-      return Promise.resolve();
-    },
-  );
-
-  assertEquals({ attempts, relogins, error: result.error }, {
-    attempts: 2,
-    relogins: 1,
-    error: "still failed",
-  });
-});
-
-Deno.test("does not retry an unrelated failure", async () => {
-  let attempts = 0;
-  let relogins = 0;
-  await retryInvalidToken(
-    () => {
-      attempts++;
-      return Promise.resolve({
-        status: { success: false },
-        error: "rate limited",
-      });
-    },
-    () => {
-      relogins++;
-      return Promise.resolve();
-    },
-  );
-
-  assertEquals({ attempts, relogins }, { attempts: 1, relogins: 0 });
-});

prompt.md

@@ -18,61 +18,34 @@ the head of the pull request when there is one, with full history and the
 author's push credentials. Read the code there, run its checks and tests when
 they bear on the task, and push from there.
 
-For a `pull_request` event, and for a comment on a pull request that asks you to
+For a `pull_request` event, review the PR without changing code, using the
-review it, use the installed `superpowers:requesting-code-review` skill before
+`requesting-code-review` skill from superpowers: run its code reviewer template
-inspecting the PR. Its exact installed instructions and reviewer template are
+against the PR's base and head, and make its complete output your final response
-included below, so this run fails before reaching you if they could not be
+instead of the short comment style above. Run the project's checks on the head
-loaded. You are the reviewer that has already been dispatched, so run the
+and treat a failure as at least Important. Check the whole repository against
-skill's code reviewer template yourself instead of dispatching another reviewer.
+the code rules at the end of this prompt, not only the diff; a violation is at
-Use the pull request and triggering instruction as its description and
+least Important even when the diff did not cause it. Your final response is
-requirements, and review the exact base and head SHAs without changing code. Run
+posted verbatim as a pull request review from the bot account, so it is the
-the project's required checks on the head and treat a real failure as at least
+review text and nothing else: no narration about what you did, verified, or are
-Important. The bot automation workflow itself is not a project check: ignore its
+about to post, whether you reviewed yourself or relayed a reviewer subagent. Its
-skipped or canceled duplicate/automatic runs, and never reject a PR because the
+first line must be exactly the template's verdict and nothing else: `Yes`, `No`,
-current review run is unfinished. Only a failed required check for the reviewed
+or `With fixes`. `Yes` approves and the other two request changes; any other
-head blocks approval. Check the whole repository against the code rules at the
+first line is posted as a plain comment, which wastes the run. Minor issues
-end of this prompt, not only the diff; a violation is at least Important even
+alone never block, and neither does a finding the author has answered in the
-when the diff did not cause it. Write the complete review, and nothing else, to
+comment history below as intended or a false alarm, once the code or docs make
-the file `${REVIEW_PATH}`: it is posted verbatim as a pull request review from
+that clear. When the verdict is not `Yes`, the second line names what must
-the bot account, and your final response is not posted at all. The file's first
+change in one line, addressed to the author; the author's own agent picks the
-line must be exactly the verdict and nothing else: `Approved` when the head is
+fixes up, so never ask `@bot` to make them. For UI changes, check that the
-ready to merge, `Changes requested` otherwise. The mark in front of it is added
+result is aligned, clean, and pixel-perfect, and that included screenshots prove
-when posting, so write the words alone; any other first line is posted as a
+the intended result was achieved.
-plain comment, which wastes the run. Minor issues alone never block, and neither
-does a finding the author has answered in the comment history below as intended
-or a false alarm, once the code or docs make that clear. When the verdict is
-`Changes requested`, the second line names what must change in one line,
-addressed to the author; the author's own agent picks the fixes up, so never ask
-`@bot` to make them. For UI changes, check that the result is aligned, clean,
-and pixel-perfect, and that included screenshots prove the intended result was
-achieved.
 
-# Installed Superpowers review skill
+The review must read at a glance: everything outside `<details>` blocks totals
-
+under 512 bytes. Only core information stays visible: the verdict, the summary
-${SUPERPOWERS_REVIEW_SKILL}
+line, and the section headings. Anything verbose goes into a `<details>` block
-
+whose `<summary>` is a few words, such as the `file:line` and title of an issue
-# Installed Superpowers reviewer template
+with the what, why, and how inside; the same for each strength, each
-
+recommendation, the reasoning, and any compliance notes. Details blocks are
-${SUPERPOWERS_REVIEW_TEMPLATE}
+top-level, never inside a list item, because Gitea breaks them there.
-
-Every finding that belongs to one line of the diff goes on that line instead of
-into the body. Write those to `${ANCHORS_PATH}` as a JSON array, each entry
-`{"path": "<path from the repository root>", "line": <number>, "side": "new" |
-"old", "body": "<the finding>"}`.
-`side` is `new` for a line in the head file and `old` for one only in the base
-file; `line` is that file's own line number, and it must be a line the diff
-touches, or Gitea refuses the anchor. Write the file only when there is
-something to anchor, and keep each body to the what, the why, and the how, with
-no `file:line` prefix; the line carries that.
-
-The review body must read at a glance: everything outside `<details>` blocks
-totals under 512 bytes. Only core information stays visible: the verdict, the
-summary line, and the section headings. Anything verbose goes into a `<details>`
-block whose `<summary>` is a few words, such as the title of an issue with the
-what, why, and how inside; the same for each strength, each recommendation, the
-reasoning, and any compliance notes. A finding you anchored belongs there only
-as its title, since its detail is on the line. Details blocks are top-level,
-never inside a list item, because Gitea breaks them there.
 
 For an `issue_comment` or `pull_request_review_comment` event, treat the `body`
 in the triggering comment payload below as the user's exact instruction.

run.ts

@@ -3,14 +3,6 @@
 // GITEA_TOKEN; everything this script posts goes through the reviewer token,
 // so it appears as the bot account.
 import { TextLineStream } from "jsr:@std/streams@1/text-line-stream";
-import { retryInvalidToken } from "./auth.ts";
-import {
-  type BotType,
-  loadSuperpowersReviewGuide,
-  parseBotType,
-  superpowersInstallCommands,
-  type SuperpowersReviewGuide,
-} from "./superpowers.ts";
 
 type GiteaUser = { login: string; email: string };
 type GiteaComment = { user: GiteaUser; created_at: string; body: string };
@@ -25,17 +17,9 @@ const API = env("GITEA_API_URL");
 const REPO = env("GITEA_REPOSITORY");
 const INDEX = env("ISSUE_INDEX");
 const EVENT = env("EVENT_NAME");
-const BOT = parseBotType(env("BOT_TYPE"));
 const AUTHOR_TOKEN = env("GITEA_TOKEN");
 const REVIEWER_TOKEN = env("REVIEWER_TOKEN");
 const RULES_PATH = "repos/commons/code-rules/raw/README.md";
-// The mid tiers: a run follows a fixed template and the project's checks.
-const DEFAULT_MODELS: Record<string, string> = {
-  claude: "claude-sonnet-5",
-  codex: "gpt-5.6-terra",
-};
-const model = (bot: string): string =>
-  Deno.env.get("MODEL") || DEFAULT_MODELS[bot];
 
 // The reviewer token is withheld so the agent cannot approve as the bot.
 const { REVIEWER_TOKEN: _, ...agentEnv } = Deno.env.toObject();
@@ -68,84 +52,21 @@ async function postComment(body: string): Promise<void> {
   });
 }
 
-// A review is posted whenever the agent wrote one, whether a review request or
+// A pull request event is a review request, so the response becomes a review.
-// a comment asked for it. It comes through a file, because a final chat message
+// Its first line is the verdict; anything unexpected only comments, never
-// picks up narration while a file's first line is written on purpose. That line
+// approves.
-// is the verdict, matched whole; anything unexpected only comments, never
+const VERDICTS: Record<string, string> = {
-// approves. The mark in front is added here, so it is never part of the match.
+  Yes: "APPROVED",
-const REVIEW_DIR = await Deno.makeTempDir();
+  No: "REQUEST_CHANGES",
-const REVIEW_PATH = `${REVIEW_DIR}/review.md`;
+  "With fixes": "REQUEST_CHANGES",
-const VERDICTS: Record<string, [event: string, mark: string]> = {
-  Approved: ["APPROVED", "✅"],
-  "Changes requested": ["REQUEST_CHANGES", "🛑"],
 };
 
-// A finding about one line is posted on that line of the diff rather than as
-// `file:line` prose in the body. Those anchors come as JSON, so the file and
-// line are structured instead of parsed back out of English; a malformed entry
-// fails the run, because a silently dropped finding is worse than a red run.
-const ANCHORS_PATH = `${REVIEW_DIR}/anchors.json`;
-type Anchor = { path: string; line: number; side: "new" | "old"; body: string };
-
-function parseAnchors(text: string): Anchor[] {
-  const entries: unknown = JSON.parse(text);
-  if (!Array.isArray(entries)) throw new Error(`${ANCHORS_PATH}: not an array`);
-  return entries.map((entry: unknown, index) => {
-    const at = `${ANCHORS_PATH}[${index}]`;
-    if (typeof entry !== "object" || entry === null) {
-      throw new Error(`${at}: not an object`);
-    }
-    const { path, line, side = "new", body } = entry as Record<string, unknown>;
-    if (typeof path !== "string" || path === "") {
-      throw new Error(`${at}.path: expected a repository path`);
-    }
-    if (typeof line !== "number" || !Number.isInteger(line) || line < 1) {
-      throw new Error(`${at}.line: expected a line number`);
-    }
-    if (side !== "new" && side !== "old") {
-      throw new Error(`${at}.side: expected "new" or "old"`);
-    }
-    if (typeof body !== "string" || body.trim() === "") {
-      throw new Error(`${at}.body: expected the finding`);
-    }
-    return { path, line, side, body };
-  });
-}
-
-async function readAnchors(): Promise<Anchor[]> {
-  const written = await Deno.readTextFile(ANCHORS_PATH).catch(() => null);
-  return written === null ? [] : parseAnchors(written);
-}
-
 async function postResult(body: string): Promise<void> {
-  const review = await Deno.readTextFile(REVIEW_PATH).catch(() => null);
+  if (EVENT !== "pull_request") return postComment(body);
-  if (review === null) {
+  const [verdict] = body.split("\n", 1);
-    if (EVENT === "pull_request") {
+  await gitea(REVIEWER_TOKEN, `repos/${REPO}/pulls/${INDEX}/reviews`, {
-      throw new Error(`no review was written to ${REVIEW_PATH}`);
+    body: stripAnsi(body),
-    }
+    event: VERDICTS[verdict.trim()] ?? "COMMENT",
-    return postComment(body);
-  }
-  const [verdict, ...rest] = review.split("\n");
-  const [event, mark] = VERDICTS[verdict.trim()] ?? ["COMMENT", "💬"];
-  const post = (anchors: Anchor[]) =>
-    gitea(REVIEWER_TOKEN, `repos/${REPO}/pulls/${INDEX}/reviews`, {
-      body: stripAnsi([`${mark} ${verdict.trim()}`, ...rest].join("\n")),
-      event,
-      comments: anchors.map(({ path, line, side, body }) => ({
-        path,
-        body: stripAnsi(body),
-        new_position: side === "new" ? line : 0,
-        old_position: side === "old" ? line : 0,
-      })),
-    });
-  const anchors = await readAnchors();
-  // Gitea rejects the whole review when an anchor names a line outside the
-  // diff, and a verdict that never lands blocks the pull request, so the body
-  // goes up alone rather than not at all.
-  await post(anchors).catch(async (error: Error) => {
-    if (anchors.length === 0) throw error;
-    console.error(`inline comments rejected: ${error.message}`);
-    await post([]);
   });
 }
 
@@ -154,28 +75,6 @@ async function run(command: string, args: string[]): Promise<void> {
   if (!success) throw new Error(`${command} ${args[0]} exited with ${code}`);
 }
 
-// The reviewer uses Superpowers' requesting-code-review template. Both plugin
-// installers are idempotent on the persisted bot home.
-async function installSuperpowers(bot: BotType): Promise<void> {
-  for (const { command, args } of superpowersInstallCommands(bot)) {
-    await run(command, args);
-  }
-}
-
-async function prepareSuperpowers(
-  bot: BotType,
-): Promise<SuperpowersReviewGuide> {
-  await installSuperpowers(bot);
-  const guide = await loadSuperpowersReviewGuide(bot, env("HOME"));
-  console.log(
-    `Loaded Superpowers requesting-code-review ${guide.version} from ${guide.skillPath}`,
-  );
-  console.log(
-    `Loaded Superpowers reviewer template from ${guide.templatePath}`,
-  );
-  return guide;
-}
-
 // Commits belong to the same account as the pull request they end up in.
 async function configureGitAuthor(): Promise<void> {
   const user: GiteaUser = await (await gitea(AUTHOR_TOKEN, "user")).json();
@@ -184,7 +83,20 @@ async function configureGitAuthor(): Promise<void> {
   }
 }
 
-async function renderPrompt(guide: SuperpowersReviewGuide): Promise<string> {
+// The superpowers plugin gives the agent its skills, including the code review
+// one that the prompt asks for. Both installs are idempotent on the persisted
+// home.
+async function installSuperpowers(bot: string): Promise<void> {
+  const commands = bot === "claude"
+    ? [
+      ["plugin", "marketplace", "add", "obra/superpowers-marketplace"],
+      ["plugin", "install", "-y", "superpowers@superpowers-marketplace"],
+    ]
+    : [["plugin", "add", "superpowers@openai-curated-remote"]];
+  for (const args of commands) await run(bot, args);
+}
+
+async function renderPrompt(): Promise<string> {
   const comments: GiteaComment[] = await (await gitea(
     REVIEWER_TOKEN,
     `repos/${REPO}/issues/${INDEX}/comments?limit=100`,
@@ -199,10 +111,6 @@ async function renderPrompt(guide: SuperpowersReviewGuide): Promise<string> {
     GITEA_API_URL: API,
     GITEA_REPOSITORY: REPO,
     ISSUE_INDEX: INDEX,
-    REVIEW_PATH,
-    ANCHORS_PATH,
-    SUPERPOWERS_REVIEW_SKILL: guide.skill,
-    SUPERPOWERS_REVIEW_TEMPLATE: guide.template,
   };
   const template = await Deno.readTextFile(
     new URL("prompt.md", import.meta.url),
@@ -213,20 +121,20 @@ async function renderPrompt(guide: SuperpowersReviewGuide): Promise<string> {
   );
 }
 
-async function runClaude(): Promise<string> {
+async function runClaude(prompt: string): Promise<string> {
   const token = Deno.env.get("BOT_TOKEN");
   if (!token) {
     throw new Error(
       "Run `claude setup-token` locally and set the `bot-token` action input.",
     );
   }
-  const prompt = await renderPrompt(await prepareSuperpowers("claude"));
+  await installSuperpowers("claude");
   const claude = new Deno.Command("claude", {
     args: [
       "--print",
       "--dangerously-skip-permissions",
       "--model",
-      model("claude"),
+      "claude-fable-5",
       "--output-format",
       "stream-json",
       "--verbose",
@@ -271,63 +179,47 @@ async function codexDeviceLogin(): Promise<void> {
       new WritableStream({ write: (chunk) => void (shown += chunk) }),
     );
   const drained = Promise.all([collect(login.stdout), collect(login.stderr)]);
-  const status = login.status;
   await new Promise((resolve) => setTimeout(resolve, 3000));
-  while (shown.trim() === "") {
-    const exited = await Promise.race([
-      status.then(() => true),
-      new Promise<boolean>((resolve) => setTimeout(() => resolve(false), 100)),
-    ]);
-    if (exited) throw new Error("AI bot login produced no instructions");
-  }
   await postComment(shown);
-  await Promise.all([status, drained]);
+  await Promise.all([login.status, drained]);
+  const status = await new Deno.Command("codex", { args: ["login", "status"] })
+    .output();
+  await postComment(new TextDecoder().decode(status.stdout));
 }
 
-async function runCodex(): Promise<string> {
+async function runCodex(prompt: string): Promise<string> {
   const loggedIn = await new Deno.Command("codex", {
     args: ["login", "status"],
   })
     .output();
   if (!loggedIn.success) await codexDeviceLogin();
-  const prompt = await renderPrompt(await prepareSuperpowers("codex"));
+  await installSuperpowers("codex");
   const file = await Deno.makeTempFile();
-  const attempt = async () => {
+  const status = await new Deno.Command("codex", {
-    const codex = new Deno.Command("codex", {
+    args: [
-      args: [
+      "exec",
-        "exec",
+      "--model",
-        "--model",
+      "gpt-5.5",
-        model("codex"),
+      "--dangerously-bypass-approvals-and-sandbox",
-        "--dangerously-bypass-approvals-and-sandbox",
+      "--output-last-message",
-        "--output-last-message",
+      file,
-        file,
+      prompt,
-        prompt,
+    ],
-      ],
+    env: agentEnv,
-      env: agentEnv,
+    clearEnv: true,
-      clearEnv: true,
+    stdout: "inherit",
-      stdout: "inherit",
+    stderr: "inherit",
-      stderr: "piped",
+  }).spawn().status;
-    }).spawn();
-    const decoder = new TextDecoder();
-    let error = "";
-    for await (const chunk of codex.stderr) {
-      await Deno.stderr.write(chunk);
-      error += decoder.decode(chunk, { stream: true });
-    }
-    error += decoder.decode();
-    return { status: await codex.status, error };
-  };
-  const { status } = await retryInvalidToken(attempt, async () => {
-    await run("codex", ["logout"]);
-    await codexDeviceLogin();
-  });
   if (!status.success) throw new Error(`codex exited with ${status.code}`);
   return await Deno.readTextFile(file);
 }
 
 try {
   await configureGitAuthor();
-  const result = BOT === "claude" ? await runClaude() : await runCodex();
+  const prompt = await renderPrompt();
+  const result = env("BOT_TYPE") === "claude"
+    ? await runClaude(prompt)
+    : await runCodex(prompt);
   await postResult(result);
 } catch (error) {
   await postComment(`Bot failed: ${error}`);

superpowers.ts

@@ -1,147 +0,0 @@
-import { join } from "jsr:@std/path@1";
-
-export type BotType = "claude" | "codex";
-
-export type InstallCommand = {
-  command: string;
-  args: string[];
-};
-
-export type SuperpowersReviewGuide = {
-  version: string;
-  skillPath: string;
-  templatePath: string;
-  skill: string;
-  template: string;
-};
-
-export type SuperpowersFileSystem = {
-  readDir(path: string): AsyncIterable<Deno.DirEntry>;
-  readTextFile(path: string): Promise<string>;
-};
-
-const systemFileSystem: SuperpowersFileSystem = {
-  readDir: Deno.readDir,
-  readTextFile: Deno.readTextFile,
-};
-
-export function parseBotType(value: string): BotType {
-  if (value === "claude" || value === "codex") return value;
-  throw new Error(`unsupported bot type: ${value}`);
-}
-
-export function superpowersInstallCommands(
-  bot: BotType,
-): InstallCommand[] {
-  if (bot === "claude") {
-    return [
-      {
-        command: "claude",
-        args: [
-          "plugin",
-          "marketplace",
-          "add",
-          "obra/superpowers-marketplace",
-        ],
-      },
-      {
-        command: "claude",
-        args: [
-          "plugin",
-          "install",
-          "-y",
-          "superpowers@superpowers-marketplace",
-        ],
-      },
-    ];
-  }
-  return [{
-    command: "codex",
-    args: ["plugin", "add", "superpowers@openai-curated-remote"],
-  }];
-}
-
-type Candidate = SuperpowersReviewGuide & { directory: string };
-
-async function readCandidate(
-  directory: string,
-  fileSystem: SuperpowersFileSystem,
-): Promise<Candidate | null> {
-  if (!directory.split(/[\\/]/).includes("superpowers")) return null;
-  const skillPath = join(directory, "SKILL.md");
-  const templatePath = join(directory, "code-reviewer.md");
-  try {
-    const [skill, template] = await Promise.all([
-      fileSystem.readTextFile(skillPath),
-      fileSystem.readTextFile(templatePath),
-    ]);
-    return {
-      directory,
-      version: directory.split(/[\\/]/).at(-3) ?? "unknown",
-      skillPath,
-      templatePath,
-      skill,
-      template,
-    };
-  } catch (error) {
-    if (error instanceof Deno.errors.NotFound) return null;
-    throw error;
-  }
-}
-
-async function findCandidates(
-  directory: string,
-  candidates: Candidate[],
-  fileSystem: SuperpowersFileSystem,
-): Promise<void> {
-  let entries: Deno.DirEntry[];
-  try {
-    entries = [];
-    for await (const entry of fileSystem.readDir(directory)) {
-      entries.push(entry);
-    }
-  } catch (error) {
-    if (error instanceof Deno.errors.NotFound) return;
-    throw error;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory) continue;
-    const child = join(directory, entry.name);
-    if (entry.name === "requesting-code-review") {
-      const candidate = await readCandidate(child, fileSystem);
-      if (candidate !== null) candidates.push(candidate);
-    } else {
-      await findCandidates(child, candidates, fileSystem);
-    }
-  }
-}
-
-// Load the installed files rather than trusting skill discovery in a later
-// non-interactive agent process. The newest cached plugin version is the one
-// the installers activate, and the exact paths are reported by the caller.
-export async function loadSuperpowersReviewGuide(
-  bot: BotType,
-  home: string,
-  fileSystem: SuperpowersFileSystem = systemFileSystem,
-): Promise<SuperpowersReviewGuide> {
-  const root = join(
-    home,
-    bot === "codex" ? ".codex" : ".claude",
-    "plugins",
-    "cache",
-  );
-  const candidates: Candidate[] = [];
-  await findCandidates(root, candidates, fileSystem);
-  candidates.sort((left, right) =>
-    left.version.localeCompare(right.version, undefined, { numeric: true }) ||
-    left.directory.localeCompare(right.directory)
-  );
-  const guide = candidates.at(-1);
-  if (guide === undefined) {
-    throw new Error(
-      `installed Superpowers requesting-code-review files not found under ${root}`,
-    );
-  }
-  const { directory: _, ...result } = guide;
-  return result;
-}

superpowers_test.ts

@@ -1,119 +0,0 @@
-import { assertEquals, assertRejects, assertThrows } from "jsr:@std/assert@1";
-import { join } from "jsr:@std/path@1";
-import {
-  loadSuperpowersReviewGuide,
-  parseBotType,
-  type SuperpowersFileSystem,
-  superpowersInstallCommands,
-} from "./superpowers.ts";
-
-function fakeFileSystem(files: Record<string, string>): SuperpowersFileSystem {
-  return {
-    readTextFile(path) {
-      const contents = files[path];
-      return contents === undefined
-        ? Promise.reject(new Deno.errors.NotFound(path))
-        : Promise.resolve(contents);
-    },
-    async *readDir(directory) {
-      const prefix = `${directory}/`;
-      const children = new Map<string, boolean>();
-      for (const path of Object.keys(files)) {
-        if (!path.startsWith(prefix)) continue;
-        const [name, ...rest] = path.slice(prefix.length).split("/");
-        if (name !== "") children.set(name, rest.length > 0);
-      }
-      if (children.size === 0) throw new Deno.errors.NotFound(directory);
-      for (const [name, isDirectory] of children) {
-        yield {
-          name,
-          isDirectory,
-          isFile: !isDirectory,
-          isSymlink: false,
-        };
-      }
-    },
-  };
-}
-
-Deno.test("installs Superpowers from the Codex marketplace", () => {
-  assertEquals(superpowersInstallCommands("codex"), [{
-    command: "codex",
-    args: ["plugin", "add", "superpowers@openai-curated-remote"],
-  }]);
-});
-
-Deno.test("installs Superpowers from the Claude marketplace", () => {
-  assertEquals(superpowersInstallCommands("claude"), [
-    {
-      command: "claude",
-      args: [
-        "plugin",
-        "marketplace",
-        "add",
-        "obra/superpowers-marketplace",
-      ],
-    },
-    {
-      command: "claude",
-      args: [
-        "plugin",
-        "install",
-        "-y",
-        "superpowers@superpowers-marketplace",
-      ],
-    },
-  ]);
-});
-
-Deno.test("rejects an unsupported bot type", () => {
-  assertThrows(
-    () => parseBotType("other"),
-    Error,
-    "unsupported bot type: other",
-  );
-});
-
-Deno.test("loads the newest installed Superpowers review guide", async () => {
-  const home = "/home/bot";
-  const older = join(
-    home,
-    ".codex/plugins/cache/openai-curated-remote/superpowers/6.3.0/skills/requesting-code-review",
-  );
-  const newer = join(
-    home,
-    ".codex/plugins/cache/openai-curated-remote/superpowers/6.10.0/skills/requesting-code-review",
-  );
-  const guide = await loadSuperpowersReviewGuide(
-    "codex",
-    home,
-    fakeFileSystem({
-      [join(older, "SKILL.md")]: "old",
-      [join(older, "code-reviewer.md")]: "old template",
-      [join(newer, "SKILL.md")]: "new",
-      [join(newer, "code-reviewer.md")]: "template",
-    }),
-  );
-
-  assertEquals(guide.version, "6.10.0");
-  assertEquals(guide.skill, "new");
-  assertEquals(guide.template, "template");
-  assertEquals(guide.skillPath, join(newer, "SKILL.md"));
-});
-
-Deno.test("fails when the installed review guide is incomplete", async () => {
-  const home = "/home/bot";
-  const directory = join(
-    home,
-    ".claude/plugins/cache/superpowers-marketplace/superpowers/6.3.0/skills/requesting-code-review",
-  );
-  const fileSystem = fakeFileSystem({
-    [join(directory, "SKILL.md")]: "skill",
-  });
-
-  await assertRejects(
-    () => loadSuperpowersReviewGuide("claude", home, fileSystem),
-    Error,
-    "installed Superpowers requesting-code-review files not found",
-  );
-});