78 file(s) changed (+1348 −362) across 14 area(s)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
{
  "kind": "cloudflare::Worker",
  "id": "smithers-review",
  "fqn": "smithers-review/williamcory/smithers-review",
  "seq": 1,
  "data": {},
  "status": "created",
  "output": {
    "Symbol(alchemy::ResourceKind)": "cloudflare::Worker",
    "Symbol(alchemy::ResourceID)": "smithers-review",
    "Symbol(alchemy::ResourceFQN)": "smithers-review/williamcory/smithers-review",
    "Symbol(alchemy::ResourceScope)": {
      "@scope": null
    },
    "Symbol(alchemy::ResourceSeq)": 1,
    "entrypoint": "src/server/worker.ts",
    "compatibilityDate": "2025-05-01",
    "url": "https://smithers-review-smithers-review-williamcory.willcory10.workers.dev",
    "adopt": true,
    "bindings": {
      "WALKTHROUGHS": {
        "Symbol(alchemy::ResourceKind)": "cloudflare::R2Bucket",
        "Symbol(alchemy::ResourceID)": "walkthroughs",
        "Symbol(alchemy::ResourceFQN)": "smithers-review/williamcory/walkthroughs",
        "Symbol(alchemy::ResourceScope)": {
          "@scope": null
        },
        "Symbol(alchemy::ResourceSeq)": 0,
        "name": "smithers-review-walkthroughs-williamcory",
        "location": "ENAM",
        "creationDate": {
          "@date": "2026-06-11T15:39:38.296Z"
        },
        "jurisdiction": "default",
        "type": "r2_bucket",
        "accountId": "dd3525a4132493566aeb38de533c8827",
        "dev": {
          "id": "smithers-review-walkthroughs-williamcory",
          "remote": false,
          "isDeployed": true
        }
      },
      "REVIEW_PUBLISH_TOKEN": {
        "@secret": {
          "version": "v1",
          "ciphertext": "rsY5I9W/Aavyu/UBGuu27u3q8516cN7P3xsrcJfkW9Ro+asMVlrOk6WAYVyHYyH2",
          "iv": "rD0t2XWYdbVj2LCP",
          "salt": "XXlQtBU9UTurm0L70bH/8w==",
          "tag": "gX8FpNvG+SH2mPTDIQKoKg=="
        }
      },
      "PUBLIC_BASE_URL": "https://review.jjhub.tech"
    },
    "domains": [
      {
        "Symbol(alchemy::ResourceKind)": "cloudflare::CustomDomain",
        "Symbol(alchemy::ResourceID)": "review.jjhub.tech",
        "Symbol(alchemy::ResourceFQN)": "smithers-review/williamcory/smithers-review/review.jjhub.tech",
        "Symbol(alchemy::ResourceScope)": {
          "@scope": null
        },
        "Symbol(alchemy::ResourceSeq)": 0,
        "name": "review.jjhub.tech",
        "zoneId": "72854846f57d9e46794e7e6aae7e3328",
        "adopt": true,
        "workerName": "smithers-review-smithers-review-williamcory",
        "dev": false,
        "id": "c52358c69dc05bde3d76c7f8a3ccd97de845d03e",
        "environment": "production",
        "createdAt": 1781192629587,
        "updatedAt": 1781192629587
      }
    ],
    "routes": [],
    "type": "service",
    "id": "smithers-review",
    "name": "smithers-review-smithers-review-williamcory",
    "cwd": "",
    "compatibilityFlags": [],
    "format": "esm",
    "createdAt": {
      "@date": "2026-06-11T15:43:49.589Z"
    },
    "updatedAt": {
      "@date": "2026-06-11T15:43:49.589Z"
    },
    "dev": {
      "hasRemote": true
    }
  },
  "props": {
    "entrypoint": "src/server/worker.ts",
    "compatibilityDate": "2025-05-01",
    "url": true,
    "adopt": true,
    "bindings": {
      "WALKTHROUGHS": {
        "Symbol(alchemy::ResourceKind)": "cloudflare::R2Bucket",
        "Symbol(alchemy::ResourceID)": "walkthroughs",
        "Symbol(alchemy::ResourceFQN)": "smithers-review/williamcory/walkthroughs",
        "Symbol(alchemy::ResourceScope)": {
          "@scope": null
        },
        "Symbol(alchemy::ResourceSeq)": 0,
        "name": "smithers-review-walkthroughs-williamcory",
        "location": "ENAM",
        "creationDate": {
          "@date": "2026-06-11T15:39:38.296Z"
        },
        "jurisdiction": "default",
        "type": "r2_bucket",
        "accountId": "dd3525a4132493566aeb38de533c8827",
        "dev": {
          "id": "smithers-review-walkthroughs-williamcory",
          "remote": false,
          "isDeployed": true
        }
      },
      "REVIEW_PUBLISH_TOKEN": {
        "@secret": {
          "version": "v1",
          "ciphertext": "tye0CasMa/nqnCR8ORNb6B6zj/u5WGRYhVokVrowhceOjrYa1PwSE1mckG3Olp1x",
          "iv": "satWrjDI+zifa6vG",
          "salt": "v3hCyfy/oGnUEZ+u43leGA==",
          "tag": "sDddZ8OfYAXOPwNIKVbqpg=="
        }
      },
      "PUBLIC_BASE_URL": "https://review.jjhub.tech"
    },
    "domains": [
      {
        "domainName": "review.jjhub.tech",
        "zoneId": "72854846f57d9e46794e7e6aae7e3328",
        "adopt": true
      }
    ],
    "routes": []
  }
}
No newline at end of file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
/**
 * Cloudflare Worker serving published walkthroughs at review.smithers.sh.
 *
 * POST /api/walkthroughs  (Bearer REVIEW_PUBLISH_TOKEN, HTML body) -> { id, url }
 * GET  /w/<id>            serve a published walkthrough
 * GET  /                  usage landing page
 *
 * Storage is R2; ids are random capability links, there is no listing.
 */

