import { test, expect, type Page } from '@playwright/test';
import Database from 'better-sqlite3';
import { resolve } from 'node:path';
import { openSpaceTab } from './helpers/spaceTabs';

// ── Shared helpers for the space task/settings parity suite ───────────────────
//
// The tests below all start the same way: open Spaces, create a case space, open
// it, and (for chat actions) start an inline chat. The first batch of tests in
// this file inlines that flow; the feature-parity tests added later reuse these
// helpers to stay focused on the action under test. The helpers mirror the
// inlined flow exactly (same testids, same waits) — they do NOT relax any
// assertion, they just remove copy-paste.

// The no-auth + live-session probe allowlist shared by the chat/settings tests.
// Identical set to the inline-chat/settings tests above: with auth disabled the
// UI's /api/auth/me probe 404s on purpose and falls back to the synthetic local
// user; CreateTaskDialog's org/MCP probes 401; the per-task console/browser
// status probes 404 with no live session. All benign, not failures.
const SPACE_BENIGN_PATHS = new Set([
  '/api/auth/me',
  '/api/users/me/orgs',
  '/api/mcp/connections',
  '/api/mcp/servers',
  '/api/mcp/user-servers',
  '/api/ssh/connections',
]);
const SPACE_BENIGN_ASSET = /\.(ico|png|svg|map|webmanifest|json)$/i;
const SPACE_BENIGN_PATH_RE =
  /\/api\/local\/tasks\/\d+\/console\/status$|\/api\/local\/browser\/sessions\/task-session\/\d+$/;

/** Attach the standard fatal-error tracker used by every space test and return
 *  the collected list (assert it stays empty at the end of the test). */
function trackFatalErrors(page: Page): string[] {
  const fatalErrors: string[] = [];
  page.on('pageerror', (err) => fatalErrors.push(`pageerror: ${err.message}`));
  page.on('response', (res) => {
    if (res.status() >= 400) {
      const { pathname } = new URL(res.url());
      if (
        !SPACE_BENIGN_ASSET.test(pathname) &&
        !SPACE_BENIGN_PATHS.has(pathname) &&
        !SPACE_BENIGN_PATH_RE.test(pathname)
      ) {
        fatalErrors.push(`HTTP ${res.status()} ${res.url()}`);
      }
    }
  });
  return fatalErrors;
}

/** Open Spaces, create a case space with a unique title, select it, and return
 *  the detail locator + the title used. Mirrors the inlined create flow. */
async function createAndOpenCaseSpace(page: Page, label: string) {
  await page.goto('/ui');
  await page.getByTestId('nav-spaces').click();
  const rail = page.getByTestId('space-rail');
  await expect(rail).toBeVisible();

  await page.getByTestId('create-space-btn').click();
  const titleInput = page.getByTestId('space-title-input');
  await expect(titleInput).toBeVisible();
  const caseTitle = `${label}-${Date.now()}`;
  await titleInput.fill(caseTitle);
  await page.getByTestId('space-form-submit').click();
  await expect(titleInput).toHaveCount(0);

  const caseRow = rail
    .locator('[data-testid="space-row"][data-space-kind="case"]')
    .filter({ hasText: caseTitle });
  await expect(caseRow).toBeVisible();
  const spaceId = await caseRow.getAttribute('data-space-id');
  expect(spaceId).toBeTruthy();
  await caseRow.click();

  const detail = page.getByTestId('space-detail');
  await expect(detail).toBeVisible();
  return { detail, caseTitle, rail, spaceId: spaceId as string };
}

/** Start a new inline chat in the currently-open space, returning the inline
 *  conversation locator and the created task id (from the chat= URL param). */
async function startInlineChat(page: Page, body: string) {
  await page.getByTestId('space-tab-chat').click();
  await page.getByTestId('space-new-chat-btn').click();
  const composer = page.getByTestId('create-task-body');
  await expect(composer).toBeVisible();
  await composer.fill(body);
  await page.getByTestId('create-task-submit').click();

  const conversation = page.getByTestId('space-conversation');
  await expect(conversation).toBeVisible();
  await expect(page).toHaveURL(/[?&]chat=\d+/);
  const taskId = new URL(page.url()).searchParams.get('chat');
  expect(taskId).toBeTruthy();
  return { conversation, taskId: taskId as string };
}

type TaskDetail = {
  task?: {
    latestJob?: { id?: string; status?: string } | null;
    feedbackRating?: string | null;
    visibility?: string | null;
  };
};

/** Fetch the task detail. NOTE the API wraps the row under `.task`. */
async function fetchTask(page: Page, taskId: string): Promise<TaskDetail['task'] | null> {
  const res = await page.request.get(`/api/local/tasks/${taskId}`);
  if (!res.ok()) return null;
  return ((await res.json()) as TaskDetail).task ?? null;
}

const TERMINAL_JOB_STATES = ['succeeded', 'failed', 'waiting_human', 'cancelled', 'aborted'];

/** Poll the task detail until the latest job reaches a terminal state, OR the
 *  window expires. Returns the terminal status, or '' if the job never settled.
 *
 *  ENV NOTE: a terminal job requires the worker to actually run the job, which
 *  needs a reachable LLM. The E2E env configures NO provider, so the worker
 *  stays unhealthy and the job sits `queued` indefinitely — it never reaches a
 *  terminal state here. Tests that need the terminal branch (Continue / Feedback)
 *  therefore skip when this returns '' (documented at each call site), and run
 *  the full active assertion only when a real LLM IS reachable. */
async function waitForTerminalJob(page: Page, taskId: string, timeout = 30_000): Promise<string> {
  const deadline = Date.now() + timeout;
  while (Date.now() < deadline) {
    const task = await fetchTask(page, taskId);
    const status = task?.latestJob?.status ?? '';
    if (TERMINAL_JOB_STATES.includes(status)) return status;
    await page.waitForTimeout(1500);
  }
  return '';
}

// End-to-end smoke for the spaces-foundation UI (plan 4, Task 5).
//
// Drives the real orchestrator (auth off => synthetic 'local' user). The
// personal space is auto-created on the first /api/local/spaces call, so it is
// always present in a fresh temp DB. We then create a case space and open it.
//
// Selectors use data-testid added to the spaces components rather than brittle
// Japanese label text, but the visible labels stay Japanese.

