orizu 0.4.1 → 0.5.0

package/dist/help.js

@@ -16,6 +16,11 @@ const GROUPS = [
     { name: 'Apps', summary: 'Create, preview, update, inspect, and export review apps.' },
     { name: 'Tasks', summary: 'Create review tasks, mutate task status, assign reviewers, and export labels.' },
     { name: 'Datasets', summary: 'Upload, version, split, mutate, export, lock, clone, and delete datasets.' },
+    { name: 'Workspace', summary: 'Metadata-first sync of the workbench contract: inspect status, reconcile, pull, and apply.' },
+    { name: 'Sessions', summary: 'Start, inspect, and end durable workspace sessions for agent/operator work.' },
+    { name: 'Workbench runs', summary: 'Start, inspect, tail, and finish resumable workbench runs.' },
+    { name: 'Connectors', summary: 'Inspect project connector/integration readiness (read-only; secrets redacted).' },
+    { name: 'Promotion manifests', summary: 'List, inspect, approve, reject, and idempotently apply promotion manifests.' },
 ];
 export const COMMAND_DOCS = [
     {
@@ -54,28 +59,36 @@ export const COMMAND_DOCS = [
     },
     {
         path: ['setup'],
-        usage: 'orizu setup [--agent <claude|codex>]... [--scope global|project] [--mode auto|link|copy] [--workspace|--no-workspace] [--no-install] [--no-handoff] [--launch <claude|codex>] [--skip-login] [--yes] [--dry-run] [--no-input] [--json]',
-        summary: 'Guided onboarding: sign in, set up your coding agents, create a local workspace, and hand off to your agent.',
+        usage: 'orizu setup [--team <slug>] [--agent <claude|codex>]... [--workspace [path]|--no-workspace] [--validate] [--fix] [--no-symlinks] [--verbose] [--no-install] [--handoff|--no-handoff] [--launch <claude|codex>] [--skip-login] [--yes] [--dry-run] [--no-input|--non-interactive] [--json]',
+        summary: 'Guided onboarding: sign in, initialize the workbench contract, and install agent skills.',
         group: 'Agent setup',
         options: [
-            { name: '--agent <agent>', help: 'Coding agent to set up. Repeat for multiple agents.', repeatable: true, choices: ['claude', 'codex'] },
-            { name: '--scope <scope>', help: 'global (default) installs for you across all projects; project installs into the current repo.', choices: ['global', 'project'] },
-            { name: '--mode <mode>', help: 'Skill install sync mode (auto, link, copy).', choices: ['auto', 'link', 'copy'] },
-            { name: '--workspace', help: 'Create the gitignored .orizu/ workspace without prompting.' },
-            { name: '--no-workspace', help: 'Skip workspace creation.' },
-            { name: '--no-install', help: 'Skip the agent integration phase.' },
-            { name: '--no-handoff', help: 'Skip printing the coding-agent setup prompt.' },
+            { name: '--team <slug>', help: 'Team/workbench slug. Authenticated setup materializes all projects in this team.' },
+            { name: '--workspace [path]', help: 'Initialize or validate a workspace path, or the current directory when no path is provided. If provided, the value must be a filesystem path.' },
+            { name: '--service-origin <url>', help: 'Service origin written to setup metadata. Defaults to the active CLI server.' },
+            { name: '--attach-workspace <id>', help: 'Record an existing Orizu workspace id for future attachment.' },
+            { name: '--validate', help: 'Inspect the workspace contract without writing files.' },
+            { name: '--fix', help: 'Apply safe idempotent repairs only.' },
+            { name: '--no-symlinks', help: 'Write CLAUDE.md as a pointer file instead of a symlink to AGENTS.md.' },
+            { name: '--verbose', help: 'Show per-file setup actions. Default setup output is summary-oriented.' },
+            { name: '--agent <agent>', help: 'Install the global Orizu skill for this coding agent after workspace setup. Repeat for multiple agents.', repeatable: true, choices: ['claude', 'codex'] },
+            { name: '--no-workspace', help: 'Skip workspace creation during guided setup. `--validate` and `--fix` still inspect or repair the workspace contract.' },
+            { name: '--no-install', help: 'Skip the coding-agent skill install step.' },
+            { name: '--handoff', help: 'Print the coding-agent setup prompt after setup. By default, setup points to `orizu setup prompt` instead of printing it inline.' },
+            { name: '--no-handoff', help: 'Compatibility flag; suppresses --handoff/--launch. Setup does not print the handoff prompt by default.' },
             { name: '--launch <agent>', help: 'Launch a detected coding agent with the setup prompt (interactive terminals only).', choices: ['claude', 'codex'] },
             { name: '--skip-login', help: 'Skip the authentication phase.' },
-            { name: '--yes', help: 'Apply changes without per-step confirmation prompts.' },
+            { name: '--yes', help: 'Replace existing managed skill links without prompting.' },
             { name: '--dry-run', help: 'Preview every planned change without writing.' },
             { name: '--no-input', help: 'Never prompt; behave as in a non-interactive terminal.' },
+            { name: '--non-interactive', help: 'Alias for --no-input.' },
             { name: '--json', help: 'Emit the setup summary as JSON.' },
         ],
         examples: [
             'orizu setup',
-            'orizu setup --agent claude --agent codex --yes',
-            'orizu setup --skip-login --no-workspace --dry-run',
+            'orizu setup --team highlight',
+            'orizu setup --team highlight --agent codex --agent claude --non-interactive --yes',
+            'orizu setup --validate --workspace ./workbench',
         ],
     },
     {
@@ -88,7 +101,7 @@ export const COMMAND_DOCS = [
     {
         path: ['install-skill'],
         usage: 'orizu install-skill [--agent <claude|codex>]... [--scope global|project] [--mode auto|link|copy] [--target <target>]... [--yes] [--dry-run]',
-        summary: 'Set up the Orizu skill for your coding agents (Claude Code, Codex/Open Agent Skills, or project instructions).',
+        summary: 'Install or repair the Orizu coding-agent skill.',
         group: 'Agent setup',
         aliases: [['skills', 'install']],
         options: [
@@ -112,7 +125,7 @@ export const COMMAND_DOCS = [
                 name: '--target <target>',
                 help: 'Advanced: explicit install destination ID. Repeat for multiple targets.',
                 repeatable: true,
-                choices: ['agent-user', 'agents-project', 'codex-project', 'claude-user', 'claude-project', 'agents-md'],
+                choices: ['codex-user', 'agent-user', 'agents-project', 'codex-project', 'claude-user', 'claude-project', 'agents-md'],
             },
             { name: '--yes', help: 'Replace an existing managed skill or AGENTS.md section without prompting.' },
             { name: '--dry-run', help: 'Show planned writes without changing files.' },
@@ -201,7 +214,7 @@ export const COMMAND_DOCS = [
     },
     {
         path: ['teams', 'members', 'role'],
-        usage: 'orizu teams members role --team <teamSlug> --email <email> --role <admin|member>',
+        usage: 'orizu teams members role --team <teamSlug> --email <email> --role <admin|curator|judge>',
         summary: 'Change a member role.',
         group: 'Teams',
     },
@@ -454,6 +467,18 @@ export const COMMAND_DOCS = [
         summary: 'Create a draft review task by default, with auto distribution or an explicit row-assignment JSONL file.',
         group: 'Tasks',
     },
+    {
+        path: ['tasks', 'update'],
+        usage: 'orizu tasks update --task <taskId> [--title <text>] [--description <text>|--description-file <path>] [--instructions <text>|--instructions-file <path>] [--dataset <datasetId>] [--app <appId> [--version <n>]] [--labels-per-item <n>] [--assignees <userIdOrEmail1,userIdOrEmail2> | --assignment-file <path>] [--json]',
+        summary: 'Update a draft review task before publishing.',
+        group: 'Tasks',
+    },
+    {
+        path: ['tasks', 'discard'],
+        usage: 'orizu tasks discard --task <taskId> [--yes] [--json]',
+        summary: 'Permanently discard a draft review task.',
+        group: 'Tasks',
+    },
     {
         path: ['tasks', 'publish'],
         usage: 'orizu tasks publish --task <taskId> (--assignees <userId1,userId2> | --assignment-file <path>) [--json]',
@@ -501,6 +526,12 @@ export const COMMAND_DOCS = [
         summary: 'Resume a paused task.',
         group: 'Tasks',
     },
+    {
+        path: ['tasks', 'complete'],
+        usage: 'orizu tasks complete --task <taskId>',
+        summary: 'Mark an active or paused task completed.',
+        group: 'Tasks',
+    },
     {
         path: ['tasks', 'export'],
         usage: 'orizu tasks export [--task <taskId>] [--format <csv|json|jsonl>] [--out <path>]',
@@ -579,6 +610,230 @@ export const COMMAND_DOCS = [
         summary: 'Clone a dataset.',
         group: 'Datasets',
     },
+    {
+        path: ['workspace', 'status'],
+        usage: 'orizu workspace status [--remote] [--json]',
+        summary: 'Show tracked-resource status: local dirtiness vs the last-sync cache, plus missing and untracked files; --remote adds server statuses via a server-side reconciliation.',
+        group: 'Workspace',
+        options: [
+            { name: '--remote', help: 'Attach server statuses. This performs the same server-side reconciliation as `orizu workspace sync` — it registers and updates tracked-resource records; there is no read-only remote status in v0. The local cache is never advanced.' },
+            { name: '--json', help: 'Emit the machine-readable status result.' },
+        ],
+        examples: ['orizu workspace status', 'orizu workspace status --remote --json'],
+    },
+    {
+        path: ['workspace', 'sync'],
+        usage: 'orizu workspace sync [--json]',
+        summary: 'Metadata-first reconcile of the whole workbench. Attaches the workspace on first run; advances the cache base only on a clean convergence.',
+        group: 'Workspace',
+        options: [
+            { name: '--json', help: 'Emit the machine-readable per-resource status list.' },
+        ],
+        examples: ['orizu workspace sync', 'orizu workspace sync --json'],
+    },
+    {
+        path: ['workspace', 'pull'],
+        usage: 'orizu workspace pull <path> [--json]',
+        summary: 'Fast-forward a resource to the server truth (v0: manifest canonical block + cache only). Refuses when local edits are ahead and no-ops when the server has no truth (local-only/stale). Bulk content materializes via the primitive command (e.g. orizu prompts pull).',
+        group: 'Workspace',
+        options: [
+            { name: '--json', help: 'Emit the machine-readable pull result.' },
+        ],
+        examples: ['orizu workspace pull projects/hip/prompts/judge/orizu.prompt.json'],
+    },
+    {
+        path: ['workspace', 'apply'],
+        usage: 'orizu workspace apply <path> [--json]',
+        summary: 'Promote a repo-owned resource to the server, addressed by the row id recorded by sync. Refuses (409) DB-native/object-storage owners, conflicts, remote-newer, and lost compare-and-set races — on any refusal, run `orizu workspace sync`, converge, then retry.',
+        group: 'Workspace',
+        options: [
+            { name: '--json', help: 'Emit the machine-readable apply result.' },
+        ],
+        examples: ['orizu workspace apply projects/hip/prompts/judge/orizu.prompt.json'],
+    },
+    {
+        path: ['session', 'start'],
+        usage: 'orizu session start [--project <team/project>] [--json]',
+        summary: 'Start a durable workspace session for the attached workspace and print the session id for later resume.',
+        group: 'Sessions',
+        options: [
+            { name: '--project <team/project>', help: 'Optionally scope the session to a project in the attached workspace.' },
+            { name: '--json', help: 'Emit the machine-readable session payload.' },
+        ],
+        examples: ['orizu session start', 'orizu session start --project highlight/hip --json'],
+    },
+    {
+        path: ['session', 'status'],
+        usage: 'orizu session status [--session <id> | --status active|ended] [--json]',
+        summary: 'Inspect one session by id, including run summaries, or list sessions for the attached workspace.',
+        group: 'Sessions',
+        options: [
+            { name: '--session <id>', help: 'Resume by session id; does not require the original terminal.' },
+            { name: '--status <status>', help: 'Filter attached-workspace sessions when --session is omitted.', choices: ['active', 'ended'] },
+            { name: '--json', help: 'Emit the machine-readable session or session-list payload.' },
+        ],
+        examples: ['orizu session status --session sess_123 --json', 'orizu session status --status active'],
+    },
+    {
+        path: ['session', 'end'],
+        usage: 'orizu session end --session <id> [--json]',
+        summary: 'Mark a durable workspace session ended.',
+        group: 'Sessions',
+        options: [
+            { name: '--session <id>', help: 'Session id to end.', required: true },
+            { name: '--json', help: 'Emit the machine-readable ended session payload.' },
+        ],
+        examples: ['orizu session end --session sess_123'],
+    },
+    {
+        path: ['session', 'finish'],
+        usage: 'orizu session finish --session <id> [--project <team/project>] [--json]',
+        summary: 'Finish a hosted session branch: no changes deletes the branch; changes create a repo_merge promotion manifest to review and approve (no GitHub PR).',
+        group: 'Sessions',
+        options: [
+            { name: '--session <id>', help: 'Session id whose branch to finish.', required: true },
+            { name: '--project <team/project>', help: 'Project scope for the manifest when the session is not already project-scoped.' },
+            { name: '--json', help: 'Emit the machine-readable outcome (no-changes or the created manifest).' },
+        ],
+        examples: ['orizu session finish --session sess_123', 'orizu session finish --session sess_123 --project highlight/hip --json'],
+    },
+    {
+        path: ['run', 'start'],
+        usage: 'orizu run start --session <id> --title <title> [--project <team/project>] [--json]',
+        summary: 'Start a resumable workbench run inside a workspace session and print the run id.',
+        group: 'Workbench runs',
+        options: [
+            { name: '--session <id>', help: 'Workspace session id.', required: true },
+            { name: '--title <title>', help: 'Human-readable run title.', required: true },
+            { name: '--project <team/project>', help: 'Optionally override the session project scope.' },
+            { name: '--json', help: 'Emit the machine-readable run payload.' },
+        ],
+        examples: ['orizu run start --session sess_123 --title "Fix evaluator drift" --json'],
+    },
+    {
+        path: ['run', 'status'],
+        usage: 'orizu run status --run <id> [--json]',
+        summary: 'Inspect a workbench run by id, including evidence and latest event sequence.',
+        group: 'Workbench runs',
+        options: [
+            { name: '--run <id>', help: 'Workbench run id.', required: true },
+            { name: '--json', help: 'Emit the machine-readable run payload.' },
+        ],
+        examples: ['orizu run status --run run_123 --json'],
+    },
+    {
+        path: ['run', 'tail'],
+        usage: 'orizu run tail --run <id> [--after <seq>] [--interval <seconds>] [--once] [--json]',
+        summary: 'Cursor-poll a workbench run event log; JSON mode emits one event object per line.',
+        group: 'Workbench runs',
+        options: [
+            { name: '--run <id>', help: 'Workbench run id.', required: true },
+            { name: '--after <seq>', help: 'Start after this event sequence. Defaults to 0.' },
+            { name: '--interval <seconds>', help: 'Polling interval for non-terminal runs. Defaults to 2.' },
+            { name: '--once', help: 'Fetch one page and exit; useful for tests and agents.' },
+            { name: '--json', help: 'Emit JSONL, one event object per line.' },
+        ],
+        examples: ['orizu run tail --run run_123', 'orizu run tail --run run_123 --after 42 --once --json'],
+    },
+    {
+        path: ['run', 'complete'],
+        usage: 'orizu run complete --run <id> [--summary <text>] [--json]',
+        summary: 'Mark a workbench run succeeded.',
+        group: 'Workbench runs',
+        options: [
+            { name: '--run <id>', help: 'Workbench run id.', required: true },
+            { name: '--summary <text>', help: 'Optional note stored in the run summary.' },
+            { name: '--json', help: 'Emit the machine-readable run payload.' },
+        ],
+        examples: ['orizu run complete --run run_123 --summary "All gates passed"'],
+    },
+    {
+        path: ['run', 'fail'],
+        usage: 'orizu run fail --run <id> [--summary <text>] [--json]',
+        summary: 'Mark a workbench run failed.',
+        group: 'Workbench runs',
+        options: [
+            { name: '--run <id>', help: 'Workbench run id.', required: true },
+            { name: '--summary <text>', help: 'Optional note stored in the run summary.' },
+            { name: '--json', help: 'Emit the machine-readable run payload.' },
+        ],
+        examples: ['orizu run fail --run run_123 --summary "Lint failed"'],
+    },
+    {
+        path: ['run', 'cancel'],
+        usage: 'orizu run cancel --run <id> [--summary <text>] [--json]',
+        summary: 'Mark a workbench run cancelled.',
+        group: 'Workbench runs',
+        options: [
+            { name: '--run <id>', help: 'Workbench run id.', required: true },
+            { name: '--summary <text>', help: 'Optional note stored in the run summary.' },
+            { name: '--json', help: 'Emit the machine-readable run payload.' },
+        ],
+        examples: ['orizu run cancel --run run_123 --summary "Superseded by run_456"'],
+    },
+    {
+        path: ['connectors', 'status'],
+        usage: 'orizu connectors [status] [--project <team/project>] [--json]',
+        summary: 'Show project connector readiness (configured/missing/stale/unauthorized/unsupported/unknown) derived read-only from stored integration state. Secrets are always redacted.',
+        group: 'Connectors',
+        options: [
+            { name: '--project <team/project>', help: 'Project whose connector readiness to inspect.' },
+            { name: '--json', help: 'Emit the machine-readable connector readiness payload.' },
+        ],
+        examples: ['orizu connectors', 'orizu connectors status --project highlight/hip --json'],
+    },
+    {
+        path: ['manifests', 'list'],
+        usage: 'orizu manifests list [--project <team/project>] [--status <status>] [--json]',
+        summary: 'List promotion manifests for a project, newest first, optionally filtered by status.',
+        group: 'Promotion manifests',
+        options: [
+            { name: '--project <team/project>', help: 'Project whose manifests to list.' },
+            { name: '--status <status>', help: 'Filter by status.', choices: ['draft', 'pending_approval', 'approved', 'applied', 'rejected'] },
+            { name: '--json', help: 'Emit the machine-readable manifest list.' },
+        ],
+        examples: ['orizu manifests list --project highlight/hip --status pending_approval'],
+    },
+    {
+        path: ['manifests', 'show'],
+        usage: 'orizu manifests show <id> [--json]',
+        summary: 'Show one promotion manifest, including current/proposed state, evidence, outcome, and approver.',
+        group: 'Promotion manifests',
+        options: [
+            { name: '--json', help: 'Emit the machine-readable manifest payload.' },
+        ],
+        examples: ['orizu manifests show manifest_123 --json'],
+    },
+    {
+        path: ['manifests', 'approve'],
+        usage: 'orizu manifests approve <id> [--json]',
+        summary: 'Approve a draft or pending_approval manifest; records the approver principal separately from the author.',
+        group: 'Promotion manifests',
+        options: [
+            { name: '--json', help: 'Emit the machine-readable manifest payload.' },
+        ],
+        examples: ['orizu manifests approve manifest_123'],
+    },
+    {
+        path: ['manifests', 'reject'],
+        usage: 'orizu manifests reject <id> [--json]',
+        summary: 'Reject a manifest so it can no longer be applied.',
+        group: 'Promotion manifests',
+        options: [
+            { name: '--json', help: 'Emit the machine-readable manifest payload.' },
+        ],
+        examples: ['orizu manifests reject manifest_123'],
+    },
+    {
+        path: ['manifests', 'apply'],
+        usage: 'orizu manifests apply <id> [--json]',
+        summary: 'Apply an approved manifest. Idempotent: re-applying returns the stored outcome with no second effect. v0 records the outcome and links evidence; content promotion still flows through the primitive commands.',
+        group: 'Promotion manifests',
+        options: [
+            { name: '--json', help: 'Emit the machine-readable manifest payload.' },
+        ],
+        examples: ['orizu manifests apply manifest_123 --json'],
+    },
 ];
 function groupByName(name) {
     return GROUPS.find(group => group.name === name);
@@ -625,7 +880,7 @@ export function renderRootHelp() {
             lines.push(`    ${doc.usage}`);
         }
     }
-    lines.push('', 'Examples:', '  orizu install-skill --target agent-user --yes', '  orizu apps preview --file ./App.tsx --input-schema ./input.json --output-schema ./output.json --sample-row ./row.json --screenshot ./preview.png', '  orizu tasks create --project core/evals --dataset <datasetId> --app <appId> --title "Review"', '  orizu tasks publish --task <taskId> --assignees <userId1,userId2>', '', 'More:', '  orizu <group> --help', '  orizu <command> --help', '  orizu capabilities --json', '  https://docs.orizu.ai');
+    lines.push('', 'Examples:', '  orizu install-skill --target codex-user --yes', '  orizu apps preview --file ./App.tsx --input-schema ./input.json --output-schema ./output.json --sample-row ./row.json --screenshot ./preview.png', '  orizu tasks create --project core/evals --dataset <datasetId> --app <appId> --title "Review"', '  orizu tasks publish --task <taskId> --assignees <userId1,userId2>', '', 'More:', '  orizu <group> --help', '  orizu <command> --help', '  orizu capabilities --json', '  https://docs.orizu.ai');
     return lines.join('\n');
 }
 export function renderGroupHelp(args) {

package/dist/hosted-bootstrap-rehearsal.js

@@ -0,0 +1,235 @@
+/**
+ * Self-contained rehearsal for the hosted bootstrap (ALI-925), extending the
+ * ALI-973 `daytona-slice-rehearsal` pattern.
+ *
+ * The whole `bootstrapHostedSandbox` flow runs against the local-sim provider
+ * with NO Daytona and NO GitHub: a REAL bare git repo backs the session branch,
+ * and a REAL HTTP broker (`hosted-broker-server.ts`) stands in for the Orizu
+ * control plane (per-repo token broker + RunAPI event ingest).
+ *
+ * The broker runs as a SEPARATE PROCESS on purpose: local-sim's `exec` blocks on
+ * `spawnSync`, and the in-sandbox credential helper it runs calls the broker over
+ * the network — an in-process server could not answer while the test thread is
+ * blocked. The broker journals events/tokens to files the rehearsal reads back.
+ */
+import { spawnSync } from 'child_process';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { basename, join } from 'path';
+import { fileURLToPath } from 'url';
+import { seedLocalBareRepo } from './daytona-slice-rehearsal.js';
+import { createLocalSimProvider } from './sandbox-provider.js';
+import { gitHttpEnv } from './hosted-git-http-server.js';
+/** The loopback host the git server binds; the helper is scoped to it. */
+const LOOPBACK_HOST = '127.0.0.1';
+function git(args, cwd) {
+    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;
+}
+function bunSpawn() {
+    const b = globalThis.Bun;
+    if (!b?.spawn)
+        throw new Error('Bun.spawn is required for the hosted-bootstrap rehearsal (run under bun test)');
+    return b;
+}
+/**
+ * Env keys the broker server reads (kept here so callers do not hand-roll them).
+ */
+export function brokerEnv(config) {
+    const env = { HB_BEARER: config.bearer, HB_REPO: config.repo };
+    if (config.eventsFile)
+        env.HB_EVENTS_FILE = config.eventsFile;
+    if (config.tokensFile)
+        env.HB_TOKENS_FILE = config.tokensFile;
+    if (config.sessionId)
+        env.HB_SESSION_ID = config.sessionId;
+    if (config.sessionBranch)
+        env.HB_SESSION_BRANCH = config.sessionBranch;
+    if (config.repoTokenStatus)
+        env.HB_REPO_TOKEN_STATUS = String(config.repoTokenStatus);
+    if (config.eventsStatus)
+        env.HB_EVENTS_STATUS = String(config.eventsStatus);
+    if (config.denyWrite)
+        env.HB_DENY_WRITE = '1';
+    if (config.fullRunApi)
+        env.HB_FULL_RUN_API = '1';
+    return env;
+}
+/**
+ * Spawn the broker server as its own process and resolve once it prints
+ * `LISTENING <port>` on stdout.
+ */
+export async function spawnBrokerProcess(config) {
+    const brokerPath = fileURLToPath(new URL('./hosted-broker-server.ts', import.meta.url));
+    const proc = bunSpawn().spawn({
+        cmd: ['bun', brokerPath],
+        env: { ...process.env, ...brokerEnv(config) },
+        stdout: 'pipe',
+        stderr: 'inherit',
+    });
+    const decoder = new TextDecoder();
+    const reader = proc.stdout.getReader();
+    let buffered = '';
+    const deadline = Date.now() + 10_000;
+    while (Date.now() <= deadline) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (value)
+            buffered += decoder.decode(value, { stream: true });
+        const match = buffered.match(/LISTENING (\d+)/);
+        if (match) {
+            reader.releaseLock();
+            const port = Number.parseInt(match[1], 10);
+            return { apiBaseUrl: `http://127.0.0.1:${port}`, port, stop: () => proc.kill() };
+        }
+    }
+    reader.releaseLock();
+    proc.kill();
+    throw new Error('broker server did not report a listening port in time');
+}
+/**
+ * Spawn the authenticated smart-HTTP git server as its own process (same
+ * separate-process rationale as the broker) and resolve once it prints
+ * `LISTENING <port>`. `baseUrl` is the clone URL root; append the repo segment.
+ */
+export async function spawnGitHttpProcess(config) {
+    const serverPath = fileURLToPath(new URL('./hosted-git-http-server.ts', import.meta.url));
+    const proc = bunSpawn().spawn({
+        cmd: ['bun', serverPath],
+        env: { ...process.env, ...gitHttpEnv(config) },
+        stdout: 'pipe',
+        stderr: 'inherit',
+    });
+    const decoder = new TextDecoder();
+    const reader = proc.stdout.getReader();
+    let buffered = '';
+    const deadline = Date.now() + 10_000;
+    while (Date.now() <= deadline) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (value)
+            buffered += decoder.decode(value, { stream: true });
+        const match = buffered.match(/LISTENING (\d+)/);
+        if (match) {
+            reader.releaseLock();
+            const port = Number.parseInt(match[1], 10);
+            return { baseUrl: `http://127.0.0.1:${port}`, port, stop: () => proc.kill() };
+        }
+    }
+    reader.releaseLock();
+    proc.kill();
+    throw new Error('git http server did not report a listening port in time');
+}
+function readJsonl(file) {
+    let raw = '';
+    try {
+        raw = readFileSync(file, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    return raw
+        .split('\n')
+        .filter(line => line.length > 0)
+        .map(line => JSON.parse(line));
+}
+function readLines(file) {
+    try {
+        return readFileSync(file, 'utf8').split('\n').filter(line => line.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+export async function createHostedBootstrapRehearsal(options = {}) {
+    const bearer = options.bearer ?? 'pat_rehearsal_bearer_do_not_log';
+    const base = mkdtempSync(join(tmpdir(), 'orizu-hosted-boot-'));
+    const repo = seedLocalBareRepo(base, {
+        teamSlug: 'acme',
+        projectSlug: 'support-bot',
+        workspaceSlug: 'support-bot-hosted',
+    });
+    const workspaceId = 'ws-hosted-1';
+    const sessionId = 'sess-hosted-1';
+    const runId = 'run-hosted-1';
+    const sessionBranch = `orizu/session-${sessionId}`;
+    // Cut the session branch off main on the real bare repo.
+    gitOrThrow(['--git-dir', repo.gitDir, 'branch', sessionBranch, repo.defaultBranch]);
+    // Optionally seed a customer setup hook onto the session branch. `.orizu/` is
+    // git-ignored by the workbench contract, so the hook is force-added — an open
+    // question flagged in the secrets-policy doc.
+    if (options.setupHookBody) {
+        const work = mkdtempSync(join(base, 'hook-'));
+        gitOrThrow(['clone', '--branch', sessionBranch, repo.gitDir, work]);
+        mkdirSync(join(work, '.orizu'), { recursive: true });
+        writeFileSync(join(work, '.orizu', 'setup.sh'), options.setupHookBody);
+        const ident = ['-c', 'user.email=hook@orizu.local', '-c', 'user.name=Hook'];
+        gitOrThrow([...ident, '-C', work, 'add', '-f', '.orizu/setup.sh']);
+        gitOrThrow([...ident, '-C', work, 'commit', '-m', 'seed setup hook']);
+        gitOrThrow(['-C', work, 'push', 'origin', sessionBranch]);
+        rmSync(work, { recursive: true, force: true });
+    }
+    const eventsFile = join(base, 'events.jsonl');
+    const tokensFile = join(base, 'tokens.txt');
+    const authLogFile = join(base, 'git-auth.jsonl');
+    writeFileSync(eventsFile, '');
+    writeFileSync(tokensFile, '');
+    writeFileSync(authLogFile, '');
+    const broker = await spawnBrokerProcess({
+        bearer,
+        repo: repo.repoFullName,
+        eventsFile,
+        tokensFile,
+        repoTokenStatus: options.repoTokenStatus,
+        eventsStatus: options.eventsStatus,
+        fullRunApi: options.fullRunApi,
+        sessionId,
+        sessionBranch,
+    });
+    // Real authenticated smart-HTTP git server on loopback: this is what makes the
+    // clone go git → credential helper → broker → token → Basic auth → served repo,
+    // instead of a filesystem clone that bypasses the helper entirely.
+    const gitServer = await spawnGitHttpProcess({ repoDir: repo.gitDir, authLogFile });
+    // git includes the (non-standard) port in the credential `host` field, so the
+    // helper must be scoped to `127.0.0.1:<port>`, not the bare loopback host.
+    const host = `${LOOPBACK_HOST}:${gitServer.port}`;
+    const insecureHttpHosts = [host];
+    const cloneUrl = `${gitServer.baseUrl}/${basename(repo.gitDir)}`;
+    const provider = createLocalSimProvider({ rootDir: join(base, 'sandboxes'), keepOnDestroy: Boolean(options.keep) });
+    return {
+        apiBaseUrl: broker.apiBaseUrl,
+        bearer,
+        workspaceId,
+        sessionId,
+        runId,
+        sessionBranch,
+        repoFullName: repo.repoFullName,
+        provider,
+        resolveCloneUrl: () => cloneUrl,
+        host,
+        insecureHttpHosts,
+        events: () => readJsonl(eventsFile),
+        tokensIssued: () => readLines(tokensFile),
+        basicAuthPasswords: () => readJsonl(authLogFile).map(entry => entry.pass),
+        cleanup: async () => {
+            broker.stop();
+            gitServer.stop();
+            if (!options.keep)
+                rmSync(base, { recursive: true, force: true });
+        },
+    };
+}