orizu 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orizu",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "private": false,
   "type": "module",
   "bin": {
@@ -20,6 +20,9 @@
     "postpack": "node scripts/vendor-gepa-python.mjs --clean && node scripts/vendor-orizu-skill.mjs --clean"
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.201",
+    "@daytonaio/sdk": "0.193.0",
+    "@vercel/sandbox": "1.10.2",
     "@playwright/test": "^1.60.0",
     "@tailwindcss/postcss": "^4.1.7",
     "esbuild": "^0.25.8",

package/src/artifact-archive.ts

@@ -0,0 +1,182 @@
+import { createHash } from 'crypto'
+import { readdirSync, readFileSync, statSync } from 'fs'
+import { join } from 'path'
+
+export interface StoredZipEntry {
+  path: string
+  data: Buffer
+}
+
+export interface ArtifactArchive {
+  zipBase64: string
+  contentSha256: string
+}
+
+const ARTIFACT_EXCLUDED_PATH_NAMES = new Set([
+  '.git',
+  '.DS_Store',
+  '__pycache__',
+  '.pytest_cache',
+  '.orizu',
+])
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return error instanceof Error
+}
+
+function expandHomePath(path: string): string {
+  if (path.startsWith('~/')) {
+    const home = process.env.HOME || ''
+    return `${home}/${path.slice(2)}`
+  }
+
+  return path
+}
+
+/**
+ * Archives must be byte-identical for identical logical content across machines
+ * because content-addressed deduplication depends on deterministic inputs.
+ *
+ * Tradeoff: runner artifacts are downloaded, unzipped, and executed directly
+ * (there is no install step), so vendored dependency trees such as
+ * node_modules, .venv/venv, and build outputs are legitimate runtime payload
+ * and are deliberately NOT excluded — hash reproducibility therefore depends
+ * on the author shipping identical vendored trees across machines. Only true
+ * junk (.git, .DS_Store, __pycache__, .pytest_cache, .orizu) and secrets
+ * (.env, .env.*) are stripped: secrets must never ship, because runners
+ * receive their configuration at exec time.
+ */
+export function shouldExcludeArtifactPath(relativePath: string): boolean {
+  const parts = relativePath.split('/')
+  return parts.some(part =>
+    ARTIFACT_EXCLUDED_PATH_NAMES.has(part) ||
+    part === '.env' ||
+    part.startsWith('.env.')
+  )
+}
+
+export function collectArtifactFiles(sourceDir: string, relativeDir = ''): string[] {
+  const absoluteDir = relativeDir ? join(sourceDir, relativeDir) : sourceDir
+  return readdirSync(absoluteDir, { withFileTypes: true })
+    .flatMap(entry => {
+      const relativePath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name
+      if (shouldExcludeArtifactPath(relativePath)) {
+        return []
+      }
+      if (entry.isDirectory()) {
+        return collectArtifactFiles(sourceDir, relativePath)
+      }
+      return entry.isFile() ? [relativePath] : []
+    })
+    .sort((left, right) => left < right ? -1 : left > right ? 1 : 0)
+}
+
+export const ZIP_GENERAL_PURPOSE_UTF8 = 0x0800
+export const ZIP_DOS_TIME_2000_01_01 = 0
+export const ZIP_DOS_DATE_2000_01_01 = ((2000 - 1980) << 9) | (1 << 5) | 1
+
+const CRC32_TABLE = Array.from({ length: 256 }, (_, index) => {
+  let value = index
+  for (let bit = 0; bit < 8; bit++) {
+    value = (value & 1) ? (0xedb88320 ^ (value >>> 1)) : (value >>> 1)
+  }
+  return value >>> 0
+})
+
+function crc32(bytes: Buffer): number {
+  let crc = 0xffffffff
+  for (const byte of bytes) {
+    crc = CRC32_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8)
+  }
+  return (crc ^ 0xffffffff) >>> 0
+}
+
+export function createStoredZip(entries: StoredZipEntry[]): Buffer {
+  const localParts: Buffer[] = []
+  const centralParts: Buffer[] = []
+  let offset = 0
+
+  for (const entry of entries) {
+    const name = Buffer.from(entry.path, 'utf8')
+    const crc = crc32(entry.data)
+    const localHeader = Buffer.alloc(30)
+    localHeader.writeUInt32LE(0x04034b50, 0)
+    localHeader.writeUInt16LE(10, 4)
+    localHeader.writeUInt16LE(ZIP_GENERAL_PURPOSE_UTF8, 6)
+    localHeader.writeUInt16LE(0, 8)
+    localHeader.writeUInt16LE(ZIP_DOS_TIME_2000_01_01, 10)
+    localHeader.writeUInt16LE(ZIP_DOS_DATE_2000_01_01, 12)
+    localHeader.writeUInt32LE(crc, 14)
+    localHeader.writeUInt32LE(entry.data.length, 18)
+    localHeader.writeUInt32LE(entry.data.length, 22)
+    localHeader.writeUInt16LE(name.length, 26)
+    localHeader.writeUInt16LE(0, 28)
+
+    localParts.push(localHeader, name, entry.data)
+
+    const centralHeader = Buffer.alloc(46)
+    centralHeader.writeUInt32LE(0x02014b50, 0)
+    centralHeader.writeUInt16LE(20, 4)
+    centralHeader.writeUInt16LE(10, 6)
+    centralHeader.writeUInt16LE(ZIP_GENERAL_PURPOSE_UTF8, 8)
+    centralHeader.writeUInt16LE(0, 10)
+    centralHeader.writeUInt16LE(ZIP_DOS_TIME_2000_01_01, 12)
+    centralHeader.writeUInt16LE(ZIP_DOS_DATE_2000_01_01, 14)
+    centralHeader.writeUInt32LE(crc, 16)
+    centralHeader.writeUInt32LE(entry.data.length, 20)
+    centralHeader.writeUInt32LE(entry.data.length, 24)
+    centralHeader.writeUInt16LE(name.length, 28)
+    centralHeader.writeUInt16LE(0, 30)
+    centralHeader.writeUInt16LE(0, 32)
+    centralHeader.writeUInt16LE(0, 34)
+    centralHeader.writeUInt16LE(0, 36)
+    centralHeader.writeUInt32LE(0, 38)
+    centralHeader.writeUInt32LE(offset, 42)
+    centralParts.push(centralHeader, name)
+
+    offset += localHeader.length + name.length + entry.data.length
+  }
+
+  const centralDirectoryOffset = offset
+  const centralDirectory = Buffer.concat(centralParts)
+  const endOfCentralDirectory = Buffer.alloc(22)
+  endOfCentralDirectory.writeUInt32LE(0x06054b50, 0)
+  endOfCentralDirectory.writeUInt16LE(0, 4)
+  endOfCentralDirectory.writeUInt16LE(0, 6)
+  endOfCentralDirectory.writeUInt16LE(entries.length, 8)
+  endOfCentralDirectory.writeUInt16LE(entries.length, 10)
+  endOfCentralDirectory.writeUInt32LE(centralDirectory.length, 12)
+  endOfCentralDirectory.writeUInt32LE(centralDirectoryOffset, 16)
+  endOfCentralDirectory.writeUInt16LE(0, 20)
+
+  return Buffer.concat([...localParts, centralDirectory, endOfCentralDirectory])
+}
+
+export function zipDirectoryToBase64(dirArg: string): ArtifactArchive {
+  const sourceDir = expandHomePath(dirArg)
+  try {
+    const stats = statSync(sourceDir)
+    if (!stats.isDirectory()) {
+      throw new Error(`${sourceDir} is not a directory`)
+    }
+  } catch (error: unknown) {
+    if (isNodeError(error) && error.code === 'ENOENT') {
+      throw new Error(`Directory not found: ${sourceDir}`)
+    }
+    throw error
+  }
+
+  const files = collectArtifactFiles(sourceDir)
+  if (files.length === 0) {
+    throw new Error(`Directory contains no artifact files: ${sourceDir}`)
+  }
+
+  const bytes = createStoredZip(files.map(relativePath => ({
+    path: relativePath,
+    data: readFileSync(join(sourceDir, relativePath)),
+  })))
+  return {
+    zipBase64: bytes.toString('base64'),
+    contentSha256: createHash('sha256').update(bytes).digest('hex'),
+  }
+}

