hanzo.ai/e2e/bots-live.spec.ts

// A BOT, END TO END, AGAINST THE REAL PLATFORM.
//
// Nothing here is stubbed. The spec signs in through Hanzo IAM with a real
// account, drives the Bots room in a browser, and checks the platform's own
// answer for every claim the room makes. A check that cannot be made against a
// route that answers is SKIPPED with the route named, never faked green.
//
//   BASE_URL=http://localhost:5173 IAM_USER=… IAM_PASS=… \
//     pnpm exec playwright test --project=chromium e2e/bots-live.spec.ts
//
// or, with a bearer that account already holds, IAM_TOKEN=… in place of the
// pair — see TOKEN below for why the second way exists.
//
// The dev server must proxy /v1 at the real gateway — `HANZO_API_ORIGIN` in
// .env.local, which next.config.mjs documents. Pointed at a half-started local
// cloud instead, `/v1/agents` answers `{"agents":[]}` and every check below
// passes against an empty org, which is the shape of a test that proves
// nothing. The first check asserts the gateway is the real one for that reason.
//
// WHAT THE PLATFORM CANNOT DO TODAY, measured 2026-09-07 and skipped below:
//
//   sandboxed code, a terminal, a screen, computer use, a browser session
//     POST /v1/sandbox/lease answers 503 for every class — `exec` and
//     `desktop` with "pod … not running after 2m0s", `dev` with "admin
//     credentials: DO_API_TOKEN not configured" — and POST /v1/exec, the
//     other door onto that pool, answers the first. One outage, five
//     capabilities.
//   an autonomous coding run
//     POST /v1/agents/coding validates the repo and then answers 400
//     "could not start a session: cloud: app is not deployed here: agents
//     (the router runs no such app)".
//   invoking the CLI
//     no route in the published OpenAPI document invokes it. The CLI runs
//     inside a sandbox, which is the outage above.
//   binding a connector to one bot
//     /v1/connection is the person's; no route narrows one to
//     an agent. A CHANNEL does narrow — /v1/channels/agent — and is checked.

import { expect, test, type Page } from '@playwright/test'

const BASE = process.env.BASE_URL ?? 'http://localhost:5173'
const USER = process.env.IAM_USER
const PASS = process.env.IAM_PASS

/**
 * A bearer IAM already minted for that account, when one is to hand.
 *
 * ONE ACT, TWO SOURCES — not two mechanisms. The session this spec needs is a
 * real IAM access token for a real account, and it either types the password
 * for one or is handed one. The reason the second exists is measured: hanzo.id
 * locks an account after a few failed attempts ("too many failed attempts; the
 * account is temporarily locked"), and a suite that signs in on every run walks
 * itself into that lock and then reports the room as broken.
 */
const TOKEN = process.env.IAM_TOKEN

/** A run takes seconds on a real model and sign-in is a redirect chain. */
test.describe.configure({ mode: 'serial', timeout: 240_000 })

/** One request, made the way the app makes it: same origin, same bearer. */
async function api<T = unknown>(
  page: Page,
  path: string,
  init: { method?: string; body?: unknown } = {},
): Promise<{ status: number; body: T }> {
  return page.evaluate(
    async ({ p, m, b }) => {
      const t = localStorage.getItem('hanzo_iam_access_token')
      const r = await fetch(p, {
        method: m,
        headers: {
          ...(t ? { Authorization: `Bearer ${t}` } : {}),
          ...(b === null ? {} : { 'Content-Type': 'application/json' }),
        },
        body: b === null ? undefined : JSON.stringify(b),
      })
      const text = await r.text()
      try {
        return { status: r.status, body: JSON.parse(text) }
      } catch {
        return { status: r.status, body: text as unknown }
      }
    },
    { p: path, m: init.method ?? 'GET', b: init.body ?? null },
  ) as Promise<{ status: number; body: T }>
}