const MAX_WALKTHROUGH_BYTES = 25 * 1024 * 1024;

type R2ObjectBody = { body: ReadableStream } | null;

type WalkthroughBucket = {
  put(key: string, value: ArrayBuffer | string, options?: { httpMetadata?: { contentType?: string } }): Promise<unknown>;
  get(key: string): Promise<R2ObjectBody>;
};

export type ReviewWorkerEnv = {
  WALKTHROUGHS: WalkthroughBucket;
  REVIEW_PUBLISH_TOKEN: string;
  PUBLIC_BASE_URL?: string;
};

const landingPage = `<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>smithers review</title>
<style>
body { margin: 0; font: 16px/1.6 -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif; color: #1f2328; background: #f6f8fa; }
main { max-width: 720px; margin: 0 auto; padding: 64px 24px; }
h1 { font-size: 28px; margin: 0 0 8px; }
p { color: #59636e; max-width: 65ch; }
pre { background: #fff; border: 1px solid #d1d9e0; border-radius: 8px; padding: 14px 16px; overflow-x: auto; font-size: 13px; }
code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
</style>
</head>
<body>
<main>
<h1>smithers review</h1>
<p>Code review plus story-form walkthroughs. Walkthroughs published here are unlisted; you need the link.</p>
<p>Publish one from a repo:</p>
<pre><code>smithers-review --from main --to HEAD --publish</code></pre>
<p>Part of <a href="https://github.com/smithersai/smithers">smithers</a>.</p>
</main>
</body>
</html>`;

function newWalkthroughId(): string {
  const bytes = new Uint8Array(12);
  crypto.getRandomValues(bytes);
  return [...bytes].map((b) => (b % 36).toString(36)).join("");
}

function timingSafeEqual(a: string, b: string): boolean {
  const encoder = new TextEncoder();
  const left = encoder.encode(a);
  const right = encoder.encode(b);
  if (left.length !== right.length) return false;
  let diff = 0;
  for (let i = 0; i < left.length; i += 1) diff |= left[i] ^ right[i];
  return diff === 0;
}

