app/worker/src/MaintainerDO.ts

 // One Durable Object instance per repo -- the Maintainer DO

 // (site/content/remote-backend/index.md), now backed by the real,

 // unified CloudflareBackend (cloudflareBackend.ts) rather than three

 // separate pieces. Deliberately thin itself: it reuses

 // agent/tools.ts's real ToolDef.execute() functions verbatim via

 // callTool, scoped to this instance's own storage/Artifacts repo via

 // engine/backend.ts's withBackend() (AsyncLocalStorage) -- the same

 // reason step 3's design note gave, now extended to the whole tool

 // surface, not just ask()/answer()/proposeLane(). Every RBAC check,

 // the changeset_review gate, the embedded-files guard, run unchanged;

 // this file has no protocol logic of its own.

 import { DurableObject } from "cloudflare:workers";

 import { withBackend } from "../../engine/backend.js";

 import { ALL_TOOLS } from "../../agent/tools.js";

 import { createCloudflareBackend } from "./cloudflareBackend.js";

 import type { ArtifactsNamespace } from "./cloudflareGitBackend.js";

 interface Env {

  ARTIFACTS: ArtifactsNamespace;

  DB: D1Database;

 }

 // Tools that fundamentally can't run in a Worker -- no child_process,

 // no real git worktrees, no `gh` CLI -- never dispatched here even by

 // name. Listed explicitly so calling one by name fails with a clear

 // reason instead of a confusing downstream crash.

 const WORKER_INCOMPATIBLE_TOOLS = new Set(["run_in_sandbox", "gh_fetch_issues", "gh_fetch_pull_requests", "gh_fetch_releases", "gh_fetch_contributors", "gh_fetch_thread_comments"]);

 export class MaintainerDO extends DurableObject<Env> {

  // This DO's identity doubles as the Backend's "repo" key -- one DO

  // instance already is one repo's storage, so every tool call below

  // is scoped to it regardless of whatever `repo` string a caller

  // passes in its args (kept for shape-compatibility with

  // agent/tools.ts's parameters, not actually branched on).

  private artifactsName = "do";

  private backend = createCloudflareBackend(this.ctx.storage, this.env.ARTIFACTS, this.artifactsName, this.env.DB);

  /** Which Artifacts repo this DO instance actually operates on -- set once, before any tool call, since the DO's own id (from idFromName) doesn't reverse back to the name that created it.

  *

  * No-op when already configured for this same repo -- confirmed live: handleApiCallTool (every CLI/TUI tool call) calls this on EVERY single HTTP request, so rebuilding the Backend unconditionally threw away cloudflareBackend.ts's notesCache on every call, defeating it entirely for any multi-call sequence that crosses HTTP requests (e.g. the TUI resolving a Ladder tree one ladder_read per HTTP call -- 6 calls, 6 fresh checkouts of ref content 3 of those calls share). webApp.ts's own internal getLadderTree never hit this since it configures once then calls multiple times in-process; CLI/TUI calls, one HTTP request per tool call, always did. Staying configured for the same repo across calls means the cache (and cachedRootCommitOid, already durable-stored) actually survives for this DO instance's warm lifetime, not just one call -- a bounded, self-healing staleness window (any cold start/eviction clears it), same tradeoff already accepted for the durable root-oid cache. */

  async configure(artifactsName: string): Promise<void> {

  if (this.artifactsName === artifactsName) return;

  this.artifactsName = artifactsName;

  this.backend = createCloudflareBackend(this.ctx.storage, this.env.ARTIFACTS, artifactsName, this.env.DB);

  }

  /** The tool surface, by name -- the same ToolDef.execute() contract agent/tools.ts already defines, just reached over RPC instead of an in-process call. */

  async callTool(name: string, args: Record<string, unknown>): Promise<unknown> {

  if (WORKER_INCOMPATIBLE_TOOLS.has(name)) {

  throw new Error(`"${name}" can't run on a Worker (no child_process, no real git worktrees, no \`gh\` CLI there) -- it's a local-only tool.`);

  }

  const tool = ALL_TOOLS.find((t) => t.name === name);

  if (!tool) throw new Error(`no such tool: ${name}`);

  return withBackend(this.backend, () => tool.execute(args));

  }

 }