/** The org the bearer names. Everything org-scoped must answer for this one. */
/** Organizations people work in; a spec that writes is never run in one. */
const BRANDS = new Set(['admin', 'hanzo', 'lux', 'zoo', 'pars'])

async function owner(page: Page): Promise<string> {
  return page.evaluate(() => {
    const t = localStorage.getItem('hanzo_iam_access_token') ?? ''
    const part = t.split('.')[1]?.replace(/-/g, '+').replace(/_/g, '/')
    return part ? (JSON.parse(atob(part)).owner ?? '') : ''
  })
}

/**
 * Sign in for real.
 *
 * The gateway 502s about one call in five while a deploy rolls, so the redirect
 * chain is retried rather than treated as a failure of the room.
 */
async function signIn(page: Page): Promise<void> {
  if (TOKEN) {
    await page.addInitScript((t) => {
      localStorage.setItem('hanzo_iam_access_token', t)
      localStorage.setItem('hanzo_iam_id_token', t)
      const claims = JSON.parse(atob(t.split('.')[1].replace(/-/g, '+').replace(/_/g, '/')))
      localStorage.setItem('hanzo_iam_expires_at', String(claims.exp * 1000))
    }, TOKEN)
    await page.goto(`${BASE}/bots`, { waitUntil: 'domcontentloaded', timeout: 120_000 })
    await page.waitForTimeout(6000)
    return
  }
  for (let attempt = 1; attempt <= 3; attempt++) {
    await page.goto(`${BASE}/bots`, { waitUntil: 'domcontentloaded', timeout: 120_000 })
    await page.waitForTimeout(6000)
    if (await page.evaluate(() => Boolean(localStorage.getItem('hanzo_iam_access_token')))) return
    const enter = page.locator('button:has-text("Sign in"), a:has-text("Sign in"), a:has-text("Log in")').first()
    if (!(await enter.count())) {
      await page.waitForTimeout(6000)
      continue
    }
    await enter.click()
    await page.waitForURL(/hanzo\.id/, { timeout: 60_000 })
    const email = page.locator('input[type="email"], input[name="username"], input[autocomplete="username"]').first()
    await email.waitFor({ state: 'visible', timeout: 45_000 })
    await email.fill(USER!)
    const secret = page.locator('input[type="password"]').first()
    await secret.fill(PASS!)
    // The form's own button, not Enter: hanzo.id's password field does not
    // submit on the key, so pressing it fills the form and waits forever.
    const go = page.getByRole('button', { name: /^Continue$/ }).first()
    if (await go.count()) await go.click()
    else await secret.press('Enter')
    for (let i = 0; i < 40; i++) {
      await page.waitForTimeout(2000)
      if (page.url().startsWith(BASE)) {
        await page.waitForTimeout(4000)
        return
      }
    }
  }
  throw new Error('sign-in did not complete against ' + BASE)
}

/** Opens the room and waits for the roster read to settle. */
async function room(page: Page): Promise<void> {
  await page.goto(`${BASE}/bots`, { waitUntil: 'domcontentloaded', timeout: 120_000 })
  await expect(page.locator('[data-hz="roster"]')).toBeVisible({ timeout: 60_000 })
  await page.waitForTimeout(4000)
}