export default {
  async fetch(request: Request, env: ReviewWorkerEnv): Promise<Response> {
    const url = new URL(request.url);

    if (request.method === "GET" && url.pathname === "/") {
      return new Response(landingPage, { headers: { "content-type": "text/html; charset=utf-8" } });
    }

    if (request.method === "POST" && url.pathname === "/api/walkthroughs") {
      const token = env.REVIEW_PUBLISH_TOKEN ?? "";
      const auth = request.headers.get("authorization") ?? "";
      if (!token || !timingSafeEqual(auth, `Bearer ${token}`)) {
        return Response.json({ error: "unauthorized" }, { status: 401 });
      }
      const html = await request.arrayBuffer();
      if (html.byteLength === 0) {
        return Response.json({ error: "empty body" }, { status: 400 });
      }
      if (html.byteLength > MAX_WALKTHROUGH_BYTES) {
        return Response.json({ error: "walkthrough exceeds 25MB" }, { status: 413 });
      }
      const id = newWalkthroughId();
      await env.WALKTHROUGHS.put(`walkthroughs/${id}.html`, html, {
        httpMetadata: { contentType: "text/html; charset=utf-8" },
      });
      const base = (env.PUBLIC_BASE_URL ?? url.origin).replace(/\/$/, "");
      return Response.json({ id, url: `${base}/w/${id}` }, { status: 201 });
    }

    if (request.method === "GET" && /^\/w\/[a-z0-9]{8,32}$/.test(url.pathname)) {
      const id = url.pathname.slice("/w/".length);
      const object = await env.WALKTHROUGHS.get(`walkthroughs/${id}.html`);
      if (!object) return new Response("Not found", { status: 404 });
      return new Response(object.body, {
        headers: {
          "content-type": "text/html; charset=utf-8",
          "cache-control": "public, max-age=31536000, immutable",
          "x-robots-tag": "noindex",
        },
      });
    }

    return new Response("Not found", { status: 404 });
  },
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/**
 * Alchemy infrastructure-as-code for the smithers review publish service.
 *
 * One Cloudflare Worker (entry: src/server/worker.ts) + one R2 bucket. The
 * Worker keeps its workers.dev URL and serves review.jjhub.tech as a custom
 * domain (the jjhub.tech zone is on this Cloudflare account).
 *
 * review.smithers.sh: the smithers.sh zone lives on Vercel DNS (registrar
 * Name.com), so serving it from this Worker needs Cloudflare for SaaS
 * (custom hostname on jjhub.tech + a CNAME at Vercel). The current
 * CLOUDFLARE_API_TOKEN lacks the SSL-and-Certificates permission for custom
 * hostnames and the available VERCEL_API_TOKEN is expired, so that leg is
 * gated behind REVIEW_ENABLE_SMITHERS_SH_ROUTE=1 until credentials exist.
 * See .smithers/specs/smithers-review-walkthrough.md, "Publishing".
 *
 * Deploy:   REVIEW_PUBLISH_TOKEN=... bun x alchemy deploy   (from apps/review)
 * Destroy:  bun x alchemy destroy
 *
 * Required env: CLOUDFLARE_API_TOKEN, ALCHEMY_PASSWORD, REVIEW_PUBLISH_TOKEN.
 */
import alchemy from "alchemy";
import { R2Bucket, Worker } from "alchemy/cloudflare";

const JJHUB_ZONE_ID = "72854846f57d9e46794e7e6aae7e3328";

const app = await alchemy("smithers-review");

const publishToken = process.env.REVIEW_PUBLISH_TOKEN?.trim();
if (!publishToken) {
  throw new Error("REVIEW_PUBLISH_TOKEN is required to deploy (the publish API bearer token).");
}

const bucket = await R2Bucket("walkthroughs", {
  adopt: true,
});

const smithersShRoutes =
  process.env.REVIEW_ENABLE_SMITHERS_SH_ROUTE === "1"
    ? [{ pattern: "review.smithers.sh/*", zoneId: JJHUB_ZONE_ID, adopt: true }]
    : [];

export const worker = await Worker("smithers-review", {
  entrypoint: "src/server/worker.ts",
  compatibilityDate: "2025-05-01",
  url: true,
  adopt: true,
  bindings: {
    WALKTHROUGHS: bucket,
    REVIEW_PUBLISH_TOKEN: alchemy.secret(publishToken),
    PUBLIC_BASE_URL: process.env.REVIEW_PUBLIC_BASE_URL?.trim() || "https://review.jjhub.tech",
  },
  domains: [{ domainName: "review.jjhub.tech", zoneId: JJHUB_ZONE_ID, adopt: true }],
  routes: smithersShRoutes,
});

console.log(`smithers review deployed → ${worker.url ?? "(no workers.dev url)"}`);

await app.finalize();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import { existsSync, readFileSync } from "node:fs";
import { homedir } from "node:os";
import { join } from "node:path";

const DEFAULT_PUBLISH_URL = "https://review.smithers.sh";

function loadPublishConfig(): { url: string; token: string } {
  let url = process.env.SMITHERS_REVIEW_PUBLISH_URL?.trim() || "";
  let token = process.env.SMITHERS_REVIEW_PUBLISH_TOKEN?.trim() || "";
  if (!url || !token) {
    const path = join(homedir(), ".smithers-review.json");
    if (existsSync(path)) {
      const raw = JSON.parse(readFileSync(path, "utf8")) as { publishUrl?: string; publishToken?: string };
      url = url || raw.publishUrl?.trim() || "";
      token = token || raw.publishToken?.trim() || "";
    }
  }
  url = url || DEFAULT_PUBLISH_URL;
  if (!token) {
    throw new Error(
      "no publish token: set SMITHERS_REVIEW_PUBLISH_TOKEN or write ~/.smithers-review.json with { \"publishToken\": \"...\" }",
    );
  }
  return { url: url.replace(/\/$/, ""), token };
}

/** Upload a walkthrough HTML file to the publish service; returns the share URL. */
export async function publishWalkthrough(htmlPath: string): Promise<string> {
  const { url, token } = loadPublishConfig();
  const html = readFileSync(htmlPath);
  const response = await fetch(`${url}/api/walkthroughs`, {
    method: "POST",
    headers: {
      authorization: `Bearer ${token}`,
      "content-type": "text/html; charset=utf-8",
    },
    body: html,
  });
  if (!response.ok) {
    const detail = await response.text().catch(() => "");
    throw new Error(`publish failed: HTTP ${response.status}${detail ? ` ${detail.slice(0, 200)}` : ""}`);
  }
  const data = (await response.json()) as { url?: string };
  if (!data.url) throw new Error("publish failed: response had no url");
  return data.url;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
{
  "kind": "cloudflare::R2Bucket",
  "id": "walkthroughs",
  "fqn": "smithers-review/williamcory/walkthroughs",
  "seq": 0,
  "data": {},
  "status": "created",
  "output": {
    "Symbol(alchemy::ResourceKind)": "cloudflare::R2Bucket",
    "Symbol(alchemy::ResourceID)": "walkthroughs",
    "Symbol(alchemy::ResourceFQN)": "smithers-review/williamcory/walkthroughs",
    "Symbol(alchemy::ResourceScope)": {
      "@scope": null
    },
    "Symbol(alchemy::ResourceSeq)": 0,
    "name": "smithers-review-walkthroughs-williamcory",
    "location": "ENAM",
    "creationDate": {
      "@date": "2026-06-11T15:39:38.296Z"
    },
    "jurisdiction": "default",
    "type": "r2_bucket",
    "accountId": "dd3525a4132493566aeb38de533c8827",
    "dev": {
      "id": "smithers-review-walkthroughs-williamcory",
      "remote": false,
      "isDeployed": true
    }
  },
  "props": {
    "adopt": true,
    "dev": {
      "force": false
    }
  }
}
No newline at end of file

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
{
  "kind": "cloudflare::CustomDomain",
  "id": "review.jjhub.tech",
  "fqn": "smithers-review/williamcory/smithers-review/review.jjhub.tech",
  "seq": 0,
  "data": {},
  "status": "created",
  "output": {
    "Symbol(alchemy::ResourceKind)": "cloudflare::CustomDomain",
    "Symbol(alchemy::ResourceID)": "review.jjhub.tech",
    "Symbol(alchemy::ResourceFQN)": "smithers-review/williamcory/smithers-review/review.jjhub.tech",
    "Symbol(alchemy::ResourceScope)": {
      "@scope": null
    },
    "Symbol(alchemy::ResourceSeq)": 0,
    "name": "review.jjhub.tech",
    "zoneId": "72854846f57d9e46794e7e6aae7e3328",
    "adopt": true,
    "workerName": "smithers-review-smithers-review-williamcory",
    "dev": false,
    "id": "c52358c69dc05bde3d76c7f8a3ccd97de845d03e",
    "environment": "production",
    "createdAt": 1781192629587,
    "updatedAt": 1781192629587
  },
  "props": {
    "name": "review.jjhub.tech",
    "zoneId": "72854846f57d9e46794e7e6aae7e3328",
    "adopt": true,
    "workerName": "smithers-review-smithers-review-williamcory",
    "dev": false
  }
}
No newline at end of file

6 unmodified lines
7
8
9
10
11
12
13
11 unmodified lines
25
26
27
28
29
30
31
61 unmodified lines
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
99
112
113
114
115
6 unmodified lines
import { createReviewAgents } from "../workflow/createReviewAgents";
import { createReviewWorkflow } from "../workflow/createReviewWorkflow";
import { parseReviewArgs, type ReviewArgs } from "./parseReviewArgs";
import { publishWalkthrough } from "./publishWalkthrough";

const USAGE = `smithers review — code review + story-form HTML walkthrough

11 unmodified lines
  --concurrency <n>         parallel file reviews (default 8)
  --timeout <min>           per-agent-task timeout in minutes (default 10)
  --split                   side-by-side diffs instead of unified
  --publish                 upload to review.smithers.sh and print the share URL
  --open                    open the walkthrough in the default browser
  -h, --help                show this help`;

61 unmodified lines
  if (review?.message) console.log(`Review: ${String(review.message)}`);
  console.log(String(walkthrough.message ?? `Walkthrough written to ${String(walkthrough.path)}`));

  let publishFailed = false;
  if (args.publish) {
    try {
      const shareUrl = await publishWalkthrough(String(walkthrough.path));
      console.log(`Published: ${shareUrl}`);
    } catch (error) {
      publishFailed = true;
      console.error(`smithers-review: ${(error as Error).message}`);
    }
  }

  if (args.open) {
    const opener = process.platform === "darwin" ? "open" : "xdg-open";
    spawn(opener, [String(walkthrough.path)], { stdio: "ignore", detached: true }).unref();
  }

  const failed = result.status === "failed" || result.status === "cancelled";
  const failed = result.status === "failed" || result.status === "cancelled" || publishFailed;
  process.exit(failed ? 1 : 0);
}

2 unmodified lines
3
4
5
6
6
7
8
9
10
9
10
11
12
2 unmodified lines
/**
 * Default agent arrays for review and narration. Mirrors .smithers/agents.ts:
 * the ClaudeCode subscription providers are the reliable ones locally
 * (issue #236); opus primary, sonnet failover.
 * (issue #236); Fable primary, Opus failover.
 */
export function createReviewAgents(repoDir: string): { review: AgentLike[]; narrate: AgentLike[] } {
  const primary = new ClaudeCodeAgent({ model: process.env.SMITHERS_REVIEW_MODEL ?? "claude-opus-4-7", cwd: repoDir });
  const fallback = new ClaudeCodeAgent({ model: process.env.SMITHERS_REVIEW_FALLBACK_MODEL ?? "claude-sonnet-4-7", cwd: repoDir });
  const primary = new ClaudeCodeAgent({ model: process.env.SMITHERS_REVIEW_MODEL ?? "claude-fable-5", cwd: repoDir });
  const fallback = new ClaudeCodeAgent({ model: process.env.SMITHERS_REVIEW_FALLBACK_MODEL ?? "claude-opus-4-8", cwd: repoDir });
  return { review: [primary, fallback], narrate: [primary, fallback] };
}

11 unmodified lines
12
13
14
15
16
17
18
13 unmodified lines
32
33
34
35
36
37
38
16 unmodified lines
55
56
57
58
59
60
61
11 unmodified lines
  concurrency: number;
  timeout: number;
  split: boolean;
  publish: boolean;
  open: boolean;
  help: boolean;
};
13 unmodified lines
    concurrency: 8,
    timeout: 10,
    split: false,
    publish: false,
    open: false,
    help: false,
  };