package/src/connectors-cli.ts

@@ -0,0 +1,115 @@
+/**
+ * Connector readiness CLI (ALI-903). Thin, read-only consumer of the
+ * project-scoped `/api/cli/connectors` endpoint. Pure command logic with an
+ * injected fetcher and project resolver; the entry point owns argument parsing
+ * and human/JSON output. Secret material is never printed (the endpoint already
+ * redacts config and surfaces credentials only as a boolean).
+ */
+
+import { authedFetch } from './http.js'
+
+export type CliFetcher = (path: string, init?: RequestInit) => Promise<Response>
+
+export interface ConnectorReadiness {
+  type: string
+  status: string
+  hasCredentials: boolean
+  updatedAt: string | null
+  config: Record<string, unknown>
+}
+
+export interface ConnectorsResult {
+  connectors: ConnectorReadiness[]
+}
+
+export interface FetchConnectorsOptions {
+  fetcher?: CliFetcher
+  projectSlug: string
+}
+
+export interface ConnectorsCommandIo {
+  json: boolean
+  print: (line: string) => void
+  fetcher?: CliFetcher
+  resolveProjectSlug?: (arg: string | null) => Promise<string>
+}
+
+async function responseMessage(response: Response): Promise<string> {
+  try {
+    const data = (await response.clone().json()) as Record<string, unknown>
+    const error = typeof data.error === 'string' ? data.error : null
+    const message = typeof data.message === 'string' ? data.message : null
+    return error || message || response.statusText || String(response.status)
+  } catch {
+    return response.statusText || String(response.status)
+  }
+}
+
+export async function fetchConnectors(opts: FetchConnectorsOptions): Promise<ConnectorsResult> {
+  const fetcher = opts.fetcher ?? authedFetch
+  const response = await fetcher(`/api/cli/connectors?project=${encodeURIComponent(opts.projectSlug)}`)
+  if (!response.ok) {
+    throw new Error(`Connector status failed (${response.status}): ${await responseMessage(response)}`)
+  }
+  const data = (await response.json()) as ConnectorsResult
+  return { connectors: Array.isArray(data.connectors) ? data.connectors : [] }
+}
+
+function argValue(args: string[], flag: string): string | null {
+  const index = args.indexOf(flag)
+  if (index === -1 || index + 1 >= args.length || args[index + 1].startsWith('--')) {
+    return null
+  }
+  return args[index + 1]
+}
+
+// Positional tokens only: skips flags AND their values, so
+// `orizu connectors --project team/slug` never misreads the value.
+function positionalArgs(args: string[]): string[] {
+  const values: string[] = []
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i]
+    if (arg.startsWith('--')) {
+      if (argValue(args, arg) !== null) {
+        i += 1
+      }
+      continue
+    }
+    values.push(arg)
+  }
+  return values
+}
+
+function formatConnector(connector: ConnectorReadiness): string {
+  const creds = connector.hasCredentials ? 'credentials:yes' : 'credentials:no'
+  return `${connector.type}  ${connector.status}  ${creds}`
+}
+
+export async function connectorsCommand(args: string[], io: ConnectorsCommandIo): Promise<number> {
+  const subcommand = positionalArgs(args)[0]
+  if (subcommand && subcommand !== 'status') {
+    io.print('Usage: orizu connectors [status] [--project <team/project>] [--json]')
+    return 1
+  }
+
+  const resolveProjectSlug = io.resolveProjectSlug
+  if (!resolveProjectSlug) {
+    throw new Error('Project resolver unavailable')
+  }
+  const projectSlug = await resolveProjectSlug(argValue(args, '--project'))
+  const result = await fetchConnectors({ fetcher: io.fetcher, projectSlug })
+
+  if (io.json) {
+    io.print(JSON.stringify(result))
+    return 0
+  }
+
+  if (result.connectors.length === 0) {
+    io.print('No connectors known for this project.')
+    return 0
+  }
+  for (const connector of result.connectors) {
+    io.print(formatConnector(connector))
+  }
+  return 0
+}