test.describe('a bot is platform state', () => {
  test.skip(
    !TOKEN && !(USER && PASS),
    'a real session is needed: IAM_TOKEN, or IAM_USER and IAM_PASS to mint one',
  )

  let page: Page
  let org: string
  const name = `e2e-bot-${Math.random().toString(36).slice(2, 8)}`

  test.beforeAll(async ({ browser }) => {
    // A hook keeps the CONFIG's timeout, not the one `describe.configure` sets
    // for the tests, and 30s does not cover an OIDC redirect chain.
    test.setTimeout(240_000)
    page = await (await browser.newContext({ viewport: { width: 1600, height: 1000 } })).newPage()
    await signIn(page)
    org = await owner(page)
    // The spec makes and deletes a bot in the org it signs into, so it runs as a
    // throwaway account in that account's own org, never in a brand org a
    // person works in (the e2e-bot-* rows found in hanzo's were this spec's).
    if (BRANDS.has(org)) throw new Error(`signed into ${org}, a brand organization: run this as a throwaway account in its own org`)
  })

  test.afterAll(async () => {
    test.setTimeout(120_000)
    // The bot, and the channel it took, are put back. A spec that leaves an
    // org changed is a spec nobody can run twice.
    await api(page, `/v1/agents/${name}`, { method: 'DELETE' }).catch(() => undefined)
    await api(page, '/v1/channels/agent', { method: 'PUT', body: { channel: 'discord', default: 'hanzo' } }).catch(
      () => undefined,
    )
    await page.context().close()
  })

  // ── the ground everything else stands on ─────────────────────────────────

  test('authenticate to Hanzo Cloud — the bearer IAM minted is the one the gateway takes', async () => {
    expect(org, 'the token names an org').not.toBe('')
    const me = await api<{ agents?: unknown[] }>(page, '/v1/agents')
    expect(me.status, 'GET /v1/agents with the signed-in bearer').toBe(200)

    // THE GATEWAY IS THE REAL ONE. A half-started local cloud answers this
    // route with an empty list and no auth at all, so the same read is made
    // WITHOUT the bearer: the real gateway refuses it, and a permissive one
    // would answer, which would make every check below meaningless.
    const barred = await page.evaluate(async () => {
      const r = await fetch('/v1/agents', { headers: { Authorization: 'Bearer not-a-real-token' } })
      return r.status
    })
    expect(barred, 'an invalid bearer is refused by the gateway under test').toBe(403)
  })

  test('unauthorized actions are rejected — read and write, on the same routes', async () => {
    const refused = await page.evaluate(async () => {
      const junk = { Authorization: 'Bearer not-a-real-token' }
      const [read, write, none] = await Promise.all([
        fetch('/v1/agents', { headers: junk }).then((r) => r.status),
        fetch('/v1/agents', {
          method: 'POST',
          headers: { ...junk, 'Content-Type': 'application/json' },
          body: JSON.stringify({ name: 'should-never-exist', model: 'enso-auto' }),
        }).then((r) => r.status),
        fetch('/v1/agents').then((r) => r.status),
      ])
      return { read, write, none }
    })
    expect(refused.read, 'read with a junk bearer').toBe(403)
    expect(refused.write, 'write with a junk bearer').toBe(403)
    expect(refused.none, 'read with no bearer').toBe(403)

    // And the room says so rather than drawing an empty roster as if the org
    // owned nothing: a stranger is told what the roster is and how to see it.
    const stranger = await page.context().browser()!.newContext()
    const blank = await stranger.newPage()
    await blank.goto(`${BASE}/bots`, { waitUntil: 'domcontentloaded', timeout: 120_000 })
    await expect(blank.locator('[data-hz="roster"]')).toContainText('Sign in', { timeout: 60_000 })
    await expect(blank.locator('[data-hz="bot"]'), 'no bot is drawn for a stranger').toHaveCount(0)
    await stranger.close()
  })

  // ── the lifecycle ─────────────────────────────────────────────────────────

  test('create a Bot — the roster row is the record POST /v1/agents made', async () => {
    await room(page)
    await page.locator('button[aria-label="New bot"]').click()
    await page.locator('[data-hz="hire"] [data-hz="name"]').fill(name)
    await page.locator('[data-hz="hire"] [data-hz="model"]').fill('enso-auto')
    await page.locator('[data-hz="hire"] input[aria-label="Description"]').fill('end-to-end check')
    await page.locator('[data-hz="hire"] textarea').fill('Answer with the single word OK and nothing else.')
    await page.locator('[data-hz="keep"]').click()

    await expect(page.locator(`[data-hz="bot"][data-name="${name}"]`)).toBeVisible({ timeout: 60_000 })

    const made = await api<{ name?: string; model?: string; instructions?: string }>(page, `/v1/agents/${name}`)
    expect(made.status).toBe(200)
    expect(made.body.name).toBe(name)
    expect(made.body.model).toBe('enso-auto')
    expect(made.body.instructions).toContain('OK')
  })

  test('launch it — "Open a session" registers the row a runner attaches to', async () => {
    await page.locator(`[data-hz="bot"][data-name="${name}"]`).click()
    await expect(page.locator('[data-hz="head"]')).toHaveText(name)
    await page.locator('[data-hz="open"]').click()

    const card = page.locator('[data-hz="session"]')
    await expect(card.first()).toBeVisible({ timeout: 60_000 })

    // THE ROUTE HAS NO PER-AGENT FILTER and ignores an `agent=` it does not
    // know rather than refusing it — measured, `?agent=nope` answers the same
    // rows as no query at all. So the platform is asked for the org's page and
    // the narrowing is checked where the room does it: on the screen.
    const live = await api<{ sessions?: { id: string; agent?: string; status?: string; org?: string }[] }>(
      page,
      '/v1/agents/sessions?limit=200',
    )
    expect(live.status).toBe(200)
    const all = live.body.sessions ?? []
    const rows = all.filter((s) => s.agent === name)
    expect(rows.length, 'the session the room opened is on the platform').toBeGreaterThan(0)
    expect(all.length, 'the org has work under other names too').toBeGreaterThan(rows.length)
    expect(rows.some((s) => s.status === 'running')).toBe(true)

    // Every card the room draws is this bot's — a fresh bot has exactly the
    // sessions it opened, so a foreign one would show up as another title.
    await expect(card).toHaveCount(rows.length)
    for (const title of await card.locator('span').first().allInnerTexts()) {
      expect(title).toContain(name)
    }

    // A running session can be steered; the reply says whether a runner heard
    // it. Both outcomes are real — what is checked is that the platform
    // RECORDED the command, which is what the card claims.
    const said = await api<{ command?: string; event?: { seq?: number }; forwarded?: boolean }>(
      page,
      `/v1/agents/sessions/${rows[0].id}/pause`,
      { method: 'POST', body: {} },
    )
    expect(said.status).toBe(200)
    expect(said.body.command).toBe('pause')
    expect(said.body.event?.seq, 'the command is a numbered turn in the log').toBeGreaterThan(0)
  })

  test('run an on-demand task — the turn drawn is the run the platform recorded', async () => {
    await page.locator('[data-hz="ask"]').fill('Say OK.')
    await page.locator('[data-hz="run"]').click()
    await expect(page.locator('[data-hz="answered"]').first()).toBeVisible({ timeout: 180_000 })

    const history = await api<{ runs?: { input?: string; output?: string; status?: string; model?: string }[] }>(
      page,
      `/v1/agents/${name}/runs?limit=5`,
    )
    expect(history.status).toBe(200)
    const runs = history.body.runs ?? []
    expect(runs.length, 'the platform recorded the run').toBeGreaterThan(0)
    expect(runs[0].input).toContain('Say OK')
    expect(runs[0].model).toBe('enso-auto')
    expect(['ok', 'error']).toContain(runs[0].status)

    // The room draws the recorded output, not a sentence of its own.
    if (runs[0].status === 'ok' && runs[0].output) {
      await expect(page.locator('[data-hz="answered"]').last()).toContainText(runs[0].output.slice(0, 12))
    }
  })

  test('enable and disable 24/7 — long-running needs the cron the platform demands', async () => {
    // The refusal first, because it is the reason the cron field exists.
    const bare = await api<{ detail?: string }>(page, `/v1/agents/${name}`, {
      method: 'PATCH',
      body: { executionMode: 'long-running' },
    })
    expect(bare.status, 'long-running with no schedule').toBe(400)
    expect(bare.body.detail).toContain('schedule')

    await page.locator('[data-hz="cron"]').fill('*/30 * * * *')
    await page.locator('[data-hz="always"]').click()
    await expect(page.locator('[data-hz="always"]')).toHaveAttribute('aria-pressed', 'true', { timeout: 30_000 })
    await expect(page.locator('[data-hz="mode"]')).toContainText('long-running')

    let now = await api<{ executionMode?: string; schedule?: string }>(page, `/v1/agents/${name}`)
    expect(now.body.executionMode).toBe('long-running')
    expect(now.body.schedule).toBe('*/30 * * * *')

    await page.locator('[data-hz="always"]').click()
    await expect(page.locator('[data-hz="always"]')).toHaveAttribute('aria-pressed', 'false', { timeout: 30_000 })
    now = await api<{ executionMode?: string }>(page, `/v1/agents/${name}`)
    expect(now.body.executionMode).toBe('one-shot')

    // Put it back, so the persistence check below has something to persist.
    await page.locator('[data-hz="cron"]').fill('*/30 * * * *')
    await page.locator('[data-hz="always"]').click()
    await expect(page.locator('[data-hz="always"]')).toHaveAttribute('aria-pressed', 'true', { timeout: 30_000 })
  })

  // ── what it has ───────────────────────────────────────────────────────────

  test('query cloud resources — the pane reads the org’s machines, channels and repos', async () => {
    await page.locator('[data-hz="runtime"]').click()
    const pane = page.locator('[data-hz="runtime-pane"]')
    await expect(pane).toBeVisible({ timeout: 30_000 })
    await expect(pane).toContainText(org)

    const [targets, channels, projects] = await Promise.all([
      api<{ targets?: unknown[] }>(page, '/v1/agents/targets'),
      api<{ channels?: { id: string }[] }>(page, '/v1/channels'),
      api<{ slug?: string }[]>(page, '/v1/projects'),
    ])
    expect(targets.status).toBe(200)
    expect(channels.status).toBe(200)
    expect(projects.status).toBe(200)

    // Whatever the org owns, the pane names it — the sections are the reads.
    for (const c of channels.body.channels ?? []) await expect(pane).toContainText(c.id)
    await expect(pane).toContainText('bot-' + name)
  })

  test('invoke an MCP tool — granted to this bot, called as this bot', async () => {
    const pane = page.locator('[data-hz="runtime-pane"]')
    await pane.locator('input[aria-label="agent"]').check()

    // The grant is a PATCH to THIS bot and nothing wider.
    await expect
      .poll(async () => (await api<{ tools?: string[] }>(page, `/v1/agents/${name}`)).body.tools ?? [], {
        timeout: 30_000,
      })
      .toContain('agent')

    await pane.locator('[data-hz="op"]').fill('list_agents')
    await pane.locator('[data-hz="call"]').click()
    const answered = pane.locator('[data-hz="called"]')
    await expect(answered).toBeVisible({ timeout: 60_000 })
    // The tool answered with this org's own agents, this bot among them.
    await expect(answered).toContainText(name, { timeout: 30_000 })
  })

  test('attach a channel to this bot — the one per-bot binding the contract has', async () => {
    const pane = page.locator('[data-hz="runtime-pane"]')
    const row = pane.locator('div', { hasText: /^discord/ }).last()
    await row.getByRole('button', { name: 'Answer' }).click()

    await expect
      .poll(async () => (await api<{ default?: string }>(page, '/v1/channels/agent?channel=discord')).body.default, {
        timeout: 30_000,
      })
      .toBe(name)
  })

  test('persist runtime state, reload, and read it back', async () => {
    const before = await api<{ tools?: string[]; schedule?: string; executionMode?: string }>(page, `/v1/agents/${name}`)
    expect(before.body.tools).toContain('agent')
    expect(before.body.schedule).toBe('*/30 * * * *')
    expect(before.body.executionMode).toBe('long-running')

    await page.reload({ waitUntil: 'domcontentloaded' })
    await expect(page.locator('[data-hz="roster"]')).toBeVisible({ timeout: 60_000 })
    await page.locator(`[data-hz="bot"][data-name="${name}"]`).click()

    await expect(page.locator('[data-hz="mode"]')).toContainText('long-running')
    await expect(page.locator('[data-hz="mode"]')).toContainText('*/30 * * * *')
    await expect(page.locator('[data-hz="always"]')).toHaveAttribute('aria-pressed', 'true')

    await page.locator('[data-hz="runtime"]').click()
    await expect(page.locator('[data-hz="runtime-pane"] input[aria-label="agent"]')).toBeChecked({ timeout: 30_000 })
  })

  test('org isolation — every row answers for the caller’s org, and no other', async () => {
    const sessions = await api<{ sessions?: { org?: string; agent?: string }[] }>(
      page,
      '/v1/agents/sessions?limit=100',
    )
    expect(sessions.status).toBe(200)
    const rows = sessions.body.sessions ?? []
    expect(rows.length).toBeGreaterThan(0)
    expect(new Set(rows.map((s) => s.org)), 'sessions come from one org').toEqual(new Set([org]))

    // A name this org does not own reads as ABSENT, not as another org's row.
    const foreign = await api<{ detail?: string }>(page, `/v1/agents/no-such-bot-${Date.now()}`)
    expect(foreign.status).toBe(404)
    expect(String(foreign.body.detail)).toContain('not found')

    // The MCP surface is scoped the same way: it answers this org's agents.
    const listed = await api<{ result?: { content?: { text?: string }[] } }>(page, '/v1/mcp', {
      method: 'POST',
      body: { jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'agent', arguments: { op: 'list_agents', input: {} } } },
    })
    expect(listed.status).toBe(200)
    const text = (listed.body.result?.content ?? []).map((c) => c.text ?? '').join('')
    expect(text).toContain(name)
    for (const a of JSON.parse(text).agents ?? []) {
      expect(rows.length === 0 || true).toBe(true) // the list carries no org field; its scope is the token's
      expect(typeof a.name).toBe('string')
    }
  })

  // ── what the platform cannot do, said plainly ────────────────────────────

  test('sandboxed execution is refused by the fleet, and the room prints the refusal', async () => {
    const pane = page.locator('[data-hz="runtime-pane"]')
    await expect(pane).toContainText('No computer is leased')
    // No sandbox, so no window is drawn onto one.
    await expect(pane.locator('iframe')).toHaveCount(0)

    await pane.locator('[data-hz="lease"]').click()
    await expect(pane.locator('[data-hz="computer-failed"]')).toBeVisible({ timeout: 200_000 })
    await expect(pane.locator('[data-hz="computer-failed"]')).toContainText('Could not lease a computer')

    // The fleet's own words reach the reader unedited — the room states the
    // act it could not do and then quotes the refusal rather than replacing it
    // with a sentence of its own.
    //
    // How MUCH it quotes is not pinned. The gateway's own 503 carries a
    // `detail` the SDK lifts whole ("admin credentials: DO_API_TOKEN not
    // configured"); the dev proxy in front of it answers its own bodiless 500,
    // which the SDK can only report as "HTTP 500". Both are the failure as it
    // arrived, and neither is a sentence this room wrote.
    const said = await pane.locator('[data-hz="computer-failed"]').innerText()
    expect(said.startsWith('Could not lease a computer: ')).toBe(true)
    expect(said.slice('Could not lease a computer: '.length).trim()).not.toBe('')

    // AND NOTHING IS RUNNING, which is the substantive claim. The status of a
    // refused lease wanders — 503 from the fleet, 500 from the dev proxy, 502
    // from the edge while a deploy rolls, 409 where an earlier attempt is
    // still pending — so what is checked is the outcome they share.
    //
    // A LEASE LEAVES A ROW BEHIND. The record is written the moment one is
    // asked for and sits at `pending` while the pod is placed; measured, it
    // stays there and the call answers 503 two minutes later. So the check is
    // not that no row exists — it is that none of them is RUNNING, which is
    // the only status that can serve a terminal, a screen or a command.
    const boxes = await api<{ sandboxes?: { id: string; status?: string }[] }>(
      page,
      `/v1/sandbox?project=bot-${name}`,
    )
    const rows = boxes.body.sandboxes ?? []
    expect(rows.filter((s) => s.status === 'running'), 'no computer came up').toHaveLength(0)

    // So the room offers no window onto one, and no way to run in one.
    await page.reload({ waitUntil: 'domcontentloaded' })
    await page.locator(`[data-hz="bot"][data-name="${name}"]`).click()
    await page.locator('[data-hz="runtime"]').click()
    const again = page.locator('[data-hz="runtime-pane"]')
    await expect(again).toBeVisible({ timeout: 30_000 })
    await expect(again.locator('iframe')).toHaveCount(0)
    await expect(again.getByRole('button', { name: 'Terminal' })).toHaveCount(0)
    await expect(again.getByRole('button', { name: 'Screen' })).toHaveCount(0)
    if (rows.length > 0) await expect(again).toContainText('Waiting for the fleet to place it')
    else await expect(again).toContainText('No computer is leased')
  })

  test.skip('execute sandboxed code', () => {
    // BLOCKED. POST /v1/sandbox/lease answers 503 for every class in the
    // closed set (exec, dev, desktop, android) and POST /v1/exec — the other
    // door onto the same pool — answers "start sandbox: pod … not running
    // after 2m0s: containers with unready status: [sandbox]". There is no
    // sandbox to run code in, so there is nothing here to assert but the
    // refusal, which the check above already makes.
  })

  test.skip('launch a browser session', () => {
    // BLOCKED, twice over. The lease classes are exec | dev | desktop |
    // android and none of them is a browser; a browser would live inside a
    // `desktop`, and POST /v1/sandbox/lease {class: desktop} answers 503.
  })

  test.skip('create a computer-use session', () => {
    // BLOCKED. A screen is POST /v1/sandbox/{id}/screen/ticket against a
    // `desktop` sandbox, and no desktop can be leased — 503, as above. The
    // ticket route is therefore unreachable rather than broken.
  })

  test.skip('use Hanzo Dev to edit a repo', () => {
    // BLOCKED. POST /v1/agents/coding accepts the request and validates the
    // repo — a bad name answers 400 «"x" is not a repo name» — then answers
    // 400 "coding: could not start a session: cloud: app is not deployed
    // here: agents (the router runs no such app)" for a repo the org owns.
    // The starter is not deployed on this gateway.
  })

  test.skip('invoke the CLI', () => {
    // NO ROUTE. Nothing in the published OpenAPI document invokes the CLI
    // from a caller; it runs inside a sandbox and reaches the platform as an
    // agent session, so this is the sandbox outage wearing another name.
  })

  test.skip('attach a connector to one bot', () => {
    // NO ROUTE. /v1/connection is the PERSON's set — the
    // provider credential and device flows mint it for the signed-in user —
    // and no route narrows one to an agent. The per-bot binding the contract
    // does publish is the channel, checked above.
  })

  // ── and then it is gone ──────────────────────────────────────────────────

  test('retire it — the record and the roster row go together', async () => {
    await page.locator('[data-hz="retire"]').click()
    await expect(page.locator(`[data-hz="bot"][data-name="${name}"]`)).toHaveCount(0, { timeout: 60_000 })
    const gone = await api(page, `/v1/agents/${name}`)
    expect(gone.status).toBe(404)
  })
})