16 unmodified lines
    else if (arg === "--concurrency") args.concurrency = Number(next());
    else if (arg === "--timeout") args.timeout = Number(next());
    else if (arg === "--split") args.split = true;
    else if (arg === "--publish") args.publish = true;
    else if (arg === "--open") args.open = true;
    else if (arg === "--help" || arg === "-h") args.help = true;
    else if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);

15 unmodified lines
16
17
18
19
19
20
21
21
22
23
23
24
25
26
4 unmodified lines
31
32
33
34
35
34
35
36
38
37
38
39
40
41
42
44
43
44
45
47
46
47
48
50
49
50
51
52
53
55
56
57
58
59
54
55
56
57
58
59
60
61
62
63
65
64
65
66
67
69
70
68
69
70
72
73
71
72
73
74
76
77
78
75
76
77
78
79
80
5 unmodified lines
86
87
88
90
91
89
90
91
92
93
172 unmodified lines
266
267
268
270
271
269
270
271
273
272
273
274
275
277
276
277
279
278
279
280
281
283
282
283
284
285
20 unmodified lines
306
307
308
310
311
309
310
311
313
312
313
314
315
317
318
316
317
318
319
321
322
320
321
322
324
323
324
326
325
326
327
328
15 unmodified lines
 *               through, so the benchmark executes them exactly as it would for
 *               any model.
 *   - SYNTHESIS: the moment gpt-5.5 is ready to answer (no tool_calls), Claude
 *               Opus 4.8 (via Smithers ClaudeCodeAgent, subscription) writes the
 *               Fable (via Smithers ClaudeCodeAgent, subscription) writes the
 *               final answer from the gathered context. That is the role-split
 *               "mixture of Opus 4.8 + Codex 5.5" (gpt-5.5 gathers, Opus 4.8
 *               "mixture of Fable + GPT-5.5" (gpt-5.5 gathers, Fable
 *               synthesizes) and it lands on the turn the graders actually
 *               measure. If Opus is unavailable, the turn falls back to gpt-5.5's
 *               measure. If Fable is unavailable, the turn falls back to gpt-5.5's
 *               own final answer. The brain contains no LLM judge of its own.
 *
 * Fairness invariants (see README): the brain only ever sees what the benchmark
4 unmodified lines
import { ClaudeCodeAgent, OpenAIAgent } from "@smithers-orchestrator/agents";

// ---- model identifiers -----------------------------------------------------
// "Codex 5.5" → gpt-5.5 (the flagship 5.5; no `gpt-5.5-codex` variant exists,
// the latest codex-tuned model is gpt-5.3-codex). gpt-5.5 is the strongest 5.5.
// "Codex 5.5" → gpt-5.5 (the flagship 5.5; no `gpt-5.5-codex` variant exists).
const GATHER_MODEL = process.env.CLAW_GATHER_MODEL ?? "gpt-5.5";
const GPT_SYNTH_MODEL = process.env.CLAW_GPT_MODEL ?? "gpt-5.5";
const OPUS_MODEL = process.env.CLAW_OPUS_MODEL ?? "opus"; // -> claude-opus-4-8
const FABLE_MODEL = process.env.CLAW_FABLE_MODEL ?? "claude-fable-5";

const OPENAI_URL = "https://api.openai.com/v1/chat/completions";

const OPENAI_KEY = process.env.OPENAI_API_KEY ?? "";

const OPUS_TIMEOUT_MS = Number(process.env.CLAW_OPUS_TIMEOUT_MS ?? 150_000);
const FABLE_TIMEOUT_MS = Number(process.env.CLAW_FABLE_TIMEOUT_MS ?? 150_000);
const GPT_TIMEOUT_MS = Number(process.env.CLAW_GPT_TIMEOUT_MS ?? 120_000);

// Each Opus draft spawns a `claude` CLI subprocess. Bound how many run at once
// Each Fable draft spawns a `claude` CLI subprocess. Bound how many run at once
// so a parallel batch can't fork-bomb the box; over the cap we simply fall back
// to the gpt-5.5 draft for that turn (synthesis still happens, just single-model).
const OPUS_MAX = Number(process.env.CLAW_OPUS_MAX_CONCURRENCY ?? 2);
const FABLE_MAX = Number(process.env.CLAW_FABLE_MAX_CONCURRENCY ?? 2);
// Cap the transcript fed to the synthesis drafts (large tool results / file dumps
// would otherwise blow up memory and token cost).
const MAX_TRANSCRIPT_CHARS = Number(process.env.CLAW_MAX_TRANSCRIPT_CHARS ?? 140_000);

let opusActive = 0;
const opusWaiters: Array<() => void> = [];
function acquireOpus(): Promise<boolean> {
  if (opusActive < OPUS_MAX) {
    opusActive++;
let fableActive = 0;
const fableWaiters: Array<() => void> = [];
function acquireFable(): Promise<boolean> {
  if (fableActive < FABLE_MAX) {
    fableActive++;
    return Promise.resolve(true);
  }
  return new Promise<boolean>((resolve) => {
    const grant = () => {
      clearTimeout(timer);
      opusActive++;
      fableActive++;
      resolve(true);
    };
    const timer = setTimeout(() => {
      const i = opusWaiters.indexOf(grant);
      if (i >= 0) opusWaiters.splice(i, 1);
      const i = fableWaiters.indexOf(grant);
      if (i >= 0) fableWaiters.splice(i, 1);
      resolve(false); // saturated -> caller falls back to gpt-only synthesis
    }, OPUS_TIMEOUT_MS);
    opusWaiters.push(grant);
    }, FABLE_TIMEOUT_MS);
    fableWaiters.push(grant);
  });
}
function releaseOpus(): void {
  opusActive = Math.max(0, opusActive - 1);
  const next = opusWaiters.shift();
function releaseFable(): void {
  fableActive = Math.max(0, fableActive - 1);
  const next = fableWaiters.shift();
  if (next) next();
}

5 unmodified lines
}

// Reused agent instances (stateless per generate()).
const opusAgent = new ClaudeCodeAgent({
  model: OPUS_MODEL,
const fableAgent = new ClaudeCodeAgent({
  model: FABLE_MODEL,
  yolo: false,
  tools: "", // decision/writing only — no tool use
  systemPrompt: SYNTH_SYSTEM(),
172 unmodified lines
}

// ---- phase 2 drafts --------------------------------------------------------
async function opusDraft(transcript: string): Promise<string> {
  const got = await acquireOpus();
async function fableDraft(transcript: string): Promise<string> {
  const got = await acquireFable();
  if (!got) {
    console.error("[mixture] opus saturated — falling back to gpt-only synthesis this turn");
    console.error("[mixture] fable saturated — falling back to gpt-only synthesis this turn");
    return "";
  }
  try {
    const res: any = await opusAgent.generate({
    const res: any = await fableAgent.generate({
      prompt: `Here is the full task context and all information already gathered via tools.\n\n${transcript}\n\nNow write the complete final answer.`,
      timeout: OPUS_TIMEOUT_MS,
      timeout: FABLE_TIMEOUT_MS,
    });
    return (res?.text ?? "").trim();
  } finally {
    releaseOpus();
    releaseFable();
  }
}

20 unmodified lines
    };
  }

  // Ready to answer -> Opus 4.8 writes the final deliverable (the graded turn).
  // gpt-5.5 has already done all the tool-driven gathering; Opus 4.8 — the
  // Ready to answer -> Fable writes the final deliverable (the graded turn).
  // gpt-5.5 has already done all the tool-driven gathering; Fable — the
  // stronger synthesizer — composes the final answer from that context. This is
  // the role-split mixture: GPT-5.5 gathers, Opus 4.8 synthesizes. (No LLM
  // the role-split mixture: GPT-5.5 gathers, Fable synthesizes. (No LLM
  // arbiter: the only LLM-as-judge in the whole pipeline is the benchmark's own
  // neutral judge, keeping the fairness story minimal.)
  const { transcript } = renderTranscript(req.messages);
  const opusFinal = await opusDraft(transcript).catch((e) => {
    console.error("[mixture] opusDraft failed:", String(e).slice(0, 200));
  const fableFinal = await fableDraft(transcript).catch((e) => {
    console.error("[mixture] fableDraft failed:", String(e).slice(0, 200));
    return "";
  });
  if (opusFinal) {
    return finalResult(opusFinal, g.usage, { phase: "synthesis", writer: "opus-4.8" });
  if (fableFinal) {
    return finalResult(fableFinal, g.usage, { phase: "synthesis", writer: "claude-fable-5" });
  }
  // Opus unavailable/saturated -> fall back to gpt-5.5's own final answer.
  // Fable unavailable/saturated -> fall back to gpt-5.5's own final answer.
  const gptFinal = (g.content ?? "").trim() || (await gptDraft(transcript).catch(() => ""));
  return finalResult(gptFinal, g.usage, { phase: "synthesis", writer: "gpt-5.5", reason: "opus unavailable" });
  return finalResult(gptFinal, g.usage, { phase: "synthesis", writer: "gpt-5.5", reason: "fable unavailable" });
}

function finalResult(

17 unmodified lines
18
19
20
21
22
23
24
21
22
23
24
25
27
26
27
28
30
31
29
30
31
33
34
35
36
37
32
33
34
35
36
37
38
39
43
44
45
46
40
41
42
43
48
49
50
51
52
44
45
46
47
48
55
49
50
51
58
59
52
53
54
61
62
63
55
56
57
58
59
60
61
62
17 unmodified lines
];

/**
 * Claude Opus 4.8 implementer. Reads the task spec + repo and edits files in
 * place to satisfy the requirements. Runs on the host `claude` CLI against the
 * extracted checkout (`cwd`), using the user's subscription (the constructor
 * clears ANTHROPIC_API_KEY so it does not fall back to metered API billing).
 * GPT-5.5 implementer. Reads the task spec + repo and edits files in place to
 * satisfy the requirements. Runs on the host `codex` CLI with workspace-write
 * sandboxing scoped to the extracted checkout.
 *
 * @param {{ cwd: string, model?: string, timeoutMs?: number }} opts
 * @returns {ClaudeCodeAgent}
 * @returns {CodexAgent}
 */
export function implementerAgent(opts) {
  return new ClaudeCodeAgent({
    id: "opus-implementer",
  return new CodexAgent({
    id: "gpt-implementer",
    cwd: opts.cwd,
    model: opts.model ?? process.env.SWEBP_IMPLEMENTER_MODEL ?? "claude-opus-4-8",
    permissionMode: "bypassPermissions",
    yolo: true,
    allowedTools: BUILD_TOOLS,
    disallowedTools: ["WebFetch", "WebSearch"],
    model: opts.model ?? process.env.SWEBP_IMPLEMENTER_MODEL ?? "gpt-5.5",
    sandbox: "workspace-write",
    fullAuto: true,
    timeoutMs: opts.timeoutMs ?? 30 * 60 * 1000,
  });
}

/**
 * Codex 5.5 (GPT-5.5) reviewer/repairer. Independently re-reads the spec, audits
 * Opus's working-tree diff, builds/tests what it can, and directly fixes any
 * remaining gaps. Runs on the host `codex` CLI with workspace-write sandboxing
 * scoped to the checkout, so it can edit but not roam the host.
 * Claude Fable reviewer/repairer. Independently re-reads the spec, audits the
 * GPT implementer's working-tree diff, builds/tests what it can, and directly
 * fixes any remaining gaps using the user's Claude subscription.
 *
 * Network posture (kept symmetric with the implementer on purpose): `--full-auto`
 * selects Codex's workspace-write sandbox, which disables network access by
 * default — so the reviewer cannot fetch external solutions. The implementer
 * keeps Bash for dependency installs but is denied WebFetch/WebSearch. Neither
 * agent can reach the hidden tests, which exist only inside the scoring container.
 * Network posture: the reviewer keeps Bash for local build/test commands but is
 * denied WebFetch/WebSearch. Neither agent can reach the hidden tests, which
 * exist only inside the scoring container.
 *
 * @param {{ cwd: string, model?: string, timeoutMs?: number }} opts
 * @returns {CodexAgent}
 * @returns {ClaudeCodeAgent}
 */
export function reviewerAgent(opts) {
  return new CodexAgent({
    id: "codex-reviewer",
  return new ClaudeCodeAgent({
    id: "fable-reviewer",
    cwd: opts.cwd,
    model: opts.model ?? process.env.SWEBP_REVIEWER_MODEL ?? "gpt-5.5",
    sandbox: "workspace-write",
    fullAuto: true,
    model: opts.model ?? process.env.SWEBP_REVIEWER_MODEL ?? "claude-fable-5",
    permissionMode: "bypassPermissions",
    yolo: true,
    allowedTools: BUILD_TOOLS,
    disallowedTools: ["WebFetch", "WebSearch"],
    timeoutMs: opts.timeoutMs ?? 30 * 60 * 1000,
  });
}

13 unmodified lines
14
15
16
17
17
18
19
20
21
22
23
24
24
25
26
27
26
27
28
29
29
30
31
31
32
33
33
34
35
36
8 unmodified lines
45
46
47
48
48
49
50
51
80 unmodified lines
132
133
134
135
135
13 unmodified lines
// Bun caps idleTimeout at 255s, and a turn is idle on the socket for its whole
// gather+synthesis duration (the response is only written after both phases
// finish). mixture.ts reads its per-phase budgets from CLAW_GPT_TIMEOUT_MS +
// CLAW_OPUS_TIMEOUT_MS at module load, and their defaults (120s + 150s = 270s)
// CLAW_FABLE_TIMEOUT_MS at module load, and their defaults (120s + 150s = 270s)
// exceed that ceiling, so a slow synthesis turn would be killed by Bun before
// it could respond. Clamp the sum to fit under idleTimeout (with margin) BEFORE
// importing mixture.ts so the per-phase timeouts become the real constraint.
const IDLE_TIMEOUT_S = 255; // Bun's documented maximum.
const PHASE_BUDGET_MS = (IDLE_TIMEOUT_S - 5) * 1000; // leave headroom for I/O.
{
  const opus = Number(process.env.CLAW_OPUS_TIMEOUT_MS ?? 150_000);
  const fable = Number(process.env.CLAW_FABLE_TIMEOUT_MS ?? 150_000);
  const gpt = Number(process.env.CLAW_GPT_TIMEOUT_MS ?? 120_000);
  if (opus + gpt > PHASE_BUDGET_MS) {
    const scale = PHASE_BUDGET_MS / (opus + gpt);
  if (fable + gpt > PHASE_BUDGET_MS) {
    const scale = PHASE_BUDGET_MS / (fable + gpt);
    process.env.CLAW_GPT_TIMEOUT_MS = String(Math.floor(gpt * scale));
    process.env.CLAW_OPUS_TIMEOUT_MS = String(Math.floor(opus * scale));
    process.env.CLAW_FABLE_TIMEOUT_MS = String(Math.floor(fable * scale));
    console.warn(
      `[gateway] gather+synthesis budget ${opus + gpt}ms exceeds idle ceiling; ` +
      `[gateway] gather+synthesis budget ${fable + gpt}ms exceeds idle ceiling; ` +
        `clamped to CLAW_GPT_TIMEOUT_MS=${process.env.CLAW_GPT_TIMEOUT_MS} ` +
        `CLAW_OPUS_TIMEOUT_MS=${process.env.CLAW_OPUS_TIMEOUT_MS}`,
        `CLAW_FABLE_TIMEOUT_MS=${process.env.CLAW_FABLE_TIMEOUT_MS}`,
    );
  }
}
8 unmodified lines
process.on("unhandledRejection", (reason) => console.error("[gateway] unhandledRejection:", reason));

const PORT = Number(process.env.CLAW_GATEWAY_PORT ?? 8788);
const MODEL_ID = process.env.CLAW_MODEL_ID ?? "smithers-mixture-opus48-gpt55";
const MODEL_ID = process.env.CLAW_MODEL_ID ?? "smithers-mixture-fable5-gpt55";

function requireEnv() {
  const missing: string[] = [];
80 unmodified lines

console.log(`[gateway] Smithers mixture brain listening on http://127.0.0.1:${server.port}`);
console.log(`[gateway] model_id=${MODEL_ID}`);
console.log(`[gateway] gather=${process.env.CLAW_GATHER_MODEL ?? "gpt-5.5"} opus=${process.env.CLAW_OPUS_MODEL ?? "opus"} arbiter=${process.env.CLAW_ARBITER_MODEL ?? "gemini-3.5-flash"}`);
console.log(`[gateway] gather=${process.env.CLAW_GATHER_MODEL ?? "gpt-5.5"} fable=${process.env.CLAW_FABLE_MODEL ?? "claude-fable-5"} arbiter=${process.env.CLAW_ARBITER_MODEL ?? "gemini-3.5-flash"}`);

56 unmodified lines
57
58
59
60
61
60
61
62
63
64
130 unmodified lines
195
196
197
198
199
198
199
200
201
202
56 unmodified lines
    SWEBP_GATEWAY_HOST: host,
    SWEBP_GATEWAY_WORKFLOW_KEY: key,
    SWEBP_DB_PATH: join(runDir, "gateway.db"),
    SWEBP_IMPLEMENTER_MODEL: opts.implementerModel ?? process.env.SWEBP_IMPLEMENTER_MODEL ?? "claude-opus-4-8",
    SWEBP_REVIEWER_MODEL: opts.reviewerModel ?? process.env.SWEBP_REVIEWER_MODEL ?? "gpt-5.5",
    SWEBP_IMPLEMENTER_MODEL: opts.implementerModel ?? process.env.SWEBP_IMPLEMENTER_MODEL ?? "gpt-5.5",
    SWEBP_REVIEWER_MODEL: opts.reviewerModel ?? process.env.SWEBP_REVIEWER_MODEL ?? "claude-fable-5",
    ...(opts.token ? { SWEBP_GATEWAY_TOKEN: opts.token } : {}),
  };

130 unmodified lines
    dataset: `${config.upstream.dataset}:${config.upstream.datasetSplit}`,
    transport: "gateway",
    models: {
      implementer: opts.implementerModel ?? process.env.SWEBP_IMPLEMENTER_MODEL ?? "claude-opus-4-8",
      reviewer: opts.reviewerModel ?? process.env.SWEBP_REVIEWER_MODEL ?? "gpt-5.5",
      implementer: opts.implementerModel ?? process.env.SWEBP_IMPLEMENTER_MODEL ?? "gpt-5.5",
      reviewer: opts.reviewerModel ?? process.env.SWEBP_REVIEWER_MODEL ?? "claude-fable-5",
    },
    integrityChecked: !opts.skipIntegrity,
    finishedAtMs: opts.nowMs ?? null,

9 unmodified lines
10
11
12
13
14
15
16
13
14
15
16
17
18
19
9 unmodified lines
 * Two frontier models collaborate on a real repository checkout (already pinned
 * to `base_commit` with history stripped by the runner):
 *
 *   implement — Claude Opus 4.8 reads the task spec, edits the source in place,
 *               and self-verifies with the repo's own build/test where it can.
 *   review    — Codex 5.5 independently audits the working-tree diff against the
 *               requirements/interface, rebuilds, and directly fixes any gaps.
 *   implement — GPT-5.5 reads the task spec, edits the source in place, and
 *               self-verifies with the repo's own build/test where it can.
 *   review    — Claude Fable independently audits the working-tree diff against
 *               the requirements/interface, rebuilds, and directly fixes gaps.
 *
 * The agents never receive the hidden tests or the gold patch — only the
 * problem statement, behavioral requirements, and interface. The runner captures

10 unmodified lines
11
12
13
14
14
15
16
17
41 unmodified lines
59
60
61
62
63
62
63
64
65
66
10 unmodified lines
 *
 * Instances run sequentially by default: the canonical images are amd64 and run
 * under emulation on Apple Silicon, and each instance already spawns its own
 * Opus + Codex subprocesses, so serial execution keeps the box responsive and
 * GPT + Fable subprocesses, so serial execution keeps the box responsive and
 * the timings honest. Set `concurrency > 1` only on a fast amd64 host.
 *
 * @param {object} opts
41 unmodified lines
  const report = summarizeResults(results, {
    dataset: `${config.upstream.dataset}:${config.upstream.datasetSplit}`,
    models: {
      implementer: opts.implementerModel ?? process.env.SWEBP_IMPLEMENTER_MODEL ?? "claude-opus-4-8",
      reviewer: opts.reviewerModel ?? process.env.SWEBP_REVIEWER_MODEL ?? "gpt-5.5",
      implementer: opts.implementerModel ?? process.env.SWEBP_IMPLEMENTER_MODEL ?? "gpt-5.5",
      reviewer: opts.reviewerModel ?? process.env.SWEBP_REVIEWER_MODEL ?? "claude-fable-5",
    },
    integrityChecked: !opts.skipIntegrity,
    finishedAtMs: opts.nowMs ?? null,

44 unmodified lines
45
46
47
48
49
48
49
50
51
52
44 unmodified lines
  --limit N           Cap count

Run options:
  --implementer M     Implementer model (default claude-opus-4-8)
  --reviewer M        Reviewer model    (default gpt-5.5-codex)
  --implementer M     Implementer model (default gpt-5.5)
  --reviewer M        Reviewer model    (default claude-fable-5)
  --skip-integrity    Skip gold/empty controls (faster, less rigorous)
  --agent-timeout-ms  Per-instance agent wall-clock cap
  --report PATH       Where to write the JSON report