test('spaces foundation: rail, create case space, open detail tabs', async ({ page }) => {
  // Track only genuinely fatal client errors. Uncaught JS exceptions
  // (pageerror) are always fatal. Generic console "Failed to load resource"
  // messages carry no URL, so we resolve the real culprit from the matching
  // HTTP response and ignore benign static-asset 404s (favicon, source maps,
  // PWA manifest) that don't break the flow.
  const fatalErrors: string[] = [];
  const benignAsset = /\.(ico|png|svg|map|webmanifest|json)$/i;
  // When auth is disabled (our default E2E config), /api/auth/me is NOT mounted,
  // so the UI's probe 404s on purpose and falls back to the synthetic local
  // user. That 404 is the expected no-auth signal, not a failure.
  const benignPaths = new Set(['/api/auth/me']);

  page.on('pageerror', (err) => fatalErrors.push(`pageerror: ${err.message}`));
  page.on('response', (res) => {
    if (res.status() >= 400) {
      const url = res.url();
      const { pathname } = new URL(url);
      if (!benignAsset.test(pathname) && !benignPaths.has(pathname)) {
        fatalErrors.push(`HTTP ${res.status()} ${url}`);
      }
    }
  });

  // 1. Open the app. The server redirects / -> /ui; load /ui directly.
  await page.goto('/ui');

  // App shell is up — the Spaces nav tab is rendered.
  const navSpaces = page.getByTestId('nav-spaces');
  await expect(navSpaces).toBeVisible();

  // 2. Navigate to the Spaces tab.
  await navSpaces.click();

  // 3. The space rail renders, with the auto-created personal space pinned.
  const rail = page.getByTestId('space-rail');
  await expect(rail).toBeVisible();

  const personalRow = rail.locator('[data-testid="space-row"][data-space-kind="personal"]');
  await expect(personalRow).toHaveCount(1);
  await expect(personalRow).toBeVisible();

  // 4. Create a new case space via 新規.
  await page.getByTestId('create-space-btn').click();

  const titleInput = page.getByTestId('space-title-input');
  await expect(titleInput).toBeVisible();
  const caseTitle = `E2E案件-${Date.now()}`;
  await titleInput.fill(caseTitle);

  await page.getByTestId('space-form-submit').click();

  // 5. The new case space appears in the rail (and dialog closes).
  await expect(titleInput).toHaveCount(0);
  const caseRow = rail
    .locator('[data-testid="space-row"][data-space-kind="case"]')
    .filter({ hasText: caseTitle });
  await expect(caseRow).toBeVisible();

  // 6. Selecting it (creation auto-selects it) shows the SpaceDetail with both tabs.
  await caseRow.click();
  const detail = page.getByTestId('space-detail');
  await expect(detail).toBeVisible();
  await expect(detail.getByText(caseTitle)).toBeVisible();

  await expect(page.getByTestId('space-tab-chat')).toBeVisible();
  await expect(page.getByTestId('space-tab-files')).toBeVisible();

  // 7. The files tab opens without a fatal error (empty tree is fine).
  await page.getByTestId('space-tab-files').click();
  await expect(page.getByTestId('space-files')).toBeVisible();

  // No fatal client errors (uncaught exceptions / non-asset HTTP failures).
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// Mobile (<md) layout: the rail and detail must NOT sit side-by-side on a
// phone. Startup auto-opens the personal workspace (App.tsx's one-shot
// personalSpaceAutoOpened guard), so detail is the initial full-width view;
// backing out returns to the full-width rail (the guard does not re-fire) and
// selecting another space replaces the rail with detail plus a
// "← ワークスペース一覧" back control that returns to the rail. At >=md both
// are visible together (unchanged), so this invariant only holds at narrow
// widths.
test('spaces mobile: rail <-> detail switch with back control at 390px', async ({ page }) => {
  await page.setViewportSize({ width: 390, height: 844 });

  // At phone widths the nav collapses into a drawer (both shell layouts do
  // this), so the nav-spaces control isn't directly clickable. Navigate via
  // the URL state (page=spaces) instead — it's the same selection, sans drawer.
  await page.goto('/ui?page=spaces');

  // Startup auto-opens the personal workspace: detail is the visible
  // full-width view, rail is hidden, and the back control is already present.
  const rail = page.getByTestId('space-rail');
  const detail = page.getByTestId('space-detail');
  const back = page.getByTestId('space-back-to-list');
  await expect(detail).toBeVisible();
  await expect(rail).toBeHidden();
  await expect(back).toBeVisible();

  // Tapping back clears the selection and returns to the full-width rail. The
  // auto-open guard is one-shot, so it does not immediately re-select.
  await back.click();
  await expect(rail).toBeVisible();
  await expect(detail).toBeHidden();
  await expect(page.getByTestId('space-back-to-list')).toHaveCount(0);

  // Create + auto-select a case space.
  await page.getByTestId('create-space-btn').click();
  const titleInput = page.getByTestId('space-title-input');
  await expect(titleInput).toBeVisible();
  const caseTitle = `E2Eモバイル-${Date.now()}`;
  await titleInput.fill(caseTitle);
  await page.getByTestId('space-form-submit').click();
  await expect(titleInput).toHaveCount(0);

  // A space is open: detail is now the visible full-width view, rail is hidden,
  // and the mobile back control is present.
  await expect(detail).toBeVisible();
  await expect(detail.getByText(caseTitle)).toBeVisible();
  await expect(rail).toBeHidden();
  await expect(back).toBeVisible();

  // Tapping back clears the selection and returns to the full-width rail.
  await back.click();
  await expect(rail).toBeVisible();
  await expect(detail).toBeHidden();
  await expect(page.getByTestId('space-back-to-list')).toHaveCount(0);
});

// Inline conversation inside a space (plan 6). The user starts a chat from the
// space's チャット tab and the conversation (ChatPane: messages + composer)
// renders INLINE — without ever navigating to the Tasks page. No LLM is
// configured in the E2E env, so the agent never completes; we only assert the
// conversation UI is present and the no-navigation invariant holds.
test('space inline chat: create + open conversation without leaving for Tasks', async ({ page }) => {
  const fatalErrors: string[] = [];
  const benignAsset = /\.(ico|png|svg|map|webmanifest|json)$/i;
  // With auth disabled, these probes 401 on purpose (the CreateTaskDialog
  // fetches orgs + MCP connections which require an authenticated user). The
  // UI tolerates the 401 and falls back to empty lists, so they are the
  // expected no-auth signal — not a failure.
  const benignPaths = new Set(['/api/auth/me', '/api/users/me/orgs', '/api/mcp/connections']);
  // useVisibleDetailTabs (now used by the inline conversation's detail tabs)
  // polls per-task console/browser-session status to decide whether to show the
  // live SSH/Browser tabs. With no live session these 404 by design and the
  // hook degrades to "tab hidden" — benign, like the no-auth probes above.
  const benignPathRe = /\/api\/local\/tasks\/\d+\/console\/status$|\/api\/local\/browser\/sessions\/task-session\/\d+$/;

  page.on('pageerror', (err) => fatalErrors.push(`pageerror: ${err.message}`));
  page.on('response', (res) => {
    if (res.status() >= 400) {
      const { pathname } = new URL(res.url());
      if (!benignAsset.test(pathname) && !benignPaths.has(pathname) && !benignPathRe.test(pathname)) {
        fatalErrors.push(`HTTP ${res.status()} ${res.url()}`);
      }
    }
  });

  // 1. Open the app, go to Spaces, create a case space.
  await page.goto('/ui');
  await page.getByTestId('nav-spaces').click();

  const rail = page.getByTestId('space-rail');
  await expect(rail).toBeVisible();

  await page.getByTestId('create-space-btn').click();
  const titleInput = page.getByTestId('space-title-input');
  await expect(titleInput).toBeVisible();
  const caseTitle = `E2E会話-${Date.now()}`;
  await titleInput.fill(caseTitle);
  await page.getByTestId('space-form-submit').click();
  await expect(titleInput).toHaveCount(0);

  const caseRow = rail
    .locator('[data-testid="space-row"][data-space-kind="case"]')
    .filter({ hasText: caseTitle });
  await expect(caseRow).toBeVisible();
  await caseRow.click();

  const detail = page.getByTestId('space-detail');
  await expect(detail).toBeVisible();

  // 2. On the チャット tab, start a new chat.
  await page.getByTestId('space-tab-chat').click();
  await page.getByTestId('space-new-chat-btn').click();

  const body = page.getByTestId('create-task-body');
  await expect(body).toBeVisible();
  await body.fill('E2E: inline conversation smoke. これはテスト用の最初のメッセージです。');
  await page.getByTestId('create-task-submit').click();

  // 3. The inline conversation pane (ChatPane) appears inside the space.
  //    No LLM => the agent won't progress, but the conversation UI renders.
  const conversation = page.getByTestId('space-conversation');
  await expect(conversation).toBeVisible();

  // 4. No navigation to the Tasks page. The app stays on the Spaces page
  //    (urlState serializes page=spaces) and sets the chat= param for the
  //    selected inline chat. It must NOT switch to page=tasks (which would
  //    drop page= entirely AND have no chat=).
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  await expect(page).toHaveURL(/[?&]chat=\d+/);
  expect(page.url()).toContain('chat=');
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  // The Spaces detail (not the Tasks board) is still mounted.
  await expect(detail).toBeVisible();

  // 4b. The inline conversation exposes per-task detail tabs via the icon rail
  //     (data-testid="space-chat-rail" — since #1433 step 5 the rail is rendered
  //     at EVERY width, including narrow phone viewports; the horizontal tab
  //     bar and the swipe deck it belonged to were removed) so Progress is visible
  //     WITHOUT leaving for Tasks. Clicking 進捗 (Progress = the `activity` tab)
  //     swaps the ProgressTab content IN PLACE (no overlay/✕); pressing 進捗 a
  //     second time folds that column away and the conversation takes the row
  //     back — all while staying on page=spaces with the same chat= param.
  //     (A dedicated test below covers the rail structure.)
  //     Entry state: a brand-new chat has nothing remembered, so the rail starts
  //     on 概要, opened (RAIL_DEFAULT since #1455 — it used to be 会話).
  const overviewTab = conversation.getByTestId('space-chat-tab-overview');
  await expect(overviewTab).toHaveAttribute('aria-selected', 'true');
  const progressTab = conversation.getByTestId('space-chat-tab-activity');
  await expect(progressTab).toBeVisible();
  await progressTab.click();
  // In-place ProgressTab content renders inside the shared tabpanel (no Tasks nav).
  await expect(conversation.getByTestId('progress-tab')).toBeVisible();
  await expect(progressTab).toHaveAttribute('aria-selected', 'true');
  // In place, not on top of the conversation: the chat column keeps its own
  // space while 進捗 shows, so progress can be read while typing (#1330).
  await expect(page.getByTestId('space-chat-column')).toBeVisible();
  // Invariant: still inline on Spaces, same chat, never bounced to Tasks.
  await expect(page).toHaveURL(/[?&]chat=\d+/);
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  // Return to the conversation so the rest of the flow (creating a second chat)
  // starts from chat again. On a wide screen there is no 会話 item to press
  // (#1455 — the conversation keeps its own column, so an icon for it would be
  // the same thing twice); the way back is to press the item that is already
  // picked, which folds its column away (chatRailState.ts nextRailState) and
  // hands the width back to the conversation.
  await progressTab.click();
  await expect(progressTab).toHaveAttribute('aria-selected', 'false');
  await expect(conversation.getByTestId('progress-tab')).toHaveCount(0);
  await expect(page.getByTestId('space-chat-column')).toBeVisible();

  // 5. Create a SECOND chat in the same space and assert the conversation
  //    switches when selecting the first one again from the list.
  const firstChatUrl = new URL(page.url());
  const firstChatId = firstChatUrl.searchParams.get('chat');
  expect(firstChatId).toBeTruthy();

  await page.getByTestId('space-new-chat-btn').click();
  const body2 = page.getByTestId('create-task-body');
  await expect(body2).toBeVisible();
  await body2.fill('E2E: second inline chat. 二つ目のチャットです。');
  await page.getByTestId('create-task-submit').click();

  // The second chat auto-selects: chat= now points at a different id.
  await expect
    .poll(() => new URL(page.url()).searchParams.get('chat'))
    .not.toBe(firstChatId);
  await expect(conversation).toBeVisible();
  const secondChatId = new URL(page.url()).searchParams.get('chat');

  // Selecting the first chat row again switches the conversation back to it.
  const firstRow = page.locator(`[data-testid="space-chat-row"][data-task-id="${firstChatId}"]`);
  await expect(firstRow).toBeVisible();
  await firstRow.click();
  await expect
    .poll(() => new URL(page.url()).searchParams.get('chat'))
    .toBe(firstChatId);
  expect(secondChatId).not.toBe(firstChatId);
  await expect(conversation).toBeVisible();
  // Still on Spaces, still has a chat — never bounced to Tasks.
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();

  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// Redesigned space Files tab (feat/space-files-explorer). The space-level ファイル
// tab is now an icon grid (space-files-grid) with a breadcrumb, an upload button +
// hidden <input type=file multiple>, and a dropzone. Uploading a file makes a
// space-file-tile appear; clicking a file tile opens the file in a FLOATING
// WINDOW (role="dialog", data-frame="float") showing the content — #1551 stage 2
// routed this tab through the same window funnel as chat, so it is no longer a
// covering modal. Directory tiles navigate (breadcrumb updates) — covered here
// only by the no-nav invariant (we stay on page=spaces).
// No LLM is needed; this is pure file-management UI, so we never assert agent output.
test('space files: icon grid, upload appears as tile, click opens preview window', async ({ page }) => {
  const fatalErrors: string[] = [];
  const benignAsset = /\.(ico|png|svg|map|webmanifest|json)$/i;
  // Same no-auth probe allowlist as the other space tests: with auth disabled the
  // UI's /api/auth/me probe 404s on purpose and falls back to the synthetic local
  // user — the expected no-auth signal, not a failure.
  const benignPaths = new Set(['/api/auth/me']);

  page.on('pageerror', (err) => fatalErrors.push(`pageerror: ${err.message}`));
  page.on('response', (res) => {
    if (res.status() >= 400) {
      const { pathname } = new URL(res.url());
      if (!benignAsset.test(pathname) && !benignPaths.has(pathname)) {
        fatalErrors.push(`HTTP ${res.status()} ${res.url()}`);
      }
    }
  });

  // 1. Spaces → create a case space → open the space-level ファイル tab.
  await page.goto('/ui');
  await page.getByTestId('nav-spaces').click();

  const rail = page.getByTestId('space-rail');
  await expect(rail).toBeVisible();

  await page.getByTestId('create-space-btn').click();
  const titleInput = page.getByTestId('space-title-input');
  await expect(titleInput).toBeVisible();
  const caseTitle = `E2Eファイル-${Date.now()}`;
  await titleInput.fill(caseTitle);
  await page.getByTestId('space-form-submit').click();
  await expect(titleInput).toHaveCount(0);

  const caseRow = rail
    .locator('[data-testid="space-row"][data-space-kind="case"]')
    .filter({ hasText: caseTitle });
  await expect(caseRow).toBeVisible();
  await caseRow.click();

  const detail = page.getByTestId('space-detail');
  await expect(detail).toBeVisible();

  await page.getByTestId('space-tab-files').click();

  // 2. The grid + breadcrumb render (empty tree is fine).
  await expect(page.getByTestId('space-files-grid')).toBeVisible();
  await expect(page.getByTestId('space-files-breadcrumb')).toBeVisible();

  // 3. Upload a LARGE (>150kb) file through the hidden multiple-file input.
  //    This guards the P1 regression where a global express.json() (~100kb)
  //    shadowed the upload route's 50mb parser and 413'd any body >~100kb.
  //    A tiny buffer passed even with the bug; 160kb only passes after the fix.
  await page
    .locator('[data-testid="space-files-upload-input"]')
    .setInputFiles({
      name: 'e2e-large.txt',
      mimeType: 'text/plain',
      buffer: Buffer.alloc(160 * 1024, 'a'),
    });

  // 4. The large file shows up as a tile (upload + refetch take a moment).
  const largeTile = page.locator(
    '[data-testid="space-file-tile"][data-kind="file"][data-name="e2e-large.txt"]',
  );
  await expect(largeTile).toBeVisible({ timeout: 15000 });

  // 5. Upload a separate TINY markdown file so the modal-preview assertion stays
  //    cheap and locale-independent.
  await page
    .locator('[data-testid="space-files-upload-input"]')
    .setInputFiles({
      name: 'e2e-upload.md',
      mimeType: 'text/markdown',
      buffer: Buffer.from('# E2E\nhello'),
    });
  const tile = page.locator(
    '[data-testid="space-file-tile"][data-kind="file"][data-name="e2e-upload.md"]',
  );
  await expect(tile).toBeVisible({ timeout: 15000 });

  // 6. Clicking the tile opens the file in a FLOATING WINDOW (role="dialog",
  //    data-frame="float") showing the markdown content.
  //
  //    This used to be a covering modal closed by clicking its backdrop. #1551
  //    stage 2 routed this tab through the same window funnel as chat, and the
  //    default open mode is a window (readStoredFilePreviewOpenMode() -> 'float').
  //    A floating window has NO backdrop on purpose: the whole point is that the
  //    grid behind it stays live, so clicking outside must NOT close it. We assert
  //    that promise here (the grid is still visible) and close with the ✕, which
  //    now carries a testid so this stays locale-independent.
  //
  //    The covering shape is still reachable (Settings -> "open files in a
  //    window" off) and closing it by backdrop click is pinned in jsdom by
  //    FilePreview.backdrop.dom.test.tsx and
  //    SpaceDetail.spaceFileClose.dom.test.tsx.
  await tile.click();
  const dialog = page.getByRole('dialog');
  await expect(dialog).toBeVisible();
  await expect(dialog).toContainText('hello');
  await expect(dialog).toHaveAttribute('data-frame', 'float');
  // The list is not covered — this is what stage 2 was for.
  await expect(page.getByTestId('space-files-grid')).toBeVisible();
  await expect(tile).toBeVisible();
  await dialog.getByTestId('file-preview-close').click();
  await expect(dialog).toHaveCount(0);

  // 6. No-nav invariant: file management never leaves Spaces for the Tasks board.
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  await expect(detail).toBeVisible();

  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// #1448: the worker/GPU view moved out of the Spaces rail into a floating window
// opened from the icon at the bottom of the left nav rail. Two things are pinned
// here: the old rail footer is gone, and the new launcher opens a window that
// survives a click outside it (closing is the × only). No LLM is needed — the
// widget reads /api/local/dashboard/workers, populated in worker mode.
test('worker status: nav rail launcher opens a floating window', async ({ page }) => {
  // 1. Open the app at the default (desktop) viewport and go to Spaces.
  await page.goto('/ui');
  await page.getByTestId('nav-spaces').click();

  const rail = page.getByTestId('space-rail');
  await expect(rail).toBeVisible();

  // 2. The old rail-bottom footer is gone; the launcher lives in the nav rail.
  await expect(page.getByTestId('space-worker-status')).toHaveCount(0);
  const launcher = page.getByTestId('worker-status-launcher');
  await expect(launcher).toBeVisible();
  await expect(launcher).toHaveAttribute('aria-expanded', 'false');
  await expect(page.getByTestId('worker-status-window')).toHaveCount(0);

  // 3. Clicking it opens the window; clicking outside must NOT close it.
  await launcher.click();
  await expect(launcher).toHaveAttribute('aria-expanded', 'true');
  const win = page.getByTestId('worker-status-window');
  await expect(win).toBeVisible();
  await rail.click({ position: { x: 10, y: 10 } });
  await expect(win).toBeVisible();

  // 4. The × closes it.
  await page.getByTestId('worker-status-window-close').click();
  await expect(page.getByTestId('worker-status-window')).toHaveCount(0);
});

// Narrow viewport: the nav rail is folded into the NavDrawer, so the rail
// launcher is not rendered at all. The same entry must exist in the drawer,
// and — the part jsdom cannot check — the window must land on-screen after the
// drawer slides away. The drawer panel is moved with `transform`, which makes it
// the containing block for any `position: fixed` descendant; if the window were
// rendered inside the drawer it would ride off-screen with it.
test('worker status: drawer launcher opens the same window on a narrow screen', async ({ page }) => {
  await page.setViewportSize({ width: 390, height: 844 });
  await page.goto('/ui');

  // The rail (and its launcher) is gone at this width.
  await expect(page.getByTestId('worker-status-launcher')).toHaveCount(0);

  await page.locator('button[aria-controls="nav-drawer"]').first().click();
  const drawer = page.locator('#nav-drawer');
  await expect(drawer).toHaveAttribute('aria-hidden', 'false');

  await page.getByTestId('worker-status-launcher-drawer').click();

  // The drawer closes, the window stays.
  await expect(drawer).toHaveAttribute('aria-hidden', 'true');
  const win = page.getByTestId('worker-status-window');
  await expect(win).toBeVisible();

  const box = await win.boundingBox();
  expect(box).not.toBeNull();
  expect(box!.x).toBeGreaterThanOrEqual(0);
  expect(box!.x + box!.width).toBeLessThanOrEqual(390);

  await page.getByTestId('worker-status-window-close').click();
  await expect(page.getByTestId('worker-status-window')).toHaveCount(0);
});

// AAO Gateway / LiteLLM front: a `proxy: true` worker fans out into a backends[]
// tree (collectWorkerStatuses, unit-tested separately). This test pins the *UI*
// half: given a proxy worker payload, the widget renders the proxy badge and one
// row per backend. The /api/local/dashboard/workers response is stubbed so the
// test is deterministic without standing up a real gateway + probe registry.
test('worker status: proxy worker renders per-backend rows (AAO Gateway)', async ({ page }) => {
  await page.route('**/api/local/dashboard/workers', (route) =>
    route.fulfill({
      status: 200,
      contentType: 'application/json',
      body: JSON.stringify({
        workers: [
          {
            id: 'gw', name: 'gw', roles: ['task'], state: 'running', proxy: true,
            backends: [
              { id: 'backend-a', state: 'running', busySlots: 1, totalSlots: 4, online: true },
              { id: 'backend-b', state: 'idle', busySlots: 0, totalSlots: 4, online: true },
            ],
          },
        ],
      }),
    }),
  );

  await page.goto('/ui');
  await page.getByTestId('nav-spaces').click();
  await expect(page.getByTestId('space-rail')).toBeVisible();

  // Open the floating window; the WorkerStatusWidget mounts and fetches the stub.
  await page.getByTestId('worker-status-launcher').click();
  await expect(page.getByTestId('worker-status-window')).toBeVisible();

  // The proxy worker row + its proxy badge render.
  await expect(page.getByTestId('worker-row-gw')).toBeVisible();
  await expect(page.getByTestId('worker-proxy-badge')).toBeVisible();

  // 細部は畳んだ状態で出る（#1486）。開くまでバックエンドの行は出てこない。
  await expect(page.getByTestId('worker-backend-backend-a')).toHaveCount(0);
  await expect(page.getByTestId('worker-toggle-gw')).toHaveAttribute('aria-expanded', 'false');

  // 三角を押すと Gateway のバックエンドが 1 行ずつ並ぶ。
  await page.getByTestId('worker-toggle-gw').click();
  await expect(page.getByTestId('worker-backend-backend-a')).toBeVisible();
  await expect(page.getByTestId('worker-backend-backend-b')).toBeVisible();
  await expect(page.getByTestId('worker-backend-backend-a')).toContainText('1/4');
});

// Feature A (feat/space-gpu-and-filelinks): the inline conversation now wraps its
// chat in an OutputPreviewProvider, so clicking a rendered output-path link
// (<a class="output-path-link" data-output-path="output/...">) opens the FilePreview
// modal (role="dialog") instead of doing nothing. To produce such a link
// deterministically WITHOUT an LLM, we post a user comment whose markdown body
// contains an output-path link; MarkdownText linkifies it (markdown link whose href
// matches OUTPUT_PATH_REGEX => data-output-path anchor). We also create the file
// itself (output/note.md, output-only PUT /files/content) so the .md preview resolves
// to content rather than a 404 (previewLocalFile fetches content for markdown and
// only opens the modal on success). We assert the dialog opens, then close it; we
// never assert agent output and we never leave page=spaces.
test('space output link: chat output-path link opens a floating window without moving the screen', async ({ page }) => {
  const fatalErrors: string[] = [];
  const benignAsset = /\.(ico|png|svg|map|webmanifest|json)$/i;
  const benignPaths = new Set(['/api/auth/me', '/api/users/me/orgs', '/api/mcp/connections']);
  const benignPathRe = /\/api\/local\/tasks\/\d+\/console\/status$|\/api\/local\/browser\/sessions\/task-session\/\d+$/;

  page.on('pageerror', (err) => fatalErrors.push(`pageerror: ${err.message}`));
  page.on('response', (res) => {
    if (res.status() >= 400) {
      const { pathname } = new URL(res.url());
      if (!benignAsset.test(pathname) && !benignPaths.has(pathname) && !benignPathRe.test(pathname)) {
        fatalErrors.push(`HTTP ${res.status()} ${res.url()}`);
      }
    }
  });

  // 1. Spaces → create a case space → start an inline chat (same flow as above).
  await page.goto('/ui');
  await page.getByTestId('nav-spaces').click();

  const rail = page.getByTestId('space-rail');
  await expect(rail).toBeVisible();

  await page.getByTestId('create-space-btn').click();
  const titleInput = page.getByTestId('space-title-input');
  await expect(titleInput).toBeVisible();
  const caseTitle = `E2Eリンク-${Date.now()}`;
  await titleInput.fill(caseTitle);
  await page.getByTestId('space-form-submit').click();
  await expect(titleInput).toHaveCount(0);

  const caseRow = rail
    .locator('[data-testid="space-row"][data-space-kind="case"]')
    .filter({ hasText: caseTitle });
  await expect(caseRow).toBeVisible();
  await caseRow.click();

  const detail = page.getByTestId('space-detail');
  await expect(detail).toBeVisible();

  await page.getByTestId('space-tab-chat').click();
  await page.getByTestId('space-new-chat-btn').click();
  const body = page.getByTestId('create-task-body');
  await expect(body).toBeVisible();
  await body.fill('E2E: 出力リンクのプレビュー確認。最初のメッセージ。');
  await page.getByTestId('create-task-submit').click();

  const conversation = page.getByTestId('space-conversation');
  await expect(conversation).toBeVisible();

  // 2. Capture the created task id from the chat= URL param.
  await expect(page).toHaveURL(/[?&]chat=\d+/);
  const taskId = new URL(page.url()).searchParams.get('chat');
  expect(taskId).toBeTruthy();

  // 3. Create output/note.md via the output-only inline-edit endpoint so the
  //    markdown preview resolves to content. A freshly created chat may have a
  //    queued/running job (which locks the editor with 409); with no LLM the job
  //    settles quickly, so poll the PUT until it succeeds.
  await expect.poll(async () => {
    const res = await page.request.put(`/api/local/tasks/${taskId}/files/content`, {
      data: { section: 'output', path: 'note.md', content: '# E2E note\nhello from output' },
    });
    return res.status();
  }, { timeout: 30_000 }).toBe(200);

  // 4. Post a user comment whose markdown body carries an output-path link. The
  //    link href (output/note.md) matches OUTPUT_PATH_REGEX, so MarkdownText emits
  //    <a class="output-path-link" data-output-path="output/note.md">.
  const commentRes = await page.request.post(`/api/local/tasks/${taskId}/comments`, {
    data: { body: '結果はこちら [note.md](output/note.md) です', author: 'user' },
  });
  expect(commentRes.ok()).toBeTruthy();

  // 5. The conversation polls comments; the output-path link appears. Click it.
  const link = conversation.locator('a.output-path-link[data-output-path="output/note.md"]');
  await expect(link).toBeVisible({ timeout: 15_000 });
  await link.click();

  // 6. The file opens IN A FLOATING WINDOW, and the screen underneath does not
  //    move (#1551 step 1). This is the whole point of the change: the reader
  //    was on some other screen (Delegate, progress, the file list) and must
  //    still be on it after the click. So the rail keeps whatever it had — it
  //    must NOT gain a file item and must NOT switch to it, which is what the
  //    pane route used to do.
  const floatFrame = page.locator('[data-testid="file-preview-frame"][data-frame="float"]');
  await expect(floatFrame).toBeVisible();
  await expect(floatFrame).toContainText('hello from output');
  // The window names itself a dialog for screen readers but does NOT trap them:
  // the conversation and the file list behind it stay reachable.
  await expect(floatFrame).toHaveAttribute('aria-modal', 'false');
  await expect(conversation.getByTestId('space-chat-tab-file')).toHaveCount(0);
  // Nothing landed in the column either — the pane route is not a silent
  // fallback here.
  await expect(page.locator('[data-testid="file-preview-frame"][data-frame="pane"]')).toHaveCount(0);

  // Close via the frame's ✕, matched by testid. Its aria-label differs between the
  // floating frame (files:close) and the pane (files:closeAria), and both are
  // translated — the old name regex only matched the ja floating label.
  await floatFrame.getByTestId('file-preview-close').click();
  await expect(page.getByTestId('file-preview-frame')).toHaveCount(0);
  // The rail never gained a file item, so there is none to drop.
  await expect(conversation.getByTestId('space-chat-tab-file')).toHaveCount(0);

  // 7. No-nav invariant: clicking the link previewed in place, never bounced to Tasks.
  await expect(page).toHaveURL(/[?&]chat=\d+/);
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  await expect(detail).toBeVisible();

  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// Redesigned space-chat UX (issue #1330; the open file joined the rail in #1433
// step 4; 会話 left the rail on wide screens in #1455). The line-up lives in a
// VERTICAL ICON RAIL (data-testid="space-chat-rail", role=tablist,
// aria-orientation=vertical) on the far left: 概要 (overview) + 進捗 (activity) +
// ファイル (files) + トレース (trace) [+ ブラウザ/SSH while a live session lasts]
// [+ the OPEN FILE while one is open] [+ 会話 (chat) ONLY below 768px].
// Each button is icon-only and therefore carries its name in aria-label + title —
// for the open file that name is the file name itself. This chat-level ファイル
// item is distinct from the space-level files (SpaceDetail.tsx comment: it shows
// the chat's own input/output/logs under runs/{taskId}, not the shared space
// deliverables).
// THIS TEST RUNS AT THE DEFAULT DESKTOP VIEWPORT (1280px), so 会話 must NOT be in
// the rail: the conversation already owns its own column at this width, and an
// icon for it would put the same thing on screen twice (#1455). The narrow-screen
// half — 会話 IS in the rail below 768px — is pinned by the test right after this
// one; both halves are needed, otherwise dropping the width check would go
// unnoticed in one direction.
// The horizontal bar (data-testid="space-chat-tabs") is GONE (#1433 step 5): the
// rail owns every switch at every width, so the conversation exposes exactly one
// tablist and the bar is never rendered.
// SpaceDetail lays the conversation out in columns (#1330):
// rail / chat / whatever the rail points at (a detail screen OR the open file —
// the two are mutually exclusive). The chat column is always rendered and never
// unmounts, so the composer keeps its draft and stays usable while 概要 or 進捗 is
// on screen. Throughout, we never leave for the Tasks page (space= + chat= stay
// put; no page= param). No LLM is configured in E2E, so we assert UI/structure
// only, never agent output.
test('space chat rail: no 会話 item on a wide screen, overview open by default, fold gives the row back to the conversation', async ({ page }) => {
  const fatalErrors: string[] = [];
  const benignAsset = /\.(ico|png|svg|map|webmanifest|json)$/i;
  // Same no-auth + live-session probe allowlist as the inline-chat test above.
  const benignPaths = new Set(['/api/auth/me', '/api/users/me/orgs', '/api/mcp/connections']);
  const benignPathRe = /\/api\/local\/tasks\/\d+\/console\/status$|\/api\/local\/browser\/sessions\/task-session\/\d+$/;

  page.on('pageerror', (err) => fatalErrors.push(`pageerror: ${err.message}`));
  page.on('response', (res) => {
    if (res.status() >= 400) {
      const { pathname } = new URL(res.url());
      if (!benignAsset.test(pathname) && !benignPaths.has(pathname) && !benignPathRe.test(pathname)) {
        fatalErrors.push(`HTTP ${res.status()} ${res.url()}`);
      }
    }
  });

  // 1. Spaces → create a case space → start an inline chat (same flow as above).
  await page.goto('/ui');
  await page.getByTestId('nav-spaces').click();

  const rail = page.getByTestId('space-rail');
  await expect(rail).toBeVisible();

  await page.getByTestId('create-space-btn').click();
  const titleInput = page.getByTestId('space-title-input');
  await expect(titleInput).toBeVisible();
  const caseTitle = `E2Eタブ-${Date.now()}`;
  await titleInput.fill(caseTitle);
  await page.getByTestId('space-form-submit').click();
  await expect(titleInput).toHaveCount(0);

  const caseRow = rail
    .locator('[data-testid="space-row"][data-space-kind="case"]')
    .filter({ hasText: caseTitle });
  await expect(caseRow).toBeVisible();
  await caseRow.click();

  const detail = page.getByTestId('space-detail');
  await expect(detail).toBeVisible();

  await page.getByTestId('space-tab-chat').click();
  await page.getByTestId('space-new-chat-btn').click();
  const body = page.getByTestId('create-task-body');
  await expect(body).toBeVisible();
  await body.fill('E2E: 単一タブの会話。インプレース切替を確認する最初のメッセージ。');
  await page.getByTestId('create-task-submit').click();

  const conversation = page.getByTestId('space-conversation');
  await expect(conversation).toBeVisible();

  // 2. The icon rail (role=tablist, vertical) is visible and carries 概要 — but
  //    NOT 会話, which this width does not line up (#1455).
  const railTabs = conversation.getByTestId('space-chat-rail');
  await expect(railTabs).toBeVisible();
  await expect(railTabs).toHaveAttribute('role', 'tablist');
  await expect(railTabs).toHaveAttribute('aria-orientation', 'vertical');
  const overviewTab = conversation.getByTestId('space-chat-tab-overview');
  await expect(overviewTab).toBeVisible();
  // 会話 is not an item here: the conversation has its own column at this width,
  // so an icon for it would be the same thing on screen twice (#1455). Assert on
  // the whole page, not just the rail — if a second rail ever appears, a 会話
  // button anywhere would still be the duplicate this pins down.
  await expect(page.getByTestId('space-chat-tab-chat')).toHaveCount(0);
  // The chat-level ファイル item is present too (per-chat I/O/logs, distinct
  // from the space-level files tab).
  await expect(railTabs.getByTestId('space-chat-tab-files')).toBeVisible();
  // Icon-only controls must still be reachable by name (screen readers). 概要 is
  // the one to check now — it is in the line-up at every width.
  await expect(railTabs.getByRole('tab', { name: /^(概要|Overview)$/ })).toBeVisible();
  // The horizontal bar was removed in #1433 step 5; it is never rendered.
  await expect(conversation.getByTestId('space-chat-tabs')).toHaveCount(0);
  // No file is open, so the rail carries no file item either.
  await expect(conversation.getByTestId('space-chat-tab-file')).toHaveCount(0);
  // Exactly one tablist owns the shared tabpanel — the rail.
  await expect(conversation.getByRole('tablist')).toHaveCount(1);
  // 概要 is the default-selected item on a fresh chat (RAIL_DEFAULT since #1455 —
  // it used to be 会話, which is no longer in the line-up here). Nothing is
  // clicked to get here: this is how the conversation opens.
  await expect(overviewTab).toHaveAttribute('aria-selected', 'true');
  await expect(conversation.locator('textarea')).toBeVisible();

  // 3. 概要 opens in its own column beside the conversation, never as an overlay
  //    on top of it.
  // In place: the shared tabpanel (role=tabpanel) is mounted inside the same
  // conversation container — not a separate overlay.
  await expect(conversation.getByRole('tabpanel')).toBeVisible();
  // The right column really is on screen (the split that holds it only mounts
  // while something is in it — SpaceDetail's rightColumnsMounted).
  await expect(conversation.getByTestId('chat-detail-split')).toBeVisible();
  // The conversation keeps its own column: the composer is not merely mounted,
  // it is on screen and writable while 概要 shows. That is the whole point of
  // the column layout (#1330) — watch the progress, type the next instruction,
  // without switching back and forth. THIS is what this test is here to pin.
  await expect(page.getByTestId('space-chat-column')).toBeVisible();
  const composer = conversation.locator('textarea');
  await expect(composer).toHaveCount(1);
  await expect(composer).toBeVisible();
  await composer.fill('4 列: 概要を見ながら書けること');
  await expect(composer).toHaveValue('4 列: 概要を見ながら書けること');
  const chatColumn = page.getByTestId('space-chat-column');
  const sharedWidth = (await chatColumn.boundingBox())!.width;

  // 4. Back to the conversation. There is no 会話 item to press at this width;
  //    the way back is to press the item that is ALREADY picked, which folds its
  //    column away (chatRailState.ts nextRailState) and hands the freed width to
  //    the conversation. The chat column itself never unmounts, so the draft
  //    typed above survives the fold.
  await overviewTab.click();
  await expect(overviewTab).toHaveAttribute('aria-selected', 'false');
  // The right column is gone, not merely hidden.
  await expect(conversation.getByTestId('chat-detail-split')).toHaveCount(0);
  await expect(chatColumn).toBeVisible();
  await expect(composer).toHaveValue('4 列: 概要を見ながら書けること');
  // The conversation actually got the row back — it is wider than while it was
  // sharing with 概要.
  await expect.poll(async () => (await chatColumn.boundingBox())!.width).toBeGreaterThan(sharedWidth);

  // 5. Pressing 概要 once more opens it again (a fold is remembered, not sticky),
  //    and the draft still stands.
  await overviewTab.click();
  await expect(overviewTab).toHaveAttribute('aria-selected', 'true');
  await expect(conversation.getByTestId('chat-detail-split')).toBeVisible();
  await expect(composer).toBeVisible();
  await expect(composer).toHaveValue('4 列: 概要を見ながら書けること');

  // 6. No navigation to Tasks throughout: page=spaces + chat= held the entire time.
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  await expect(page).toHaveURL(/[?&]chat=\d+/);
  expect(page.url()).toContain('chat=');
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  await expect(detail).toBeVisible();

  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// The other half of #1455: 会話 leaves the rail on a WIDE screen only. Below
// 768px (useIsMobile) the conversation and whatever the rail points at share one
// column, so an item to get back to the conversation is the only way back — it
// must be there. The test above pins "absent when wide"; without this one, a
// change that drops the 会話 item at every width would sail through green.
//
// The whole setup runs at the desktop viewport first (the nav rail folds into
// the NavDrawer below 768px, which is a different flow and not what is under
// test here), then the window is narrowed. useIsMobile listens for matchMedia
// changes, so the item appears without a reload.
test('space chat rail: 会話 item appears once the window is narrower than 768px', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);

  await createAndOpenCaseSpace(page, 'E2E狭幅帯');
  const { conversation } = await startInlineChat(
    page,
    'E2E: 狭い画面で会話のアイコンが出ることを確認する最初のメッセージ。',
  );

  const railTabs = conversation.getByTestId('space-chat-rail');
  await expect(railTabs).toBeVisible();
  // Wide (the project's 1280px default): no 会話 item.
  await expect(page.getByTestId('space-chat-tab-chat')).toHaveCount(0);

  // Narrow: it appears. 700px is below the 768px breakpoint and still wide
  // enough that the conversation stays open (no bounce back to the space list).
  await page.setViewportSize({ width: 700, height: 900 });
  const chatTab = conversation.getByTestId('space-chat-tab-chat');
  await expect(chatTab).toBeVisible();
  // Icon-only, so it has to carry its name for screen readers.
  await expect(railTabs.getByRole('tab', { name: /^(会話|Chat)$/ })).toBeVisible();

  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// Space 設定 tab (feat/space-folder-settings). The SpaceDetail now carries a
// 設定 entry (space-tab-settings, folded into the "その他" menu since issue
// #1360 stage 1) that renders SpaceSettings: a sub-nav
// (space-settings-nav-{agents,memory,pieces,skills,mcp,ssh}) + the matching
// panel. The file-based panels (agents/memory/pieces/skills) are space-scoped —
// their API calls carry ?spaceId=<id>, so AGENTS.md saved here lands under the
// space folder, NOT the per-user folder. We prove that by saving unique text via
// the AGENTS.md editor (Monaco), reloading, and asserting it persisted. MCP/SSH
// are now ALSO per-space (DB-backed, spec §11): selecting either renders its own
// space-scoped panel (no more "not space-scoped" disclaimer). No LLM is needed;
// this is pure settings UI, so we never assert agent output and never leave
// page=spaces.
test('space settings tab: AGENTS.md per-space persistence + MCP/SSH panels render', async ({ page }) => {
  const fatalErrors: string[] = [];
  const benignAsset = /\.(ico|png|svg|map|webmanifest|json)$/i;
  // Same no-auth probe allowlist as the other space tests. With auth disabled the
  // UI's /api/auth/me probe 404s on purpose; the MCP/SSH panels also probe
  // connection endpoints which 401/404 under no-auth and degrade to empty lists.
  const benignPaths = new Set([
    '/api/auth/me',
    '/api/users/me/orgs',
    '/api/mcp/connections',
    '/api/mcp/servers',
    '/api/mcp/user-servers',
    '/api/ssh/connections',
  ]);

  page.on('pageerror', (err) => fatalErrors.push(`pageerror: ${err.message}`));
  page.on('response', (res) => {
    if (res.status() >= 400) {
      const { pathname } = new URL(res.url());
      if (!benignAsset.test(pathname) && !benignPaths.has(pathname)) {
        fatalErrors.push(`HTTP ${res.status()} ${res.url()}`);
      }
    }
  });

  // 1. Spaces → create a case space → open it.
  await page.goto('/ui');
  await page.getByTestId('nav-spaces').click();

  const rail = page.getByTestId('space-rail');
  await expect(rail).toBeVisible();

  await page.getByTestId('create-space-btn').click();
  const titleInput = page.getByTestId('space-title-input');
  await expect(titleInput).toBeVisible();
  const caseTitle = `E2E設定-${Date.now()}`;
  await titleInput.fill(caseTitle);
  await page.getByTestId('space-form-submit').click();
  await expect(titleInput).toHaveCount(0);

  const caseRow = rail
    .locator('[data-testid="space-row"][data-space-kind="case"]')
    .filter({ hasText: caseTitle });
  await expect(caseRow).toBeVisible();
  await caseRow.click();

  const detail = page.getByTestId('space-detail');
  await expect(detail).toBeVisible();

  // 2. 設定 は「その他」の中（issue #1360 段 1）。開いて選ぶと sub-nav が出る。
  await openSpaceTab(page, 'settings');

  await expect(page.getByTestId('space-settings-nav-agents')).toBeVisible();
  await expect(page.getByTestId('space-settings-nav-memory')).toBeVisible();
  await expect(page.getByTestId('space-settings-nav-pieces')).toBeVisible();
  await expect(page.getByTestId('space-settings-nav-skills')).toBeVisible();
  await expect(page.getByTestId('space-settings-nav-mcp')).toBeVisible();
  await expect(page.getByTestId('space-settings-nav-ssh')).toBeVisible();
  await expect(page.getByTestId('space-settings-nav-browser')).toBeVisible();

  // 3. AGENTS.md panel (default-selected section). The Monaco editor mounts;
  //    type unique text into it and Save. A fixed unique marker lets the reload
  //    assertion below be exact and locale-independent.
  //    assertion below be exact and locale-independent.
  await page.getByTestId('space-settings-nav-agents').click();
  const editor = page.getByTestId('monaco-file-editor');
  await expect(editor).toBeVisible();

  // Monaco loads its editor lazily (@monaco-editor/react shows a loading state
  // first). Wait for the editor surface, then drive its hidden textarea: click
  // to focus, then type. The single short line lands in the (always-rendered)
  // .view-lines so we can assert it back after a reload.
  const marker = 'AGENTS_SPACE_PERSIST_42';
  const monacoSurface = editor.locator('.monaco-editor');
  await expect(monacoSurface).toBeVisible({ timeout: 20_000 });
  // The editing line (.view-lines) must be rendered before we focus + type.
  await expect(editor.locator('.view-lines')).toBeVisible({ timeout: 20_000 });
  await monacoSurface.click();
  // Replace the entire buffer with our unique marker (select-all → type). This
  // is build-agnostic — it doesn't depend on Monaco's internal textarea class.
  await page.keyboard.press('ControlOrMeta+A');
  await page.keyboard.type(`案件専用の指示 ${marker}`);
  // The typed marker shows up in the rendered Monaco view.
  await expect(editor.locator('.view-lines')).toContainText(marker, { timeout: 10_000 });

  // The Save button (data-testid="monaco-save") enables once dirty; click it and
  // wait for the PUT to the space-scoped agents-md endpoint to succeed (200).
  const saveBtn = page.getByTestId('monaco-save');
  await expect(saveBtn).toBeEnabled();
  const savePromise = page.waitForResponse(
    (r) => /\/api\/users\/me\/agents-md\?/.test(r.url()) && r.request().method() === 'PUT',
  );
  await saveBtn.click();
  const saveRes = await savePromise;
  expect(saveRes.status()).toBe(200);
  // The save URL must carry this space's id — that is what makes it per-space.
  expect(new URL(saveRes.url()).searchParams.get('spaceId')).toBeTruthy();

  // 4. Reload the page, re-open the same space → 設定 → AGENTS.md, and assert the
  //    editor re-hydrates with the saved text (proves server-side persistence
  //    under the space folder; a fresh GET re-fetches ?spaceId=...).
  await page.reload();
  await page.getByTestId('nav-spaces').click();
  await expect(rail).toBeVisible();
  const caseRowAfter = rail
    .locator('[data-testid="space-row"][data-space-kind="case"]')
    .filter({ hasText: caseTitle });
  await expect(caseRowAfter).toBeVisible();
  await caseRowAfter.click();
  await expect(detail).toBeVisible();
  await openSpaceTab(page, 'settings');
  await page.getByTestId('space-settings-nav-agents').click();

  const editorAfter = page.getByTestId('monaco-file-editor');
  await expect(editorAfter).toBeVisible();
  // The persisted marker shows up in the rendered Monaco view.
  await expect(editorAfter.locator('.view-lines')).toContainText(marker, { timeout: 15_000 });

  // 5. MCP / SSH now render their own per-space panels when selected (the old
  //    "not space-scoped" disclaimer is gone). Light assertion — the space-scoped
  //    panel container mounts for each. (Isolation is proven by the dedicated test
  //    below.)
  await page.getByTestId('space-settings-nav-mcp').click();
  await expect(page.getByTestId('space-mcp-panel')).toBeVisible();
  await page.getByTestId('space-settings-nav-ssh').click();
  await expect(page.getByTestId('space-ssh-panel')).toBeVisible();

  // 6. No-nav invariant: settings is in-place, never leaves Spaces for Tasks.
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  await expect(detail).toBeVisible();

  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// User Folder tab retirement (chore/remove-userfolder-tab). The top-level
// "User Folder" nav tab was removed: everything it hosted (AGENTS.md / memory /
// pieces / skills / MCP / SSH / browser) is now reachable from the personal
// workspace's 設定 tab (asserted by the settings test above), and the one orphan
// — Pets — moved into global Settings as its own section. This test proves the
// removal didn't strand anything: (1) no User Folder tab in the TopBar nav, and
// (2) the Pets settings section is present and selectable in global Settings.
// No LLM needed; this is pure navigation/structure.
test('userfolder tab removed: gone from nav, Pets reachable in Settings', async ({ page }) => {
  await page.goto('/ui');

  // 1. The top-level User Folder nav tab no longer exists (testid nav-userfolder
  //    was dropped along with the page id).
  await expect(page.getByTestId('nav-userfolder')).toHaveCount(0);
  await expect(page.getByText('User Folder', { exact: true })).toHaveCount(0);

  // 2. Settings still opens, and the Pets section (relocated here) is present in
  //    the sidebar and selectable. Pets is a user-scoped section, so it shows
  //    even with auth disabled (synthetic local user).
  await page.getByTestId('nav-settings').click();
  await expect(page).toHaveURL(/[?&]page=settings(&|$)/);

  const petsNav = page.getByTestId('settings-nav-pets');
  await expect(petsNav).toBeVisible();
  await petsNav.click();
  // The relocated Pets panel renders (PetsForm carries data-testid="pets-form").
  await expect(page.getByTestId('pets-form')).toBeVisible();
});

// Per-space MCP isolation (feat/space-mcp-ssh-isolation). MCP servers are
// DB-backed but scoped to a space: POST /api/mcp/user-servers accepts space_id,
// and GET /api/mcp/user-servers?spaceId=<id> returns ONLY that space's servers.
// The 設定 → MCP panel lists those (data-testid="space-mcp-list", each row a
// "space-mcp-item" carrying data-server-id / data-server-name).
//
// MCP is the deterministic choice over SSH here: registering an api_key server
// needs no OAuth dance and no private key, and the MCP subsystem is mounted in
// E2E via a fixed MCP_ENCRYPTION_KEY (see playwright.config.ts). The unreachable
// server URL only defers tool discovery (caught server-side), so register still
// returns 200. We then prove isolation TWO ways: (a) via the API — the server
// shows under ?spaceId=A but NOT ?spaceId=B; and (b) via the UI — it appears in
// space A's MCP list but is absent from space B's. No LLM is configured in E2E,
// so we assert structure only, never agent output.
test('space MCP isolation: server registered in A is visible in A, absent in B', async ({ page }) => {
  const fatalErrors: string[] = [];
  const benignAsset = /\.(ico|png|svg|map|webmanifest|json)$/i;
  // Same no-auth probe allowlist as the settings test. With auth disabled the
  // /api/auth/me probe 404s on purpose; the MCP panel also probes the admin
  // /api/mcp/servers + /api/mcp/connections endpoints which degrade to empty
  // lists under no-auth, and SSH (mounted alongside in the sub-nav) 404s since
  // its subsystem stays off — all benign, not failures.
  const benignPaths = new Set([
    '/api/auth/me',
    '/api/users/me/orgs',
    '/api/mcp/connections',
    '/api/mcp/servers',
    '/api/ssh/connections',
  ]);

  page.on('pageerror', (err) => fatalErrors.push(`pageerror: ${err.message}`));
  page.on('response', (res) => {
    if (res.status() >= 400) {
      const { pathname } = new URL(res.url());
      if (!benignAsset.test(pathname) && !benignPaths.has(pathname)) {
        fatalErrors.push(`HTTP ${res.status()} ${res.url()}`);
      }
    }
  });

  // 1. Create TWO case spaces (A and B) via the same API the create dialog uses.
  //    POST returns 201 with the full space row, so we capture each id.
  const stamp = Date.now();
  const resA = await page.request.post('/api/local/spaces', { data: { title: `E2E-MCP-A-${stamp}` } });
  expect(resA.status()).toBe(201);
  const spaceA = (await resA.json()) as { id: string };
  expect(spaceA.id).toBeTruthy();

  const resB = await page.request.post('/api/local/spaces', { data: { title: `E2E-MCP-B-${stamp}` } });
  expect(resB.status()).toBe(201);
  const spaceB = (await resB.json()) as { id: string };
  expect(spaceB.id).toBeTruthy();
  expect(spaceB.id).not.toBe(spaceA.id);

  // 2. Register an api_key MCP server INTO space A via the UI's register endpoint
  //    (POST /api/mcp/user-servers with space_id). api_key avoids the OAuth flow;
  //    the unreachable URL only defers tool discovery (caught server-side), so
  //    the register still returns ok.
  const mcpId = `e2e-mcp-${stamp}`;
  const mcpName = `spaceA-mcp-${stamp}`;
  const reg = await page.request.post('/api/mcp/user-servers', {
    data: {
      id: mcpId,
      name: mcpName,
      url: 'https://example.invalid/mcp',
      authKind: 'api_key',
      staticToken: 'e2e-static-token',
      space_id: spaceA.id,
    },
  });
  expect(reg.ok(), `register failed: ${reg.status()} ${await reg.text()}`).toBeTruthy();

  // 3. API-level isolation: the server appears under ?spaceId=A but NOT ?spaceId=B.
  const listA = (await (await page.request.get(
    `/api/mcp/user-servers?spaceId=${encodeURIComponent(spaceA.id)}`,
  )).json()) as { servers: Array<{ id: string; name: string }> };
  expect(listA.servers.some((s) => s.id === mcpId)).toBeTruthy();

  const listB = (await (await page.request.get(
    `/api/mcp/user-servers?spaceId=${encodeURIComponent(spaceB.id)}`,
  )).json()) as { servers: Array<{ id: string; name: string }> };
  expect(listB.servers.some((s) => s.id === mcpId)).toBeFalsy();

  // 4. UI: open Spaces, select space A by its id, go to 設定 → MCP. The space MCP
  //    list renders and contains our server (proves the panel reads ?spaceId=A).
  await page.goto('/ui');
  await page.getByTestId('nav-spaces').click();
  const rail = page.getByTestId('space-rail');
  await expect(rail).toBeVisible();

  const rowA = rail.locator(`[data-testid="space-row"][data-space-id="${spaceA.id}"]`);
  await expect(rowA).toBeVisible();
  await rowA.click();

  const detail = page.getByTestId('space-detail');
  await expect(detail).toBeVisible();
  await openSpaceTab(page, 'settings');
  await page.getByTestId('space-settings-nav-mcp').click();

  // The space-scoped MCP panel mounts and its list carries our per-space item.
  await expect(page.getByTestId('space-mcp-panel')).toBeVisible();
  const listAUi = page.getByTestId('space-mcp-list');
  await expect(listAUi).toBeVisible({ timeout: 15_000 });
  await expect(
    listAUi.locator(`[data-testid="space-mcp-item"][data-server-id="${mcpId}"]`),
  ).toBeVisible({ timeout: 15_000 });
  await expect(listAUi).toContainText(mcpName);

  // 5. THE KEY ASSERTION — open space B → 設定 → MCP. The server registered in A
  //    must NOT appear here. Space B has no per-space MCP servers, so its list
  //    wrapper isn't rendered (empty-state); either way our item must be absent.
  const rowB = rail.locator(`[data-testid="space-row"][data-space-id="${spaceB.id}"]`);
  await expect(rowB).toBeVisible();
  await rowB.click();
  await expect(detail).toBeVisible();
  await openSpaceTab(page, 'settings');
  await page.getByTestId('space-settings-nav-mcp').click();

  // The space-B MCP panel renders, but our server is nowhere in it.
  await expect(page.getByTestId('space-mcp-panel')).toBeVisible();
  await expect(
    page.locator(`[data-testid="space-mcp-item"][data-server-id="${mcpId}"]`),
  ).toHaveCount(0);
  await expect(page.getByTestId('space-mcp-panel')).not.toContainText(mcpName);

  // No-nav invariant + no fatal client errors.
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// ════════════════════════════════════════════════════════════════════════════
// Space task/settings feature parity (feat/space-feature-parity-tests).
//
// Phase 1 added per-chat delete / share / continue controls to the inline
// SpaceConversation. Issue #1433 moved the two that survive (continue + delete)
// out of the chat tab bar's right-hand zone (data-testid="space-chat-actions",
// which the conversation no longer renders) and down into the composer's button
// row, where delete sits at the FAR LEFT — away from send. Locate them by
// their own testids under the conversation, never through the retired zone. These tests
// prove each action works INSIDE a space without ever bouncing to the Tasks
// page, plus the 概要 (overview) feedback flow and every 設定 sub-tab.
//
// No LLM is configured in E2E, so a queued job fails fast and settles terminal
// (waitForTerminalJob), which is exactly what unlocks Continue + Overview
// feedback. Throughout we assert page=spaces is held (the no-nav invariant the
// user cares about) and no fatal client errors leak.
// ════════════════════════════════════════════════════════════════════════════

// 1. DELETE — the user-reported gap. The composer row exposes a delete button
//    (data-testid="space-chat-delete"); clicking it pops a confirm() dialog, and
//    on accept the chat is removed and the conversation returns to the empty
//    list state (the chat row disappears). This guards the exact bug the user
//    hit: a missing delete button in space chats.
test('space chat DELETE: toolbar delete removes the chat and returns to the list', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);

  await createAndOpenCaseSpace(page, 'E2E削除');
  const { conversation, taskId } = await startInlineChat(
    page,
    'E2E: 削除テスト用チャット。最初のメッセージ。',
  );

  // The delete button is present in the conversation (composer row since #1433).
  const deleteBtn = conversation.getByTestId('space-chat-delete');
  await expect(deleteBtn).toBeVisible();
  // …in the composer's own action zone, not the retired tab-bar zone. (The
  // left-most / away-from-send ordering inside that row is pinned by
  // ui/src/components/spaces/SpaceDetail.composerActions.test.tsx.)
  await expect(conversation.getByTestId('chat-composer-actions')).toBeVisible();

  // The chat row for this task exists in the space's chat list before delete.
  const chatRow = page.locator(`[data-testid="space-chat-row"][data-task-id="${taskId}"]`);
  await expect(chatRow).toBeVisible();

  // Accept the confirm() dialog that guards the destructive delete.
  page.once('dialog', (dialog) => {
    expect(dialog.type()).toBe('confirm');
    void dialog.accept();
  });
  await deleteBtn.click();

  // The chat disappears from the list AND the inline conversation closes
  // (SpaceConversation calls onBack(0) on delete → spaceTaskId null → no
  // conversation). The chat= URL param is dropped.
  await expect(chatRow).toHaveCount(0, { timeout: 15_000 });
  await expect(conversation).toHaveCount(0);
  await expect.poll(() => new URL(page.url()).searchParams.get('chat')).toBeFalsy();

  // No-nav invariant: deletion stayed on Spaces, never bounced to Tasks.
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// 2. CANCEL — seed a stable running job in the isolated E2E DB, then exercise
//    the real ChatPane -> POST /cancel -> persisted terminal state. Waiting for
//    the stub LLM to claim a job used to skip this check, or race a transient
//    busy state and time out before the stop button could be clicked.
test('space chat CANCEL: ChatPane stop button cancels a running task', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  const { spaceId } = await createAndOpenCaseSpace(page, 'E2Eキャンセル');
  const created = await page.request.post('/api/local/tasks', {
    data: {
      body: 'E2E: キャンセルテスト用の実行中タスク',
      piece: 'chat', spaceId, workspaceMode: 'persistent',
    },
  });
  expect(created.ok()).toBeTruthy();
  const taskId = String((await created.json()).task.id);
  let jobId: string | undefined;
  await expect.poll(async () => {
    jobId = (await fetchTask(page, taskId))?.latestJob?.id;
    return jobId;
  }).toBeTruthy();

  const e2eTmp = process.env.E2E_TMP;
  if (!e2eTmp) throw new Error('E2E_TMP must be set by playwright.config.ts');
  const db = new Database(resolve(e2eTmp, 'e2e.db'));
  try {
    db.pragma('busy_timeout = 8000');
    const changed = db.prepare("UPDATE jobs SET status = 'running' WHERE id = ?").run(jobId!);
    expect(changed.changes).toBe(1);
  } finally {
    db.close();
  }

  const url = new URL(page.url());
  url.searchParams.set('chat', taskId);
  await page.goto(url.href);
  const conversation = page.getByTestId('space-conversation');
  await expect(conversation).toBeVisible();
  const stopBtn = conversation.getByRole('button', { name: /^(Stop|停止)$/ });
  await expect(stopBtn).toBeVisible();
  const response = page.waitForResponse(res =>
    new URL(res.url()).pathname === '/api/local/tasks/' + taskId + '/cancel'
    && res.request().method() === 'POST');
  await stopBtn.click();
  expect((await response).status()).toBe(200);
  expect(await waitForTerminalJob(page, taskId, 20_000)).toBe('cancelled');
  await expect(stopBtn).toHaveCount(0);

  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, 'fatal errors:\n' + fatalErrors.join('\n')).toEqual([]);
});

// 4. CONTINUE-WITH-PIECE — the Continue button (data-testid=
//    "space-chat-continue", reusing ContinueButton, in the composer row since
//    issue #1433) is gated: disabled until the
//    latest job is TERMINAL, enabled after. We always assert the wiring that IS
//    observable without an LLM — the button is present and DISABLED while the job
//    is non-terminal (queued). Then, IF the job reaches a terminal state (needs a
//    reachable LLM; the E2E env has none, so this branch is skipped + reported),
//    we click it and assert ContinueWithPieceDialog opens with piece options.
test('space chat CONTINUE: button gated on terminal job; opens ContinueWithPieceDialog when terminal', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);

  await createAndOpenCaseSpace(page, 'E2E継続');
  const { conversation, taskId } = await startInlineChat(
    page,
    'E2E: 継続テスト用チャット。最初のメッセージ。',
  );

  // Always-verifiable: the Continue button exists and is DISABLED while the job
  // is non-terminal (proves the terminal-gating in ContinueButton is wired).
  const continueBtn = conversation.getByTestId('space-chat-continue');
  await expect(continueBtn).toBeVisible();
  await expect(continueBtn).toBeDisabled();

  // Active path: only reachable when the job goes terminal (needs an LLM).
  const status = await waitForTerminalJob(page, taskId);
  test.skip(
    status === '',
    'no LLM reachable: the job stays queued (never terminal), so Continue stays ' +
      'disabled — the dialog-open assertion needs a terminal job',
  );

  await expect(continueBtn).toBeEnabled({ timeout: 15_000 });
  await continueBtn.click();

  // ContinueWithPieceDialog opens: the piece <select> + instruction textarea
  // (stable ids) are present, and the select carries ≥1 piece option.
  const pieceSelect = page.locator('#continue-piece');
  await expect(pieceSelect).toBeVisible();
  await expect(page.locator('#continue-instruction')).toBeVisible();
  await expect.poll(async () => pieceSelect.locator('option').count()).toBeGreaterThan(0);

  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// 5. VISIBILITY — space chats have a FIXED scope: always visible to the space's
//    members, never user-selectable. The visibility <select> was removed when the
//    scope became fixed, and the static note chip that replaced it was removed in
//    PR #780 (the scope is documented in help instead). This test guards that no
//    visibility control sneaks back into the conversation toolbar, while the
//    action buttons that DO belong there (continue / delete) stay present — so the
//    assertion can't pass vacuously on a broken/empty toolbar. The auth-mode twin
//    of this guard lives in ui/e2e-auth/sharing-scope.auth.spec.ts. (History:
//    issue #782 — the old "change to public persists" test referenced the removed
//    testid and had been silently dead since the selector was retired. Same trap
//    again in issue #1338: the positive anchor was space-chat-share, but the
//    per-task share link was retired in PR #962 — sharing is a space-level feature
//    now — so the button and its testid went away while this line kept waiting for
//    it. The anchors are now the two controls that actually ship — they live in
//    the composer row since issue #1433, and are found by their own testids.)
test('space chat VISIBILITY: no visibility control (fixed member-only scope)', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);

  await createAndOpenCaseSpace(page, 'E2E可視性');
  const { conversation } = await startInlineChat(
    page,
    'E2E: 可視性テスト用チャット。最初のメッセージ。',
  );

  // Positive anchor first: the per-chat actions are rendered (composer row since
  // issue #1433), so the negative assertions below are checked against a live,
  // non-empty conversation UI.
  await expect(conversation.getByTestId('space-chat-continue')).toBeVisible();
  await expect(conversation.getByTestId('space-chat-delete')).toBeVisible();

  // No visibility selector, no visibility note — scope is fixed and implicit.
  await expect(conversation.getByTestId('space-chat-visibility')).toHaveCount(0);
  await expect(conversation.getByTestId('space-chat-visibility-note')).toHaveCount(0);

  // Still on the spaces view with the chat selected. The current URL scheme
  // carries space= + chat= params (the legacy page=spaces param is gone; other
  // tests in this file still assert it and are stale — see issue #782 follow-up).
  await expect(page).toHaveURL(/[?&]space=[^&]+/);
  await expect(page).toHaveURL(/[?&]chat=\d+/);
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// 6. FEEDBACK via 概要 tab — the in-place 概要 (overview) tab renders OverviewTab.
//    We always assert that switching to 概要 swaps the OverviewTab content in
//    place (the conversation composer disappears; the shared tabpanel mounts) —
//    verifiable without an LLM. The FeedbackPanel itself only renders for a
//    COMPLETE (succeeded / failed) job, which needs a reachable LLM; the E2E env
//    has none, so the rating round-trip is skipped + reported and runs for real
//    only against a live LLM.
test('space chat FEEDBACK: 概要 tab renders OverviewTab; rating round-trip saves + persists', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);

  const { detail, spaceId } = await createAndOpenCaseSpace(page, 'E2Eフィードバック');
  const { conversation, taskId } = await startInlineChat(
    page,
    'E2E: フィードバックテスト用チャット。最初のメッセージ。',
  );

  // Always-verifiable: 概要 opens as a right-pane detail panel and the shared
  // tabpanel is mounted. Nothing is clicked to get there — a fresh chat opens on
  // 概要 already (RAIL_DEFAULT since #1455; it used to be 会話). Pressing it here
  // would do the opposite of what this test needs: the item that is already
  // picked folds its column away (chatRailState.ts nextRailState), taking the
  // FeedbackPanel below off screen.
  const overviewTab = conversation.getByTestId('space-chat-tab-overview');
  await expect(overviewTab).toBeVisible();
  await expect(overviewTab).toHaveAttribute('aria-selected', 'true');
  const panel = conversation.getByRole('tabpanel');
  await expect(panel).toBeVisible();
  // The conversation keeps its own column beside 概要 on desktop (#1330), so the
  // composer is both mounted and on screen — exactly one textarea.
  await expect(conversation.locator('textarea')).toHaveCount(1);
  await expect(conversation.locator('textarea')).toBeVisible();

  // Active path: the FeedbackPanel only renders once the job is succeeded/failed.
  const status = await waitForTerminalJob(page, taskId);
  test.skip(
    status !== 'succeeded' && status !== 'failed',
    'no LLM reachable: the job never completes (succeeded/failed), so the ' +
      'Overview FeedbackPanel does not render — the rating round-trip needs a completed job',
  );

  // The 👍 rating button appears once the job is complete. The 👍 emoji is
  // locale-independent (the text label beside it is i18n), so match the emoji.
  const good = panel.getByRole('button', { name: /👍/ });
  await expect(good).toBeVisible({ timeout: 15_000 });
  await good.click();
  // Pick a good-rating tag (GOOD_TAGS are literal JP strings, not i18n), then
  // submit. The Submit label IS i18n, so match English/Japanese. Wait for the
  // feedback PUT to commit before asserting the saved state.
  await panel.getByRole('button', { name: '出力の精度が高い' }).click();
  const fbPromise = page.waitForResponse(
    (r) => /\/api\/local\/tasks\/\d+\/feedback$/.test(r.url()) && r.request().method() === 'PUT',
  );
  await panel.getByRole('button', { name: /^(Submit|送信)$/ }).click();
  const fbRes = await fbPromise;
  expect(fbRes.status()).toBe(200);

  // Saved → the panel collapses to its summary view: a change button appears
  // (only rendered when feedback exists and we're not editing). Label is i18n.
  await expect(panel.getByRole('button', { name: /^(Change|変更)$/ })).toBeVisible({ timeout: 15_000 });

  // Persistence: the rating is on the task server-side.
  await expect
    .poll(async () => (await fetchTask(page, taskId))?.feedbackRating ?? null)
    .toBe('good');

  // Reload + reopen via URL state → the 概要 panel still shows the saved summary.
  await page.goto(`/ui?page=spaces&space=${spaceId}&chat=${taskId}`);
  await expect(detail).toBeVisible();
  const conversationAfter = page.getByTestId('space-conversation');
  // The rail remembers the pick per chat (localStorage), so 概要 may already be
  // open here. Pressing the item that is already open does NOT re-open it: it
  // folds that column away (chatRailState.ts nextRailState), which would take
  // the FeedbackPanel off screen. So click only when it is not already
  // selected.
  const overviewAfter = conversationAfter.getByTestId('space-chat-tab-overview');
  if ((await overviewAfter.getAttribute('aria-selected')) !== 'true') {
    await overviewAfter.click();
  }
  await expect(
    conversationAfter.getByRole('tabpanel').getByRole('button', { name: /^(Change|変更)$/ }),
  ).toBeVisible({ timeout: 15_000 });

  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// 7a. SETTINGS sub-tabs render — every 設定 sub-tab (agents/memory/pieces/skills/
//     mcp/ssh) opens its space-scoped panel without a crash or fatal 404. The
//     AGENTS.md Monaco round-trip + MCP/SSH panels are covered by the dedicated
//     settings test above; here we additionally prove pieces + skills + memory
//     panels mount their content (stable in-panel markers), so a regression that
//     blanks any one sub-tab is caught.
test('space settings sub-tabs: agents/memory/pieces/skills/mcp/ssh all render their panel', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);

  await createAndOpenCaseSpace(page, 'E2E設定タブ');
  await openSpaceTab(page, 'settings');

  // agents → Monaco editor mounts.
  await page.getByTestId('space-settings-nav-agents').click();
  await expect(page.getByTestId('monaco-file-editor')).toBeVisible({ timeout: 20_000 });

  // memory → the MemoryEntriesPanel header + new-entry button render. The header
  // text is i18n (English in the E2E browser locale, Japanese otherwise).
  await page.getByTestId('space-settings-nav-memory').click();
  await expect(page.getByRole('heading', { name: /Memory entries|メモリエントリ/ })).toBeVisible({ timeout: 15_000 });
  await expect(page.getByRole('button', { name: /New entry|新しいエントリ/ })).toBeVisible();

  // pieces → the SpacePiecesPanel list (Default / Custom sections) renders.
  // These section labels are i18n (spaces.json settings.pieces.default/custom).
  await page.getByTestId('space-settings-nav-pieces').click();
  await expect(page.getByText(/^(Default|標準)$/)).toBeVisible({ timeout: 15_000 });
  await expect(page.getByText(/^(Custom|カスタム)$/)).toBeVisible();

  // skills → the SkillsForm heading renders (the install-from-URL input is
  // intentionally hidden in space mode — the Git install path isn't space-scoped
  // yet — so the unique heading is the panel-mounted marker). The heading is now
  // i18n (settings.json skills.title), and this runner's locale is ja-JP, so the
  // name has to accept both languages like the Default/Custom checks above.
  await page.getByTestId('space-settings-nav-skills').click();
  await expect(page.getByRole('heading', { name: /^(Skills|スキル)$/ })).toBeVisible({ timeout: 15_000 });

  // mcp / ssh → their space-scoped panel containers render.
  await page.getByTestId('space-settings-nav-mcp').click();
  await expect(page.getByTestId('space-mcp-panel')).toBeVisible({ timeout: 15_000 });
  await page.getByTestId('space-settings-nav-ssh').click();
  await expect(page.getByTestId('space-ssh-panel')).toBeVisible({ timeout: 15_000 });

  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// 7b. MEMORY per-space persistence + isolation — memory is space-scoped: the
//     panel reads/writes /api/local/memory/entries?spaceId=<id>. We seed an entry
//     into space A via the same space-scoped API the panel uses, open A's 設定 →
//     メモリ and assert the entry renders (proves the panel reads ?spaceId=A and
//     the write persisted to the space folder), then open space B's メモリ and
//     assert the entry is absent (isolation). Mirrors the MCP-isolation pattern.
test('space settings MEMORY: entry saved in space A persists + is absent in space B', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);

  const stamp = Date.now();
  const resA = await page.request.post('/api/local/spaces', { data: { title: `E2E-MEM-A-${stamp}` } });
  expect(resA.status()).toBe(201);
  const spaceA = (await resA.json()) as { id: string };
  const resB = await page.request.post('/api/local/spaces', { data: { title: `E2E-MEM-B-${stamp}` } });
  expect(resB.status()).toBe(201);
  const spaceB = (await resB.json()) as { id: string };
  expect(spaceB.id).not.toBe(spaceA.id);

  // Seed a memory entry into space A via the space-scoped API (same endpoint the
  // panel's modal posts to). A unique name lets the UI assertion be exact.
  const memName = `e2e-mem-${stamp}`;
  const putRes = await page.request.put(
    `/api/local/memory/entries/${memName}?spaceId=${encodeURIComponent(spaceA.id)}`,
    { data: { description: 'E2E space-scoped memory', type: 'reference', body: 'space A only' } },
  );
  expect(putRes.status(), `memory PUT failed: ${putRes.status()} ${await putRes.text()}`).toBe(200);

  // Open Spaces, select A → 設定 → メモリ; the seeded entry renders (persisted +
  // read back via ?spaceId=A).
  await page.goto('/ui');
  await page.getByTestId('nav-spaces').click();
  const rail = page.getByTestId('space-rail');
  await expect(rail).toBeVisible();

  const detail = page.getByTestId('space-detail');
  await rail.locator(`[data-testid="space-row"][data-space-id="${spaceA.id}"]`).click();
  await expect(detail).toBeVisible();
  await openSpaceTab(page, 'settings');
  await page.getByTestId('space-settings-nav-memory').click();
  await expect(page.getByText(memName, { exact: true })).toBeVisible({ timeout: 15_000 });

  // Open space B → 設定 → メモリ; the entry from A must NOT appear (isolation).
  await rail.locator(`[data-testid="space-row"][data-space-id="${spaceB.id}"]`).click();
  await expect(detail).toBeVisible();
  await openSpaceTab(page, 'settings');
  await page.getByTestId('space-settings-nav-memory').click();
  await expect(page.getByRole('heading', { name: /Memory entries|メモリエントリ/ })).toBeVisible({ timeout: 15_000 });
  await expect(page.getByText(memName, { exact: true })).toHaveCount(0);

  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// ── Space calendar tab (feat/space-calendar, plan stage 4) ───────────────────
//
// The per-space カレンダー tab renders a self-built month grid (no external
// calendar lib) plus a day panel with three sections (タスク / 変更ファイル /
// 予定) and event CRUD. These E2E reuse the shared create-space / inline-chat
// helpers above and the same fatal-error tracker — they assert the calendar
// behaves on the real orchestrator (auth off => synthetic 'local' user, who is
// the space owner and therefore can edit events).
//
// 'today' is computed in the viewer's local frame exactly like the UI's
// localToday(), so the `space-cal-day-{date}` testid matches the cell the UI
// renders for today (the grid + day endpoint share the tz_offset).
function e2eLocalToday(): string {
  const d = new Date();
  const mm = String(d.getMonth() + 1).padStart(2, '0');
  const dd = String(d.getDate()).padStart(2, '0');
  return `${d.getFullYear()}-${mm}-${dd}`;
}

const ADJACENT_MONTH_CLOCK = new Date('2026-07-15T12:00:00.000Z');
const ADJACENT_MONTH_FIRST = '2026-06-28';
const ADJACENT_MONTH_LAST = '2026-08-08';

async function seedCalendarTaskDate(
  page: Page,
  spaceId: string,
  date: string,
  body: string,
): Promise<number> {
  const created = await page.request.post('/api/local/tasks', {
    data: { body, piece: 'chat', spaceId, workspaceMode: 'persistent' },
  });
  expect(created.ok()).toBeTruthy();
  const taskId = (await created.json()).task.id as number;
  const e2eTmp = process.env.E2E_TMP;
  if (!e2eTmp) throw new Error('E2E_TMP must be set by playwright.config.ts');
  const db = new Database(resolve(e2eTmp, 'e2e.db'));
  db.pragma('busy_timeout = 8000');
  db.prepare('UPDATE local_tasks SET created_at = ?, updated_at = ? WHERE id = ?')
    .run(`${date}T12:00:00.000Z`, `${date}T12:00:00.000Z`, taskId);
  db.close();
  return taskId;
}

async function seedCalendarEvent(page: Page, spaceId: string, date: string, title: string, endDate?: string) {
  const created = await page.request.post(`/api/local/spaces/${spaceId}/calendar/events`, {
    data: { date, end_date: endDate, title },
  });
  expect(created.ok()).toBeTruthy();
  return (await created.json()).id as number;
}

test('space calendar: tab renders month grid + month nav', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  await createAndOpenCaseSpace(page, 'E2Eカレンダー表示');

  await openSpaceTab(page, 'calendar');
  await expect(page.getByTestId('space-calendar')).toBeVisible();
  await expect(page.getByTestId('space-cal-grid')).toBeVisible();

  // Today's cell is present in the current-month grid.
  const today = e2eLocalToday();
  await expect(page.getByTestId(`space-cal-day-${today}`)).toBeVisible();

  // Month nav changes the YYYY年M月 header. Capture, step forward, assert it
  // differs, step back, assert it returns.
  const title = page.getByTestId('space-cal-title');
  const initial = (await title.textContent())?.trim();
  expect(initial).toMatch(/\d{4}年\d{1,2}月/);
  await page.getByTestId('space-cal-next').click();
  await expect(title).not.toHaveText(initial!);
  await page.getByTestId('space-cal-prev').click();
  await expect(title).toHaveText(initial!);

  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

test('space calendar: add event → list + day badge + persists across reload', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  await createAndOpenCaseSpace(page, 'E2Eカレンダー予定');

  await openSpaceTab(page, 'calendar');
  await expect(page.getByTestId('space-cal-grid')).toBeVisible();

  const today = e2eLocalToday();
  const todayCell = page.getByTestId(`space-cal-day-${today}`);
  // Baseline: today's event count badge (📌N) is absent before adding.
  await expect(todayCell.getByText(/^📌/)).toHaveCount(0);

  // Open today's day panel and add an event.
  await todayCell.click();
  const panel = page.getByTestId('space-cal-day-panel');
  await expect(panel).toBeVisible();

  await panel.getByTestId('space-cal-add-event-btn').click();
  const form = page.getByTestId('space-cal-add-event');
  await expect(form).toBeVisible();
  const eventTitle = `打合せ-${Date.now()}`;
  await form.getByTestId('space-cal-event-title').fill(eventTitle);
  await form.getByTestId('space-cal-event-time').fill('14:30');
  await form.getByTestId('space-cal-event-description').fill('E2E: テスト予定');
  await form.getByTestId('space-cal-event-save').click();

  // The new event appears in the 予定 list (with its time) after invalidation.
  await expect(panel.getByText(eventTitle, { exact: true })).toBeVisible({ timeout: 10_000 });
  await expect(panel.getByText('14:30')).toBeVisible();

  // Grab the event id from its panel row so we can assert both month-grid
  // indicators by id (a single-day event drives TWO separate render paths).
  const row = panel.locator('[data-testid^="space-cal-event-"]').filter({ hasText: eventTitle }).first();
  const eventId = (await row.getAttribute('data-testid'))!.replace('space-cal-event-', '');
  expect(eventId).toMatch(/^\d+$/);

  // Month grid shows BOTH indicators for the single-day event:
  //  - the 📌1 day-cell badge (counts.eventCount path, added in #808 / #804).
  //    exact:true so it pins count===1, not a substring of 📌1x.
  //  - a colSpan-1 week bar (layoutWeekBars path) — a separate code path, so
  //    assert it explicitly (a badge-only check would miss a phantom-bar bug).
  await expect(todayCell.getByText('📌1', { exact: true })).toBeVisible({ timeout: 10_000 });
  await expect(page.getByTestId(`space-cal-bar-${eventId}`)).toBeVisible({ timeout: 10_000 });

  // Persists across a full reload (server-backed, not just client state):
  // day-cell badge, week bar, and the day-panel event all come back.
  await page.reload();
  await openSpaceTab(page, 'calendar');
  await expect(page.getByTestId(`space-cal-day-${today}`).getByText('📌1', { exact: true })).toBeVisible({ timeout: 10_000 });
  await expect(page.getByTestId(`space-cal-bar-${eventId}`)).toBeVisible({ timeout: 10_000 });
  await page.getByTestId(`space-cal-day-${today}`).click();
  await expect(page.getByTestId('space-cal-day-panel').getByText(eventTitle, { exact: true })).toBeVisible({ timeout: 10_000 });

  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

test('space calendar: edit + delete an event', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  await createAndOpenCaseSpace(page, 'E2Eカレンダー編集');

  await openSpaceTab(page, 'calendar');
  const today = e2eLocalToday();
  const todayCell = page.getByTestId(`space-cal-day-${today}`);
  await todayCell.click();
  const panel = page.getByTestId('space-cal-day-panel');
  await expect(panel).toBeVisible();

  // Create one event.
  await panel.getByTestId('space-cal-add-event-btn').click();
  const origTitle = `元タイトル-${Date.now()}`;
  await page.getByTestId('space-cal-event-title').fill(origTitle);
  await page.getByTestId('space-cal-event-save').click();
  await expect(panel.getByText(origTitle, { exact: true })).toBeVisible({ timeout: 10_000 });

  // Grab the rendered event id from its row testid (space-cal-event-{id}).
  const row = panel.locator('[data-testid^="space-cal-event-"]').filter({ hasText: origTitle }).first();
  const rowTestId = await row.getAttribute('data-testid');
  const eventId = rowTestId!.replace('space-cal-event-', '');
  expect(eventId).toMatch(/^\d+$/);

  // Edit: open the edit form, change the title, save.
  await panel.getByTestId(`space-cal-event-edit-${eventId}`).click();
  const newTitle = `編集後-${Date.now()}`;
  await page.getByTestId('space-cal-event-title').fill(newTitle);
  await page.getByTestId('space-cal-event-save').click();
  await expect(panel.getByText(newTitle, { exact: true })).toBeVisible({ timeout: 10_000 });
  await expect(panel.getByText(origTitle, { exact: true })).toHaveCount(0);
  // While the event exists the day cell carries both month-grid indicators:
  // the 📌1 badge (eventCount path) and the colSpan-1 week bar (layoutWeekBars
  // path). Assert both so a regression in either path is caught.
  await expect(todayCell.getByText('📌1', { exact: true })).toBeVisible({ timeout: 10_000 });
  await expect(page.getByTestId(`space-cal-bar-${eventId}`)).toBeVisible({ timeout: 10_000 });

  // Delete: confirm the window.confirm() then assert the row disappears and
  // BOTH month-grid indicators clear (badge tracks eventCount, bar comes from
  // the events array — separate paths, so a delete could orphan one).
  page.once('dialog', (d) => d.accept());
  await panel.getByTestId(`space-cal-event-delete-${eventId}`).click();
  await expect(panel.getByTestId(`space-cal-event-${eventId}`)).toHaveCount(0, { timeout: 10_000 });
  await expect(todayCell.getByText(/^📌/)).toHaveCount(0, { timeout: 10_000 });
  await expect(page.getByTestId(`space-cal-bar-${eventId}`)).toHaveCount(0, { timeout: 10_000 });

  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

test('space calendar: day panel lists tasks created in the space', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  await createAndOpenCaseSpace(page, 'E2Eカレンダータスク');

  // Create an inline chat (task) in this space — it is created "today", so it
  // must surface in today's calendar day panel タスク section.
  const { taskId } = await startInlineChat(page, 'E2E: カレンダー日詳細用のタスク。');
  expect(taskId).toBeTruthy();

  // Switch to the calendar tab and open today's cell.
  await openSpaceTab(page, 'calendar');
  await expect(page.getByTestId('space-cal-grid')).toBeVisible();
  const today = e2eLocalToday();
  const todayCell = page.getByTestId(`space-cal-day-${today}`);
  // The task badge (💬N) should be present for today.
  await expect(todayCell.getByText(/^💬/)).toBeVisible({ timeout: 10_000 });
  await todayCell.click();

  const panel = page.getByTestId('space-cal-day-panel');
  await expect(panel).toBeVisible();
  // The created task is listed and clicking it opens the chat (switches tab).
  const taskBtn = panel.getByTestId(`space-cal-task-${taskId}`);
  await expect(taskBtn).toBeVisible({ timeout: 10_000 });
  await taskBtn.click();
  await expect(page.getByTestId('space-conversation')).toBeVisible();
  await expect(page).toHaveURL(/[?&]chat=\d+/);

  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

test('space calendar: adjacent month days show badges, details, and spanning bars', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  await page.clock.setFixedTime(ADJACENT_MONTH_CLOCK);
  const { spaceId } = await createAndOpenCaseSpace(page, 'E2E個別隣接月');
  const first = ADJACENT_MONTH_FIRST;
  const last = ADJACENT_MONTH_LAST;

  const firstTaskId = await seedCalendarTaskDate(page, spaceId, first, `個別先頭タスク-${Date.now()}`);
  const lastTaskId = await seedCalendarTaskDate(page, spaceId, last, `個別末尾タスク-${Date.now()}`);
  const firstEvent = `個別先頭予定-${Date.now()}`;
  const lastEvent = `個別末尾予定-${Date.now()}`;
  await seedCalendarEvent(page, spaceId, first, firstEvent);
  await seedCalendarEvent(page, spaceId, last, lastEvent);
  const spanningEvent = `個別両境界予定-${Date.now()}`;
  const spanningId = await seedCalendarEvent(page, spaceId, first, spanningEvent, last);

  await openSpaceTab(page, 'calendar');
  const firstCell = page.getByTestId(`space-cal-day-${first}`);
  const lastCell = page.getByTestId(`space-cal-day-${last}`);
  await expect(firstCell.getByText('💬1', { exact: true })).toBeVisible({ timeout: 10_000 });
  await expect(firstCell.getByText('📌2', { exact: true })).toBeVisible();
  await expect(lastCell.getByText('💬1', { exact: true })).toBeVisible();
  await expect(lastCell.getByText('📌2', { exact: true })).toBeVisible();
  await expect(page.getByTestId(`space-cal-bar-${spanningId}`)).toHaveCount(6);

  await firstCell.click();
  const panel = page.getByTestId('space-cal-day-panel');
  await expect(panel.getByTestId(`space-cal-task-${firstTaskId}`)).toBeVisible();
  await expect(panel.getByText(firstEvent, { exact: true })).toBeVisible();
  await expect(panel.getByText(spanningEvent, { exact: true })).toBeVisible();
  await lastCell.click();
  await expect(panel.getByTestId(`space-cal-task-${lastTaskId}`)).toBeVisible();
  await expect(panel.getByText(lastEvent, { exact: true })).toBeVisible();
  await expect(panel.getByText(spanningEvent, { exact: true })).toBeVisible();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// ── Space members panel (feat/shared-space, stage 3) ─────────────────────────
//
// The 設定 → メンバー sub-tab renders SpaceMembersPanel. Membership management
// (invite/role/remove) is gated on canManage, which in the E2E env (auth OFF)
// resolves to TRUE: useAuthState() is `disabled`, so the synthetic 'local' user
// can manage. The invite button therefore renders.
//
// ENV NOTE — no owner row in this harness: a case space created under no-auth is
// stored with owner_id = NULL (POST /api/local/spaces: `viewer.id === 'local' ?
// null : viewer.id`), and that space owns no space_members rows yet. The members
// GET only synthesizes an owner row when space.ownerId is set, so under no-auth
// the list is legitimately empty — there is no real user identity to attribute
// the owner row to. We therefore assert the realistic no-auth surface: the panel
// mounts, the empty list is handled without a crash, and the invite flow shows
// the no-auth sharing hint (pickable returns [] -> "認証を有効化すると…"). The
// owner-badge / role-select / remove controls are exercised by the API + (auth-on)
// component tests; they cannot be reached in this auth-off harness. A future
// auth-on harness (a second seeded user) would assert invite -> member appears.
//
// /api/users/pickable returns 200 with [] in no-auth (mirrors /api/admin/users),
// so it is NOT a fatal HTTP error — the shared SPACE_BENIGN_PATHS set is enough.
test('space settings MEMBERS: panel renders + invite shows no-auth hint', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);

  await createAndOpenCaseSpace(page, 'E2Eメンバー');
  await openSpaceTab(page, 'settings');

  // メンバー sub-tab → the panel mounts with its header.
  await page.getByTestId('space-settings-nav-members').click();
  const panel = page.getByTestId('space-members-panel');
  await expect(panel).toBeVisible({ timeout: 15_000 });
  await expect(panel.getByRole('heading', { name: 'メンバー' })).toBeVisible();

  // canManage is true (no-auth), so the invite button renders. Clicking it opens
  // the picker, which — with an empty pickable list — shows the no-auth sharing
  // hint instead of a user list.
  const inviteBtn = panel.getByTestId('space-member-invite');
  await expect(inviteBtn).toBeVisible();
  await inviteBtn.click();
  const picker = panel.getByTestId('space-member-picker');
  await expect(picker).toBeVisible({ timeout: 15_000 });
  await expect(picker.getByText('認証を有効化するとワークスペースを共有できます。')).toBeVisible();

  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// ── Space source library (feat/space-source-library, stage 2) ────────────────
//
// The Files tab now renders a curated "ソース" group at the top (testid
// space-sources) sourced from source/index.jsonl. Two surfaces are observable
// WITHOUT an LLM:
//   1. EMPTY-STATE: a fresh space has no source/index.jsonl → the GET on
//      .../files/content?path=source/index.jsonl 404s, fetchSpaceSourceIndex
//      swallows it and returns [], and the group shows the empty hint.
//      NOTE: that 404 is EXPECTED here, so we use a local response tracker that
//      treats the space source-index content 404 as benign (the shared
//      trackFatalErrors would otherwise flag it; SPACE_BENIGN_ASSET only covers
//      .json, not .jsonl).
//   2. POPULATED: we seed source/research.md + source/index.jsonl via the space
//      file upload API (POST /files/upload, path=source), then assert the group
//      lists the entry with its title and origin host.
const b64 = (s: string) => Buffer.from(s, 'utf8').toString('base64');

// The curated ソース list view was removed (#6): a fresh space's ファイル tab no
// longer renders the source list or its empty-state. (Previously this asserted
// the empty-state was visible; now it must be ABSENT.) The Files grid renders
// instead, and the UI no longer fetches source/index.jsonl on open.
test('space sources: curated ソース list view (incl. empty-state) is absent on a fresh space', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);

  await createAndOpenCaseSpace(page, 'E2Eソース空');
  await page.getByTestId('space-tab-files').click();

  // The Files grid renders, but the old ソース list view + its empty-state are gone.
  await expect(page.getByTestId('space-files-grid')).toBeVisible({ timeout: 15_000 });
  await expect(page.getByTestId('space-sources')).toHaveCount(0);
  await expect(page.getByTestId('space-sources-empty')).toHaveCount(0);

  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// The curated ソース list view was removed (#6). The source/ folder + its
// index.jsonl provenance STILL accumulate (agent WebFetch/DownloadFile → source/),
// but the Files UI no longer renders a special list — source/ is just a normal
// folder in the grid. This test proves: (1) the seeded source/ upload succeeds,
// (2) the old space-sources list view is gone, (3) source/ is browsable as a
// regular folder and its file shows up there.
test('space sources: source/ folder still accumulates and is browsable; curated ソース list view removed', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);

  const { spaceId } = await createAndOpenCaseSpace(page, 'E2Eソース');

  // Seed a source file + provenance index into the space's source/ dir via the
  // same upload API the Files tab uses (path=source places files under source/).
  const indexLine = JSON.stringify({
    file: 'research.md',
    url: 'https://example.com/article',
    title: 'リサーチ記事タイトル',
    fetched_at: '2026-06-19T10:00:00Z',
    tool: 'WebFetch',
    bytes: 2048,
  });
  const upRes = await page.request.post(`/api/local/spaces/${spaceId}/files/upload`, {
    data: {
      path: 'source',
      files: [
        { name: 'research.md', contentBase64: b64('# 調査結果\n\n本文。') },
        { name: 'index.jsonl', contentBase64: b64(`${indexLine}\n`) },
      ],
    },
  });
  expect(upRes.status(), `upload failed: ${upRes.status()} ${await upRes.text()}`).toBe(200);

  // Open the Files tab. The curated ソース list view (#6) is GONE.
  await page.getByTestId('space-tab-files').click();
  await expect(page.getByTestId('space-files-grid')).toBeVisible({ timeout: 15_000 });
  await expect(page.getByTestId('space-sources')).toHaveCount(0);

  // source/ appears as a normal folder tile; navigate into it.
  const sourceDir = page.locator('[data-testid="space-file-tile"][data-kind="directory"][data-name="source"]');
  await expect(sourceDir).toBeVisible({ timeout: 15_000 });
  await sourceDir.click();

  // The seeded research.md shows in the source/ folder (index.jsonl stays hidden
  // — it is filtered out of the raw file window as before).
  await expect(
    page.locator('[data-testid="space-file-tile"][data-kind="file"][data-name="research.md"]'),
  ).toBeVisible({ timeout: 15_000 });
  await expect(
    page.locator('[data-testid="space-file-tile"][data-name="index.jsonl"]'),
  ).toHaveCount(0);

  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// ── Space settings → ブラウザ section (workstream 2, stage 2) ─────────────────
//
// The 設定 sub-nav now carries a "ブラウザ" section (space-settings-nav-browser)
// rendering SpaceBrowserPanel: three groups — ブラウザセッション
// (space-browser-sessions), ブラウザマクロ (space-browser-macros), 録画
// (space-browser-recordings). All three are space-scoped (their fetches carry
// ?spaceId=<id>). In the auth-off harness there are no real sessions/macros/
// recordings for a fresh space, so we assert the panel mounts and each group
// shows its in-product empty state without a crash or fatal 4xx/5xx. The
// per-user-DEK "作成者のみ利用可" badge and management gating are exercised by the
// component/API tests; this render test guards against a regression that blanks
// the whole section.
//
// ENV NOTE — benign endpoints under no-auth: the panel lists profiles via
// GET /api/browser-sessions/profiles?spaceId=… and macros/recordings via
// GET /api/users/me/folder/{list}?subdir=…&spaceId=…. Under no-auth the synthetic
// 'local' user is the space owner, so these return 200 with empty arrays — no new
// benign paths are needed beyond the shared set. The add-session control renders
// because canManage is TRUE in the auth-off harness (useAuthState() = disabled).
test('space settings BROWSER: panel + three groups render with empty states', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);

  await createAndOpenCaseSpace(page, 'E2Eブラウザ');
  await openSpaceTab(page, 'settings');

  // The ブラウザ sub-tab is present and selecting it mounts SpaceBrowserPanel.
  const browserNav = page.getByTestId('space-settings-nav-browser');
  await expect(browserNav).toBeVisible();
  await browserNav.click();

  const panel = page.getByTestId('space-browser-panel');
  await expect(panel).toBeVisible({ timeout: 15_000 });

  // 1. セッション group: header + empty state.
  const sessions = page.getByTestId('space-browser-sessions');
  await expect(sessions).toBeVisible();
  await expect(sessions.getByRole('heading', { name: 'ブラウザセッション' })).toBeVisible();
  await expect(sessions).toContainText('このワークスペースにはまだブラウザセッションがありません');
  // canManage (no-auth) → the add-session control renders.
  await expect(page.getByTestId('space-browser-add-session')).toBeVisible();

  // 2. マクロ group: header + empty state.
  const macros = page.getByTestId('space-browser-macros');
  await expect(macros).toBeVisible();
  await expect(macros.getByRole('heading', { name: 'ブラウザマクロ' })).toBeVisible();
  await expect(macros).toContainText('このワークスペースにはまだブラウザマクロがありません');

  // 3. 録画 group: header + empty state.
  const recordings = page.getByTestId('space-browser-recordings');
  await expect(recordings).toBeVisible();
  await expect(recordings.getByRole('heading', { name: '録画' })).toBeVisible();
  await expect(recordings).toContainText('このワークスペースにはまだ録画がありません');

  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// ════════════════════════════════════════════════════════════════════════════
// Workspace management + file management (feat/workspace-files-mgmt).
//
// - File delete with multi-select in the ファイル tab (#8).
// - Workspace rename via the header pencil (#8).
// - Workspace (case) delete via the header trash → returns to the list (#8).
// - The curated ソース list view was removed (#6); source/ still accumulates as
//   a normal folder, but the SpaceSources list (data-testid="space-sources") is
//   gone from the Files UI.
// All run with auth disabled; no LLM needed (pure management UI).
// ════════════════════════════════════════════════════════════════════════════

test('space files DELETE: select a file and delete it (gone); ソース list view is removed', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  const { detail } = await createAndOpenCaseSpace(page, 'E2E削除');

  await page.getByTestId('space-tab-files').click();
  await expect(page.getByTestId('space-files-grid')).toBeVisible();

  // The curated ソース list view (#6) must NOT be rendered anymore.
  await expect(page.getByTestId('space-sources')).toHaveCount(0);

  // Upload a file so we have something to delete.
  await page
    .locator('[data-testid="space-files-upload-input"]')
    .setInputFiles({ name: 'delete-me.txt', mimeType: 'text/plain', buffer: Buffer.from('bye') });
  const tile = page.locator('[data-testid="space-file-tile"][data-kind="file"][data-name="delete-me.txt"]');
  await expect(tile).toBeVisible({ timeout: 15000 });

  // Select it via its checkbox → the bulk 削除 button appears.
  await page.getByTestId('space-file-select-delete-me.txt').check();
  const deleteSelected = page.getByTestId('space-files-delete-selected');
  await expect(deleteSelected).toBeVisible();

  // Accept the confirm() dialog guarding the destructive delete.
  page.once('dialog', (dialog) => { expect(dialog.type()).toBe('confirm'); void dialog.accept(); });
  await deleteSelected.click();

  // The tile disappears after the delete + refetch.
  await expect(tile).toHaveCount(0, { timeout: 15000 });

  // No-nav invariant.
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  await expect(detail).toBeVisible();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

test('space files DELETE: multi-select all + per-file trash icon', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  await createAndOpenCaseSpace(page, 'E2E複数削除');
  await page.getByTestId('space-tab-files').click();
  await expect(page.getByTestId('space-files-grid')).toBeVisible();

  // Upload two files.
  await page.locator('[data-testid="space-files-upload-input"]').setInputFiles([
    { name: 'one.txt', mimeType: 'text/plain', buffer: Buffer.from('1') },
    { name: 'two.txt', mimeType: 'text/plain', buffer: Buffer.from('2') },
  ]);
  await expect(
    page.locator('[data-testid="space-file-tile"][data-kind="file"][data-name="two.txt"]'),
  ).toBeVisible({ timeout: 15000 });

  // "Select all" checks both; the count reflects 2 選択中.
  await page.getByTestId('space-files-select-all').check();
  await expect(page.getByTestId('space-files-selected-count')).toContainText('2');

  // Delete the whole selection.
  page.once('dialog', (d) => void d.accept());
  await page.getByTestId('space-files-delete-selected').click();
  await expect(
    page.locator('[data-testid="space-file-tile"][data-kind="file"][data-name="one.txt"]'),
  ).toHaveCount(0, { timeout: 15000 });
  await expect(
    page.locator('[data-testid="space-file-tile"][data-kind="file"][data-name="two.txt"]'),
  ).toHaveCount(0);

  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

test('space files DOWNLOAD: bulk zip + per-tile download', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  await createAndOpenCaseSpace(page, 'E2Eダウンロード');
  await page.getByTestId('space-tab-files').click();
  await expect(page.getByTestId('space-files-grid')).toBeVisible();

  // Upload two files to download.
  await page.locator('[data-testid="space-files-upload-input"]').setInputFiles([
    { name: 'one.txt', mimeType: 'text/plain', buffer: Buffer.from('1') },
    { name: 'two.txt', mimeType: 'text/plain', buffer: Buffer.from('2') },
  ]);
  await expect(
    page.locator('[data-testid="space-file-tile"][data-kind="file"][data-name="two.txt"]'),
  ).toBeVisible({ timeout: 15000 });

  // Bulk: select all → ダウンロード → a single files.zip download fires.
  await page.getByTestId('space-files-select-all').check();
  const [zipDownload] = await Promise.all([
    page.waitForEvent('download'),
    page.getByTestId('space-files-download-selected').click(),
  ]);
  expect(zipDownload.suggestedFilename()).toBe('files.zip');

  // Per-tile: the download anchor downloads that single file (name preserved).
  const [single] = await Promise.all([
    page.waitForEvent('download'),
    page.getByTestId('space-file-download-one.txt').click(),
  ]);
  expect(single.suggestedFilename()).toBe('one.txt');

  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

test('space RENAME: header pencil renames the workspace and the title updates', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  const { detail, caseTitle, rail } = await createAndOpenCaseSpace(page, 'E2E改名');

  // Open the header pencil, which reuses the create/edit SpaceFormDialog
  // (space-title-input pre-filled with the current title, same submit button
  // as create). There is no dedicated inline rename input/save pair.
  await page.getByTestId('space-edit').click();
  const input = page.getByTestId('space-title-input');
  await expect(input).toBeVisible();
  const renamed = `${caseTitle}-改`;
  await input.fill(renamed);
  await page.getByTestId('space-form-submit').click();

  // The header reflects the new title, and the rail row updates too.
  await expect(detail).toContainText(renamed);
  await expect(
    rail.locator('[data-testid="space-row"][data-space-kind="case"]').filter({ hasText: renamed }),
  ).toBeVisible({ timeout: 15000 });

  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

test('space DELETE: case workspace delete returns to the list (selection cleared)', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  const { caseTitle, rail } = await createAndOpenCaseSpace(page, 'E2EWS削除');

  // Click the header trash → inline confirm → 削除する.
  await page.getByTestId('space-delete').click();
  const confirm = page.getByTestId('space-delete-confirm');
  await expect(confirm).toBeVisible();
  await confirm.click();

  // The space row disappears from the rail and the selection is cleared
  // (space= URL param dropped → back to the list / empty detail).
  await expect(
    rail.locator('[data-testid="space-row"][data-space-kind="case"]').filter({ hasText: caseTitle }),
  ).toHaveCount(0, { timeout: 15000 });
  await expect.poll(() => new URL(page.url()).searchParams.get('space')).toBeFalsy();

  // Still on Spaces, never bounced to Tasks.
  expect(new URL(page.url()).searchParams.get('page')).toBeFalsy();
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

// ── Workspace apps tab (feat/workspace-apps-stage2) ──────────────────────────
// The "アプリ" tab lists apps = subfolders under apps/ that contain an
// index.html, reading an optional app.json for title/description, and launches
// the selected one in the sandboxed AppRunner.

test('space apps: empty-state on a fresh workspace', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  await createAndOpenCaseSpace(page, 'E2EApps空');

  await openSpaceTab(page, 'apps');
  await expect(page.getByTestId('space-apps')).toBeVisible();
  // A fresh case workspace has no apps/ folder → in-product empty-state.
  await expect(page.getByTestId('space-apps-empty')).toBeVisible({ timeout: 15_000 });
  await expect(page.getByTestId('space-apps-empty')).toContainText('ワークスペース・アプリを作って');
  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});

test('space apps: seeded app lists with its title and opens in the AppRunner', async ({ page }) => {
  const fatalErrors = trackFatalErrors(page);
  const { spaceId } = await createAndOpenCaseSpace(page, 'E2EApps起動');

  // Seed apps/demo/index.html (+ app.json) via the restricted write endpoint
  // (only apps/ + output/ are writable, which is exactly where apps live).
  const html =
    '<!doctype html><meta charset="utf-8"><title>demo</title>' +
    '<body><h1 id="hdr">デモアプリ</h1><script>document.getElementById("hdr").textContent="ready";</script>';
  const w1 = await page.request.post(`/api/local/spaces/${spaceId}/files/write`, {
    data: { path: 'apps/demo/index.html', content: html },
  });
  expect(w1.ok()).toBeTruthy();
  const w2 = await page.request.post(`/api/local/spaces/${spaceId}/files/write`, {
    data: {
      path: 'apps/demo/app.json',
      content: JSON.stringify({ title: 'デモ・アプリ', description: '起動テスト用' }),
    },
  });
  expect(w2.ok()).toBeTruthy();

  // Open the アプリ tab and assert the seeded app appears with its manifest title.
  await openSpaceTab(page, 'apps');
  await expect(page.getByTestId('space-apps')).toBeVisible();
  const card = page.getByTestId('space-app-demo');
  await expect(card).toBeVisible({ timeout: 15_000 });
  await expect(card).toContainText('デモ・アプリ');
  await expect(card).toContainText('起動テスト用');

  // 開く → AppRunner mounts (sandbox iframe overlay).
  await page.getByTestId('space-app-open-demo').click();
  await expect(page.getByTestId('app-runner')).toBeVisible({ timeout: 15_000 });

  expect(fatalErrors, `fatal errors:\n${fatalErrors.join('\n')}`).toEqual([]);
});