package/src/credentials.ts

@@ -20,6 +20,10 @@ import {
   StoredCredentialsV3,
 } from './types.js'
 
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return error instanceof Error
+}
+
 function getConfigDir(): string {
   if (process.env.ORIZU_CONFIG_DIR) {
     return process.env.ORIZU_CONFIG_DIR
@@ -100,8 +104,8 @@ function writeCredentials(config: StoredCredentialsV2 | StoredCredentialsV3) {
   chmodSync(tempPath, 0o600)
   try {
     renameSync(tempPath, path)
-  } catch (error: any) {
-    if (process.platform === 'win32' && error?.code === 'EEXIST') {
+  } catch (error: unknown) {
+    if (process.platform === 'win32' && isNodeError(error) && error.code === 'EEXIST') {
       rmSync(path, { force: true })
       renameSync(tempPath, path)
     } else {

package/src/daytona-slice-rehearsal.ts

@@ -0,0 +1,320 @@
+/**
+ * Self-contained rehearsal harness for the Daytona slice (ALI-973 / WS-F).
+ *
+ * Extends the smoke test's in-memory fake-server technique to the WS-F broker /
+ * session-branch / finish-branch / apply contracts, and backs it with a REAL
+ * local bare git repo so the whole flow (clone → commit → push → merge) runs
+ * against genuine git. Consumed by BOTH the unit test and the local-sim
+ * rehearsal in `scripts/daytona-workbench-slice.mjs`, so the two never drift.
+ *
+ * This is the piece that makes `--provider local-sim` a rehearsal, not a mock:
+ * `finish-branch` and `apply` shell out to git on the bare repo (rev-list /
+ * update-ref), so a session branch really is merged into `main`.
+ */
+
+import { spawnSync } from 'child_process'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+
+import { WORKSPACE_SCHEMA_VERSION } from './workspace.js'
+import type { SliceConfig, SliceFetcher } from './daytona-slice.js'
+import { createLocalSimProvider } from './sandbox-provider.js'
+import type { SandboxProvider } from './sandbox-provider.js'
+
+function git(args: string[], cwd?: string): { stdout: string; stderr: string; status: number } {
+  // Strip git's repo-context env vars before spawning. When this code runs
+  // inside a git hook (e.g. the pre-push hook running `bun test`), git sets
+  // GIT_DIR in the environment — and `git init --bare <dir>` with GIT_DIR set
+  // REINITIALIZES the repo GIT_DIR points at as bare (core.bare=true in the
+  // shared config), breaking every linked worktree. Scope every child git
+  // strictly to its cwd/args instead.
+  const env: NodeJS.ProcessEnv = { ...process.env, GIT_CONFIG_NOSYSTEM: '1', GIT_TERMINAL_PROMPT: '0' }
+  delete env.GIT_DIR
+  delete env.GIT_WORK_TREE
+  delete env.GIT_INDEX_FILE
+  delete env.GIT_OBJECT_DIRECTORY
+  delete env.GIT_COMMON_DIR
+  const res = spawnSync('git', args, { cwd, encoding: 'utf8', env })
+  return { stdout: res.stdout ?? '', stderr: res.stderr ?? '', status: res.status ?? 1 }
+}
+
+function gitOrThrow(args: string[], cwd?: string): string {
+  const r = git(args, cwd)
+  if (r.status !== 0) {
+    throw new Error(`git ${args.join(' ')} failed: ${r.stderr.trim() || `exit ${r.status}`}`)
+  }
+  return r.stdout
+}
+
+export interface SeededBareRepo {
+  gitDir: string
+  repoFullName: string
+  defaultBranch: string
+}
+
+/**
+ * Create a bare git repo seeded with the Phase-1 workbench contract (matching
+ * `lib/workbench-repo-contract.ts`) on a `main` branch: root manifests, a
+ * `.gitignore` that ignores `.orizu/`, and a project stub.
+ */
+export function seedLocalBareRepo(baseDir: string, config: SliceConfig): SeededBareRepo {
+  const gitDir = join(baseDir, 'workbench.git')
+  gitOrThrow(['init', '--bare', '--initial-branch=main', gitDir])
+
+  const work = mkdtempSync(join(baseDir, 'seed-'))
+  gitOrThrow(['init', '--initial-branch=main', work])
+  const ident = ['-c', 'user.email=seed@orizu.local', '-c', 'user.name=Seed']
+
+  const teamManifest = {
+    schemaVersion: WORKSPACE_SCHEMA_VERSION,
+    kind: 'team',
+    slug: config.teamSlug,
+    canonical: { owner: 'repo', repoState: 'source', objectRef: null },
+  }
+  const projectManifest = {
+    schemaVersion: WORKSPACE_SCHEMA_VERSION,
+    kind: 'project',
+    slug: config.projectSlug,
+    canonical: { owner: 'repo', repoState: 'draft', objectRef: null },
+  }
+  writeFileSync(join(work, 'orizu.team.json'), `${JSON.stringify(teamManifest, null, 2)}\n`)
+  writeFileSync(join(work, '.gitignore'), '# Orizu workspace policy\n.orizu/\n')
+  writeFileSync(join(work, 'AGENTS.md'), '# Workbench\n')
+  const projectDir = join(work, 'projects', config.projectSlug)
+  mkdirSync(projectDir, { recursive: true })
+  writeFileSync(join(projectDir, 'orizu.project.json'), `${JSON.stringify(projectManifest, null, 2)}\n`)
+  writeFileSync(join(projectDir, '.gitkeep'), '')
+
+  gitOrThrow([...ident, 'add', '-A'], work)
+  gitOrThrow([...ident, 'commit', '-m', 'seed workbench contract'], work)
+  gitOrThrow(['remote', 'add', 'origin', gitDir], work)
+  gitOrThrow(['push', 'origin', 'main'], work)
+  rmSync(work, { recursive: true, force: true })
+
+  return { gitDir, repoFullName: `orizu-sim/orizu-workbench-${config.teamSlug}`, defaultBranch: 'main' }
+}
+
+interface StoredSession {
+  id: string
+  workspaceId: string
+  branch: string | null
+  headSha: string | null
+  projectSlug: string | null
+}
+
+interface StoredMint {
+  id: string
+  workspaceId: string
+  purpose: string
+  revoked: boolean
+}
+
+interface StoredManifest {
+  id: string
+  status: string
+  branch: string
+  headSha: string
+  outcome: Record<string, unknown>
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } })
+}
+
+/**
+ * In-memory WS-F control plane over a real bare repo. Session-start cuts a real
+ * branch; finish-branch diffs it; apply fast-forwards `main`. Tracks token mints
+ * so revocation is observable and asserts tokens never leak into stored state.
+ */
+export class FakeWorkbenchApi {
+  workspaces = new Map<string, { id: string; teamSlug: string; slug: string }>()
+  sessions = new Map<string, StoredSession>()
+  mints = new Map<string, StoredMint>()
+  manifests = new Map<string, StoredManifest>()
+  tokensIssued: string[] = []
+  private counter = 0
+
+  constructor(private readonly repo: SeededBareRepo) {}
+
+  private id(prefix: string): string {
+    this.counter += 1
+    return `${prefix}-${this.counter}`
+  }
+
+  private branchHead(branch: string): string {
+    return gitOrThrow(['--git-dir', this.repo.gitDir, 'rev-parse', branch]).trim()
+  }
+
+  newFetcher(): SliceFetcher {
+    return async (path: string, init: RequestInit = {}) => {
+      const method = (init.method || 'GET').toUpperCase()
+      const [rawPath] = path.split('?')
+      const body = typeof init.body === 'string' ? (JSON.parse(init.body) as Record<string, unknown>) : {}
+
+      // Workspace create-or-attach (idempotent on teamSlug + slug).
+      if (method === 'POST' && rawPath === '/api/cli/workspaces') {
+        const key = `${body.teamSlug}/${body.slug}`
+        const existing = this.workspaces.get(key)
+        if (existing) return jsonResponse({ workspace: { ...existing } }, 200)
+        const workspace = { id: this.id('ws'), teamSlug: String(body.teamSlug), slug: String(body.slug) }
+        this.workspaces.set(key, workspace)
+        return jsonResponse({ workspace }, 201)
+      }
+
+      // Session start — cut a real `orizu/session-<id>` branch off main.
+      const sessMatch = rawPath.match(/^\/api\/cli\/workspaces\/([^/]+)\/sessions$/)
+      if (method === 'POST' && sessMatch) {
+        const sessionId = this.id('sess')
+        const stored: StoredSession = {
+          id: sessionId,
+          workspaceId: sessMatch[1],
+          branch: null,
+          headSha: null,
+          projectSlug: typeof body.projectSlug === 'string' ? body.projectSlug : null,
+        }
+        if (body.repoBranch !== false) {
+          const branch = `orizu/session-${sessionId}`
+          gitOrThrow(['--git-dir', this.repo.gitDir, 'branch', branch, this.repo.defaultBranch])
+          stored.branch = branch
+          stored.headSha = this.branchHead(branch)
+        }
+        this.sessions.set(sessionId, stored)
+        return jsonResponse(
+          { session: { id: sessionId, repoBranch: stored.branch, repoHeadSha: stored.headSha, status: 'active' } },
+          201
+        )
+      }
+
+      // Repo-token mint.
+      const tokenMatch = rawPath.match(/^\/api\/cli\/workspaces\/([^/]+)\/repo-token$/)
+      if (method === 'POST' && tokenMatch) {
+        const purpose = String(body.purpose)
+        const mintId = this.id('mint')
+        const token = `ghs_sim_${purpose}_${mintId}_${Math.random().toString(36).slice(2)}`
+        this.mints.set(mintId, { id: mintId, workspaceId: tokenMatch[1], purpose, revoked: false })
+        this.tokensIssued.push(token)
+        return jsonResponse({
+          token,
+          expiresAt: new Date(Date.now() + 3600_000).toISOString(),
+          repo: this.repo.repoFullName,
+          mintId,
+        })
+      }
+
+      // Repo-token revoke.
+      if (method === 'DELETE' && tokenMatch) {
+        const mintId = String(body.mintId)
+        const mint = this.mints.get(mintId)
+        if (!mint) return jsonResponse({ error: 'Token mint not found' }, 404)
+        mint.revoked = true
+        return jsonResponse({ revoked: true, mintId })
+      }
+
+      // Finish-branch — compare the session branch against main.
+      const finishMatch = rawPath.match(/^\/api\/cli\/sessions\/([^/]+)\/finish-branch$/)
+      if (method === 'POST' && finishMatch) {
+        const session = this.sessions.get(finishMatch[1])
+        if (!session || !session.branch) return jsonResponse({ error: 'Session has no repo branch' }, 400)
+        const ahead = Number.parseInt(
+          gitOrThrow(['--git-dir', this.repo.gitDir, 'rev-list', '--count', `${this.repo.defaultBranch}..${session.branch}`]).trim(),
+          10
+        )
+        if (ahead === 0) {
+          gitOrThrow(['--git-dir', this.repo.gitDir, 'branch', '-D', session.branch])
+          return jsonResponse({ outcome: 'no-changes', branch: session.branch })
+        }
+        const headSha = this.branchHead(session.branch)
+        const manifestId = this.id('man')
+        this.manifests.set(manifestId, {
+          id: manifestId,
+          status: 'pending_approval',
+          branch: session.branch,
+          headSha,
+          outcome: {},
+        })
+        return jsonResponse(
+          { outcome: 'manifest', manifest: { id: manifestId, status: 'pending_approval', actionType: 'repo_merge' } },
+          201
+        )
+      }
+
+      // Manifest approve / apply / reject.
+      const manifestMatch = rawPath.match(/^\/api\/cli\/promotion-manifests\/([^/]+)$/)
+      if (method === 'POST' && manifestMatch) {
+        const manifest = this.manifests.get(manifestMatch[1])
+        if (!manifest) return jsonResponse({ error: 'Promotion manifest not found' }, 404)
+        const action = String(body.action)
+        if (action === 'approve') {
+          if (manifest.status === 'pending_approval' || manifest.status === 'draft') manifest.status = 'approved'
+          return jsonResponse({ manifest: { id: manifest.id, status: manifest.status } })
+        }
+        if (action === 'apply') {
+          if (manifest.status === 'applied') {
+            return jsonResponse({ manifest: { id: manifest.id, status: 'applied', outcome: manifest.outcome } })
+          }
+          if (manifest.status !== 'approved') {
+            return jsonResponse({ error: 'Manifest must be approved before it can be applied' }, 400)
+          }
+          // Re-verify the branch head, then fast-forward main to it (real merge).
+          const head = this.branchHead(manifest.branch)
+          if (head !== manifest.headSha) return jsonResponse({ error: 'branch moved' }, 409)
+          gitOrThrow(['--git-dir', this.repo.gitDir, 'update-ref', `refs/heads/${this.repo.defaultBranch}`, head])
+          gitOrThrow(['--git-dir', this.repo.gitDir, 'branch', '-D', manifest.branch])
+          manifest.status = 'applied'
+          manifest.outcome = { merged: true, mergeSha: head }
+          return jsonResponse({ manifest: { id: manifest.id, status: 'applied', outcome: manifest.outcome } })
+        }
+        if (action === 'reject') {
+          manifest.status = 'rejected'
+          gitOrThrow(['--git-dir', this.repo.gitDir, 'branch', '-D', manifest.branch])
+          return jsonResponse({ manifest: { id: manifest.id, status: 'rejected' } })
+        }
+        return jsonResponse({ error: "action must be one of 'approve', 'reject', 'apply'" }, 400)
+      }
+
+      throw new Error(`FakeWorkbenchApi: unexpected fetch ${method} ${path}`)
+    }
+  }
+}
+
+export interface SliceRehearsal {
+  config: SliceConfig
+  api: FakeWorkbenchApi
+  provider: SandboxProvider
+  makeFetcher: () => SliceFetcher
+  resolveCloneUrl: (repo: string) => string
+  bareRepoDir: string
+  defaultBranch: () => string
+  cleanup: () => void
+}
+
+/**
+ * Wire a full self-contained rehearsal: seed a bare repo, stand up the fake
+ * control plane, and hand back a local-sim provider + resolveCloneUrl that maps
+ * the broker's repo name to the bare repo path.
+ */
+export function createSliceRehearsal(options: { config?: Partial<SliceConfig>; keep?: boolean } = {}): SliceRehearsal {
+  const config: SliceConfig = {
+    teamSlug: options.config?.teamSlug ?? 'acme',
+    projectSlug: options.config?.projectSlug ?? 'support-bot',
+    workspaceSlug: options.config?.workspaceSlug ?? 'support-bot-slice',
+  }
+  const base = mkdtempSync(join(tmpdir(), 'orizu-slice-rehearsal-'))
+  const repo = seedLocalBareRepo(base, config)
+  const api = new FakeWorkbenchApi(repo)
+  const provider = createLocalSimProvider({ rootDir: join(base, 'sandboxes'), keepOnDestroy: Boolean(options.keep) })
+
+  return {
+    config,
+    api,
+    provider,
+    makeFetcher: () => api.newFetcher(),
+    resolveCloneUrl: () => repo.gitDir,
+    bareRepoDir: repo.gitDir,
+    defaultBranch: () => gitOrThrow(['--git-dir', repo.gitDir, 'rev-parse', repo.defaultBranch]).trim(),
+    cleanup: () => {
+      if (!options.keep) rmSync(base, { recursive: true, force: true })
+    },
+  }
+}