diff --git a/apps/web/src/app/(app)/gastown/[townId]/settings/TownSettingsPageClient.tsx b/apps/web/src/app/(app)/gastown/[townId]/settings/TownSettingsPageClient.tsx
index 5b3d6a234f..3fe5abdf28 100644
--- a/apps/web/src/app/(app)/gastown/[townId]/settings/TownSettingsPageClient.tsx
+++ b/apps/web/src/app/(app)/gastown/[townId]/settings/TownSettingsPageClient.tsx
@@ -31,6 +31,7 @@ import {
   Container,
   User,
   Key,
+  MessageSquareText,
   X,
 } from 'lucide-react';
 import {
@@ -40,6 +41,7 @@ import {
   AccordionContent,
 } from '@/components/ui/accordion';
 import { Slider } from '@/components/ui/slider';
+import { Textarea } from '@/components/ui/textarea';
 import { motion } from 'motion/react';
 import { AdminViewingBanner } from '@/components/gastown/AdminViewingBanner';
 import { useRouter } from 'next/navigation';
@@ -71,6 +73,7 @@ const SECTIONS = [
   { id: 'merge-strategy', label: 'Merge Strategy', icon: GitPullRequest },
   { id: 'refinery', label: 'Refinery', icon: Shield },
   { id: 'container', label: 'Container', icon: Container },
+  { id: 'custom-instructions', label: 'Custom Instructions', icon: MessageSquareText },
   { id: 'danger-zone', label: 'Danger Zone', icon: Trash2 },
 ] as const;
 
@@ -280,6 +283,9 @@ export function TownSettingsPageClient({ townId, readOnly = false, organizationI
   const [gitAuthorName, setGitAuthorName] = useState('');
   const [gitAuthorEmail, setGitAuthorEmail] = useState('');
   const [disableAiCoauthor, setDisableAiCoauthor] = useState(false);
+  const [polecatInstructions, setPolecatInstructions] = useState('');
+  const [refineryInstructions, setRefineryInstructions] = useState('');
+  const [mayorInstructions, setMayorInstructions] = useState('');
   const [initialized, setInitialized] = useState(false);
   const [showTokens, setShowTokens] = useState(false);
 
@@ -316,6 +322,9 @@ export function TownSettingsPageClient({ townId, readOnly = false, organizationI
     setGitAuthorName(cfg.git_author_name ?? '');
     setGitAuthorEmail(cfg.git_author_email ?? '');
     setDisableAiCoauthor(cfg.disable_ai_coauthor ?? false);
+    setPolecatInstructions(cfg.custom_instructions?.polecat ?? '');
+    setRefineryInstructions(cfg.custom_instructions?.refinery ?? '');
+    setMayorInstructions(cfg.custom_instructions?.mayor ?? '');
     setInitialized(true);
   }
 
@@ -366,6 +375,11 @@ export function TownSettingsPageClient({ townId, readOnly = false, organizationI
           auto_merge_delay_minutes: autoMergeDelayMinutes,
         },
         convoy_merge_mode: convoyMergeMode,
+        custom_instructions: {
+          polecat: polecatInstructions || undefined,
+          refinery: refineryInstructions || undefined,
+          mayor: mayorInstructions || undefined,
+        },
       },
     });
   }
@@ -1057,13 +1071,47 @@ export function TownSettingsPageClient({ townId, readOnly = false, organizationI
                 </div>
               </SettingsSection>
 
+              {/* ── Custom Instructions ────────────────────────────────── */}
+              <SettingsSection
+                id="custom-instructions"
+                title="Custom Instructions"
+                description="Customize the system prompt for each agent role. These instructions are appended to the default prompt and apply to all agents of that role."
+                icon={MessageSquareText}
+                index={10}
+              >
+                <div className="space-y-5">
+                  {(
+                    [
+                      ['Polecat Instructions', polecatInstructions, setPolecatInstructions],
+                      ['Refinery Instructions', refineryInstructions, setRefineryInstructions],
+                      ['Mayor Instructions', mayorInstructions, setMayorInstructions],
+                    ] as const
+                  ).map(([roleLabel, value, setValue]) => (
+                    <FieldGroup key={roleLabel} label={roleLabel}>
+                      <div className="relative">
+                        <Textarea
+                          value={value}
+                          onChange={e => setValue(e.target.value.slice(0, 2000))}
+                          placeholder={`Custom instructions for ${roleLabel.replace(' Instructions', '').toLowerCase()} agents…`}
+                          rows={4}
+                          className="border-white/[0.08] bg-white/[0.03] text-sm text-white/85 placeholder:text-white/20"
+                        />
+                        <span className="absolute right-2 bottom-2 text-[10px] text-white/20">
+                          {value.length} / 2000
+                        </span>
+                      </div>
+                    </FieldGroup>
+                  ))}
+                </div>
+              </SettingsSection>
+
               {/* ── Danger Zone ──────────────────────────────────────── */}
               <SettingsSection
                 id="danger-zone"
                 title="Danger Zone"
                 description="Irreversible actions for this town."
                 icon={Trash2}
-                index={9}
+                index={11}
               >
                 <div className="space-y-3">
                   <div className="flex items-center justify-between rounded-lg border border-red-500/20 bg-red-500/5 px-4 py-3">
diff --git a/apps/web/src/components/gastown/AgentDetailDrawer.tsx b/apps/web/src/components/gastown/AgentDetailDrawer.tsx
index 2168a6479d..60ba09d2ae 100644
--- a/apps/web/src/components/gastown/AgentDetailDrawer.tsx
+++ b/apps/web/src/components/gastown/AgentDetailDrawer.tsx
@@ -80,7 +80,7 @@ export function AgentDetailDrawer({
       <Drawer.Portal>
         <Drawer.Overlay className="fixed inset-0 z-50 bg-black/60" />
         <Drawer.Content
-          className="fixed top-0 right-0 bottom-0 z-50 flex w-[480px] max-w-[94vw] flex-col outline-none"
+          className="fixed top-0 right-0 bottom-0 z-50 flex w-[600px] max-w-[94vw] flex-col outline-none"
           style={{ '--initial-transform': 'calc(100% + 8px)' } as React.CSSProperties}
         >
           <div className="flex h-full flex-col overflow-hidden rounded-l-2xl border-l border-white/[0.08] bg-[oklch(0.12_0_0)]">
diff --git a/apps/web/src/components/gastown/BeadDetailDrawer.tsx b/apps/web/src/components/gastown/BeadDetailDrawer.tsx
index 1e6c0ebe22..7695172664 100644
--- a/apps/web/src/components/gastown/BeadDetailDrawer.tsx
+++ b/apps/web/src/components/gastown/BeadDetailDrawer.tsx
@@ -67,7 +67,7 @@ export function BeadDetailDrawer({
       <Drawer.Portal>
         <Drawer.Overlay className="fixed inset-0 z-50 bg-black/60" />
         <Drawer.Content
-          className="fixed top-0 right-0 bottom-0 z-50 flex w-[520px] max-w-[94vw] flex-col outline-none"
+          className="fixed top-0 right-0 bottom-0 z-50 flex w-[640px] max-w-[94vw] flex-col outline-none"
           style={{ '--initial-transform': 'calc(100% + 8px)' } as React.CSSProperties}
         >
           <div className="flex h-full flex-col overflow-hidden rounded-l-2xl border-l border-white/[0.08] bg-[oklch(0.12_0_0)]">
@@ -76,7 +76,7 @@ export function BeadDetailDrawer({
               <div className="min-w-0 flex-1">
                 <Drawer.Title className="flex items-center gap-2 text-base font-semibold text-white/90">
                   <Hexagon className="size-4 shrink-0 text-[color:oklch(95%_0.15_108_/_0.7)]" />
-                  <span className="truncate">{bead?.title ?? 'Bead'}</span>
+                  <span>{bead?.title ?? 'Bead'}</span>
                 </Drawer.Title>
                 <Drawer.Description className="mt-1.5 text-xs text-white/35">
                   Full inspection view — metadata, body, and event timeline.
diff --git a/apps/web/src/components/gastown/DrawerStack.tsx b/apps/web/src/components/gastown/DrawerStack.tsx
index eed3b366a3..f5ec6352cb 100644
--- a/apps/web/src/components/gastown/DrawerStack.tsx
+++ b/apps/web/src/components/gastown/DrawerStack.tsx
@@ -94,7 +94,7 @@ export function DrawerStackProvider({
 
 // ── Renderer ─────────────────────────────────────────────────────────────
 
-const DRAWER_WIDTH = 500;
+const DRAWER_WIDTH = 620;
 /** How many px each background layer shifts left per depth level */
 const DEPTH_OFFSET = 40;
 /** Extra shift on hover */
diff --git a/apps/web/src/components/gastown/EventDetailDrawer.tsx b/apps/web/src/components/gastown/EventDetailDrawer.tsx
index 9c7e3d3c1d..194b3f4159 100644
--- a/apps/web/src/components/gastown/EventDetailDrawer.tsx
+++ b/apps/web/src/components/gastown/EventDetailDrawer.tsx
@@ -91,7 +91,7 @@ export function EventDetailDrawer({ open, onOpenChange, event }: EventDetailDraw
       <Drawer.Portal>
         <Drawer.Overlay className="fixed inset-0 z-50 bg-black/50" />
         <Drawer.Content
-          className="fixed top-0 right-0 bottom-0 z-50 flex w-[440px] max-w-[92vw] flex-col outline-none"
+          className="fixed top-0 right-0 bottom-0 z-50 flex w-[560px] max-w-[92vw] flex-col outline-none"
           style={{ '--initial-transform': 'calc(100% + 8px)' } as React.CSSProperties}
         >
           <div className="flex h-full flex-col overflow-hidden rounded-l-2xl border-l border-white/[0.08] bg-[oklch(0.12_0_0)]">
diff --git a/apps/web/src/components/gastown/GastownBeadDetailSheet.tsx b/apps/web/src/components/gastown/GastownBeadDetailSheet.tsx
index e128fd35a2..ac2ce293da 100644
--- a/apps/web/src/components/gastown/GastownBeadDetailSheet.tsx
+++ b/apps/web/src/components/gastown/GastownBeadDetailSheet.tsx
@@ -63,16 +63,14 @@ export function GastownBeadDetailSheet({
       <SheetContent
         side="right"
         className={cn(
-          'w-[540px] max-w-[92vw] border-white/10 bg-[color:oklch(0.155_0_0)]',
+          'w-[660px] max-w-[92vw] border-white/10 bg-[color:oklch(0.155_0_0)]',
           'shadow-[0_30px_120px_-70px_rgba(0,0,0,0.95)]'
         )}
       >
         <SheetHeader className="gap-2">
           <div className="flex items-start justify-between gap-3">
             <div className="min-w-0">
-              <SheetTitle className="truncate text-base text-white/90">
-                {bead?.title ?? 'Bead'}
-              </SheetTitle>
+              <SheetTitle className="text-base text-white/90">{bead?.title ?? 'Bead'}</SheetTitle>
               <SheetDescription className="mt-1 text-xs text-white/45">
                 Click-through audit trail: events, status changes, hooks, and mail.
               </SheetDescription>
diff --git a/apps/web/src/components/gastown/drawer-panels/BeadPanel.tsx b/apps/web/src/components/gastown/drawer-panels/BeadPanel.tsx
index c588f098af..35f4644ae8 100644
--- a/apps/web/src/components/gastown/drawer-panels/BeadPanel.tsx
+++ b/apps/web/src/components/gastown/drawer-panels/BeadPanel.tsx
@@ -245,7 +245,7 @@ export function BeadPanel({
               className="h-7 border-white/10 bg-white/5 text-sm font-semibold text-white/90"
             />
           ) : (
-            <span className="truncate text-base font-semibold text-white/90">{bead.title}</span>
+            <span className="text-base font-semibold text-white/90">{bead.title}</span>
           )}
           <button
             onClick={editing ? cancelEdit : enterEditMode}
diff --git a/apps/web/src/lib/gastown/types/router.d.ts b/apps/web/src/lib/gastown/types/router.d.ts
index f2667ce30b..54d45a161d 100644
--- a/apps/web/src/lib/gastown/types/router.d.ts
+++ b/apps/web/src/lib/gastown/types/router.d.ts
@@ -504,6 +504,13 @@ export declare const gastownRouter: import('@trpc/server').TRPCBuiltRouter<
         git_author_name?: string | undefined;
         git_author_email?: string | undefined;
         disable_ai_coauthor: boolean;
+        custom_instructions?:
+          | {
+              polecat?: string | undefined;
+              refinery?: string | undefined;
+              mayor?: string | undefined;
+            }
+          | undefined;
       };
       meta: object;
     }>;
@@ -561,6 +568,13 @@ export declare const gastownRouter: import('@trpc/server').TRPCBuiltRouter<
           git_author_name?: string | undefined;
           git_author_email?: string | undefined;
           disable_ai_coauthor?: boolean | undefined;
+          custom_instructions?:
+            | {
+                polecat?: string | undefined;
+                refinery?: string | undefined;
+                mayor?: string | undefined;
+              }
+            | undefined;
         };
       };
       output: {
@@ -612,6 +626,13 @@ export declare const gastownRouter: import('@trpc/server').TRPCBuiltRouter<
         git_author_name?: string | undefined;
         git_author_email?: string | undefined;
         disable_ai_coauthor: boolean;
+        custom_instructions?:
+          | {
+              polecat?: string | undefined;
+              refinery?: string | undefined;
+              mayor?: string | undefined;
+            }
+          | undefined;
       };
       meta: object;
     }>;
@@ -1815,6 +1836,13 @@ export declare const wrappedGastownRouter: import('@trpc/server').TRPCBuiltRoute
             git_author_name?: string | undefined;
             git_author_email?: string | undefined;
             disable_ai_coauthor: boolean;
+            custom_instructions?:
+              | {
+                  polecat?: string | undefined;
+                  refinery?: string | undefined;
+                  mayor?: string | undefined;
+                }
+              | undefined;
           };
           meta: object;
         }>;
@@ -1872,6 +1900,13 @@ export declare const wrappedGastownRouter: import('@trpc/server').TRPCBuiltRoute
               git_author_name?: string | undefined;
               git_author_email?: string | undefined;
               disable_ai_coauthor?: boolean | undefined;
+              custom_instructions?:
+                | {
+                    polecat?: string | undefined;
+                    refinery?: string | undefined;
+                    mayor?: string | undefined;
+                  }
+                | undefined;
             };
           };
           output: {
@@ -1923,6 +1958,13 @@ export declare const wrappedGastownRouter: import('@trpc/server').TRPCBuiltRoute
             git_author_name?: string | undefined;
             git_author_email?: string | undefined;
             disable_ai_coauthor: boolean;
+            custom_instructions?:
+              | {
+                  polecat?: string | undefined;
+                  refinery?: string | undefined;
+                  mayor?: string | undefined;
+                }
+              | undefined;
           };
           meta: object;
         }>;
diff --git a/apps/web/src/routers/admin/gastown-router.ts b/apps/web/src/routers/admin/gastown-router.ts
index 48ff20dc4d..43dc72def8 100644
--- a/apps/web/src/routers/admin/gastown-router.ts
+++ b/apps/web/src/routers/admin/gastown-router.ts
@@ -151,6 +151,13 @@ const TownConfigRecord = z.object({
   alarm_interval_idle: z.number().optional(),
   container: z.object({ sleep_after_minutes: z.number().optional() }).optional(),
   staged_convoys_default: z.boolean().optional(),
+  custom_instructions: z
+    .object({
+      polecat: z.string().optional(),
+      refinery: z.string().optional(),
+      mayor: z.string().optional(),
+    })
+    .optional(),
 });
 
 const ConvoyDetailRecord = z.object({
diff --git a/services/gastown/container/src/agent-runner.ts b/services/gastown/container/src/agent-runner.ts
index f965209777..a5e802756a 100644
--- a/services/gastown/container/src/agent-runner.ts
+++ b/services/gastown/container/src/agent-runner.ts
@@ -416,7 +416,7 @@ async function createMayorWorkspace(rigId: string): Promise<string> {
  * user customization), the TownDO sends the updated prompt and we
  * rewrite this file.
  */
-async function writeMayorSystemPromptToAgentsMd(
+export async function writeMayorSystemPromptToAgentsMd(
   workspaceDir: string,
   systemPrompt: string
 ): Promise<void> {
diff --git a/services/gastown/container/src/control-server.ts b/services/gastown/container/src/control-server.ts
index 012e736f83..b56eb97e64 100644
--- a/services/gastown/container/src/control-server.ts
+++ b/services/gastown/container/src/control-server.ts
@@ -1,6 +1,6 @@
 import { Hono } from 'hono';
 import { z } from 'zod';
-import { runAgent, resolveGitCredentials } from './agent-runner';
+import { runAgent, resolveGitCredentials, writeMayorSystemPromptToAgentsMd } from './agent-runner';
 import {
   stopAgent,
   sendMessage,
@@ -318,6 +318,29 @@ app.patch('/agents/:agentId/model', async c => {
   return c.json({ updated: true });
 });
 
+// PUT /agents/:agentId/system-prompt
+// Rewrite the mayor's AGENTS.md with an updated system prompt.
+// Used when custom instructions change so the running mayor picks them up
+// on its next session restart without a full container restart.
+app.put('/agents/:agentId/system-prompt', async c => {
+  const { agentId } = c.req.param();
+  const agent = getAgentStatus(agentId);
+  if (!agent) {
+    return c.json({ error: `Agent ${agentId} not found` }, 404);
+  }
+  const body: unknown = await c.req.json().catch(() => null);
+  if (
+    !body ||
+    typeof body !== 'object' ||
+    !('systemPrompt' in body) ||
+    typeof body.systemPrompt !== 'string'
+  ) {
+    return c.json({ error: 'Missing or invalid systemPrompt field' }, 400);
+  }
+  await writeMayorSystemPromptToAgentsMd(agent.workdir, body.systemPrompt);
+  return c.json({ updated: true });
+});
+
 // GET /agents/:agentId/status
 app.get('/agents/:agentId/status', c => {
   const { agentId } = c.req.param();
diff --git a/services/gastown/docs/local-debug-testing.md b/services/gastown/docs/local-debug-testing.md
index 7d795592f0..9e69aaa438 100644
--- a/services/gastown/docs/local-debug-testing.md
+++ b/services/gastown/docs/local-debug-testing.md
@@ -309,3 +309,60 @@ Triage/escalation beads pile up with `rig_id=NULL`. These are by design:
 - GUPP force-stop beads are created by the patrol system for stuck agents
 
 During testing, container restarts generate many of these. Bulk-close via admin panel if needed.
+
+## 7. Auto-Merge with Workers AI Thread Classification
+
+The auto-merge flow uses Workers AI (Gemma 4 26B) to classify unresolved PR review threads as blocking vs non-blocking. This prevents informational bot comments (status reports, code review summaries) from blocking auto-merge.
+
+### How It Works
+
+1. `poll_pr` runs every ~60s for MR beads with a `pr_url`
+2. `checkPRFeedback` fetches review threads via GitHub GraphQL (including comment bodies)
+3. If unresolved threads exist, `areThreadsBlocking()` sends them to Workers AI
+4. The model classifies threads as BLOCKING (requires code changes, bugs, security) or NON-BLOCKING (informational, nits, bot status reports)
+5. Only truly blocking threads prevent auto-merge
+
+### Config Required
+
+Set these on the town config (via `PATCH /debug/towns/:townId/config`):
+
+```json
+{
+  "refinery": {
+    "auto_merge": true,
+    "auto_merge_delay_minutes": 0,
+    "auto_resolve_pr_feedback": true
+  }
+}
+```
+
+### Testing Locally
+
+The `areThreadsBlocking` AI call only triggers when:
+
+- An MR bead has a `pr_url` (external GitHub PR exists)
+- The PR has unresolved review threads on GitHub
+- `auto_merge` is enabled in the town config
+
+In local dev, PRs created by the refinery in review-and-merge mode may not create external GitHub PRs, so the AI classification branch won't fire. To test the AI path end-to-end:
+
+1. Manually create a PR with unresolved review comments on the target repo
+2. Create an MR bead that references that PR
+3. Watch the wrangler logs for `areThreadsBlocking` output
+
+### Monitoring in Production
+
+Query Analytics Engine for the `areThreadsBlocking` log output:
+
+```bash
+# Check wrangler tail for AI classification logs
+npx wrangler tail gastown --format json --search "areThreadsBlocking"
+```
+
+The `areThreadsBlocking` method logs its decision:
+
+```
+[town] areThreadsBlocking: blocking=false reason=<explanation> threads=2
+```
+
+If the AI call fails, it conservatively defaults to `blocking=true` and logs a warning.
diff --git a/services/gastown/src/dos/Town.do.ts b/services/gastown/src/dos/Town.do.ts
index 1c5655495a..53546ee8e2 100644
--- a/services/gastown/src/dos/Town.do.ts
+++ b/services/gastown/src/dos/Town.do.ts
@@ -326,6 +326,10 @@ export class TownDO extends DurableObject<Env> {
               ? convoyFeatureBranch
               : (rig?.default_branch ?? 'main');
 
+          console.log(
+            `${TOWN_LOG} dispatch polecat: bead=${beadId} convoyId=${convoyId ?? 'none'} mergeMode=${convoyMergeMode ?? 'none'} featureBranch=${convoyFeatureBranch ?? 'none'} targetBranch=${targetBranch}`
+          );
+
           systemPromptOverride = buildPolecatSystemPrompt({
             agentName: agent.name,
             rigId,
@@ -1134,6 +1138,18 @@ export class TownDO extends DurableObject<Env> {
 
     agents.updateAgentStatus(this.sql, agentId, 'idle');
 
+    // Reset dispatch_attempts so the reconciler will dispatch this agent
+    // immediately on the next tick instead of waiting for cooldown/backoff.
+    query(
+      this.sql,
+      /* sql */ `
+        UPDATE ${agent_metadata}
+        SET ${agent_metadata.columns.dispatch_attempts} = 0
+        WHERE ${agent_metadata.bead_id} = ?
+      `,
+      [agentId]
+    );
+
     console.log(
       `${TOWN_LOG} resetAgent: reset agent=${agentId} hookedBead=${hookedBeadId ?? 'none'}`
     );
@@ -2460,6 +2476,49 @@ export class TownDO extends DurableObject<Env> {
     // model from the updated town config automatically.
   }
 
+  /**
+   * Rewrite the running mayor's AGENTS.md with the current system prompt
+   * (including custom instructions). Called when custom instructions change
+   * so the mayor picks them up on its next session restart.
+   */
+  async updateMayorSystemPrompt(): Promise<void> {
+    const townId = this.townId;
+    const mayor = agents.listAgents(this.sql, { role: 'mayor' })[0];
+    if (!mayor) return;
+
+    const containerStatus = await dispatch.checkAgentContainerStatus(this.env, townId, mayor.id);
+    const isAlive = containerStatus.status === 'running' || containerStatus.status === 'starting';
+    if (!isAlive) return;
+
+    const townConfig = await this.getTownConfig();
+    const systemPrompt = dispatch.appendCustomInstructions(
+      dispatch.systemPromptForRole({
+        role: 'mayor',
+        identity: mayor.identity,
+        agentName: 'mayor',
+        rigId: `mayor-${townId}`,
+        townId,
+        gates: townConfig.refinery?.gates ?? [],
+      }),
+      'mayor',
+      townConfig
+    );
+
+    const updated = await dispatch.updateMayorSystemPromptInContainer(
+      this.env,
+      townId,
+      mayor.id,
+      systemPrompt
+    );
+    if (updated) {
+      console.log(`${TOWN_LOG} updateMayorSystemPrompt: rewrote AGENTS.md for mayor ${mayor.id}`);
+    } else {
+      console.warn(
+        `${TOWN_LOG} updateMayorSystemPrompt: failed to rewrite AGENTS.md for mayor ${mayor.id}`
+      );
+    }
+  }
+
   async getMayorStatus(): Promise<{
     configured: boolean;
     townId: string;
@@ -4156,9 +4215,11 @@ export class TownDO extends DurableObject<Env> {
     };
 
     // Check for unresolved review threads via GraphQL.
-    // Fetches the first 100 threads; if there are more (hasNextPage),
-    // conservatively treat the PR as having unresolved comments to avoid
-    // auto-merging with un-checked reviewer feedback.
+    // Fetches the first 100 threads with comment bodies; if there are more
+    // (hasNextPage), conservatively treat the PR as having unresolved comments.
+    // When unresolved threads exist, uses Workers AI to classify whether they
+    // are truly blocking (requesting code changes, identifying bugs) vs
+    // informational (status reports, nits, praise, warnings about future work).
     let hasUnresolvedComments = false;
     try {
       const graphqlRes = await fetch('https://api.github.com/graphql', {
@@ -4170,7 +4231,15 @@ export class TownDO extends DurableObject<Env> {
               pullRequest(number: $number) {
                 reviewThreads(first: 100) {
                   pageInfo { hasNextPage }
-                  nodes { isResolved }
+                  nodes {
+                    isResolved
+                    comments(first: 5) {
+                      nodes {
+                        body
+                        author { login }
+                      }
+                    }
+                  }
                 }
               }
             }
@@ -4191,7 +4260,21 @@ export class TownDO extends DurableObject<Env> {
                         reviewThreads: z
                           .object({
                             pageInfo: z.object({ hasNextPage: z.boolean() }).optional(),
-                            nodes: z.array(z.object({ isResolved: z.boolean() })),
+                            nodes: z.array(
+                              z.object({
+                                isResolved: z.boolean(),
+                                comments: z
+                                  .object({
+                                    nodes: z.array(
+                                      z.object({
+                                        body: z.string(),
+                                        author: z.object({ login: z.string() }).nullable(),
+                                      })
+                                    ),
+                                  })
+                                  .optional(),
+                              })
+                            ),
                           })
                           .optional(),
                       })
@@ -4207,7 +4290,16 @@ export class TownDO extends DurableObject<Env> {
           : undefined;
         const threads = reviewThreads?.nodes ?? [];
         const hasMorePages = reviewThreads?.pageInfo?.hasNextPage === true;
-        hasUnresolvedComments = threads.some(t => !t.isResolved) || hasMorePages;
+
+        if (hasMorePages) {
+          // Too many threads to inspect — conservatively block auto-merge
+          hasUnresolvedComments = true;
+        } else {
+          const unresolvedThreads = threads.filter(t => !t.isResolved);
+          if (unresolvedThreads.length > 0) {
+            hasUnresolvedComments = await this.areThreadsBlocking(unresolvedThreads);
+          }
+        }
       }
     } catch (err) {
       console.warn(`${TOWN_LOG} checkPRFeedback: GraphQL failed for ${prUrl}`, err);
@@ -4312,6 +4404,112 @@ export class TownDO extends DurableObject<Env> {
     return { hasUnresolvedComments, hasFailingChecks, allChecksPass, hasUncheckedRuns };
   }
 
+  /**
+   * Use Workers AI to determine if unresolved PR review threads contain
+   * blocking feedback that should prevent auto-merge.
+   *
+   * Returns true if any thread is blocking (requires code changes, identifies
+   * bugs/security issues). Returns false if all threads are informational
+   * (status reports, nits, praise, warnings about future considerations).
+   *
+   * Falls back to true (conservatively blocking) if the AI call fails.
+   */
+  private async areThreadsBlocking(
+    threads: Array<{
+      isResolved: boolean;
+      comments?: { nodes: Array<{ body: string; author: { login: string } | null }> };
+    }>
+  ): Promise<boolean> {
+    try {
+      const threadSummaries = threads.map((t, i) => {
+        const comments = t.comments?.nodes ?? [];
+        const commentText = comments
+          .map(c => `  [${c.author?.login ?? 'unknown'}]: ${c.body}`)
+          .join('\n');
+        return `Thread ${i + 1}:\n${commentText}`;
+      });
+
+      const prompt = `You are evaluating unresolved PR review comment threads to decide if a pull request is safe to auto-merge.
+
+Here are the unresolved review threads:
+
+${threadSummaries.join('\n\n')}
+
+For each thread, classify it as BLOCKING or NON-BLOCKING:
+- BLOCKING: Requests a code change, identifies a bug, security vulnerability, correctness problem, or raises a warning about the code that should be addressed before merge.
+- NON-BLOCKING: Approvals, praise, "LGTM", status summaries (e.g. "Code review passed", "No issues found"), acknowledgements, or comments that express approval of the code without requesting changes.
+
+Important: A comment is only NON-BLOCKING if it expresses approval or is purely a status report. If a comment raises any concern, warning, suggestion, or question about the code — even if phrased softly — it is BLOCKING.
+
+Respond with ONLY a JSON object (no markdown, no explanation): { "blocking": true/false, "reason": "brief one-sentence explanation" }`;
+
+      const response: unknown = await this.env.AI.run(
+        // Model may not be in the AiModels type map yet — cast to access it.
+        '@cf/google/gemma-4-26b-a4b-it' as keyof AiModels,
+        {
+          messages: [{ role: 'user', content: prompt }],
+          max_tokens: 256,
+          temperature: 0,
+          // Disable Gemma 4's thinking/reasoning mode — we only need the
+          // final JSON answer, not a chain-of-thought. Without this, the
+          // model burns all tokens on reasoning and returns content: null.
+          chat_template_kwargs: { enable_thinking: false },
+        } as AiTextGenerationInput
+      );
+
+      // Gemma 4 returns OpenAI-compatible chat completion format:
+      //   { choices: [{ message: { content: "..." } }] }
+      // Older Workers AI models return { response: "..." }.
+      // Parse both shapes defensively.
+      const openAiResult = z
+        .object({
+          choices: z.array(z.object({ message: z.object({ content: z.string() }) })),
+        })
+        .safeParse(response);
+      const legacyResult = z.object({ response: z.string() }).safeParse(response);
+
+      const text = openAiResult.success
+        ? openAiResult.data.choices[0]?.message.content
+        : legacyResult.success
+          ? legacyResult.data.response
+          : null;
+      if (!text) {
+        console.warn(
+          `${TOWN_LOG} areThreadsBlocking: could not extract text from AI response, defaulting to blocking. Raw: ${JSON.stringify(response)?.slice(0, 500)}`
+        );
+        return true;
+      }
+
+      // Extract JSON from response (model may wrap in markdown code fences)
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) {
+        console.warn(
+          `${TOWN_LOG} areThreadsBlocking: no JSON in AI response, defaulting to blocking: ${text}`
+        );
+        return true;
+      }
+
+      const parsed = z
+        .object({ blocking: z.boolean(), reason: z.string().optional() })
+        .safeParse(JSON.parse(jsonMatch[0]));
+
+      if (!parsed.success) {
+        console.warn(
+          `${TOWN_LOG} areThreadsBlocking: failed to parse AI response, defaulting to blocking: ${text}`
+        );
+        return true;
+      }
+
+      console.log(
+        `${TOWN_LOG} areThreadsBlocking: blocking=${parsed.data.blocking} reason=${parsed.data.reason ?? 'none'} threads=${threads.length}`
+      );
+      return parsed.data.blocking;
+    } catch (err) {
+      console.warn(`${TOWN_LOG} areThreadsBlocking: AI call failed, defaulting to blocking`, err);
+      return true;
+    }
+  }
+
   /**
    * Merge a PR via GitHub API. Used by the auto-merge feature.
    * Returns true if the merge succeeded.
@@ -4330,29 +4528,42 @@ export class TownDO extends DurableObject<Env> {
       return false;
     }
 
-    const response = await fetch(
-      `https://api.github.com/repos/${owner}/${repo}/pulls/${numberStr}/merge`,
-      {
+    const mergeUrl = `https://api.github.com/repos/${owner}/${repo}/pulls/${numberStr}/merge`;
+    const mergeHeaders = {
+      Authorization: `token ${token}`,
+      Accept: 'application/vnd.github.v3+json',
+      'Content-Type': 'application/json',
+      'User-Agent': 'Gastown-Refinery/1.0',
+    };
+
+    // Try merge methods in order of preference. Repos may only allow a subset
+    // (e.g. squash-only). A 405 "not allowed" response means that method is
+    // disabled — try the next one.
+    const methods = ['squash', 'merge', 'rebase'] as const;
+    for (const method of methods) {
+      const response = await fetch(mergeUrl, {
         method: 'PUT',
-        headers: {
-          Authorization: `token ${token}`,
-          Accept: 'application/vnd.github.v3+json',
-          'Content-Type': 'application/json',
-          'User-Agent': 'Gastown-Refinery/1.0',
-        },
-        body: JSON.stringify({ merge_method: 'merge' }),
-      }
-    );
+        headers: mergeHeaders,
+        body: JSON.stringify({ merge_method: method }),
+      });
+
+      if (response.ok) return true;
 
-    if (!response.ok) {
       const text = await response.text().catch(() => '(unreadable)');
+      if (response.status === 405 && text.includes('not allowed')) {
+        // This merge method is disabled on the repo — try the next one
+        continue;
+      }
+
+      // Any other error (409 conflict, 422 validation, etc.) is a real failure
       console.warn(
-        `${TOWN_LOG} mergePR: GitHub API returned ${response.status} for ${prUrl}: ${text.slice(0, 500)}`
+        `${TOWN_LOG} mergePR: GitHub API returned ${response.status} for ${prUrl} (method=${method}): ${text.slice(0, 500)}`
       );
       return false;
     }
 
-    return true;
+    console.warn(`${TOWN_LOG} mergePR: all merge methods rejected for ${prUrl}`);
+    return false;
   }
 
   /**
diff --git a/services/gastown/src/dos/town/actions.ts b/services/gastown/src/dos/town/actions.ts
index 60d0cc2544..067195860e 100644
--- a/services/gastown/src/dos/town/actions.ts
+++ b/services/gastown/src/dos/town/actions.ts
@@ -652,49 +652,61 @@ export function applyAction(ctx: ApplyActionContext, action: Action): (() => Pro
                 feedback.hasFailingChecks ||
                 feedback.hasUncheckedRuns)
             ) {
-              const existingFeedback = hasExistingFeedbackBead(sql, action.bead_id);
-              if (!existingFeedback) {
-                const prMeta = parsePrUrl(action.pr_url);
-                const rmRows = z
-                  .object({ branch: z.string() })
-                  .array()
-                  .parse([
-                    ...query(
-                      sql,
-                      /* sql */ `
-                        SELECT ${review_metadata.columns.branch}
-                        FROM ${review_metadata}
-                        WHERE ${review_metadata.bead_id} = ?
-                      `,
-                      [action.bead_id]
-                    ),
-                  ]);
-                const branch = rmRows[0]?.branch ?? '';
-
-                ctx.insertEvent('pr_feedback_detected', {
-                  bead_id: action.bead_id,
-                  payload: {
-                    mr_bead_id: action.bead_id,
-                    pr_url: action.pr_url,
-                    pr_number: prMeta?.prNumber ?? 0,
-                    repo: prMeta?.repo ?? '',
-                    branch,
-                    has_unresolved_comments: feedback.hasUnresolvedComments,
-                    has_failing_checks: feedback.hasFailingChecks,
-                    has_unchecked_runs: feedback.hasUncheckedRuns,
-                  },
-                });
-              }
+              // Re-verify the PR is still open before creating a feedback bead.
+              // The checkPRFeedback call above takes ~2s (3+ GitHub API calls).
+              // If the PR was merged externally during that window, inserting
+              // pr_feedback_detected would create a feedback bead for a merged
+              // PR — leading to a duplicate PR on an already-merged branch.
+              const freshStatus = await ctx.checkPRStatus(action.pr_url);
+              if (freshStatus !== 'open') {
+                console.log(
+                  `${LOG} poll_pr: PR status changed to '${freshStatus}' during feedback check, skipping feedback for bead=${action.bead_id}`
+                );
+              } else {
+                const existingFeedback = hasExistingFeedbackBead(sql, action.bead_id);
+                if (!existingFeedback) {
+                  const prMeta = parsePrUrl(action.pr_url);
+                  const rmRows = z
+                    .object({ branch: z.string() })
+                    .array()
+                    .parse([
+                      ...query(
+                        sql,
+                        /* sql */ `
+                          SELECT ${review_metadata.columns.branch}
+                          FROM ${review_metadata}
+                          WHERE ${review_metadata.bead_id} = ?
+                        `,
+                        [action.bead_id]
+                      ),
+                    ]);
+                  const branch = rmRows[0]?.branch ?? '';
+
+                  ctx.insertEvent('pr_feedback_detected', {
+                    bead_id: action.bead_id,
+                    payload: {
+                      mr_bead_id: action.bead_id,
+                      pr_url: action.pr_url,
+                      pr_number: prMeta?.prNumber ?? 0,
+                      repo: prMeta?.repo ?? '',
+                      branch,
+                      has_unresolved_comments: feedback.hasUnresolvedComments,
+                      has_failing_checks: feedback.hasFailingChecks,
+                      has_unchecked_runs: feedback.hasUncheckedRuns,
+                    },
+                  });
+                }
 
-              query(
-                sql,
-                /* sql */ `
-                  UPDATE ${review_metadata}
-                  SET ${review_metadata.columns.last_feedback_check_at} = ?
-                  WHERE ${review_metadata.bead_id} = ?
-                `,
-                [now(), action.bead_id]
-              );
+                query(
+                  sql,
+                  /* sql */ `
+                    UPDATE ${review_metadata}
+                    SET ${review_metadata.columns.last_feedback_check_at} = ?
+                    WHERE ${review_metadata.bead_id} = ?
+                  `,
+                  [now(), action.bead_id]
+                );
+              }
             }
 
             // Auto-merge timer: track grace period when everything is green
@@ -706,6 +718,10 @@ export function applyAction(ctx: ApplyActionContext, action: Action): (() => Pro
                 !feedback.hasFailingChecks &&
                 feedback.allChecksPass;
 
+              console.log(
+                `${LOG} poll_pr: bead=${action.bead_id} allGreen=${allGreen} unresolved=${feedback.hasUnresolvedComments} failing=${feedback.hasFailingChecks} allPass=${feedback.allChecksPass} unchecked=${feedback.hasUncheckedRuns}`
+              );
+
               if (allGreen) {
                 const readySinceRows = z
                   .object({ auto_merge_ready_since: z.string().nullable() })
@@ -724,6 +740,10 @@ export function applyAction(ctx: ApplyActionContext, action: Action): (() => Pro
 
                 const readySince = readySinceRows[0]?.auto_merge_ready_since;
 
+                console.log(
+                  `${LOG} poll_pr: bead=${action.bead_id} readySince=${readySince ?? 'null'} rows=${readySinceRows.length}`
+                );
+
                 if (!readySince) {
                   query(
                     sql,
@@ -736,7 +756,14 @@ export function applyAction(ctx: ApplyActionContext, action: Action): (() => Pro
                   );
                 } else {
                   const elapsed = Date.now() - new Date(readySince).getTime();
-                  if (elapsed >= (refineryConfig.auto_merge_delay_minutes ?? 0) * 60_000) {
+                  const delayMs = (refineryConfig.auto_merge_delay_minutes ?? 0) * 60_000;
+                  console.log(
+                    `${LOG} poll_pr: bead=${action.bead_id} elapsed=${elapsed}ms delay=${delayMs}ms shouldMerge=${elapsed >= delayMs}`
+                  );
+                  if (elapsed >= delayMs) {
+                    console.log(
+                      `${LOG} poll_pr: inserting pr_auto_merge event for bead=${action.bead_id}`
+                    );
                     ctx.insertEvent('pr_auto_merge', {
                       bead_id: action.bead_id,
                       payload: {
diff --git a/services/gastown/src/dos/town/config.ts b/services/gastown/src/dos/town/config.ts
index 33bf9ef916..16bea46bff 100644
--- a/services/gastown/src/dos/town/config.ts
+++ b/services/gastown/src/dos/town/config.ts
@@ -101,6 +101,23 @@ export async function updateTownConfig(
               update.container.sleep_after_minutes ?? current.container?.sleep_after_minutes,
           }
         : current.container,
+    custom_instructions:
+      update.custom_instructions !== undefined
+        ? {
+            polecat:
+              'polecat' in update.custom_instructions
+                ? update.custom_instructions.polecat
+                : current.custom_instructions?.polecat,
+            refinery:
+              'refinery' in update.custom_instructions
+                ? update.custom_instructions.refinery
+                : current.custom_instructions?.refinery,
+            mayor:
+              'mayor' in update.custom_instructions
+                ? update.custom_instructions.mayor
+                : current.custom_instructions?.mayor,
+          }
+        : current.custom_instructions,
   };
 
   const validated = TownConfigSchema.parse(merged);
diff --git a/services/gastown/src/dos/town/container-dispatch.ts b/services/gastown/src/dos/town/container-dispatch.ts
index 65d6266aa4..ac2c0ff50d 100644
--- a/services/gastown/src/dos/town/container-dispatch.ts
+++ b/services/gastown/src/dos/town/container-dispatch.ts
@@ -241,6 +241,21 @@ export function systemPromptForRole(params: {
   }
 }
 
+/**
+ * Append per-role custom instructions from town config to a system prompt.
+ * Returns the prompt unchanged when no custom instructions exist for the role.
+ */
+export function appendCustomInstructions(
+  systemPrompt: string,
+  role: string,
+  townConfig: TownConfig
+): string {
+  const roleKey = role as keyof NonNullable<TownConfig['custom_instructions']>;
+  const instructions = townConfig.custom_instructions?.[roleKey]?.trim();
+  if (!instructions) return systemPrompt;
+  return `${systemPrompt}\n\n## Custom Instructions (from town settings)\n\n${instructions}`;
+}
+
 /** Generate a branch name for an agent working on a specific bead. */
 export function branchForAgent(name: string, beadId?: string): string {
   const slug = name
@@ -412,16 +427,19 @@ export async function startAgentInContainer(
         }),
         model: resolveModel(params.townConfig, params.rigId, params.role),
         smallModel: resolveSmallModel(params.townConfig),
-        systemPrompt:
+        systemPrompt: appendCustomInstructions(
           params.systemPromptOverride ??
-          systemPromptForRole({
-            role: params.role,
-            identity: params.identity,
-            agentName: params.agentName,
-            rigId: params.rigId,
-            townId: params.townId,
-            gates: params.townConfig.refinery?.gates ?? [],
-          }),
+            systemPromptForRole({
+              role: params.role,
+              identity: params.identity,
+              agentName: params.agentName,
+              rigId: params.rigId,
+              townId: params.townId,
+              gates: params.townConfig.refinery?.gates ?? [],
+            }),
+          params.role,
+          params.townConfig
+        ),
         gitUrl: params.gitUrl,
         branch: params.convoyFeatureBranch
           ? branchForConvoyAgent(params.convoyFeatureBranch, params.agentName, params.beadId)
@@ -665,6 +683,29 @@ export async function sendMessageToAgent(
   }
 }
 
+/**
+ * Rewrite the mayor's AGENTS.md with an updated system prompt.
+ * Called when custom instructions change so the running mayor picks them up.
+ */
+export async function updateMayorSystemPromptInContainer(
+  env: Env,
+  townId: string,
+  agentId: string,
+  systemPrompt: string
+): Promise<boolean> {
+  try {
+    const container = getTownContainerStub(env, townId);
+    const response = await container.fetch(`http://container/agents/${agentId}/system-prompt`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ systemPrompt }),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Hot-update the model for a running agent without restarting the session.
  * Best-effort — returns false if the container is down or the agent is not running.
diff --git a/services/gastown/src/dos/town/reconciler.ts b/services/gastown/src/dos/town/reconciler.ts
index ab4bd06bfd..9e61229d34 100644
--- a/services/gastown/src/dos/town/reconciler.ts
+++ b/services/gastown/src/dos/town/reconciler.ts
@@ -1160,12 +1160,17 @@ export function reconcileReviewQueue(
     }
   }
 
-  // When refinery code review is disabled, fast-track open MR beads that
-  // have a pr_url to in_progress so poll_pr handles them. MR beads without
-  // pr_url (direct merge strategy) still need the refinery for the merge
-  // operation itself — Rules 5-6 handle those.
+  // When refinery code review is disabled, fast-track ALL open MR beads
+  // to in_progress so poll_pr handles them once pr_url is populated.
+  // This must include beads without pr_url yet (timing window between
+  // review_submitted and the polecat setting pr_url) to prevent Rules 5-6
+  // from dispatching the refinery for a code review that shouldn't happen.
+  //
+  // Direct-merge strategy MR beads (no pr_url, refinery merges itself)
+  // still need the refinery — but those are only created when
+  // merge_strategy='direct', which inherently requires the refinery.
   if (!refineryCodeReview) {
-    const openMrsWithPr = z
+    const openMrs = z
       .object({ bead_id: z.string() })
       .array()
       .parse([
@@ -1174,16 +1179,13 @@ export function reconcileReviewQueue(
           /* sql */ `
             SELECT b.${beads.columns.bead_id}
             FROM ${beads} b
-            INNER JOIN ${review_metadata} rm
-              ON rm.${review_metadata.columns.bead_id} = b.${beads.columns.bead_id}
             WHERE b.${beads.columns.type} = 'merge_request'
               AND b.${beads.columns.status} = 'open'
-              AND rm.${review_metadata.columns.pr_url} IS NOT NULL
           `,
           []
         ),
       ]);
-    for (const { bead_id } of openMrsWithPr) {
+    for (const { bead_id } of openMrs) {
       actions.push({
         type: 'transition_bead',
         bead_id,
diff --git a/services/gastown/src/handlers/town-config.handler.ts b/services/gastown/src/handlers/town-config.handler.ts
index de0929abad..f0a48135b3 100644
--- a/services/gastown/src/handlers/town-config.handler.ts
+++ b/services/gastown/src/handlers/town-config.handler.ts
@@ -40,7 +40,18 @@ export async function handleUpdateTownConfig(c: Context<GastownEnv>, params: { t
   }
 
   const townDO = getTownDOStub(c.env, params.townId);
+  const existingConfig = await townDO.getTownConfig();
   const config = await townDO.updateTownConfig(parsed.data);
+
+  // Rewrite the mayor's AGENTS.md when custom instructions change
+  if (config.custom_instructions?.mayor !== existingConfig.custom_instructions?.mayor) {
+    try {
+      await townDO.updateMayorSystemPrompt();
+    } catch (err) {
+      console.warn(`${LOG} handleUpdateTownConfig: updateMayorSystemPrompt failed:`, err);
+    }
+  }
+
   console.log(`${LOG} handleUpdateTownConfig: town=${params.townId} updated config`);
   return c.json(resSuccess(maskSensitiveValues(config)));
 }
diff --git a/services/gastown/src/trpc/router.ts b/services/gastown/src/trpc/router.ts
index be1d5feaf6..761fbe6876 100644
--- a/services/gastown/src/trpc/router.ts
+++ b/services/gastown/src/trpc/router.ts
@@ -998,6 +998,18 @@ export const gastownRouter = router({
         console.warn('[gastown-trpc] updateTownConfig: syncConfigToContainer failed:', err);
       }
 
+      // Rewrite the mayor's AGENTS.md when custom instructions change so the
+      // running mayor picks them up on its next session restart.
+      const mayorInstructionsChanged =
+        result.custom_instructions?.mayor !== existingConfig.custom_instructions?.mayor;
+      if (mayorInstructionsChanged) {
+        try {
+          await townStub.updateMayorSystemPrompt();
+        } catch (err) {
+          console.warn('[gastown-trpc] updateTownConfig: updateMayorSystemPrompt failed:', err);
+        }
+      }
+
       // Hot-update the running mayor session when the effective model or
       // auth-relevant config changed. The SDK server is a child process
       // that captures env at spawn time, so it must be restarted to pick
diff --git a/services/gastown/src/types.ts b/services/gastown/src/types.ts
index 2746b704a4..ea3f84fc93 100644
--- a/services/gastown/src/types.ts
+++ b/services/gastown/src/types.ts
@@ -317,6 +317,15 @@ export const TownConfigSchema = z.object({
   /** When true, AI agent co-authorship trailer is omitted from commits.
    *  Only takes effect when git_author_name is set. */
   disable_ai_coauthor: z.boolean().default(false),
+
+  /** Per-role custom instructions appended to the agent's system prompt. */
+  custom_instructions: z
+    .object({
+      polecat: z.string().max(2000).optional(),
+      refinery: z.string().max(2000).optional(),
+      mayor: z.string().max(2000).optional(),
+    })
+    .optional(),
 });
 
 export type TownConfig = z.infer<typeof TownConfigSchema>;
@@ -378,6 +387,13 @@ export const TownConfigUpdateSchema = z.object({
   git_author_name: z.string().optional(),
   git_author_email: z.string().optional(),
   disable_ai_coauthor: z.boolean().optional(),
+  custom_instructions: z
+    .object({
+      polecat: z.string().max(2000).optional(),
+      refinery: z.string().max(2000).optional(),
+      mayor: z.string().max(2000).optional(),
+    })
+    .optional(),
 });
 export type TownConfigUpdate = z.infer<typeof TownConfigUpdateSchema>;
 
diff --git a/services/gastown/worker-configuration.d.ts b/services/gastown/worker-configuration.d.ts
index 1acac8ca52..a58bfe9616 100644
--- a/services/gastown/worker-configuration.d.ts
+++ b/services/gastown/worker-configuration.d.ts
@@ -39,6 +39,7 @@ declare namespace Cloudflare {
 		TOWN_CONTAINER: DurableObjectNamespace<import("./src/gastown.worker").TownContainerDO>;
 		AGENT: DurableObjectNamespace<import("./src/gastown.worker").AgentDO>;
 		GIT_TOKEN_SERVICE: GitTokenService;
+		AI: Ai;
 	}
 	interface Env {
 		GASTOWN_AE: AnalyticsEngineDataset;
@@ -56,6 +57,7 @@ declare namespace Cloudflare {
 		TOWN_CONTAINER: DurableObjectNamespace<import("./src/gastown.worker").TownContainerDO>;
 		AGENT: DurableObjectNamespace<import("./src/gastown.worker").AgentDO>;
 		GIT_TOKEN_SERVICE: GitTokenService;
+		AI: Ai;
 		HYPERDRIVE?: Hyperdrive;
 		CF_VERSION_METADATA?: WorkerVersionMetadata;
 		SENTRY_DSN?: string; // worker secret
diff --git a/services/gastown/wrangler.jsonc b/services/gastown/wrangler.jsonc
index f045ffd723..54ef41f5ec 100644
--- a/services/gastown/wrangler.jsonc
+++ b/services/gastown/wrangler.jsonc
@@ -82,6 +82,8 @@
     },
   ],
 
+  "ai": { "binding": "AI" },
+
   "analytics_engine_datasets": [{ "binding": "GASTOWN_AE", "dataset": "gastown_events" }],
 
   "services": [
@@ -145,6 +147,8 @@
           "entrypoint": "GitTokenRPCEntrypoint",
         },
       ],
+      "ai": { "binding": "AI" },
+
       "analytics_engine_datasets": [{ "binding": "GASTOWN_AE", "dataset": "gastown_events" }],
       "secrets_store_secrets": [
         {