orizu 0.4.1 → 0.5.0

package/README.md

@@ -35,23 +35,24 @@ Install the CLI globally with your package manager:
 | pnpm | `pnpm add -g orizu` |
 | Bun | `bun add -g orizu` |
 
-Then run the guided setup — it signs you in, sets up your coding agents,
-optionally creates a gitignored `.orizu/` workspace, and hands your agent a
-prompt to plan repo-specific Orizu adoption:
+Then run the guided setup — it signs you in, initializes the local workspace
+contract, installs global coding-agent skill symlinks, and shows the next
+command for repo-specific Orizu adoption:
 
 ```bash
 orizu setup
 ```
 
-Or install just the companion coding-agent skill:
+To repair or customize skill installs later, run the companion skill installer
+directly:
 
 ```bash
 orizu install-skill --agent claude --agent codex --yes
 ```
 
-First-class plugin packages for Codex and Claude Code live under `plugins/`
-in this repository. Plugins bundle the same skill; the CLI remains the runtime
-either way.
+Experimental plugin packages for Codex and Claude Code live under `plugins/`
+in this repository. The CLI-installed skill remains the default onboarding path
+for now; the CLI is the runtime either way.
 
 ```bash
 # Codex
@@ -63,11 +64,11 @@ codex plugin add orizu@orizu-plugins
 /plugin install orizu@orizu
 ```
 
-The npm package ships the skill alongside the CLI. Run `orizu install-skill` in
-a terminal for an interactive chooser (Claude Code and Codex preselected,
-user-level installs by default), or use `orizu install-skill --help` for
-project-scope installs, sync modes, and advanced targets including the managed
-`AGENTS.md` section. Keep installs in sync after CLI upgrades with
+The npm package ships the skill alongside the CLI. Run
+`orizu install-skill --agent claude --agent codex --yes` for an explicit global
+install, or use `orizu install-skill --help` for project-scope installs, sync
+modes, and advanced targets including the managed `AGENTS.md` section for
+non-workspace repos. Keep installs in sync after CLI upgrades with
 `orizu skills status` and `orizu skills update`.
 
 Coding agents can also read the bundled skill directly without installing it:
@@ -121,7 +122,7 @@ orizu logout
   </tr>
   <tr>
     <td>Install the bundled agent skill</td>
-    <td><code>orizu install-skill --target agent-user --yes</code></td>
+    <td><code>orizu install-skill --target codex-user --yes</code></td>
   </tr>
   <tr>
     <td>Locate the bundled skill (read-only)</td>
@@ -274,6 +275,14 @@ orizu logout
     <td>Publish a draft task</td>
     <td><code>orizu tasks publish --task &lt;taskId&gt; --assignees &lt;userId1,userId2&gt;</code></td>
   </tr>
+  <tr>
+    <td>Update a draft task</td>
+    <td><code>orizu tasks update --task &lt;taskId&gt; --title "Support QA Round 1b" --labels-per-item 2</code></td>
+  </tr>
+  <tr>
+    <td>Discard a draft task</td>
+    <td><code>orizu tasks discard --task &lt;taskId&gt; --yes</code></td>
+  </tr>
   <tr>
     <td>Check task status</td>
     <td><code>orizu tasks status --task &lt;taskId&gt;</code></td>

package/dist/artifact-archive.js

@@ -0,0 +1,152 @@
+import { createHash } from 'crypto';
+import { readdirSync, readFileSync, statSync } from 'fs';
+import { join } from 'path';
+const ARTIFACT_EXCLUDED_PATH_NAMES = new Set([
+    '.git',
+    '.DS_Store',
+    '__pycache__',
+    '.pytest_cache',
+    '.orizu',
+]);
+function isNodeError(error) {
+    return error instanceof Error;
+}
+function expandHomePath(path) {
+    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) {
+    const parts = relativePath.split('/');
+    return parts.some(part => ARTIFACT_EXCLUDED_PATH_NAMES.has(part) ||
+        part === '.env' ||
+        part.startsWith('.env.'));
+}
+export function collectArtifactFiles(sourceDir, relativeDir = '') {
+    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) {
+    let crc = 0xffffffff;
+    for (const byte of bytes) {
+        crc = CRC32_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+export function createStoredZip(entries) {
+    const localParts = [];
+    const centralParts = [];
+    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) {
+    const sourceDir = expandHomePath(dirArg);
+    try {
+        const stats = statSync(sourceDir);
+        if (!stats.isDirectory()) {
+            throw new Error(`${sourceDir} is not a directory`);
+        }
+    }
+    catch (error) {
+        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/dist/connectors-cli.js

@@ -0,0 +1,80 @@
+/**
+ * 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';
+async function responseMessage(response) {
+    try {
+        const data = (await response.clone().json());
+        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) {
+    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());
+    return { connectors: Array.isArray(data.connectors) ? data.connectors : [] };
+}
+function argValue(args, flag) {
+    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) {
+    const values = [];
+    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) {
+    const creds = connector.hasCredentials ? 'credentials:yes' : 'credentials:no';
+    return `${connector.type}  ${connector.status}  ${creds}`;
+}
+export async function connectorsCommand(args, io) {
+    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/dist/credentials.js

@@ -2,6 +2,9 @@ import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readF
 import { join } from 'path';
 import { homedir } from 'os';
 import { randomBytes } from 'crypto';
+function isNodeError(error) {
+    return error instanceof Error;
+}
 function getConfigDir() {
     if (process.env.ORIZU_CONFIG_DIR) {
         return process.env.ORIZU_CONFIG_DIR;
@@ -68,7 +71,7 @@ function writeCredentials(config) {
         renameSync(tempPath, path);
     }
     catch (error) {
-        if (process.platform === 'win32' && error?.code === 'EEXIST') {
+        if (process.platform === 'win32' && isNodeError(error) && error.code === 'EEXIST') {
             rmSync(path, { force: true });
             renameSync(tempPath, path);
         }

package/dist/daytona-slice-rehearsal.js

@@ -0,0 +1,255 @@
+/**
+ * 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 { createLocalSimProvider } from './sandbox-provider.js';
+function git(args, cwd) {
+    // 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 = { ...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, cwd) {
+    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;
+}
+/**
+ * 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, config) {
+    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' };
+}
+function jsonResponse(body, status = 200) {
+    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 {
+    repo;
+    workspaces = new Map();
+    sessions = new Map();
+    mints = new Map();
+    manifests = new Map();
+    tokensIssued = [];
+    counter = 0;
+    constructor(repo) {
+        this.repo = repo;
+    }
+    id(prefix) {
+        this.counter += 1;
+        return `${prefix}-${this.counter}`;
+    }
+    branchHead(branch) {
+        return gitOrThrow(['--git-dir', this.repo.gitDir, 'rev-parse', branch]).trim();
+    }
+    newFetcher() {
+        return async (path, init = {}) => {
+            const method = (init.method || 'GET').toUpperCase();
+            const [rawPath] = path.split('?');
+            const body = typeof init.body === 'string' ? JSON.parse(init.body) : {};
+            // 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 = {
+                    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}`);
+        };
+    }
+}
+/**
+ * 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 = {}) {
+    const config = {
+        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 });
+        },
+    };
+}