diff --git a/apps/api/src/routes/runtime-settings.test.ts b/apps/api/src/routes/runtime-settings.test.ts
index 79959110..c0573cb6 100644
--- a/apps/api/src/routes/runtime-settings.test.ts
+++ b/apps/api/src/routes/runtime-settings.test.ts
@@ -29,6 +29,7 @@ describe('GET /api/runtime/settings', () => {
     expect(body.settings.temperature).toBeNull();
     expect(body.settings.top_p).toBeNull();
     expect(body.settings.repeat_penalty).toBeNull();
+    expect(body.settings.reply_speed).toBeNull();
   });
 
   it('returns requires_restart: false on initial GET', async () => {
@@ -47,6 +48,7 @@ describe('GET /api/runtime/settings', () => {
       temperature: null,
       top_p: null,
       repeat_penalty: null,
+      reply_speed: null,
     });
   });
 });
@@ -314,6 +316,79 @@ describe('POST /api/runtime/settings/reset', () => {
   });
 });
 
+// ── Reply speed (issue #501) ─────────────────────────────────────────────────
+
+describe('runtime settings — reply_speed', () => {
+  it('persists a chosen speed', async () => {
+    const res = await app.inject({
+      method: 'PUT',
+      url: '/api/runtime/settings',
+      payload: { reply_speed: 'fast' },
+    });
+    expect(res.statusCode).toBe(200);
+    expect(res.json<RuntimeSettingsResponse>().settings.reply_speed).toBe('fast');
+
+    const get = await app.inject({ method: 'GET', url: '/api/runtime/settings' });
+    expect(get.json<RuntimeSettingsResponse>().settings.reply_speed).toBe('fast');
+  });
+
+  it('returns requires_restart: false — it is read per turn', async () => {
+    const res = await app.inject({
+      method: 'PUT',
+      url: '/api/runtime/settings',
+      payload: { reply_speed: 'detailed' },
+    });
+    expect(res.json<RuntimeSettingsResponse>().requires_restart).toBe(false);
+  });
+
+  it('returns 422 for a speed the UI cannot render', async () => {
+    const res = await app.inject({
+      method: 'PUT',
+      url: '/api/runtime/settings',
+      payload: { reply_speed: 'ludicrous' },
+    });
+    expect(res.statusCode).toBe(422);
+    expect(res.json<{ message: string }>().message).toMatch(/Reply speed/);
+  });
+
+  it('survives a partial update of the numeric settings', async () => {
+    await app.inject({
+      method: 'PUT',
+      url: '/api/runtime/settings',
+      payload: { reply_speed: 'fast' },
+    });
+    await app.inject({
+      method: 'PUT',
+      url: '/api/runtime/settings',
+      payload: { threads: 4 },
+    });
+    const res = await app.inject({ method: 'GET', url: '/api/runtime/settings' });
+    const body = res.json<RuntimeSettingsResponse>();
+    expect(body.settings.reply_speed).toBe('fast');
+    expect(body.settings.threads).toBe(4);
+  });
+
+  it('is cleared by reset', async () => {
+    await app.inject({
+      method: 'PUT',
+      url: '/api/runtime/settings',
+      payload: { reply_speed: 'fast' },
+    });
+    const res = await app.inject({ method: 'POST', url: '/api/runtime/settings/reset' });
+    expect(res.json<RuntimeSettingsResponse>().settings.reply_speed).toBeNull();
+  });
+
+  it('reads a stored value it does not recognise back as unset', async () => {
+    // A value a newer build wrote, or one hand-edited into the database, must
+    // not surface as an option the UI cannot render.
+    getDb()
+      .prepare('INSERT OR REPLACE INTO model_config (key, value) VALUES (?, ?)')
+      .run('setting.reply_speed', 'hypersonic');
+    const res = await app.inject({ method: 'GET', url: '/api/runtime/settings' });
+    expect(res.json<RuntimeSettingsResponse>().settings.reply_speed).toBeNull();
+  });
+});
+
 // ── Persistence across buildApp calls (simulating restarts) ──────────────────
 
 describe('runtime settings — persistence across restarts', () => {
diff --git a/apps/api/src/routes/runtime-settings.ts b/apps/api/src/routes/runtime-settings.ts
index bf94f207..d75c0372 100644
--- a/apps/api/src/routes/runtime-settings.ts
+++ b/apps/api/src/routes/runtime-settings.ts
@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 import type { FastifyInstance } from 'fastify';
 import { getDb } from '../db.js';
+import { REPLY_SPEEDS, isReplySpeed } from '@convsim/shared';
 import type {
+  ReplySpeed,
   RuntimeSettings,
   RuntimeSettingsResponse,
   RuntimeSettingsRequest,
@@ -15,8 +17,11 @@ const SETTING_KEYS: (keyof RuntimeSettings)[] = [
   'temperature',
   'top_p',
   'repeat_penalty',
+  'reply_speed',
 ];
 
+// reply_speed is deliberately absent: it is read per turn, so a change applies
+// to the player's very next message with no restart.
 const RESTART_REQUIRED: Set<keyof RuntimeSettings> = new Set(['context_length', 'gpu_layers']);
 
 const NULL_SETTINGS: RuntimeSettings = {
@@ -26,6 +31,7 @@ const NULL_SETTINGS: RuntimeSettings = {
   temperature: null,
   top_p: null,
   repeat_penalty: null,
+  reply_speed: null,
 };
 
 interface ModelConfigRow { key: string; value: string }
@@ -45,6 +51,13 @@ export function loadRuntimeSettings(): RuntimeSettings {
     return isNaN(n) ? null : n;
   }
 
+  function speed(k: string): ReplySpeed | null {
+    // A value a newer build wrote, or one hand-edited into the database, must
+    // not surface as an option the UI cannot render.
+    const v = map[k];
+    return isReplySpeed(v) ? v : null;
+  }
+
   return {
     context_length: num('context_length'),
     gpu_layers: num('gpu_layers'),
@@ -52,6 +65,7 @@ export function loadRuntimeSettings(): RuntimeSettings {
     temperature: num('temperature'),
     top_p: num('top_p'),
     repeat_penalty: num('repeat_penalty'),
+    reply_speed: speed('reply_speed'),
   };
 }
 
@@ -126,6 +140,16 @@ function validate(req: RuntimeSettingsRequest): RuntimeSettingsFieldError[] {
     }
   }
 
+  const speed = req.reply_speed;
+  if (speed !== null && speed !== undefined) {
+    if (!isReplySpeed(speed)) {
+      errs.push({
+        field: 'reply_speed',
+        message: `Reply speed must be one of: ${[...REPLY_SPEEDS].sort().join(', ')}.`,
+      });
+    }
+  }
+
   return errs;
 }
 
@@ -159,6 +183,7 @@ export async function runtimeSettingsRoutes(app: FastifyInstance): Promise<void>
             temperature: { type: ['number', 'null'] },
             top_p: { type: ['number', 'null'] },
             repeat_penalty: { type: ['number', 'null'] },
+            reply_speed: { type: ['string', 'null'] },
           },
         },
       },
diff --git a/apps/api/src/routes/sessions.test.ts b/apps/api/src/routes/sessions.test.ts
index cafc4792..ff66b8f9 100644
--- a/apps/api/src/routes/sessions.test.ts
+++ b/apps/api/src/routes/sessions.test.ts
@@ -85,6 +85,62 @@ describe('GET /api/sessions', () => {
     const res = await app.inject({ method: 'GET', url: '/api/sessions' });
     expect(res.json<{ sessions: unknown[] }>().sessions).toHaveLength(0);
   });
+
+  // ── status / limit (issue #501 §1) ────────────────────────────────────────
+  // The resume affordances ask for `status=in_progress&limit=1` and offer
+  // whatever comes back as "Conversation in progress". A listing that ignored
+  // the filter would offer to resume a conversation that had already ended, so
+  // this proxy honours the same contract convsim-core serves.
+
+  async function createInState(state: string): Promise<string> {
+    const r = await app.inject({ method: 'POST', url: '/api/sessions', payload: validRequest });
+    const { session_id } = r.json<SessionCreateResponse>();
+    getDb().prepare('UPDATE sessions SET state = ? WHERE session_id = ?').run(state, session_id);
+    return session_id;
+  }
+
+  it('status=in_progress returns only sessions that can be resumed', async () => {
+    const live = await createInState('PlayerTurnListening');
+    await createInState('NotStarted');
+    await createInState('Ended');
+
+    const res = await app.inject({ method: 'GET', url: '/api/sessions?status=in_progress' });
+    const { sessions } = res.json<{ sessions: SessionCreateResponse[] }>();
+    expect(sessions.map((s) => s.session_id)).toEqual([live]);
+  });
+
+  it('status=ended covers the debrief states, not just Ended', async () => {
+    const ended = await createInState('Ended');
+    const generating = await createInState('DebriefGenerating');
+    const ready = await createInState('DebriefReady');
+    const errored = await createInState('Error');
+    await createInState('PlayerTurnListening');
+
+    const res = await app.inject({ method: 'GET', url: '/api/sessions?status=ended' });
+    const { sessions } = res.json<{ sessions: SessionCreateResponse[] }>();
+    expect(sessions.map((s) => s.session_id).sort()).toEqual(
+      [ended, generating, ready, errored].sort(),
+    );
+  });
+
+  it('limit caps the listing, newest first', async () => {
+    await createInState('PlayerTurnListening');
+    const newest = await createInState('PlayerTurnListening');
+
+    const res = await app.inject({ method: 'GET', url: '/api/sessions?limit=1' });
+    const { sessions } = res.json<{ sessions: SessionCreateResponse[] }>();
+    expect(sessions.map((s) => s.session_id)).toEqual([newest]);
+  });
+
+  it('rejects an out-of-range limit and an unknown status', async () => {
+    expect((await app.inject({ method: 'GET', url: '/api/sessions?limit=0' })).statusCode).toBe(400);
+    expect((await app.inject({ method: 'GET', url: '/api/sessions?limit=501' })).statusCode).toBe(
+      400,
+    );
+    expect((await app.inject({ method: 'GET', url: '/api/sessions?status=live' })).statusCode).toBe(
+      400,
+    );
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -272,6 +328,29 @@ describe('GET /api/sessions/:session_id', () => {
     });
     expect(res.statusCode).toBe(404);
   });
+
+  it('reports the meter values a resuming screen has to redraw', async () => {
+    // Issue #501 §1: meter values otherwise only ever arrive with a turn, so a
+    // player who stepped out of a conversation and came back saw no meters at
+    // all until they sent another message.
+    const createRes = await app.inject({
+      method: 'POST',
+      url: '/api/sessions',
+      payload: validRequest,
+    });
+    const { session_id } = createRes.json<SessionCreateResponse>();
+    await app.inject({ method: 'POST', url: `/api/sessions/${session_id}/start` });
+    await app.inject({
+      method: 'POST',
+      url: `/api/sessions/${session_id}/turn`,
+      payload: { content: 'Hello there.' },
+    });
+
+    const getRes = await app.inject({ method: 'GET', url: `/api/sessions/${session_id}` });
+    const body = getRes.json<SessionCreateResponse>();
+    expect(body.visible_state).toBeTruthy();
+    expect(Object.keys(body.visible_state ?? {}).length).toBeGreaterThan(0);
+  });
 });
 
 // ---------------------------------------------------------------------------
diff --git a/apps/api/src/routes/sessions.ts b/apps/api/src/routes/sessions.ts
index 7cfc05f0..66eb9632 100644
--- a/apps/api/src/routes/sessions.ts
+++ b/apps/api/src/routes/sessions.ts
@@ -11,6 +11,9 @@ import type {
   SessionTranscriptResponse,
   EndingType,
 } from '@convsim/shared';
+// The resumable / ended partition lives in @convsim/shared so this listing and
+// the Settings screen that reads it cannot drift apart (issue #501 §1).
+import { ENDED_SESSION_STATES, RESUMABLE_SESSION_STATES } from '@convsim/shared';
 import { findScenarioInfo } from './scenarios.js';
 import { getDb, WORKBENCH_TEST_SCENARIO_ID } from '../db.js';
 import { broadcast, closeSessionSockets } from '../ws/session-events.js';
@@ -163,16 +166,48 @@ function rejectTransition(reply: { status: (code: number) => void }, state: Sess
 
 export async function sessionRoutes(app: FastifyInstance) {
   // GET /api/sessions
-  app.get('/api/sessions', async (): Promise<{ sessions: SessionCreateResponse[] }> => {
+  app.get<{ Querystring: { status?: string; limit?: string } }>(
+    '/api/sessions',
+    async (request, reply): Promise<{ sessions: SessionCreateResponse[] }> => {
     const db = getDb();
+    // `status` and `limit` are the same contract convsim-core serves
+    // (issue #501 §1). Honouring them here is not cosmetic: the resume
+    // affordances ask for `status=in_progress&limit=1` and offer whatever comes
+    // back as "Conversation in progress", so a listing that silently ignored
+    // the filter would offer to resume a conversation that has already ended.
+    const status = request.query.status ?? 'all';
+    if (status !== 'all' && status !== 'in_progress' && status !== 'ended') {
+      reply.status(400);
+      throw new Error("status must be one of: all, ended, in_progress");
+    }
+    const limit = request.query.limit === undefined ? 50 : Number(request.query.limit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 500) {
+      reply.status(400);
+      throw new Error('limit must be between 1 and 500');
+    }
+
     // Exclude temporary workbench test sessions so they never pollute the
     // player's session history (they are cleaned up on discard/reset/unmount,
     // but a lingering row must not surface here either).
+    const states =
+      status === 'in_progress'
+        ? RESUMABLE_SESSION_STATES
+        : status === 'ended'
+          ? ENDED_SESSION_STATES
+          : null;
+    const clauses = ['scenario_id != ?'];
+    const params: (string | number)[] = [WORKBENCH_TEST_SCENARIO_ID];
+    if (states !== null) {
+      clauses.push(`state IN (${states.map(() => '?').join(', ')})`);
+      params.push(...states);
+    }
+    params.push(limit);
     const rows = db
-      .prepare<[string], SessionRow>(
-        'SELECT * FROM sessions WHERE scenario_id != ? ORDER BY created_at DESC, rowid DESC',
+      .prepare<(string | number)[], SessionRow>(
+        `SELECT * FROM sessions WHERE ${clauses.join(' AND ')} ` +
+          'ORDER BY created_at DESC, rowid DESC LIMIT ?',
       )
-      .all(WORKBENCH_TEST_SCENARIO_ID);
+      .all(...params);
     return {
       sessions: rows.map((row) => ({
         session_id: row.session_id,
@@ -185,7 +220,8 @@ export async function sessionRoutes(app: FastifyInstance) {
         setup: JSON.parse(row.setup_json) as SessionCreateRequest,
       })),
     };
-  });
+  },
+  );
 
   // POST /api/sessions
   app.post<{ Body: SessionCreateRequest }>(
@@ -299,6 +335,13 @@ export async function sessionRoutes(app: FastifyInstance) {
         state: row.state as SessionState,
         created_at: row.created_at,
         setup: JSON.parse(row.setup_json) as SessionCreateRequest,
+        // A resuming conversation screen draws its meters from here
+        // (issue #501 §1): meter values otherwise only ever arrive with a turn,
+        // so without them a player who stepped out and came back saw no meters
+        // until they sent another message. Mirrors convsim-core's single-session
+        // response; this layer does not model per-variable visibility, so every
+        // tracked variable is reported.
+        visible_state: JSON.parse(row.state_vars_json || '{}') as Record<string, number>,
       };
     },
   );
diff --git a/apps/web/src/__tests__/App.test.tsx b/apps/web/src/__tests__/App.test.tsx
index 6b3471ab..8ccc5f6c 100644
--- a/apps/web/src/__tests__/App.test.tsx
+++ b/apps/web/src/__tests__/App.test.tsx
@@ -83,7 +83,9 @@ describe('App shell', () => {
   it('renders Conversation at /conversation/:id', () => {
     renderAt('/conversation/sess-001')
     expect(screen.getByRole('heading', { name: /conversation/i })).toBeInTheDocument()
-    expect(screen.getByText(/sess-001/)).toBeInTheDocument()
+    // The session id is a technical-wording detail now (issue #501 §2), so the
+    // route is identified by the screen it mounted, not by the id in its header.
+    expect(screen.getByTestId('conversation-page')).toBeInTheDocument()
   })
 
   it('renders Debrief at /debrief/:id', () => {
@@ -111,13 +113,13 @@ describe('App shell', () => {
   it('shows healthy status when backend returns ok', async () => {
     mockFetch({ status: 'ok' })
     renderAt('/')
-    expect(await screen.findByText('Local runtime: Ready')).toBeInTheDocument()
+    expect(await screen.findByText('AI engine: Ready')).toBeInTheDocument()
   })
 
   it('shows unavailable status when backend is unreachable', async () => {
     vi.stubGlobal('fetch', vi.fn(() => Promise.reject(new Error('Network error'))))
     renderAt('/')
-    expect(await screen.findByText('Local runtime: Unavailable')).toBeInTheDocument()
+    expect(await screen.findByText('AI engine: Unavailable')).toBeInTheDocument()
   })
 })
 
diff --git a/apps/web/src/__tests__/Conversation.test.tsx b/apps/web/src/__tests__/Conversation.test.tsx
index 1561060a..6275aaaa 100644
--- a/apps/web/src/__tests__/Conversation.test.tsx
+++ b/apps/web/src/__tests__/Conversation.test.tsx
@@ -24,6 +24,9 @@ vi.mock('../api/client', () => ({
     getScenario: vi.fn(),
     getSetupInstallStatus: vi.fn(),
     getSessionTranscript: vi.fn(),
+    // Resume reads the recorded setup back when there is no route state
+    // (issue #501 §1), which is how most of these tests render the screen.
+    getSession: vi.fn(),
   },
   apiClient: {
     health: vi.fn(),
@@ -144,9 +147,20 @@ function renderConversation(routeState?: Record<string, unknown>) {
 
 beforeEach(() => {
   vi.clearAllMocks()
+  // Tests that opt into technical wording (or dev mode) write to localStorage,
+  // and jsdom keeps it between tests in the same file — so a later test would
+  // inherit the previous one's wording level.
+  localStorage.clear()
   // Default: connectSession returns a no-op connection; getScenario returns null
   mockApi.connectSession.mockReturnValue({ close: vi.fn() })
   mockApi.getScenario.mockResolvedValue({ ok: true, data: null } as never)
+  // Rendering without route state is the resume path, so the screen asks the
+  // core for the setup it recorded. Default to "unavailable": these tests are
+  // about the conversation, not about what the setup fetch adds.
+  mockApi.getSession.mockResolvedValue({
+    ok: false,
+    error: { kind: 'network', message: 'not mocked' },
+  } as never)
   mockApiClient.uploadAudio.mockResolvedValue({ ok: true, data: { transcript: null, status: 'unavailable' } })
   // The screen reads health to learn which model the turn estimate belongs to.
   mockApiClient.health.mockResolvedValue({ ok: true, data: healthResponse })
@@ -179,10 +193,25 @@ describe('Conversation screen', () => {
       await waitFor(() => expect(screen.getByRole('log')).toBeInTheDocument())
     })
 
-    it('shows the session id in the header', async () => {
+    it('keeps the session id and raw flow state out of the header by default', async () => {
+      // Issue #501 §2: "Session: sess-… | State: PlayerTurnListening" was the
+      // first thing a new player read on this screen.
+      mockApi.startSession.mockResolvedValue({ ok: true, data: startResponse })
+      renderConversation()
+      await waitFor(() =>
+        expect(screen.getByTestId('conversation-subhead')).toBeInTheDocument(),
+      )
+      expect(screen.queryByText(SESSION_ID)).not.toBeInTheDocument()
+      expect(screen.queryByText('PlayerTurnListening')).not.toBeInTheDocument()
+      expect(screen.getByTestId('conversation-subhead')).toHaveTextContent('Your turn')
+    })
+
+    it('shows the session id and raw flow state at the technical wording level', async () => {
+      localStorage.setItem('convsim.ui.languageLevel', 'technical')
       mockApi.startSession.mockResolvedValue({ ok: true, data: startResponse })
       renderConversation()
       await waitFor(() => expect(screen.getByText(SESSION_ID)).toBeInTheDocument())
+      expect(screen.getByText('PlayerTurnListening')).toBeInTheDocument()
     })
 
     it('shows an error alert when startSession fails', async () => {
@@ -227,6 +256,102 @@ describe('Conversation screen', () => {
       // … and no scary error banner covers a working conversation.
       expect(screen.queryByRole('alert')).not.toBeInTheDocument()
     })
+
+    it('restores the meters when resuming, not just the transcript', async () => {
+      // Issue #501 §1 and §3: meter values only ever arrived with a turn, so a
+      // player who stepped out to Settings came back to a conversation with no
+      // meters at all — on the screen whose opening line tells them to watch
+      // the two meters above it — until they sent another message.
+      mockApi.startSession.mockResolvedValue({
+        ok: false,
+        error: { kind: 'network', message: 'INVALID_TRANSITION' },
+      })
+      mockApi.getSessionTranscript.mockResolvedValue({
+        ok: true,
+        data: {
+          session_id: SESSION_ID,
+          scenario_id: 'behavioral_interview',
+          transcript_saved: true,
+          turns: [
+            { turn_number: 0, role: 'npc_opening', content: 'Thanks for coming in.', flow_state_after: 'PlayerTurnListening' },
+            { turn_number: 1, role: 'player', content: 'Happy to be here.', flow_state_after: 'NpcThinking' },
+            { turn_number: 2, role: 'npc', content: 'Walk me through your background.', flow_state_after: 'PlayerTurnListening' },
+          ],
+        },
+      })
+      mockApi.getSession.mockResolvedValue({
+        ok: true,
+        data: {
+          session_id: SESSION_ID,
+          scenario_id: 'behavioral_interview',
+          state: 'PlayerTurnListening',
+          created_at: '2026-07-01T00:00:00Z',
+          setup: {},
+          turn_count: 1,
+          visible_state: { trust: 62, patience: 70 },
+        },
+      } as never)
+      renderConversation()
+
+      await waitFor(() => expect(screen.getByTestId('state-vars')).toBeInTheDocument())
+      expect(screen.getByTestId('state-meter-trust')).toHaveTextContent('62')
+      expect(screen.getByTestId('state-meter-patience')).toHaveTextContent('70')
+      // Nothing moved on arrival: the values the session was left at are the
+      // baseline, not a change from anything.
+      expect(screen.getByTestId('state-meter-delta-trust')).not.toHaveTextContent('+')
+    })
+
+    it('keeps counting whole turns when resuming a session that saves no transcript', async () => {
+      // Issue #501 §4: the transcript endpoint answers a session started with
+      // transcript saving off with no rows, always, so there is nothing to count
+      // the resumed turns from and the labels restarted at "Turn 1" over a
+      // session the server was three turns into — the debrief-says-4 /
+      // transcript-says-1 mismatch again, on the screen resume was added for.
+      mockApi.startSession.mockResolvedValue({
+        ok: false,
+        error: { kind: 'network', message: 'INVALID_TRANSITION' },
+      })
+      mockApi.getSessionTranscript.mockResolvedValue({
+        ok: true,
+        data: {
+          session_id: SESSION_ID,
+          scenario_id: 'behavioral_interview',
+          transcript_saved: false,
+          message: 'Transcript saving is disabled for this session.',
+          turns: [],
+        },
+      })
+      mockApi.getSession.mockResolvedValue({
+        ok: true,
+        data: {
+          session_id: SESSION_ID,
+          scenario_id: 'behavioral_interview',
+          state: 'PlayerTurnListening',
+          created_at: '2026-07-01T00:00:00Z',
+          setup: { save_transcript: false },
+          turn_count: 3,
+          visible_state: { trust: 55 },
+        },
+      } as never)
+      mockApi.submitTurn.mockResolvedValue({ ok: true, data: turnResponse })
+      renderConversation()
+
+      // Wait for the session read to land before sending, so the counter is
+      // seeded rather than racing the player's message.
+      await waitFor(() => expect(screen.getByTestId('state-meter-trust')).toHaveTextContent('55'))
+      fireEvent.change(screen.getByRole('textbox', { name: /your response/i }), {
+        target: { value: 'Picking up where we left off.' },
+      })
+      fireEvent.click(screen.getByRole('button', { name: /submit/i }))
+
+      await waitFor(() =>
+        expect(screen.getByText('Hello there. I am a simulated NPC.')).toBeInTheDocument(),
+      )
+      // Three whole turns already played, so this exchange is the fourth — both
+      // halves of it, and nothing numbered 1.
+      expect(screen.getAllByText('Turn 4')).toHaveLength(2)
+      expect(screen.queryByText('Turn 1')).not.toBeInTheDocument()
+    })
   })
 
   describe('NPC panel', () => {
@@ -418,8 +543,8 @@ describe('Conversation screen', () => {
       // The failed message must not linger in the transcript.
       expect(screen.queryByText('This will fail.')).not.toBeInTheDocument()
 
-      // A successful retry should be labelled Turn 2 (opening was Turn 1),
-      // with no gap or duplicate from the rolled-back attempt.
+      // A successful retry is the first whole turn, with no gap or duplicate
+      // from the rolled-back attempt.
       mockApi.submitTurn.mockResolvedValue({ ok: true, data: turnResponse })
       fireEvent.change(screen.getByRole('textbox', { name: /your response/i }), {
         target: { value: 'Retry message.' },
@@ -429,19 +554,45 @@ describe('Conversation screen', () => {
       await waitFor(() =>
         expect(screen.getByText('Retry message.')).toBeInTheDocument(),
       )
-      // Opening=Turn 1, retry player=Turn 2, NPC=Turn 3. The absence of a
-      // Turn 4 confirms the failed attempt did not consume a turn number.
-      expect(screen.getByText('Turn 2')).toBeInTheDocument()
-      expect(screen.queryByText('Turn 4')).not.toBeInTheDocument()
+      // Opening is labelled, the retry's message and the reply to it are both
+      // "Turn 1" (issue #501 §4). The absence of a Turn 2 confirms the failed
+      // attempt did not consume a turn number.
+      expect(screen.getByText('Opening')).toBeInTheDocument()
+      expect(screen.getAllByText('Turn 1')).toHaveLength(2)
+      expect(screen.queryByText('Turn 2')).not.toBeInTheDocument()
     })
 
-    it('shows turn number markers in the transcript', async () => {
+    it('labels the opening rather than numbering it as a turn', async () => {
+      // Issue #501 §4: the opening answers nothing, so it is not half a turn.
       mockApi.submitTurn.mockResolvedValue({ ok: true, data: turnResponse })
       renderConversation()
       await waitFor(() =>
         expect(screen.getByText('Thanks for coming in. Tell me about yourself.')).toBeInTheDocument(),
       )
-      expect(screen.getByText(/Turn 1/)).toBeInTheDocument()
+      expect(screen.getByText('Opening')).toBeInTheDocument()
+      expect(screen.queryByText(/Turn 1/)).not.toBeInTheDocument()
+    })
+
+    it('numbers one player message and the reply to it as a single turn', async () => {
+      mockApi.submitTurn.mockResolvedValue({ ok: true, data: turnResponse })
+      renderConversation()
+      await waitFor(() =>
+        expect(screen.getByRole('textbox', { name: /your response/i })).toBeInTheDocument(),
+      )
+      fireEvent.change(screen.getByRole('textbox', { name: /your response/i }), {
+        target: { value: 'I have five years of experience.' },
+      })
+      fireEvent.click(screen.getByRole('button', { name: /submit/i }))
+
+      await waitFor(() =>
+        expect(screen.getByText('Hello there. I am a simulated NPC.')).toBeInTheDocument(),
+      )
+      // Both halves of the exchange carry Turn 1 — which is also what
+      // convsim-core counts in turn_count and what max_turns is measured in.
+      const labels = screen.getAllByText('Turn 1')
+      expect(labels).toHaveLength(2)
+      expect(screen.queryByText('Turn 2')).not.toBeInTheDocument()
+      expect(screen.queryByText('Turn 3')).not.toBeInTheDocument()
     })
 
     it('shows the player message immediately after submit without waiting for REST', async () => {
@@ -583,15 +734,134 @@ describe('Conversation screen', () => {
     })
   })
 
-  describe('state variables panel', () => {
-    it('shows NPC state variables section when show_state_meters is true (default)', async () => {
+  describe('conversation meters', () => {
+    it('shows the meters when show_state_meters is true (default)', async () => {
       mockApi.startSession.mockResolvedValue({ ok: true, data: startResponse })
       renderConversation()
       await waitFor(() =>
         expect(screen.getByTestId('state-vars')).toBeInTheDocument(),
       )
-      expect(screen.getByTestId('state-vars')).toHaveTextContent('trust')
-      expect(screen.getByTestId('state-vars')).toHaveTextContent('patience')
+      expect(screen.getByTestId('state-vars')).toHaveTextContent('Trust')
+      expect(screen.getByTestId('state-vars')).toHaveTextContent('Patience')
+    })
+
+    it('humanizes snake_case variable names in plain wording', async () => {
+      // Issue #501 §3: "objective_progress" is a YAML key, not a label.
+      mockApi.startSession.mockResolvedValue({ ok: true, data: startResponse })
+      renderConversation()
+      await waitFor(() => expect(screen.getByTestId('state-vars')).toBeInTheDocument())
+      expect(screen.getByTestId('state-meter-objective_progress')).toHaveTextContent(
+        'Objective progress',
+      )
+    })
+
+    it('keeps the raw variable keys at the technical wording level', async () => {
+      localStorage.setItem('convsim.ui.languageLevel', 'technical')
+      mockApi.startSession.mockResolvedValue({ ok: true, data: startResponse })
+      renderConversation()
+      await waitFor(() => expect(screen.getByTestId('state-vars')).toBeInTheDocument())
+      expect(screen.getByTestId('state-meter-objective_progress')).toHaveTextContent(
+        'objective_progress',
+      )
+    })
+
+    it('sits above the transcript, where the tutorial says the meters are', async () => {
+      mockApi.startSession.mockResolvedValue({ ok: true, data: startResponse })
+      renderConversation()
+      await waitFor(() => expect(screen.getByTestId('state-vars')).toBeInTheDocument())
+      const meters = screen.getByTestId('state-vars')
+      const transcript = screen.getByRole('log')
+      // Node.DOCUMENT_POSITION_FOLLOWING === 4: the transcript comes after.
+      expect(meters.compareDocumentPosition(transcript) & 4).toBeTruthy()
+    })
+
+    it('shows how far each meter moved on the latest turn', async () => {
+      // The tutorial says "Engagement just ticked up"; nothing on screen used
+      // to tick (issue #501 §3).
+      mockApi.startSession.mockResolvedValue({ ok: true, data: startResponse })
+      mockApi.submitTurn.mockResolvedValue({
+        ok: true,
+        data: {
+          ...turnResponse,
+          events: [
+            turnResponse.events[0],
+            {
+              ...turnResponse.events[1],
+              payload: {
+                ...turnResponse.events[1].payload,
+                visible_state: { trust: 60, patience: 75, rapport: 50, openness: 50, objective_progress: 0 },
+              },
+            },
+          ],
+        },
+      })
+      renderConversation()
+      await waitFor(() =>
+        expect(screen.getByRole('textbox', { name: /your response/i })).toBeInTheDocument(),
+      )
+      fireEvent.change(screen.getByRole('textbox', { name: /your response/i }), {
+        target: { value: 'Something encouraging.' },
+      })
+      fireEvent.click(screen.getByRole('button', { name: /submit/i }))
+
+      await waitFor(() =>
+        expect(screen.getByTestId('state-meter-delta-trust')).toHaveTextContent('+10'),
+      )
+      // A meter that did not move says nothing.
+      expect(screen.getByTestId('state-meter-delta-patience')).not.toHaveTextContent('+')
+    })
+
+    it('keeps the movement when the authoritative snapshot repeats it', async () => {
+      // One turn produces two snapshots: npc.final applies the delta
+      // optimistically, then session.state delivers the same numbers as fact.
+      // Measured against the previous snapshot the second one is a move of
+      // zero, which wiped the arrow the first one had just earned — so the
+      // tick the tutorial talks about flashed and vanished (issue #501 §3).
+      let wsCallback: ((event: WsEvent) => void) | null = null
+      mockApi.connectSession.mockImplementation((_id, cb) => {
+        wsCallback = cb
+        return { close: vi.fn() }
+      })
+      mockApi.startSession.mockResolvedValue({ ok: true, data: startResponse })
+      mockApi.submitTurn.mockResolvedValue({ ok: true, data: turnResponse })
+      renderConversation()
+      await waitFor(() =>
+        expect(screen.getByRole('textbox', { name: /your response/i })).toBeInTheDocument(),
+      )
+      fireEvent.change(screen.getByRole('textbox', { name: /your response/i }), {
+        target: { value: 'Something encouraging.' },
+      })
+      fireEvent.click(screen.getByRole('button', { name: /submit/i }))
+
+      const moved = { trust: 60, patience: 75, rapport: 50, openness: 50, objective_progress: 0 }
+      act(() => {
+        wsCallback?.({
+          type: 'npc.final',
+          seq: 1,
+          session_id: SESSION_ID,
+          ts: '2026-07-01T00:01:00Z',
+          payload: {
+            content: 'Good to hear.',
+            emotion: 'warm',
+            state_delta: { trust: 10 },
+            event_flags: [],
+          },
+        })
+      })
+      await waitFor(() =>
+        expect(screen.getByTestId('state-meter-delta-trust')).toHaveTextContent('+10'),
+      )
+
+      act(() => {
+        wsCallback?.({
+          type: 'session.state',
+          seq: 2,
+          session_id: SESSION_ID,
+          ts: '2026-07-01T00:01:01Z',
+          payload: { state: 'PlayerTurnListening', state_vars: moved, ending_type: null },
+        })
+      })
+      expect(screen.getByTestId('state-meter-delta-trust')).toHaveTextContent('+10')
     })
 
     it('hides state variables when show_state_meters is false', async () => {
@@ -628,7 +898,79 @@ describe('Conversation screen', () => {
       await waitFor(() =>
         expect(screen.getByTestId('banner-event')).toBeInTheDocument(),
       )
-      expect(screen.getByTestId('banner-event')).toHaveTextContent('rapport_milestone')
+      // Issue #501 §2: "Scenario event: rapport_milestone" is two pieces of
+      // jargon and an identifier. Plain wording says what happened.
+      expect(screen.getByTestId('banner-event')).toHaveTextContent(
+        'Something changed: Rapport milestone',
+      )
+    })
+
+    it('announces a scenario event the engine fired on the turn', async () => {
+      // Engine-fired events (a meter crossing a threshold) arrive only on the
+      // npc_turn payload as triggered_scenario_events, and nothing read them:
+      // the banner was fed solely by the WebSocket scenario.event frame, which
+      // carries the NPC's self-declared flags and which convsim-core does not
+      // send. So the tutorial fired warm_moment and then told the player they
+      // "would have seen a short note above the transcript" (issue #501 §3).
+      mockApi.startSession.mockResolvedValue({ ok: true, data: startResponse })
+      mockApi.submitTurn.mockResolvedValue({
+        ok: true,
+        data: {
+          ...turnResponse,
+          events: [
+            turnResponse.events[0],
+            {
+              ...turnResponse.events[1],
+              payload: {
+                ...turnResponse.events[1].payload,
+                triggered_scenario_events: ['warm_moment'],
+              },
+            },
+          ],
+        },
+      })
+      renderConversation()
+      await waitFor(() =>
+        expect(screen.getByRole('textbox', { name: /your response/i })).toBeInTheDocument(),
+      )
+      fireEvent.change(screen.getByRole('textbox', { name: /your response/i }), {
+        target: { value: 'Something encouraging.' },
+      })
+      fireEvent.click(screen.getByRole('button', { name: /submit/i }))
+
+      await waitFor(() =>
+        expect(screen.getByTestId('banner-event')).toHaveTextContent(
+          'Something changed: Warm moment',
+        ),
+      )
+    })
+
+    it('keeps the raw event flags in the banner at the technical level', async () => {
+      localStorage.setItem('convsim.ui.languageLevel', 'technical')
+      let wsCallback: ((event: WsEvent) => void) | null = null
+      mockApi.connectSession.mockImplementation((_id, cb) => {
+        wsCallback = cb
+        return { close: vi.fn() }
+      })
+      mockApi.startSession.mockResolvedValue({ ok: true, data: startResponse })
+      renderConversation()
+      await waitFor(() => expect(screen.getByTestId('npc-panel')).toBeInTheDocument())
+
+      act(() => {
+        wsCallback?.({
+          type: 'scenario.event',
+          seq: 1,
+          session_id: SESSION_ID,
+          ts: '2026-07-01T00:01:00Z',
+          payload: { flags: ['rapport_milestone'] },
+        })
+      })
+
+      await waitFor(() =>
+        expect(screen.getByTestId('banner-event')).toHaveTextContent(
+          'Scenario event: rapport_milestone',
+        ),
+      )
     })
 
     it('shows a safety redirect banner when websocket delivers safety.redirect', async () => {
@@ -1513,6 +1855,26 @@ describe('Conversation screen', () => {
       }
     })
 
+    // Issue #501 §1: the playtester hit a slow turn, went to Settings to speed
+    // the model up, "was a little unclear on how to do that", and lost the
+    // session. This notice is where that detour starts, so it names the setting
+    // and links straight at it instead of saying "you can adjust settings".
+    it('points the player at the reply-speed setting by name', async () => {
+      mockApi.submitTurn.mockReturnValue(new Promise(() => {}))
+      vi.useFakeTimers({ shouldAdvanceTime: true })
+      try {
+        await submitAndWait(6_000)
+        const link = screen.getByTestId('slow-response-speed-link')
+        expect(link).toHaveTextContent(/make replies faster/i)
+        // The anchor matters: /settings alone lands the player at the top of a
+        // long page with nothing obviously changed.
+        expect(link).toHaveAttribute('href', '/settings#reply-speed')
+        expect(screen.queryByText(/you can adjust settings/i)).not.toBeInTheDocument()
+      } finally {
+        vi.useRealTimers()
+      }
+    })
+
     it('announces the elapsed wait on a coarse grid so the live region is not spammed', async () => {
       // The visible clock ticks every second; left audible that is ~270
       // announcements over a five-minute turn. It is aria-hidden, and a separate
@@ -1551,9 +1913,13 @@ describe('Conversation screen', () => {
           ).toBeInTheDocument(),
         )
         expect(screen.queryByRole('alert')).not.toBeInTheDocument()
-        // Server copy is authoritative, so the player turn stays and keeps its number.
+        // Server copy is authoritative, so the player turn stays and keeps its
+        // number — and the server's turn_number is what the whole-turn labels
+        // are derived from, so a reconciled transcript numbers identically to
+        // one built turn by turn (issue #501 §4).
         expect(screen.getByText('My answer.')).toBeInTheDocument()
-        expect(screen.getByText('Turn 3')).toBeInTheDocument()
+        expect(screen.getByText('Opening')).toBeInTheDocument()
+        expect(screen.getAllByText('Turn 1')).toHaveLength(2)
         expect(screen.getByRole('textbox', { name: /your response/i })).not.toBeDisabled()
       } finally {
         vi.useRealTimers()
diff --git a/apps/web/src/__tests__/Debrief.test.tsx b/apps/web/src/__tests__/Debrief.test.tsx
index d99aeadb..ceec9664 100644
--- a/apps/web/src/__tests__/Debrief.test.tsx
+++ b/apps/web/src/__tests__/Debrief.test.tsx
@@ -340,6 +340,117 @@ describe('Debrief screen', () => {
     })
   })
 
+  // Issue #501 §4: one turn is the player's message plus the reply to it. The
+  // debrief's key-moment numbers were already whole turns, so labelling the
+  // transcript by position made "#3" and "Turn 3" different moments.
+  describe('whole-turn labelling', () => {
+    const threeTurnExport = {
+      session: exportData.session,
+      events: [
+        { event_id: 1, session_id: SESSION_ID, event_type: 'npc_opening', payload: { content: 'Thanks for coming in.' }, created_at: '2024-01-01T00:00:00Z' },
+        { event_id: 2, session_id: SESSION_ID, event_type: 'player_turn', payload: { content: 'Player one.' }, created_at: '2024-01-01T00:00:01Z' },
+        { event_id: 3, session_id: SESSION_ID, event_type: 'npc_turn', payload: { content: 'Npc one.', emotion: 'warm' }, created_at: '2024-01-01T00:00:02Z' },
+        { event_id: 4, session_id: SESSION_ID, event_type: 'player_turn', payload: { content: 'Player two.' }, created_at: '2024-01-01T00:00:03Z' },
+        { event_id: 5, session_id: SESSION_ID, event_type: 'npc_turn', payload: { content: 'Npc two.', emotion: 'neutral' }, created_at: '2024-01-01T00:00:04Z' },
+      ],
+    }
+
+    it('labels the opening and numbers each exchange once', async () => {
+      mockApi.generateDebrief.mockResolvedValue({ ok: true, data: fullDebriefResponse })
+      mockApi.exportSession.mockResolvedValue({ ok: true, data: threeTurnExport })
+      renderDebrief()
+      await waitFor(() =>
+        expect(screen.getByTestId('transcript-section')).toBeInTheDocument(),
+      )
+      const numbers = screen
+        .getAllByTestId('transcript-turn')
+        .map((el) => el.getAttribute('data-turn-number'))
+      expect(numbers).toEqual(['0', '1', '1', '2', '2'])
+      expect(screen.getByText('Opening')).toBeInTheDocument()
+      expect(screen.getAllByText('Turn 1')).toHaveLength(2)
+      expect(screen.getAllByText('Turn 2')).toHaveLength(2)
+    })
+
+    it('labels the NPC mood rather than bracketing it beside the turn number', async () => {
+      // Next to a turn number it read as one of the meters (issue #501 §3).
+      mockApi.generateDebrief.mockResolvedValue({ ok: true, data: fullDebriefResponse })
+      mockApi.exportSession.mockResolvedValue({ ok: true, data: threeTurnExport })
+      renderDebrief()
+      await waitFor(() =>
+        expect(screen.getByTestId('transcript-section')).toBeInTheDocument(),
+      )
+      expect(screen.getByText('warm')).toBeInTheDocument()
+      expect(screen.queryByText('(warm)')).not.toBeInTheDocument()
+    })
+
+    it('a key moment points at the start of the turn it names', async () => {
+      mockApi.generateDebrief.mockResolvedValue({ ok: true, data: fullDebriefResponse })
+      mockApi.exportSession.mockResolvedValue({ ok: true, data: threeTurnExport })
+      renderDebrief()
+      await waitFor(() =>
+        expect(screen.getByTestId('transcript-section')).toBeInTheDocument(),
+      )
+      const scrolled: Element[] = []
+      for (const el of screen.getAllByTestId('transcript-turn')) {
+        el.scrollIntoView = () => { scrolled.push(el) }
+      }
+      fireEvent.click(screen.getByRole('button', { name: /go to turn 2/i }))
+      expect(scrolled).toHaveLength(1)
+      // The player's message, which is where turn 2 begins — not the second
+      // row in the list, which is the player's message of turn 1.
+      expect(scrolled[0]).toHaveTextContent('Player two.')
+    })
+  })
+
+  // Issue #501 §3: the panel the player watches during a conversation is
+  // called "Conversation meters". The debrief reviews the same bars, so it has
+  // to use the same name — a panel that is renamed between the screen it moves
+  // on and the screen that reviews it is the label/naming mismatch the report
+  // described, one screen later.
+  describe('conversation meters panel', () => {
+    const withMetrics: SessionDebriefResponse = {
+      ...fullDebriefResponse,
+      metrics: {
+        metrics_version: '1',
+        talk_ratio: 0.5,
+        words_per_turn_player: 12,
+        words_per_turn_npc: 18,
+        open_questions: 1,
+        closed_questions: 1,
+        filler_word_count: 0,
+        interruption_count: 0,
+        response_latency_p50_ms: null,
+        response_latency_p95_ms: null,
+        state_arc: [
+          { turn_number: 1, state: { engagement: 40, objective_progress: 20 } },
+          { turn_number: 2, state: { engagement: 55, objective_progress: 35 } },
+        ],
+      },
+    }
+
+    it('calls the meters what the conversation screen called them', async () => {
+      mockApi.generateDebrief.mockResolvedValue({ ok: true, data: withMetrics })
+      mockApi.exportSession.mockResolvedValue({ ok: false, error: { kind: 'network', message: 'x' } })
+      renderDebrief()
+      await waitFor(() =>
+        expect(screen.getByTestId('telemetry-panel')).toBeInTheDocument(),
+      )
+      expect(screen.getByText('Conversation meters across turns')).toBeInTheDocument()
+      expect(screen.queryByText(/state meters/i)).not.toBeInTheDocument()
+    })
+
+    it('names each meter in words rather than as a raw key', async () => {
+      mockApi.generateDebrief.mockResolvedValue({ ok: true, data: withMetrics })
+      mockApi.exportSession.mockResolvedValue({ ok: false, error: { kind: 'network', message: 'x' } })
+      renderDebrief()
+      await waitFor(() =>
+        expect(screen.getByTestId('telemetry-panel')).toBeInTheDocument(),
+      )
+      expect(screen.getByText('objective progress')).toBeInTheDocument()
+      expect(screen.queryByText('objective_progress')).not.toBeInTheDocument()
+    })
+  })
+
   describe('transcript display', () => {
     it('shows transcript turns from export when available', async () => {
       mockApi.generateDebrief.mockResolvedValue({ ok: true, data: fullDebriefResponse })
diff --git a/apps/web/src/__tests__/Home.test.tsx b/apps/web/src/__tests__/Home.test.tsx
index f03af364..077c4e43 100644
--- a/apps/web/src/__tests__/Home.test.tsx
+++ b/apps/web/src/__tests__/Home.test.tsx
@@ -58,7 +58,13 @@ function liText(expected: string) {
 
 // Stub fetch: routes by URL pattern to the appropriate response.
 // Includes text() because handleResponse now reads the body as text first.
-function stubFetches(healthResp: object, packsResp: object, logbookResp: object = makeLogbook(), scenariosResp: object[] = []) {
+function stubFetches(
+  healthResp: object,
+  packsResp: object,
+  logbookResp: object = makeLogbook(),
+  scenariosResp: object[] = [],
+  sessionsResp: object = { sessions: [] },
+) {
   vi.stubGlobal(
     'fetch',
     vi.fn((url: string) => {
@@ -66,12 +72,22 @@ function stubFetches(healthResp: object, packsResp: object, logbookResp: object
       if (url.includes('/packs')) body = packsResp
       else if (url.includes('/logbook')) body = logbookResp
       else if (url.includes('/scenarios')) body = scenariosResp
+      else if (url.includes('/sessions')) body = sessionsResp
       const text = JSON.stringify(body)
       return Promise.resolve({ ok: true, json: () => Promise.resolve(body), text: () => Promise.resolve(text) })
     }),
   )
 }
 
+const IN_PROGRESS_SESSION = {
+  session_id: 'sess-resume01',
+  scenario_id: 'behavioral_interview',
+  state: 'PlayerTurnListening',
+  created_at: '2026-10-01T10:00:00.000Z',
+  turn_count: 2,
+  setup: {},
+}
+
 function renderHome() {
   return render(
     <MemoryRouter future={{ v7_startTransition: true, v7_relativeSplatPath: true }}>
@@ -90,10 +106,10 @@ describe('Home — ready state', () => {
     expect(screen.getByRole('heading', { name: /conversation simulator/i })).toBeInTheDocument()
   })
 
-  it('shows Local runtime: Ready list item when health is ok', async () => {
+  it('shows AI engine: Ready list item when health is ok', async () => {
     stubFetches(makeHealth(), makePacks(0))
     renderHome()
-    expect(await screen.findByText(liText('Local runtime: Ready'))).toBeInTheDocument()
+    expect(await screen.findByText(liText('AI engine: Ready'))).toBeInTheDocument()
   })
 
   it('shows the active model name when LLM is ready', async () => {
@@ -109,6 +125,29 @@ describe('Home — ready state', () => {
     expect(await screen.findByText('3 installed')).toBeInTheDocument()
   })
 
+  // Issue #501 §1: "there is no 'resume in-progress session' entry point
+  // anywhere on Home or in the nav."
+  it('leads the primary actions with Resume when a conversation is in progress', async () => {
+    stubFetches(makeHealth(), makePacks(1), makeLogbook(), [], {
+      sessions: [IN_PROGRESS_SESSION],
+    })
+    renderHome()
+    const resume = await screen.findByTestId('home-resume-link')
+    expect(resume).toHaveAttribute('href', '/conversation/sess-resume01')
+    // Ahead of "Start a scenario": resuming beats starting over, which is what
+    // the playtester did instead.
+    const start = screen.getByRole('link', { name: /start a scenario/i })
+    // Node.DOCUMENT_POSITION_FOLLOWING === 4
+    expect(resume.compareDocumentPosition(start) & 4).toBeTruthy()
+  })
+
+  it('offers no Resume link when nothing is in progress', async () => {
+    stubFetches(makeHealth(), makePacks(1), makeLogbook(), [], { sessions: [] })
+    renderHome()
+    await screen.findByText(liText('AI engine: Ready'))
+    expect(screen.queryByTestId('home-resume-link')).not.toBeInTheDocument()
+  })
+
   it('links to the library for Start a scenario', () => {
     renderHome()
     expect(screen.getByRole('link', { name: /start a scenario/i })).toHaveAttribute('href', '/library')
@@ -146,7 +185,7 @@ describe('Home — no-model state', () => {
   it('shows LLM list item as Not installed', async () => {
     stubFetches(makeHealth(), makePacks(0))
     renderHome()
-    expect(await screen.findByText(liText('LLM: Not installed'))).toBeInTheDocument()
+    expect(await screen.findByText(liText('AI model: Not installed'))).toBeInTheDocument()
   })
 
   it('offers Install a GGUF model option', async () => {
@@ -232,7 +271,7 @@ describe('Home — status card links', () => {
   it('has at least five links to /settings covering LLM, STT, TTS, install, and import', async () => {
     stubFetches(makeHealth(), makePacks(0))
     renderHome()
-    await screen.findByText(liText('Local runtime: Ready'))
+    await screen.findByText(liText('AI engine: Ready'))
     const settingsLinks = screen
       .getAllByRole('link')
       .filter((el) => el.getAttribute('href') === '/settings')
@@ -240,7 +279,7 @@ describe('Home — status card links', () => {
     expect(settingsLinks.length).toBeGreaterThanOrEqual(5)
   })
 
-  it('Local runtime badge links to the recovery section when offline', async () => {
+  it('AI engine badge links to the recovery section when offline', async () => {
     vi.stubGlobal('fetch', vi.fn(() => Promise.reject(new Error('Network error'))))
     renderHome()
     await screen.findByRole('alert')
@@ -252,10 +291,10 @@ describe('Home — status card links', () => {
 })
 
 describe('Home — runtime-error state', () => {
-  it('shows Local runtime: Unavailable list item when API is unreachable', async () => {
+  it('shows AI engine: Unavailable list item when API is unreachable', async () => {
     vi.stubGlobal('fetch', vi.fn(() => Promise.reject(new Error('Network error'))))
     renderHome()
-    expect(await screen.findByText(liText('Local runtime: Unavailable'))).toBeInTheDocument()
+    expect(await screen.findByText(liText('AI engine: Unavailable'))).toBeInTheDocument()
   })
 
   it('shows a recovery alert when runtime is down', async () => {
@@ -277,7 +316,7 @@ describe('Home — runtime-error state', () => {
     renderHome()
     const alert = await screen.findByRole('alert')
     expect(alert).not.toHaveTextContent(/api server/i)
-    expect(alert).not.toHaveTextContent(/local runtime/i)
+    expect(alert).not.toHaveTextContent(/AI engine/i)
   })
 
   it('does not show the no-model section when runtime is unreachable', async () => {
@@ -298,7 +337,7 @@ describe('Home — runtime-error state', () => {
   it('does not show a last_error alert when last_error is null', async () => {
     stubFetches(makeHealth({ last_error: null }), makePacks(0))
     renderHome()
-    await screen.findByText(liText('Local runtime: Ready'))
+    await screen.findByText(liText('AI engine: Ready'))
     expect(screen.queryByRole('alert')).toBeNull()
   })
 
@@ -435,7 +474,7 @@ describe('Home — missing-pack section', () => {
   it('hides missing-pack notice when no model is configured', async () => {
     stubFetches(makeHealth({ llm_ready: false }), makePacks(0))
     renderHome()
-    await screen.findByText(liText('LLM: Not installed'))
+    await screen.findByText(liText('AI model: Not installed'))
     expect(
       screen.queryByRole('status', { name: /no scenario packs installed/i }),
     ).toBeNull()
diff --git a/apps/web/src/__tests__/PerformanceWarning.test.tsx b/apps/web/src/__tests__/PerformanceWarning.test.tsx
index 7c8373f4..8cc9a29b 100644
--- a/apps/web/src/__tests__/PerformanceWarning.test.tsx
+++ b/apps/web/src/__tests__/PerformanceWarning.test.tsx
@@ -86,15 +86,15 @@ describe('PerformanceWarningBanner', () => {
     expect(screen.getByRole('status', { name: /performance warnings/i })).toBeInTheDocument()
   })
 
-  it('navigates to /settings when Runtime Settings button is clicked', () => {
+  it('navigates to /settings when the settings button is clicked', () => {
     renderBanner([
       { code: 'use_smaller_model', title: 'NPC is slow', detail: 'Token took 4s.' },
     ])
-    fireEvent.click(screen.getByRole('button', { name: /open runtime settings/i }))
+    fireEvent.click(screen.getByRole('button', { name: /open settings/i }))
     expect(mockNavigate).toHaveBeenCalledWith('/settings')
   })
 
-  it('shows the warning without the Runtime Settings button in the demo edition', () => {
+  it('shows the warning without the settings button in the demo edition', () => {
     // The demo hides the runtime section of Settings (issue #495); the button
     // would land the player on a page with nothing to adjust.
     vi.stubEnv('VITE_CONVSIM_EDITION', 'demo')
@@ -103,7 +103,7 @@ describe('PerformanceWarningBanner', () => {
         { code: 'use_smaller_model', title: 'NPC is slow', detail: 'Token took 4s.' },
       ])
       expect(screen.getByText(/npc is slow/i)).toBeInTheDocument()
-      expect(screen.queryByRole('button', { name: /open runtime settings/i })).not.toBeInTheDocument()
+      expect(screen.queryByRole('button', { name: /open settings/i })).not.toBeInTheDocument()
     } finally {
       vi.unstubAllEnvs()
     }
diff --git a/apps/web/src/__tests__/ReplySpeedPanel.test.tsx b/apps/web/src/__tests__/ReplySpeedPanel.test.tsx
new file mode 100644
index 00000000..2596faee
--- /dev/null
+++ b/apps/web/src/__tests__/ReplySpeedPanel.test.tsx
@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { render, screen, waitFor, fireEvent } from '@testing-library/react'
+import { MemoryRouter } from 'react-router-dom'
+import { I18nProvider } from '../i18n'
+import ReplySpeedPanel from '../components/ReplySpeedPanel'
+import type { ReplySpeed, RuntimeSettingsResponse } from '@convsim/shared'
+
+vi.mock('../api/client', () => ({
+  api: {
+    getRuntimeSettings: vi.fn(),
+    updateRuntimeSettings: vi.fn(),
+  },
+}))
+
+import { api } from '../api/client'
+const mockApi = vi.mocked(api)
+
+function settings(replySpeed: ReplySpeed | null): RuntimeSettingsResponse {
+  const nulls = {
+    context_length: null,
+    gpu_layers: null,
+    threads: null,
+    temperature: null,
+    top_p: null,
+    repeat_penalty: null,
+  }
+  return {
+    settings: { ...nulls, reply_speed: replySpeed },
+    recommended: { ...nulls, reply_speed: 'balanced' },
+    requires_restart: false,
+  }
+}
+
+function renderPanel() {
+  return render(
+    <I18nProvider>
+      <MemoryRouter>
+        <ReplySpeedPanel />
+      </MemoryRouter>
+    </I18nProvider>,
+  )
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+/**
+ * Issue #501 §1: "I'm currently … trying to change my settings to attempt to
+ * speed the model up. I was a little unclear on how to do that in the Settings
+ * tab." Nothing in Settings was named after what they wanted.
+ */
+describe('ReplySpeedPanel', () => {
+  it('offers three named speeds, each with a short descriptor', async () => {
+    mockApi.getRuntimeSettings.mockResolvedValue({ ok: true, data: settings(null) })
+    renderPanel()
+    await waitFor(() => expect(screen.getByTestId('reply-speed-options')).toBeInTheDocument())
+    expect(screen.getByTestId('reply-speed-fast')).toHaveTextContent('Quick replies')
+    expect(screen.getByTestId('reply-speed-fast')).toHaveTextContent('Shortest answers')
+    expect(screen.getByTestId('reply-speed-balanced')).toHaveTextContent('Balanced')
+    expect(screen.getByTestId('reply-speed-detailed')).toHaveTextContent('Fuller replies')
+  })
+
+  it('shows balanced as the choice when none was ever made', async () => {
+    mockApi.getRuntimeSettings.mockResolvedValue({ ok: true, data: settings(null) })
+    renderPanel()
+    await waitFor(() =>
+      expect(screen.getByTestId('reply-speed-balanced')).toHaveAttribute('aria-checked', 'true'),
+    )
+    expect(screen.getByTestId('reply-speed-fast')).toHaveAttribute('aria-checked', 'false')
+  })
+
+  it('reflects the persisted choice', async () => {
+    mockApi.getRuntimeSettings.mockResolvedValue({ ok: true, data: settings('detailed') })
+    renderPanel()
+    await waitFor(() =>
+      expect(screen.getByTestId('reply-speed-detailed')).toHaveAttribute('aria-checked', 'true'),
+    )
+  })
+
+  it('persists a new choice and says it applies to the next message', async () => {
+    mockApi.getRuntimeSettings.mockResolvedValue({ ok: true, data: settings(null) })
+    mockApi.updateRuntimeSettings.mockResolvedValue({ ok: true, data: settings('fast') })
+    renderPanel()
+    await waitFor(() => expect(screen.getByTestId('reply-speed-fast')).toBeInTheDocument())
+
+    fireEvent.click(screen.getByTestId('reply-speed-fast'))
+    await waitFor(() =>
+      expect(mockApi.updateRuntimeSettings).toHaveBeenCalledWith({ reply_speed: 'fast' }),
+    )
+    await waitFor(() =>
+      expect(screen.getByText(/next message uses the new speed/i)).toBeInTheDocument(),
+    )
+  })
+
+  it('does not re-save the choice that is already active', async () => {
+    mockApi.getRuntimeSettings.mockResolvedValue({ ok: true, data: settings('fast') })
+    renderPanel()
+    await waitFor(() =>
+      expect(screen.getByTestId('reply-speed-fast')).toHaveAttribute('aria-checked', 'true'),
+    )
+    fireEvent.click(screen.getByTestId('reply-speed-fast'))
+    expect(mockApi.updateRuntimeSettings).not.toHaveBeenCalled()
+  })
+
+  it('rolls the selection back when saving fails', async () => {
+    mockApi.getRuntimeSettings.mockResolvedValue({ ok: true, data: settings('balanced') })
+    mockApi.updateRuntimeSettings.mockResolvedValue({
+      ok: false,
+      error: { kind: 'network', message: 'nope' },
+    })
+    renderPanel()
+    await waitFor(() => expect(screen.getByTestId('reply-speed-fast')).toBeInTheDocument())
+
+    fireEvent.click(screen.getByTestId('reply-speed-fast'))
+    await waitFor(() =>
+      expect(screen.getByTestId('reply-speed-balanced')).toHaveAttribute('aria-checked', 'true'),
+    )
+    expect(screen.getByTestId('reply-speed-fast')).toHaveAttribute('aria-checked', 'false')
+  })
+
+  it('names the bigger lever honestly and links to it', async () => {
+    mockApi.getRuntimeSettings.mockResolvedValue({ ok: true, data: settings(null) })
+    renderPanel()
+    await waitFor(() => expect(screen.getByTestId('reply-speed-options')).toBeInTheDocument())
+    expect(screen.getByText(/a smaller model is the biggest change/i)).toBeInTheDocument()
+    expect(screen.getByRole('link', { name: /choose a model/i })).toHaveAttribute(
+      'href',
+      '/model-manager',
+    )
+  })
+
+  it('steps aside on a bundled runtime that predates the settings endpoint', async () => {
+    // RuntimeSettingsPanel already explains the 404 and points at the update;
+    // a second notice saying the same thing is noise.
+    mockApi.getRuntimeSettings.mockResolvedValue({
+      ok: false,
+      error: { kind: 'http-error', status: 404, message: 'Not Found' },
+    })
+    const { container } = renderPanel()
+    await waitFor(() => expect(mockApi.getRuntimeSettings).toHaveBeenCalled())
+    expect(container).toBeEmptyDOMElement()
+  })
+
+  it('surfaces a real load failure with a retry', async () => {
+    mockApi.getRuntimeSettings.mockResolvedValue({
+      ok: false,
+      error: { kind: 'network', message: 'unreachable' },
+    })
+    renderPanel()
+    await waitFor(() => expect(screen.getByRole('alert')).toBeInTheDocument())
+  })
+})
diff --git a/apps/web/src/__tests__/ResumeSessionBanner.test.tsx b/apps/web/src/__tests__/ResumeSessionBanner.test.tsx
new file mode 100644
index 00000000..fcf2ab8e
--- /dev/null
+++ b/apps/web/src/__tests__/ResumeSessionBanner.test.tsx
@@ -0,0 +1,245 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { render, screen, waitFor, fireEvent } from '@testing-library/react'
+import { MemoryRouter, Route, Routes } from 'react-router-dom'
+import { I18nProvider } from '../i18n'
+import ResumeSessionBanner from '../components/ResumeSessionBanner'
+import type { ScenarioInfo } from '@convsim/shared'
+
+vi.mock('../api/client', () => ({
+  api: {
+    listSessions: vi.fn(),
+    listScenarios: vi.fn(),
+    endSession: vi.fn(),
+  },
+}))
+
+import { api } from '../api/client'
+const mockApi = vi.mocked(api)
+
+const SESSION = {
+  session_id: 'sess-abc123',
+  scenario_id: 'behavioral_interview',
+  state: 'PlayerTurnListening' as const,
+  created_at: '2026-10-01T10:00:00Z',
+  turn_count: 3,
+  ending_type: null,
+  ended_at: null,
+  setup: {
+    scenario_id: 'behavioral_interview',
+    difficulty: 'standard' as const,
+    player_role_name: 'Candidate',
+    language: 'en',
+    input_mode: 'text-only' as const,
+    tts_enabled: false,
+    show_state_meters: true,
+    save_transcript: true,
+    seed: null,
+  },
+}
+
+const SCENARIO = {
+  scenario_id: 'behavioral_interview',
+  title: 'The Behavioral Interview',
+} as unknown as ScenarioInfo
+
+function renderAt(path: string) {
+  return render(
+    <I18nProvider>
+      <MemoryRouter initialEntries={[path]}>
+        <Routes>
+          <Route path="*" element={<><ResumeSessionBanner /><div data-testid="page" /></>} />
+        </Routes>
+      </MemoryRouter>
+    </I18nProvider>,
+  )
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  localStorage.clear()
+  mockApi.listScenarios.mockResolvedValue({ ok: true, data: [SCENARIO] })
+  mockApi.endSession.mockResolvedValue({
+    ok: true,
+    data: { session_id: SESSION.session_id, state: 'Ended', ending_type: 'player_exit' },
+  })
+})
+
+/**
+ * Issue #501 §1: "I couldn't easily figure out how to resume my ongoing
+ * scenario and resorted to starting a new one." The banner lives in the app
+ * chrome so it is on every screen the detour can reach — Settings included,
+ * which is where the playtester actually was.
+ */
+describe('ResumeSessionBanner', () => {
+  it('offers the in-progress conversation by scenario title and turn count', async () => {
+    mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [SESSION] } })
+    renderAt('/settings')
+    await waitFor(() =>
+      expect(screen.getByTestId('resume-session-banner')).toBeInTheDocument(),
+    )
+    const banner = screen.getByTestId('resume-session-banner')
+    expect(banner).toHaveTextContent('The Behavioral Interview')
+    expect(banner).toHaveTextContent('3 turns')
+  })
+
+  it('says "1 turn" after a single exchange', async () => {
+    mockApi.listSessions.mockResolvedValue({
+      ok: true,
+      data: { sessions: [{ ...SESSION, turn_count: 1 }] },
+    })
+    renderAt('/settings')
+    await waitFor(() =>
+      expect(screen.getByTestId('resume-session-banner')).toBeInTheDocument(),
+    )
+    const banner = screen.getByTestId('resume-session-banner')
+    expect(banner).toHaveTextContent('1 turn so far')
+    expect(banner).not.toHaveTextContent('1 turns')
+  })
+
+  it('resumes into the conversation it names', async () => {
+    mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [SESSION] } })
+    render(
+      <I18nProvider>
+        <MemoryRouter initialEntries={['/settings']}>
+          <Routes>
+            <Route path="/settings" element={<ResumeSessionBanner />} />
+            <Route path="/conversation/:id" element={<div data-testid="conversation" />} />
+          </Routes>
+        </MemoryRouter>
+      </I18nProvider>,
+    )
+    await waitFor(() => expect(screen.getByTestId('resume-session-button')).toBeInTheDocument())
+    fireEvent.click(screen.getByTestId('resume-session-button'))
+    await waitFor(() => expect(screen.getByTestId('conversation')).toBeInTheDocument())
+  })
+
+  it('asks only for the resumable set, and only for the newest one', async () => {
+    mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [SESSION] } })
+    renderAt('/settings')
+    await waitFor(() => expect(mockApi.listSessions).toHaveBeenCalled())
+    expect(mockApi.listSessions).toHaveBeenCalledWith('in_progress', 1)
+  })
+
+  it('renders nothing when there is no conversation to resume', async () => {
+    mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [] } })
+    renderAt('/settings')
+    await waitFor(() => expect(mockApi.listSessions).toHaveBeenCalled())
+    expect(screen.queryByTestId('resume-session-banner')).not.toBeInTheDocument()
+  })
+
+  it('stays quiet rather than stacking an error when the core is unreachable', async () => {
+    mockApi.listSessions.mockResolvedValue({
+      ok: false,
+      error: { kind: 'network', message: 'unreachable' },
+    })
+    renderAt('/settings')
+    await waitFor(() => expect(mockApi.listSessions).toHaveBeenCalled())
+    expect(screen.queryByTestId('resume-session-banner')).not.toBeInTheDocument()
+  })
+
+  it('tolerates a response shape this build does not expect', async () => {
+    mockApi.listSessions.mockResolvedValue({ ok: true, data: {} as never })
+    renderAt('/settings')
+    await waitFor(() => expect(mockApi.listSessions).toHaveBeenCalled())
+    expect(screen.queryByTestId('resume-session-banner')).not.toBeInTheDocument()
+  })
+
+  it('does not ask while the player is already in the conversation', async () => {
+    mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [SESSION] } })
+    renderAt('/conversation/sess-abc123')
+    await waitFor(() => expect(screen.getByTestId('page')).toBeInTheDocument())
+    expect(mockApi.listSessions).not.toHaveBeenCalled()
+    expect(screen.queryByTestId('resume-session-banner')).not.toBeInTheDocument()
+  })
+
+  it('does not ask while the player is reading a debrief', async () => {
+    mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [SESSION] } })
+    renderAt('/debrief/sess-abc123')
+    await waitFor(() => expect(screen.getByTestId('page')).toBeInTheDocument())
+    expect(mockApi.listSessions).not.toHaveBeenCalled()
+  })
+
+  it('ending the session clears the offer', async () => {
+    mockApi.listSessions
+      .mockResolvedValueOnce({ ok: true, data: { sessions: [SESSION] } })
+      .mockResolvedValue({ ok: true, data: { sessions: [] } })
+    renderAt('/settings')
+    await waitFor(() =>
+      expect(screen.getByTestId('resume-session-banner')).toBeInTheDocument(),
+    )
+    fireEvent.click(screen.getByTestId('resume-session-end-button'))
+    await waitFor(() =>
+      expect(screen.queryByTestId('resume-session-banner')).not.toBeInTheDocument(),
+    )
+    expect(mockApi.endSession).toHaveBeenCalledWith('sess-abc123')
+  })
+
+  it('ending the session shows the debrief it just produced', async () => {
+    // Ending a conversation always produces a debrief. Left on Settings, the
+    // player would have no way to the one they just earned.
+    mockApi.listSessions
+      .mockResolvedValueOnce({ ok: true, data: { sessions: [SESSION] } })
+      .mockResolvedValue({ ok: true, data: { sessions: [] } })
+    render(
+      <I18nProvider>
+        <MemoryRouter initialEntries={['/settings']}>
+          <Routes>
+            <Route path="/settings" element={<ResumeSessionBanner />} />
+            <Route path="/debrief/:id" element={<div data-testid="debrief" />} />
+          </Routes>
+        </MemoryRouter>
+      </I18nProvider>,
+    )
+    await waitFor(() =>
+      expect(screen.getByTestId('resume-session-end-button')).toBeInTheDocument(),
+    )
+    fireEvent.click(screen.getByTestId('resume-session-end-button'))
+    await waitFor(() => expect(screen.getByTestId('debrief')).toBeInTheDocument())
+  })
+
+  it('stays put when ending fails, so nothing claims a debrief exists', async () => {
+    mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [SESSION] } })
+    mockApi.endSession.mockResolvedValue({
+      ok: false,
+      error: { kind: 'network', message: 'unreachable' },
+    })
+    render(
+      <I18nProvider>
+        <MemoryRouter initialEntries={['/settings']}>
+          <Routes>
+            <Route path="/settings" element={<ResumeSessionBanner />} />
+            <Route path="/debrief/:id" element={<div data-testid="debrief" />} />
+          </Routes>
+        </MemoryRouter>
+      </I18nProvider>,
+    )
+    await waitFor(() =>
+      expect(screen.getByTestId('resume-session-end-button')).toBeInTheDocument(),
+    )
+    fireEvent.click(screen.getByTestId('resume-session-end-button'))
+    await waitFor(() => expect(mockApi.endSession).toHaveBeenCalled())
+    expect(screen.queryByTestId('debrief')).not.toBeInTheDocument()
+  })
+
+  it('re-asks when the window regains focus, so it cannot go stale', async () => {
+    // The session can be ended on another screen, or by another window.
+    mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [SESSION] } })
+    renderAt('/settings')
+    await waitFor(() => expect(mockApi.listSessions).toHaveBeenCalledTimes(1))
+    window.dispatchEvent(new Event('focus'))
+    await waitFor(() => expect(mockApi.listSessions).toHaveBeenCalledTimes(2))
+  })
+
+  it('falls back to the scenario id when the title has not loaded', async () => {
+    mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [SESSION] } })
+    mockApi.listScenarios.mockResolvedValue({ ok: true, data: [] })
+    renderAt('/settings')
+    await waitFor(() =>
+      expect(screen.getByTestId('resume-session-banner')).toBeInTheDocument(),
+    )
+    expect(screen.getByTestId('resume-session-banner')).toHaveTextContent(
+      'behavioral_interview',
+    )
+  })
+})
diff --git a/apps/web/src/__tests__/RuntimeSettingsPanel.test.tsx b/apps/web/src/__tests__/RuntimeSettingsPanel.test.tsx
index f97ae5db..ecdd7da4 100644
--- a/apps/web/src/__tests__/RuntimeSettingsPanel.test.tsx
+++ b/apps/web/src/__tests__/RuntimeSettingsPanel.test.tsx
@@ -48,6 +48,7 @@ function makeSettings(overrides: Partial<RuntimeSettingsResponse> = {}): Runtime
       temperature: null,
       top_p: null,
       repeat_penalty: null,
+      reply_speed: null,
     },
     recommended: {
       context_length: null,
@@ -56,6 +57,7 @@ function makeSettings(overrides: Partial<RuntimeSettingsResponse> = {}): Runtime
       temperature: null,
       top_p: null,
       repeat_penalty: null,
+      reply_speed: null,
     },
     requires_restart: false,
     ...overrides,
@@ -129,7 +131,7 @@ describe('RuntimeSettingsPanel — loading', () => {
     it('explains that an update is needed and links to the instructions', async () => {
       await renderPanel()
       const notice = await screen.findByRole('status', {
-        name: /runtime advanced settings unavailable/i,
+        name: /advanced engine settings unavailable/i,
       })
       expect(notice).toHaveTextContent(/not available in this version of ConversationSimulator/i)
       expect(notice).toHaveTextContent(/update to the latest version/i)
@@ -144,9 +146,9 @@ describe('RuntimeSettingsPanel — loading', () => {
 
     it('hides the advanced settings toggle, which the missing endpoint backs', async () => {
       await renderPanel()
-      await screen.findByRole('status', { name: /runtime advanced settings unavailable/i })
+      await screen.findByRole('status', { name: /advanced engine settings unavailable/i })
       expect(
-        screen.queryByRole('button', { name: /show runtime advanced settings/i }),
+        screen.queryByRole('button', { name: /show advanced engine settings/i }),
       ).not.toBeInTheDocument()
     })
   })
@@ -178,7 +180,7 @@ describe('RuntimeSettingsPanel — loading', () => {
     await renderPanel()
     await waitFor(() => expect(screen.getByRole('alert')).toBeInTheDocument())
     expect(
-      screen.queryByRole('status', { name: /runtime advanced settings unavailable/i }),
+      screen.queryByRole('status', { name: /advanced engine settings unavailable/i }),
     ).not.toBeInTheDocument()
   })
 })
@@ -359,13 +361,13 @@ describe('RuntimeSettingsPanel — advanced settings (hidden by default)', () =>
   it('shows a "Show advanced runtime settings" button', async () => {
     await renderPanel()
     expect(
-      screen.getByRole('button', { name: /show runtime advanced settings/i }),
+      screen.getByRole('button', { name: /show advanced engine settings/i }),
     ).toBeInTheDocument()
   })
 
   it('reveals advanced inputs after clicking show advanced', async () => {
     await renderPanel()
-    fireEvent.click(screen.getByRole('button', { name: /show runtime advanced settings/i }))
+    fireEvent.click(screen.getByRole('button', { name: /show advanced engine settings/i }))
     await waitFor(() =>
       expect(screen.getByRole('spinbutton', { name: /context length/i })).toBeInTheDocument(),
     )
@@ -373,9 +375,9 @@ describe('RuntimeSettingsPanel — advanced settings (hidden by default)', () =>
 
   it('collapses advanced section when hide advanced is clicked', async () => {
     await renderPanel()
-    fireEvent.click(screen.getByRole('button', { name: /show runtime advanced settings/i }))
+    fireEvent.click(screen.getByRole('button', { name: /show advanced engine settings/i }))
     await waitFor(() => screen.getByRole('spinbutton', { name: /context length/i }))
-    fireEvent.click(screen.getByRole('button', { name: /hide runtime advanced settings/i }))
+    fireEvent.click(screen.getByRole('button', { name: /hide advanced engine settings/i }))
     expect(
       screen.queryByRole('spinbutton', { name: /context length/i }),
     ).not.toBeInTheDocument()
@@ -387,7 +389,7 @@ describe('RuntimeSettingsPanel — advanced settings (hidden by default)', () =>
 describe('RuntimeSettingsPanel — advanced settings inputs', () => {
   async function openAdvanced() {
     await renderPanel()
-    fireEvent.click(screen.getByRole('button', { name: /show runtime advanced settings/i }))
+    fireEvent.click(screen.getByRole('button', { name: /show advanced engine settings/i }))
     await waitFor(() => screen.getByRole('spinbutton', { name: /context length/i }))
   }
 
@@ -410,6 +412,7 @@ describe('RuntimeSettingsPanel — advanced settings inputs', () => {
         temperature: 0.7,
         top_p: 0.9,
         repeat_penalty: 1.1,
+        reply_speed: null,
       },
     }) })
     await openAdvanced()
@@ -435,7 +438,7 @@ describe('RuntimeSettingsPanel — advanced settings inputs', () => {
 describe('RuntimeSettingsPanel — client-side validation', () => {
   async function openAdvanced() {
     await renderPanel()
-    fireEvent.click(screen.getByRole('button', { name: /show runtime advanced settings/i }))
+    fireEvent.click(screen.getByRole('button', { name: /show advanced engine settings/i }))
     await waitFor(() => screen.getByRole('spinbutton', { name: /context length/i }))
   }
 
@@ -539,7 +542,7 @@ describe('RuntimeSettingsPanel — client-side validation', () => {
 describe('RuntimeSettingsPanel — restart required warning', () => {
   async function openAdvanced() {
     await renderPanel()
-    fireEvent.click(screen.getByRole('button', { name: /show runtime advanced settings/i }))
+    fireEvent.click(screen.getByRole('button', { name: /show advanced engine settings/i }))
     await waitFor(() => screen.getByRole('spinbutton', { name: /context length/i }))
   }
 
@@ -581,7 +584,7 @@ describe('RuntimeSettingsPanel — restart required warning', () => {
 describe('RuntimeSettingsPanel — apply advanced and reset', () => {
   async function openAdvanced() {
     await renderPanel()
-    fireEvent.click(screen.getByRole('button', { name: /show runtime advanced settings/i }))
+    fireEvent.click(screen.getByRole('button', { name: /show advanced engine settings/i }))
     await waitFor(() => screen.getByRole('spinbutton', { name: /context length/i }))
   }
 
@@ -602,7 +605,7 @@ describe('RuntimeSettingsPanel — apply advanced and reset', () => {
 
   it('clears form fields after reset', async () => {
     mockApi.getRuntimeSettings.mockResolvedValue({ ok: true, data: makeSettings({
-      settings: { context_length: 4096, gpu_layers: null, threads: null, temperature: null, top_p: null, repeat_penalty: null },
+      settings: { context_length: 4096, gpu_layers: null, threads: null, temperature: null, top_p: null, repeat_penalty: null, reply_speed: null },
     }) })
     await openAdvanced()
     await waitFor(() => expect(screen.getByRole('spinbutton', { name: /context length/i })).toHaveValue(4096))
diff --git a/apps/web/src/__tests__/Settings.test.tsx b/apps/web/src/__tests__/Settings.test.tsx
index 9039eab3..3d431015 100644
--- a/apps/web/src/__tests__/Settings.test.tsx
+++ b/apps/web/src/__tests__/Settings.test.tsx
@@ -17,6 +17,8 @@ vi.mock('../api/client', () => ({
     getFolders: vi.fn(),
     clearLocalData: vi.fn(),
     listSessions: vi.fn(),
+    // Session rows are labelled by scenario title now, not slug (issue #501 §2).
+    listScenarios: vi.fn(),
     deleteSession: vi.fn(),
     exportSession: vi.fn(),
     getModels: vi.fn(),
@@ -76,6 +78,7 @@ const STUB_RUNTIME_SETTINGS = {
     temperature: null,
     top_p: null,
     repeat_penalty: null,
+    reply_speed: null,
   },
   recommended: {
     context_length: null,
@@ -84,6 +87,7 @@ const STUB_RUNTIME_SETTINGS = {
     temperature: null,
     top_p: null,
     repeat_penalty: null,
+    reply_speed: 'balanced' as const,
   },
   requires_restart: false,
 }
@@ -162,6 +166,7 @@ beforeEach(() => {
   mockApi.getDataFolder.mockResolvedValue({ ok: true, data: { path: '/home/user/.convsim/db' } })
   mockApi.getFolders.mockResolvedValue({ ok: true, data: STUB_FOLDERS })
   mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [] } })
+  mockApi.listScenarios.mockResolvedValue({ ok: true, data: [] })
   mockApi.listPacks.mockResolvedValue({ ok: true, data: { packs: [], total: 0 } })
   mockApi.importPack.mockResolvedValue({ ok: true, data: { pack_id: 'pack-alpha', name: 'Alpha Scenarios', version: '1.0.0', dest: '/tmp/pack-alpha' } })
   mockApi.validatePack.mockResolvedValue({ ok: true, data: { pack_id: 'pack-alpha', valid: true, errors: [] } })
@@ -646,7 +651,88 @@ describe('clear local data', () => {
 // Your sessions
 // ---------------------------------------------------------------------------
 
+// ── Issue #501 §1/§2: the two sections a lost first-time player needed ───────
+
+describe('reply speed and wording sections', () => {
+  it('names reply speed as its own section, anchored for a deep link', async () => {
+    await renderSettings()
+    await waitFor(() =>
+      expect(screen.getByTestId('settings-reply-speed-section')).toBeInTheDocument(),
+    )
+    // The conversation screen's slow-reply notice links to /settings#reply-speed.
+    expect(screen.getByTestId('settings-reply-speed-section')).toHaveAttribute(
+      'id',
+      'reply-speed',
+    )
+    expect(screen.getByRole('heading', { name: /reply speed/i })).toBeInTheDocument()
+  })
+
+  it('offers the wording levels', async () => {
+    await renderSettings()
+    await waitFor(() => expect(screen.getByTestId('wording-options')).toBeInTheDocument())
+    expect(screen.getByTestId('wording-plain')).toHaveAttribute('aria-checked', 'true')
+  })
+
+  it('calls the engine section what it is rather than "Runtime"', async () => {
+    await renderSettings()
+    await waitFor(() =>
+      expect(screen.getByRole('heading', { name: /^ai engine$/i })).toBeInTheDocument(),
+    )
+    expect(screen.queryByRole('heading', { name: /^runtime$/i })).not.toBeInTheDocument()
+  })
+})
+
 describe('your sessions', () => {
+  it('offers Resume for an unfinished session', async () => {
+    // Issue #501 §1: Settings is the screen the playtester got lost on, so
+    // every unfinished conversation is one click from here — not only the
+    // newest one the chrome banner offers.
+    mockApi.listSessions.mockResolvedValue({
+      ok: true,
+      data: { sessions: [{ ...SESSION_A, state: 'PlayerTurnListening' as const }] },
+    })
+    await renderSettings()
+    await waitFor(() =>
+      expect(screen.getByRole('button', { name: /resume session sess-aaa/i })).toBeInTheDocument(),
+    )
+  })
+
+  it('does not offer Resume for a finished session', async () => {
+    mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [SESSION_A] } })
+    await renderSettings()
+    await waitFor(() =>
+      expect(screen.getByRole('button', { name: /export session sess-aaa/i })).toBeInTheDocument(),
+    )
+    expect(screen.queryByRole('button', { name: /resume session/i })).not.toBeInTheDocument()
+  })
+
+  it('does not offer Resume for a session that never started', async () => {
+    // Nothing has been said yet, so there is no conversation to go back to.
+    mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [SESSION_B] } })
+    await renderSettings()
+    await waitFor(() =>
+      expect(screen.getByRole('button', { name: /export session sess-bbb/i })).toBeInTheDocument(),
+    )
+    expect(screen.queryByRole('button', { name: /resume session/i })).not.toBeInTheDocument()
+  })
+
+  it('labels a session by its scenario title and plain state', async () => {
+    mockApi.listScenarios.mockResolvedValue({
+      ok: true,
+      data: [{ scenario_id: 'behavioral_interview', title: 'The Behavioral Interview' } as never],
+    })
+    mockApi.listSessions.mockResolvedValue({
+      ok: true,
+      data: { sessions: [{ ...SESSION_A, state: 'PlayerTurnListening' as const }] },
+    })
+    await renderSettings()
+    await waitFor(() =>
+      expect(screen.getByText('The Behavioral Interview')).toBeInTheDocument(),
+    )
+    expect(screen.getByText('Your turn')).toBeInTheDocument()
+    expect(screen.queryByText('PlayerTurnListening')).not.toBeInTheDocument()
+  })
+
   it('shows "No sessions yet." when the list is empty', async () => {
     mockApi.listSessions.mockResolvedValue({ ok: true, data: { sessions: [] } })
     await renderSettings()
@@ -788,7 +874,7 @@ describe('advanced: raw audio saving', () => {
 
   it('advanced section appears after clicking show advanced', async () => {
     await renderSettings()
-    fireEvent.click(screen.getByRole('button', { name: /show advanced/i }))
+    fireEvent.click(screen.getByRole('button', { name: 'Show advanced' }))
     await waitFor(() =>
       expect(
         screen.getByRole('checkbox', { name: /save raw audio recordings/i }),
@@ -798,14 +884,14 @@ describe('advanced: raw audio saving', () => {
 
   it('raw audio saving is off by default', async () => {
     await renderSettings()
-    fireEvent.click(screen.getByRole('button', { name: /show advanced/i }))
+    fireEvent.click(screen.getByRole('button', { name: 'Show advanced' }))
     await waitFor(() => screen.getByRole('checkbox', { name: /save raw audio recordings/i }))
     expect(screen.getByRole('checkbox', { name: /save raw audio recordings/i })).not.toBeChecked()
   })
 
   it('shows a warning when raw audio saving is enabled', async () => {
     await renderSettings()
-    fireEvent.click(screen.getByRole('button', { name: /show advanced/i }))
+    fireEvent.click(screen.getByRole('button', { name: 'Show advanced' }))
     await waitFor(() => screen.getByRole('checkbox', { name: /save raw audio recordings/i }))
     fireEvent.click(screen.getByRole('checkbox', { name: /save raw audio recordings/i }))
     await waitFor(() =>
@@ -815,9 +901,9 @@ describe('advanced: raw audio saving', () => {
 
   it('advanced section collapses when hide advanced is clicked', async () => {
     await renderSettings()
-    fireEvent.click(screen.getByRole('button', { name: /show advanced/i }))
+    fireEvent.click(screen.getByRole('button', { name: 'Show advanced' }))
     await waitFor(() => screen.getByRole('checkbox', { name: /save raw audio recordings/i }))
-    fireEvent.click(screen.getByRole('button', { name: /hide advanced/i }))
+    fireEvent.click(screen.getByRole('button', { name: 'Hide advanced' }))
     expect(
       screen.queryByRole('checkbox', { name: /save raw audio recordings/i }),
     ).not.toBeInTheDocument()
@@ -842,7 +928,7 @@ describe('advanced: developer debug mode', () => {
 
   it('developer debug toggle appears after clicking Show advanced', async () => {
     await renderSettings()
-    fireEvent.click(screen.getByRole('button', { name: /show advanced/i }))
+    fireEvent.click(screen.getByRole('button', { name: 'Show advanced' }))
     await waitFor(() =>
       expect(
         screen.getByRole('checkbox', { name: /developer debug mode/i }),
@@ -852,14 +938,14 @@ describe('advanced: developer debug mode', () => {
 
   it('developer debug mode is off by default', async () => {
     await renderSettings()
-    fireEvent.click(screen.getByRole('button', { name: /show advanced/i }))
+    fireEvent.click(screen.getByRole('button', { name: 'Show advanced' }))
     await waitFor(() => screen.getByRole('checkbox', { name: /developer debug mode/i }))
     expect(screen.getByRole('checkbox', { name: /developer debug mode/i })).not.toBeChecked()
   })
 
   it('shows a warning when developer debug mode is enabled', async () => {
     await renderSettings()
-    fireEvent.click(screen.getByRole('button', { name: /show advanced/i }))
+    fireEvent.click(screen.getByRole('button', { name: 'Show advanced' }))
     await waitFor(() => screen.getByRole('checkbox', { name: /developer debug mode/i }))
     fireEvent.click(screen.getByRole('checkbox', { name: /developer debug mode/i }))
     await waitFor(() =>
@@ -869,7 +955,7 @@ describe('advanced: developer debug mode', () => {
 
   it('writes devMode to localStorage when toggled on', async () => {
     await renderSettings()
-    fireEvent.click(screen.getByRole('button', { name: /show advanced/i }))
+    fireEvent.click(screen.getByRole('button', { name: 'Show advanced' }))
     await waitFor(() => screen.getByRole('checkbox', { name: /developer debug mode/i }))
     fireEvent.click(screen.getByRole('checkbox', { name: /developer debug mode/i }))
     expect(localStorage.getItem('convsim.devMode')).toBe('true')
@@ -878,7 +964,7 @@ describe('advanced: developer debug mode', () => {
   it('initialises as checked when convsim.devMode is set in localStorage', async () => {
     localStorage.setItem('convsim.devMode', 'true')
     await renderSettings()
-    fireEvent.click(screen.getByRole('button', { name: /show advanced/i }))
+    fireEvent.click(screen.getByRole('button', { name: 'Show advanced' }))
     await waitFor(() => screen.getByRole('checkbox', { name: /developer debug mode/i }))
     expect(screen.getByRole('checkbox', { name: /developer debug mode/i })).toBeChecked()
   })
@@ -1004,14 +1090,17 @@ describe('demo edition', () => {
 
   it('hides model tiers, voice, Steam Cloud, packs, NPC memory, system health and advanced', async () => {
     await renderDemoSettings()
-    expect(screen.queryByRole('heading', { name: /^runtime$/i })).not.toBeInTheDocument()
+    expect(screen.queryByRole('heading', { name: /^ai engine$/i })).not.toBeInTheDocument()
+    // Reply speed is a model setting, so it follows the engine section out of
+    // the demo; wording is readability and stays (issue #501).
+    expect(screen.queryByTestId('settings-reply-speed-section')).not.toBeInTheDocument()
     expect(screen.queryByRole('link', { name: /open model manager/i })).not.toBeInTheDocument()
     expect(screen.queryByRole('heading', { name: /voice output/i })).not.toBeInTheDocument()
     expect(screen.queryByTestId('steam-cloud-section')).not.toBeInTheDocument()
     expect(screen.queryByRole('heading', { name: /pack management/i })).not.toBeInTheDocument()
     expect(screen.queryByTestId('relationship-memory-section')).not.toBeInTheDocument()
     expect(screen.queryByTestId('settings-system-health')).not.toBeInTheDocument()
-    expect(screen.queryByRole('button', { name: /show advanced/i })).not.toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: 'Show advanced' })).not.toBeInTheDocument()
   })
 
   it('does not call the full-app-only endpoints', async () => {
@@ -1021,6 +1110,11 @@ describe('demo edition', () => {
     expect(mockApi.listVoices).not.toHaveBeenCalled()
   })
 
+  it('keeps the wording control, which is readability rather than full-app depth', async () => {
+    await renderDemoSettings()
+    expect(screen.getByTestId('settings-wording-section')).toBeInTheDocument()
+  })
+
   it('says that clearing local data also clears the full version, which shares the folder', async () => {
     await renderDemoSettings()
     expect(screen.getByText(/shared with the full version of conversation simulator/i)).toBeInTheDocument()
diff --git a/apps/web/src/__tests__/accessibility.test.tsx b/apps/web/src/__tests__/accessibility.test.tsx
index 277d85c2..38a5d8a7 100644
--- a/apps/web/src/__tests__/accessibility.test.tsx
+++ b/apps/web/src/__tests__/accessibility.test.tsx
@@ -15,7 +15,7 @@
  */
 import React from 'react'
 import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { render, fireEvent } from '@testing-library/react'
+import { render, fireEvent, screen } from '@testing-library/react'
 import { Link, MemoryRouter, Route, Routes } from 'react-router-dom'
 import axe from 'axe-core'
 
@@ -509,9 +509,11 @@ describe('Accessibility: FirstRunWizard', () => {
         </Routes>
       </MemoryRouter>,
     )
-    // Clicking "Get started" transitions from welcome → loading; getModels is a pending
-    // promise in this test suite so the wizard stays on the loading step.
-    fireEvent.click(container.querySelector('button')!)
+    // Clicking the primary CTA transitions from welcome → loading; getModels is a
+    // pending promise in this test suite so the wizard stays on the loading step.
+    // Targeted by name, not position: the welcome step opens with the
+    // LLM-familiarity question (issue #501 §2).
+    fireEvent.click(screen.getByRole('button', { name: /set me up/i }))
     const newH1 = container.querySelector('h1')
     expect(document.activeElement).toBe(newH1)
   })
@@ -525,7 +527,7 @@ describe('Accessibility: FirstRunWizard', () => {
         </Routes>
       </MemoryRouter>,
     )
-    fireEvent.click(container.querySelector('button')!)
+    fireEvent.click(screen.getByRole('button', { name: /set me up/i }))
     const busyEl = container.querySelector('[aria-busy="true"]')
     expect(busyEl).not.toBeNull()
   })
@@ -592,7 +594,7 @@ describe('Accessibility: FirstRunWizard', () => {
 
     // Click "Set me up" — with an empty registry there is no starter model,
     // so the loading step falls back to the choose step.
-    fireEvent.click(container.querySelector('button')!)
+    fireEvent.click(screen.getByRole('button', { name: /set me up/i }))
 
     // Wait for the choose step to appear.
     await vi.waitFor(() => {
diff --git a/apps/web/src/__tests__/edition.test.tsx b/apps/web/src/__tests__/edition.test.tsx
index e59a40d3..3042a2fc 100644
--- a/apps/web/src/__tests__/edition.test.tsx
+++ b/apps/web/src/__tests__/edition.test.tsx
@@ -423,8 +423,8 @@ describe('Home — demo edition', () => {
     await screen.findAllByTestId('demo-conversation-card')
     expect(screen.queryByRole('heading', { name: /training plan/i })).not.toBeInTheDocument()
     expect(screen.queryByRole('heading', { name: /your training/i })).not.toBeInTheDocument()
-    expect(screen.queryByText(/^STT:/)).not.toBeInTheDocument()
-    expect(screen.queryByText(/^TTS:/)).not.toBeInTheDocument()
+    expect(screen.queryByText(/^Voice input:/)).not.toBeInTheDocument()
+    expect(screen.queryByText(/^Voice output:/)).not.toBeInTheDocument()
     expect(screen.queryByText(/^Packs:/)).not.toBeInTheDocument()
   })
 
@@ -454,7 +454,7 @@ describe('Home — demo edition', () => {
   it('keeps the engine status and help sections', async () => {
     stubFetches(DEMO_HEALTH, FIVE)
     renderHome()
-    expect(await screen.findByText((_, el) => el?.tagName === 'LI' && el.textContent?.trim() === 'Local runtime: Ready')).toBeInTheDocument()
+    expect(await screen.findByText((_, el) => el?.tagName === 'LI' && el.textContent?.trim() === 'AI engine: Ready')).toBeInTheDocument()
     expect(screen.getByRole('heading', { name: /^help$/i })).toBeInTheDocument()
   })
 })
diff --git a/apps/web/src/__tests__/plainLanguage.test.ts b/apps/web/src/__tests__/plainLanguage.test.ts
new file mode 100644
index 00000000..929a93da
--- /dev/null
+++ b/apps/web/src/__tests__/plainLanguage.test.ts
@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, it, expect, beforeEach } from 'vitest'
+import {
+  DEFAULT_UI_LANGUAGE_LEVEL,
+  FLOW_STATE_LABELS,
+  UI_LANGUAGE_KEYS,
+  hasSeenFamiliarityReask,
+  humanizeEndingType,
+  humanizeFlags,
+  humanizeIdentifier,
+  flowStateLabelKey,
+  levelForFamiliarity,
+  markFamiliarityReaskShown,
+  plainFlowState,
+  readLlmFamiliarity,
+  readUiLanguageLevel,
+  writeLlmFamiliarity,
+  writeUiLanguageLevel,
+} from '../lib/plainLanguage'
+import { en } from '../i18n/locales/en'
+import { de } from '../i18n/locales/de'
+
+/** Issue #501 §2: the buffer between player-facing and technical language. */
+beforeEach(() => {
+  localStorage.clear()
+})
+
+describe('wording level', () => {
+  it('defaults to plain for a player who was never asked', () => {
+    // Plain is the safe direction: Settings is one click away, but a first
+    // session reading `PlayerTurnListening` is not recoverable.
+    expect(readUiLanguageLevel()).toBe('plain')
+    expect(DEFAULT_UI_LANGUAGE_LEVEL).toBe('plain')
+  })
+
+  it('round-trips a chosen level', () => {
+    writeUiLanguageLevel('technical')
+    expect(readUiLanguageLevel()).toBe('technical')
+    writeUiLanguageLevel('plain')
+    expect(readUiLanguageLevel()).toBe('plain')
+  })
+
+  it('reads an unrecognised stored value as plain', () => {
+    localStorage.setItem(UI_LANGUAGE_KEYS.level, 'expert-mode')
+    expect(readUiLanguageLevel()).toBe('plain')
+  })
+
+  it('notifies this document so a mounted screen re-reads it', () => {
+    // `storage` only fires in other documents, so flipping the switch in
+    // Settings would never reach a Conversation mounted behind it.
+    let fired = 0
+    const listener = () => { fired += 1 }
+    window.addEventListener('convsim:ui-language-level', listener)
+    writeUiLanguageLevel('technical')
+    window.removeEventListener('convsim:ui-language-level', listener)
+    expect(fired).toBe(1)
+  })
+})
+
+describe('familiarity answers', () => {
+  it('only the player who works with language models gets the identifiers', () => {
+    expect(levelForFamiliarity('new')).toBe('plain')
+    expect(levelForFamiliarity('some')).toBe('plain')
+    expect(levelForFamiliarity('expert')).toBe('technical')
+  })
+
+  it('an answer applies the level it implies', () => {
+    writeLlmFamiliarity('expert')
+    expect(readUiLanguageLevel()).toBe('technical')
+    writeLlmFamiliarity('new')
+    expect(readUiLanguageLevel()).toBe('plain')
+  })
+
+  it('remembers the answer so the re-ask can preselect it', () => {
+    expect(readLlmFamiliarity()).toBeNull()
+    writeLlmFamiliarity('some')
+    expect(readLlmFamiliarity()).toBe('some')
+  })
+
+  it('tracks whether the post-tutorial re-ask has been shown', () => {
+    expect(hasSeenFamiliarityReask()).toBe(false)
+    markFamiliarityReaskShown()
+    expect(hasSeenFamiliarityReask()).toBe(true)
+  })
+})
+
+describe('humanizers', () => {
+  it('turns a snake_case identifier into a sentence-cased label', () => {
+    expect(humanizeIdentifier('objective_progress')).toBe('Objective progress')
+    expect(humanizeIdentifier('trust')).toBe('Trust')
+    expect(humanizeIdentifier('preparation-score')).toBe('Preparation score')
+  })
+
+  it('leaves an empty identifier alone rather than producing an empty label', () => {
+    expect(humanizeIdentifier('')).toBe('')
+  })
+
+  it('joins several flags into one readable phrase', () => {
+    expect(humanizeFlags(['honesty_demonstrated', 'player_demonstrates_knowledge'])).toBe(
+      'Honesty demonstrated · Player demonstrates knowledge',
+    )
+  })
+
+  it('says what the NPC is doing instead of naming the flow state', () => {
+    expect(plainFlowState('PlayerTurnListening')).toBe('Your turn')
+    expect(plainFlowState('NpcThinking')).toBe('Writing a reply')
+    expect(plainFlowState('ScenarioEvent')).toBe('Something is changing')
+    expect(plainFlowState('Ended')).toBe('Finished')
+  })
+
+  it('never prints an unmapped flow state raw at a player', () => {
+    expect(plainFlowState('SomeFutureState')).toBe('In progress')
+    expect(plainFlowState('SomeFutureState')).not.toContain('SomeFutureState')
+  })
+
+  it('reads an ending type as words', () => {
+    expect(humanizeEndingType('player_exit')).toBe('player exit')
+    expect(humanizeEndingType('safety_stop')).toBe('safety stop')
+  })
+})
+
+describe('flow-state labels reach a translated screen', () => {
+  // Settings is an i18n-migrated screen, so the session list must render these
+  // through t() — printing the English table there would show a German player
+  // "Your turn" in an otherwise German UI.
+  it('maps a known state to its own locale key', () => {
+    expect(flowStateLabelKey('PlayerTurnListening')).toBe('sessionStates.PlayerTurnListening')
+  })
+
+  it('maps a state this build does not know to the unknown key', () => {
+    expect(flowStateLabelKey('SomeFutureState')).toBe('sessionStates.unknown')
+    // `unknown` is the fallback, never a state identifier a caller can ask for.
+    expect(flowStateLabelKey('unknown')).toBe('sessionStates.unknown')
+  })
+
+  it('every label in the English table has a key in every catalog', () => {
+    const states = Object.keys(FLOW_STATE_LABELS)
+    expect(states).toContain('unknown')
+    for (const catalog of [en, de]) {
+      const entries = (catalog as unknown as { sessionStates: Record<string, string> })
+        .sessionStates
+      expect(Object.keys(entries).sort()).toEqual(states.sort())
+      for (const state of states) expect(entries[state]).toBeTruthy()
+    }
+  })
+
+  it('the English catalog says exactly what the English table says', () => {
+    expect((en as unknown as { sessionStates: Record<string, string> }).sessionStates).toEqual(
+      FLOW_STATE_LABELS,
+    )
+  })
+})
diff --git a/apps/web/src/__tests__/wholeTurns.test.ts b/apps/web/src/__tests__/wholeTurns.test.ts
new file mode 100644
index 00000000..c361d38a
--- /dev/null
+++ b/apps/web/src/__tests__/wholeTurns.test.ts
@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, it, expect } from 'vitest'
+import { wholeTurnNumbersFor } from '../lib/wholeTurns'
+
+/**
+ * Issue #501 §4: one turn is the player's message plus the reply to it. The
+ * transcript used to number half-turns, so a debrief key moment at "turn 3"
+ * and the transcript's "Turn 3" pointed at different moments.
+ */
+describe('wholeTurnNumbersFor', () => {
+  it('returns nothing for an empty transcript', () => {
+    expect(wholeTurnNumbersFor([])).toEqual([])
+  })
+
+  it('gives the opening turn 0', () => {
+    expect(wholeTurnNumbersFor([{ event_type: 'npc_opening' }])).toEqual([0])
+  })
+
+  it('numbers a player message and the reply to it as one turn', () => {
+    expect(
+      wholeTurnNumbersFor([
+        { event_type: 'npc_opening' },
+        { event_type: 'player_turn' },
+        { event_type: 'npc_turn' },
+      ]),
+    ).toEqual([0, 1, 1])
+  })
+
+  it('counts successive exchanges', () => {
+    expect(
+      wholeTurnNumbersFor([
+        { event_type: 'npc_opening' },
+        { event_type: 'player_turn' },
+        { event_type: 'npc_turn' },
+        { event_type: 'player_turn' },
+        { event_type: 'npc_turn' },
+        { event_type: 'player_turn' },
+        { event_type: 'npc_turn' },
+      ]),
+    ).toEqual([0, 1, 1, 2, 2, 3, 3])
+  })
+
+  it('numbers a turn still awaiting its reply', () => {
+    expect(
+      wholeTurnNumbersFor([
+        { event_type: 'npc_opening' },
+        { event_type: 'player_turn' },
+        { event_type: 'npc_turn' },
+        { event_type: 'player_turn' },
+      ]),
+    ).toEqual([0, 1, 1, 2])
+  })
+
+  it('reads transcript rows as well as export events', () => {
+    // GET /sessions/{id}/transcript says role; the session export says
+    // event_type. Both have to label the same way.
+    expect(
+      wholeTurnNumbersFor([
+        { role: 'npc_opening' },
+        { role: 'player' },
+        { role: 'npc' },
+        { role: 'player' },
+        { role: 'npc' },
+      ]),
+    ).toEqual([0, 1, 1, 2, 2])
+  })
+
+  it('does not merge two replies into one turn', () => {
+    // Two NPC rows in a row must stay distinguishable: they are separate
+    // moments, and a key moment pointing at either has to land on the right one.
+    expect(
+      wholeTurnNumbersFor([
+        { event_type: 'player_turn' },
+        { event_type: 'npc_turn' },
+        { event_type: 'npc_turn' },
+      ]),
+    ).toEqual([1, 1, 2])
+  })
+
+  it('counts a transcript with no opening from turn 1', () => {
+    expect(
+      wholeTurnNumbersFor([{ event_type: 'player_turn' }, { event_type: 'npc_turn' }]),
+    ).toEqual([1, 1])
+  })
+})
diff --git a/apps/web/src/__tests__/wording.test.tsx b/apps/web/src/__tests__/wording.test.tsx
new file mode 100644
index 00000000..ef96f703
--- /dev/null
+++ b/apps/web/src/__tests__/wording.test.tsx
@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, it, expect, beforeEach } from 'vitest'
+import { render, screen, fireEvent } from '@testing-library/react'
+import { I18nProvider } from '../i18n'
+import WordingPanel from '../components/WordingPanel'
+import FamiliarityQuestion from '../components/FamiliarityQuestion'
+import FamiliarityReaskCard from '../components/FamiliarityReaskCard'
+import { UI_LANGUAGE_KEYS, readLlmFamiliarity, readUiLanguageLevel } from '../lib/plainLanguage'
+
+function renderIn(ui: React.ReactElement) {
+  return render(<I18nProvider>{ui}</I18nProvider>)
+}
+
+beforeEach(() => {
+  localStorage.clear()
+})
+
+/**
+ * Issue #501 §2: "customizable buffers between user and technical language,
+ * perhaps chosen by an initial LLM familiarity question. That question might
+ * be asked again after completing the tutorial."
+ */
+describe('WordingPanel', () => {
+  it('shows plain wording as the active level by default', () => {
+    renderIn(<WordingPanel />)
+    expect(screen.getByTestId('wording-plain')).toHaveAttribute('aria-checked', 'true')
+    expect(screen.getByTestId('wording-technical')).toHaveAttribute('aria-checked', 'false')
+  })
+
+  it('switching to technical persists and takes effect', () => {
+    renderIn(<WordingPanel />)
+    fireEvent.click(screen.getByTestId('wording-technical'))
+    expect(readUiLanguageLevel()).toBe('technical')
+    expect(screen.getByTestId('wording-technical')).toHaveAttribute('aria-checked', 'true')
+  })
+
+  it('reflects a level chosen elsewhere', () => {
+    localStorage.setItem(UI_LANGUAGE_KEYS.level, 'technical')
+    renderIn(<WordingPanel />)
+    expect(screen.getByTestId('wording-technical')).toHaveAttribute('aria-checked', 'true')
+  })
+})
+
+describe('FamiliarityQuestion', () => {
+  it('asks about the player, not about the setting', () => {
+    // Nobody arriving for the first time knows whether they want "technical
+    // wording"; everyone knows whether they work with language models.
+    renderIn(<FamiliarityQuestion heading="How familiar are you with AI language models?" />)
+    expect(
+      screen.getByText('How familiar are you with AI language models?'),
+    ).toBeInTheDocument()
+    expect(screen.getByTestId('familiarity-new')).toHaveTextContent('New to this')
+    expect(screen.getByTestId('familiarity-expert')).toHaveTextContent('I work with them')
+  })
+
+  it('"new to this" keeps plain wording', () => {
+    renderIn(<FamiliarityQuestion heading="q" />)
+    fireEvent.click(screen.getByTestId('familiarity-new'))
+    expect(readLlmFamiliarity()).toBe('new')
+    expect(readUiLanguageLevel()).toBe('plain')
+  })
+
+  it('"I work with them" turns the identifiers on', () => {
+    renderIn(<FamiliarityQuestion heading="q" />)
+    fireEvent.click(screen.getByTestId('familiarity-expert'))
+    expect(readUiLanguageLevel()).toBe('technical')
+  })
+
+  it('leaves plain wording in place when nobody answers', () => {
+    renderIn(<FamiliarityQuestion heading="q" />)
+    expect(readLlmFamiliarity()).toBeNull()
+    expect(readUiLanguageLevel()).toBe('plain')
+  })
+
+  it('shows the answer as selected the moment it is clicked', () => {
+    // On the first-run Welcome step nothing else re-renders when an answer is
+    // written, so a storage-only read left every option unselected and the
+    // player's answer looked ignored.
+    renderIn(<FamiliarityQuestion heading="q" />)
+    fireEvent.click(screen.getByTestId('familiarity-new'))
+    expect(screen.getByTestId('familiarity-new')).toHaveAttribute('aria-checked', 'true')
+    expect(screen.getByTestId('familiarity-expert')).toHaveAttribute('aria-checked', 'false')
+  })
+
+  it('preselects a previous answer', () => {
+    renderIn(<FamiliarityQuestion heading="q" />)
+    fireEvent.click(screen.getByTestId('familiarity-some'))
+    // Re-render as the post-tutorial re-ask would.
+    renderIn(<FamiliarityQuestion heading="q again" />)
+    const options = screen.getAllByTestId('familiarity-some')
+    expect(options[options.length - 1]).toHaveAttribute('aria-checked', 'true')
+  })
+})
+
+describe('FamiliarityReaskCard', () => {
+  it('appears on the tutorial debrief', () => {
+    renderIn(<FamiliarityReaskCard scenarioId="first_words_tutorial" />)
+    expect(screen.getByTestId('familiarity-reask')).toBeInTheDocument()
+  })
+
+  it('does not appear on any other debrief', () => {
+    const { container } = renderIn(<FamiliarityReaskCard scenarioId="behavioral_interview" />)
+    expect(container).toBeEmptyDOMElement()
+  })
+
+  it('does not appear when the scenario is unknown', () => {
+    const { container } = renderIn(<FamiliarityReaskCard scenarioId={null} />)
+    expect(container).toBeEmptyDOMElement()
+  })
+
+  it('appears once — ignoring it counts as an answer', () => {
+    // The debrief's action buttons navigate away, so most players will never
+    // click this. Re-nagging after every later session is the failure mode.
+    const first = renderIn(<FamiliarityReaskCard scenarioId="first_words_tutorial" />)
+    expect(screen.getByTestId('familiarity-reask')).toBeInTheDocument()
+    first.unmount()
+
+    const second = renderIn(<FamiliarityReaskCard scenarioId="first_words_tutorial" />)
+    expect(second.container).toBeEmptyDOMElement()
+  })
+
+  it('applies an answer and confirms it in place', () => {
+    renderIn(<FamiliarityReaskCard scenarioId="first_words_tutorial" />)
+    fireEvent.click(screen.getByTestId('familiarity-expert'))
+    expect(readUiLanguageLevel()).toBe('technical')
+    expect(screen.getByText(/technical detail is on/i)).toBeInTheDocument()
+  })
+
+  it('can be dismissed without answering', () => {
+    renderIn(<FamiliarityReaskCard scenarioId="first_words_tutorial" />)
+    fireEvent.click(screen.getByTestId('familiarity-reask-dismiss'))
+    expect(screen.queryByTestId('familiarity-reask')).not.toBeInTheDocument()
+    expect(readUiLanguageLevel()).toBe('plain')
+  })
+})
diff --git a/apps/web/src/api/client.ts b/apps/web/src/api/client.ts
index 8733d3af..24c88b30 100644
--- a/apps/web/src/api/client.ts
+++ b/apps/web/src/api/client.ts
@@ -18,6 +18,8 @@ import type {
   PackValidationResult,
   SessionCreateRequest,
   SessionCreateResponse,
+  SessionListResponse,
+  SessionListStatus,
   SessionStartResponse,
   TurnResponse,
   SessionEndResponse,
@@ -468,8 +470,24 @@ export const api = {
   validatePack(packId: string): Promise<ApiResult<PackValidationResult>> {
     return post<PackValidationResult>(`/packs/${packId}/validate`)
   },
-  listSessions(): Promise<ApiResult<{ sessions: SessionCreateResponse[] }>> {
-    return get<{ sessions: SessionCreateResponse[] }>('/sessions')
+  /** Sessions in this profile, newest first.
+   *  `status: 'in_progress'` is the resumable set — started and not ended —
+   *  which is what the resume entry points offer (issue #501). */
+  listSessions(
+    status: SessionListStatus = 'all',
+    limit?: number,
+  ): Promise<ApiResult<SessionListResponse>> {
+    const params = new URLSearchParams()
+    if (status !== 'all') params.set('status', status)
+    if (limit != null) params.set('limit', String(limit))
+    const query = params.toString()
+    return get<SessionListResponse>(`/sessions${query ? `?${query}` : ''}`)
+  },
+  /** One session's row, including the setup it was created with. Resuming reads
+   *  the setup back from here when the launch-time route state is gone — after
+   *  navigating away, a reload, or a relaunch (issue #501). */
+  getSession(sessionId: string): Promise<ApiResult<SessionCreateResponse>> {
+    return get<SessionCreateResponse>(`/sessions/${sessionId}`)
   },
   getLogbookProfile(): Promise<ApiResult<LogbookProfile>> {
     return get<LogbookProfile>('/logbook/profile')
diff --git a/apps/web/src/api/errors.ts b/apps/web/src/api/errors.ts
index 33b2e45a..66aca10b 100644
--- a/apps/web/src/api/errors.ts
+++ b/apps/web/src/api/errors.ts
@@ -23,7 +23,7 @@ interface ErrorCopy {
 
 export const ERROR_COPY: Record<ErrorKind, ErrorCopy> = {
   'runtime-unreachable': {
-    title: 'Local runtime is unavailable',
+    title: 'The AI engine is unavailable',
     description:
       'The local service is not responding. Make sure the application started correctly, then try again.',
     action: 'Try again',
diff --git a/apps/web/src/components/FamiliarityQuestion.tsx b/apps/web/src/components/FamiliarityQuestion.tsx
new file mode 100644
index 00000000..806f26c9
--- /dev/null
+++ b/apps/web/src/components/FamiliarityQuestion.tsx
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: Apache-2.0
+import { useState } from 'react'
+import { useTranslation } from '../i18n'
+import {
+  readLlmFamiliarity,
+  writeLlmFamiliarity,
+  type LlmFamiliarity,
+} from '../lib/plainLanguage'
+
+const ANSWERS: LlmFamiliarity[] = ['new', 'some', 'expert']
+
+/**
+ * "How familiar are you with AI language models?" (issue #501 §2).
+ *
+ * The note asked for the wording buffer to be "chosen by an initial LLM
+ * familiarity question", so this is a question about the player rather than a
+ * setting about the app: nobody arriving for the first time knows whether they
+ * want "technical wording", but everyone knows whether they work with language
+ * models.
+ *
+ * Deliberately not a wizard step and never blocking. Answering is one click,
+ * skipping it is free, and the unanswered default is plain wording — the safe
+ * direction, since Settings is one click away and a first session reading
+ * `PlayerTurnListening` is not recoverable.
+ */
+export default function FamiliarityQuestion({
+  heading,
+  onAnswered,
+  compact = false,
+}: {
+  /** Which phrasing to use — first run, or the post-tutorial re-ask. */
+  heading: string
+  onAnswered?: (answer: LlmFamiliarity) => void
+  compact?: boolean
+}) {
+  const { t } = useTranslation()
+  // Held in state, not read fresh from storage each render: on the first-run
+  // Welcome step nothing else re-renders when an answer is written, so a
+  // storage-only read left every option unselected after the click — the
+  // player tells the app how familiar they are and the app appears to ignore
+  // them.
+  const [current, setCurrent] = useState<LlmFamiliarity | null>(readLlmFamiliarity)
+
+  return (
+    <div data-testid="familiarity-question">
+      <p
+        style={{
+          margin: '0 0 0.5rem',
+          fontSize: compact ? '0.875rem' : '0.95rem',
+          color: '#e4e4e7',
+          fontWeight: 600,
+        }}
+      >
+        {heading}
+      </p>
+      <div
+        role="radiogroup"
+        aria-label={heading}
+        style={{ display: 'flex', gap: '0.5rem', flexWrap: 'wrap' }}
+      >
+        {ANSWERS.map((answer) => {
+          const selected = answer === current
+          return (
+            <button
+              key={answer}
+              role="radio"
+              aria-checked={selected}
+              data-testid={`familiarity-${answer}`}
+              onClick={() => {
+                writeLlmFamiliarity(answer)
+                setCurrent(answer)
+                onAnswered?.(answer)
+              }}
+              style={{
+                flex: '1 1 9rem',
+                textAlign: 'left',
+                padding: '0.5rem 0.7rem',
+                borderRadius: '6px',
+                border: selected
+                  ? '1px solid rgba(99,102,241,0.7)'
+                  : '1px solid rgba(255,255,255,0.12)',
+                background: selected ? 'rgba(99,102,241,0.15)' : 'transparent',
+                color: 'inherit',
+                cursor: 'pointer',
+                font: 'inherit',
+              }}
+            >
+              <span style={{ display: 'block', fontWeight: 600, fontSize: '0.85rem' }}>
+                {t(`familiarity.${answer}.label`)}
+              </span>
+              <span style={{ display: 'block', fontSize: '0.75rem', color: '#a1a1aa' }}>
+                {t(`familiarity.${answer}.detail`)}
+              </span>
+            </button>
+          )
+        })}
+      </div>
+    </div>
+  )
+}
diff --git a/apps/web/src/components/FamiliarityReaskCard.tsx b/apps/web/src/components/FamiliarityReaskCard.tsx
new file mode 100644
index 00000000..6c415d45
--- /dev/null
+++ b/apps/web/src/components/FamiliarityReaskCard.tsx
@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: Apache-2.0
+import { useEffect, useState } from 'react'
+import { useTranslation } from '../i18n'
+import FamiliarityQuestion from './FamiliarityQuestion'
+import {
+  hasSeenFamiliarityReask,
+  levelForFamiliarity,
+  markFamiliarityReaskShown,
+} from '../lib/plainLanguage'
+
+/** The scenario whose debrief triggers the re-ask. */
+export const TUTORIAL_SCENARIO_ID = 'first_words_tutorial'
+
+/**
+ * The post-tutorial re-ask (issue #501 §2).
+ *
+ * "That question might be asked again after completing the tutorial" — because
+ * a player who answered "new to this" before seeing anything now knows what
+ * the app actually shows them, and may want more or less of it.
+ *
+ * Automatic but not blocking, and shown once: a card on the tutorial debrief,
+ * among the other things that debrief offers, rather than a modal in front of
+ * it. It marks itself seen when it renders, so ignoring it — which is what
+ * most players will do, since the debrief's buttons navigate away — counts as
+ * an answer of "leave it alone" instead of re-nagging after the next session.
+ */
+export default function FamiliarityReaskCard({ scenarioId }: { scenarioId?: string | null }) {
+  const { t } = useTranslation()
+  const [visible, setVisible] = useState(
+    () => scenarioId === TUTORIAL_SCENARIO_ID && !hasSeenFamiliarityReask(),
+  )
+  const [applied, setApplied] = useState<'plain' | 'technical' | null>(null)
+
+  useEffect(() => {
+    if (visible) markFamiliarityReaskShown()
+  }, [visible])
+
+  if (!visible) return null
+
+  return (
+    <section
+      data-testid="familiarity-reask"
+      aria-label={t('familiarity.reaskQuestion')}
+      style={{
+        padding: '0.85rem 1rem',
+        borderRadius: 8,
+        border: '1px solid rgba(99,102,241,0.3)',
+        background: 'rgba(99,102,241,0.07)',
+      }}
+    >
+      <FamiliarityQuestion
+        heading={t('familiarity.reaskQuestion')}
+        compact
+        onAnswered={(answer) => setApplied(levelForFamiliarity(answer))}
+      />
+      <div
+        style={{
+          display: 'flex',
+          alignItems: 'center',
+          gap: '0.75rem',
+          flexWrap: 'wrap',
+          marginTop: '0.6rem',
+        }}
+      >
+        <p aria-live="polite" style={{ margin: 0, fontSize: '0.78rem', color: applied ? '#86efac' : '#71717a', flex: 1 }}>
+          {applied === 'plain'
+            ? t('familiarity.appliedPlain')
+            : applied === 'technical'
+            ? t('familiarity.appliedTechnical')
+            : t('familiarity.reaskHint')}
+        </p>
+        <button
+          onClick={() => setVisible(false)}
+          data-testid="familiarity-reask-dismiss"
+          style={{
+            padding: '0.25rem 0.7rem',
+            borderRadius: '4px',
+            border: '1px solid rgba(255,255,255,0.15)',
+            background: 'transparent',
+            color: '#a1a1aa',
+            fontSize: '0.78rem',
+            cursor: 'pointer',
+          }}
+        >
+          {applied ? t('familiarity.keep') : t('familiarity.skip')}
+        </button>
+      </div>
+    </section>
+  )
+}
diff --git a/apps/web/src/components/OfflineIndicator.tsx b/apps/web/src/components/OfflineIndicator.tsx
index 14d64841..355817ca 100644
--- a/apps/web/src/components/OfflineIndicator.tsx
+++ b/apps/web/src/components/OfflineIndicator.tsx
@@ -2,10 +2,13 @@
 import { StatusBadge } from '@convsim/ui'
 import { useApiHealth } from '../api/useApiHealth'
 
+// "AI engine", not "runtime": this badge is in the app header on every screen,
+// so it is the single most-seen label in the app, and 'runtime' is one of the
+// four words the issue #501 playtest named as unexplained jargon.
 const LABELS = {
-  loading: 'Local runtime: Checking…',
-  healthy: 'Local runtime: Ready',
-  unavailable: 'Local runtime: Unavailable',
+  loading: 'AI engine: Checking…',
+  healthy: 'AI engine: Ready',
+  unavailable: 'AI engine: Unavailable',
 } as const
 
 export default function OfflineIndicator() {
diff --git a/apps/web/src/components/PerformanceWarning.tsx b/apps/web/src/components/PerformanceWarning.tsx
index bd19133d..e44d0c7c 100644
--- a/apps/web/src/components/PerformanceWarning.tsx
+++ b/apps/web/src/components/PerformanceWarning.tsx
@@ -47,9 +47,13 @@ export default function PerformanceWarningBanner({ warnings }: PerformanceWarnin
             <strong>{w.title}:</strong> {w.detail}
           </span>
           {!isDemo && (
+          // "Runtime" is one of the four words the issue #501 playtest named as
+          // unexplained jargon, and this button renders on the conversation
+          // screen — right above the slow-reply notice that now offers "Make
+          // replies faster →". Plain wording, and the same destination.
           <button
             onClick={() => navigate('/settings')}
-            aria-label="Open Runtime Settings"
+            aria-label="Open settings"
             style={{
               padding: '0.25rem 0.75rem',
               borderRadius: 4,
@@ -61,7 +65,7 @@ export default function PerformanceWarningBanner({ warnings }: PerformanceWarnin
               flexShrink: 0,
             }}
           >
-            Runtime Settings
+            Open settings
           </button>
           )}
         </div>
diff --git a/apps/web/src/components/ReplySpeedPanel.tsx b/apps/web/src/components/ReplySpeedPanel.tsx
new file mode 100644
index 00000000..8d8441b8
--- /dev/null
+++ b/apps/web/src/components/ReplySpeedPanel.tsx
@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: Apache-2.0
+import { useCallback, useEffect, useState } from 'react'
+import { Link } from 'react-router-dom'
+import { api } from '../api/client'
+import { REPLY_SPEEDS } from '@convsim/shared'
+import type { ReplySpeed } from '@convsim/shared'
+import type { ApiError } from '../api/errors'
+import { ApiErrorView } from './ApiErrorView'
+import { useTranslation } from '../i18n'
+
+/**
+ * "Make the model respond faster", as a thing the app actually offers
+ * (issue #501 §1).
+ *
+ * The playtester went to Settings mid-tutorial to speed the model up and was
+ * "a little unclear on how to do that": the only knobs were context length,
+ * GPU layers, CPU threads and sampling, all behind a "Show runtime advanced
+ * settings" toggle and all written in runtime terms. None of them is named
+ * after what they wanted.
+ *
+ * Three named options, each with a two- or three-word descriptor — the pattern
+ * the note asked for ("3 Flash, 3 Pro" paired with "all-around thinking,
+ * advanced reasoning"). What they do lives in convsim-core's reply_speed
+ * setting; this only has to name them honestly and say what the trade is.
+ */
+export default function ReplySpeedPanel() {
+  const { t } = useTranslation()
+  const [speed, setSpeed] = useState<ReplySpeed>('balanced')
+  const [loadError, setLoadError] = useState<ApiError | null>(null)
+  const [unavailable, setUnavailable] = useState(false)
+  const [saving, setSaving] = useState(false)
+  const [saved, setSaved] = useState(false)
+  const [saveError, setSaveError] = useState<ApiError | null>(null)
+
+  const load = useCallback(async () => {
+    setLoadError(null)
+    const r = await api.getRuntimeSettings()
+    if (!r.ok) {
+      // A bundled runtime that predates /api/runtime/settings answers 404.
+      // RuntimeSettingsPanel already explains that and points at the update, so
+      // this control just steps aside rather than stacking a second notice.
+      if (r.error.kind === 'http-error' && r.error.status === 404) {
+        setUnavailable(true)
+        return
+      }
+      setLoadError(r.error)
+      return
+    }
+    setSpeed(r.data.settings.reply_speed ?? 'balanced')
+  }, [])
+
+  useEffect(() => {
+    void load()
+  }, [load])
+
+  async function choose(next: ReplySpeed) {
+    if (next === speed) return
+    const previous = speed
+    // Optimistic: the point of this control is that it feels immediate.
+    setSpeed(next)
+    setSaving(true)
+    setSaved(false)
+    setSaveError(null)
+    const r = await api.updateRuntimeSettings({ reply_speed: next })
+    setSaving(false)
+    if (!r.ok) {
+      setSpeed(previous)
+      setSaveError(r.error)
+      return
+    }
+    setSpeed(r.data.settings.reply_speed ?? next)
+    setSaved(true)
+  }
+
+  if (unavailable) return null
+  if (loadError) {
+    return <ApiErrorView error={loadError} onRetry={() => void load()} context="ReplySpeedPanel" />
+  }
+
+  return (
+    <div>
+      <div
+        role="radiogroup"
+        aria-label={t('settings.replySpeed.label')}
+        data-testid="reply-speed-options"
+        style={{ display: 'flex', gap: '0.5rem', flexWrap: 'wrap', marginBottom: '0.6rem' }}
+      >
+        {REPLY_SPEEDS.map((option) => {
+          const selected = option === speed
+          return (
+            <button
+              key={option}
+              role="radio"
+              aria-checked={selected}
+              data-testid={`reply-speed-${option}`}
+              onClick={() => void choose(option)}
+              disabled={saving}
+              style={{
+                flex: '1 1 10rem',
+                textAlign: 'left',
+                padding: '0.55rem 0.75rem',
+                borderRadius: '6px',
+                border: selected
+                  ? '1px solid rgba(99,102,241,0.7)'
+                  : '1px solid rgba(255,255,255,0.12)',
+                background: selected ? 'rgba(99,102,241,0.15)' : 'transparent',
+                color: 'inherit',
+                cursor: saving ? 'wait' : 'pointer',
+                font: 'inherit',
+              }}
+            >
+              <span
+                style={{
+                  display: 'block',
+                  fontWeight: 600,
+                  fontSize: '0.875rem',
+                  color: selected ? '#c7d2fe' : '#e8e8ea',
+                }}
+              >
+                {t(`settings.replySpeed.${option}.label`)}
+              </span>
+              <span style={{ display: 'block', fontSize: '0.78rem', color: '#a1a1aa' }}>
+                {t(`settings.replySpeed.${option}.detail`)}
+              </span>
+            </button>
+          )
+        })}
+      </div>
+
+      <p aria-live="polite" style={{ margin: 0, fontSize: '0.8rem', color: saved ? '#86efac' : '#71717a' }}>
+        {saving
+          ? t('settings.replySpeed.saving')
+          : saved
+          ? t('settings.replySpeed.saved')
+          : t('settings.replySpeed.noRestart')}
+      </p>
+
+      {saveError && (
+        <div style={{ marginTop: '0.5rem' }}>
+          <ApiErrorView error={saveError} compact context="ReplySpeedPanel-Save" />
+        </div>
+      )}
+
+      {/* Honest about the ceiling: reply length is the lever this control has,
+          and on slow hardware a smaller model is a bigger one. */}
+      <p style={{ margin: '0.6rem 0 0', fontSize: '0.8rem', color: '#71717a' }}>
+        {t('settings.replySpeed.biggerWin')}{' '}
+        <Link to="/model-manager" style={{ color: '#818cf8' }}>
+          {t('settings.replySpeed.biggerWinLink')}
+        </Link>
+      </p>
+    </div>
+  )
+}
diff --git a/apps/web/src/components/ResumeSessionBanner.tsx b/apps/web/src/components/ResumeSessionBanner.tsx
new file mode 100644
index 00000000..8582b503
--- /dev/null
+++ b/apps/web/src/components/ResumeSessionBanner.tsx
@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: Apache-2.0
+import { useNavigate, useLocation } from 'react-router-dom'
+import { api } from '../api/client'
+import { useTranslation } from '../i18n'
+import { useResumableSession } from '../hooks/useResumableSession'
+import { useScenarios } from '../api/useScenarios'
+
+/**
+ * "You have a conversation in progress — Resume" (issue #501 §1).
+ *
+ * Lives in the app chrome rather than on Home, because the screen the player
+ * got lost on was Settings: they went there to speed the model up and then
+ * could not find the way back. A strip under the header is on every screen the
+ * detour can reach, so there is always one click back into the conversation.
+ *
+ * Hidden on the conversation itself (you are already there), on the debrief for
+ * that session (you have left it on purpose), and during first-run setup.
+ */
+export default function ResumeSessionBanner() {
+  const { t } = useTranslation()
+  const navigate = useNavigate()
+  const location = useLocation()
+  const scenarios = useScenarios()
+
+  // Nothing to resume *to* while the player is mid-conversation or reading the
+  // debrief, so do not spend a request asking.
+  const onConversationRoute =
+    location.pathname.startsWith('/conversation/') ||
+    location.pathname.startsWith('/debrief/')
+  const { result, refetch } = useResumableSession(!onConversationRoute)
+
+  if (result.state !== 'ready') return null
+
+  const session = result.session
+  const title =
+    scenarios.scenarios.find((s) => s.scenario_id === session.scenario_id)?.title ??
+    session.scenario_id
+  const turns = session.turn_count ?? 0
+
+  function handleResume() {
+    navigate(`/conversation/${session.session_id}`)
+  }
+
+  async function handleEnd() {
+    const r = await api.endSession(session.session_id)
+    // Either way the banner has to re-ask: on success the session is no longer
+    // resumable, and on failure the row may have been ended by another window.
+    refetch()
+    // Ending a conversation produces a debrief, here exactly as it does from
+    // the conversation screen's End session button. Without this the player
+    // who ends from the strip is left where they were and the debrief they
+    // just earned is reachable only by typing its URL — the same kind of
+    // dead end issue #501 is about, in the other direction.
+    if (r.ok) navigate(`/debrief/${session.session_id}`)
+  }
+
+  return (
+    <div
+      role="status"
+      data-testid="resume-session-banner"
+      style={{
+        display: 'flex',
+        alignItems: 'center',
+        gap: '0.75rem',
+        flexWrap: 'wrap',
+        padding: '0.5rem 1.5rem',
+        background: 'rgba(99,102,241,0.12)',
+        borderBottom: '1px solid rgba(99,102,241,0.35)',
+        fontSize: '0.875rem',
+      }}
+    >
+      <span style={{ color: '#c7d2fe', flex: 1, minWidth: '12rem' }}>
+        <strong style={{ fontWeight: 600 }}>{t('resume.label')}</strong>{' '}
+        {turns === 0
+          ? t('resume.withoutTurns', { title })
+          : turns === 1
+          ? t('resume.withTurns_one', { title })
+          : t('resume.withTurns_other', { title, count: turns })}
+      </span>
+      <button
+        onClick={handleResume}
+        data-testid="resume-session-button"
+        style={{
+          padding: '0.3rem 0.9rem',
+          borderRadius: '4px',
+          border: 'none',
+          background: '#4f46e5',
+          color: '#fff',
+          fontWeight: 600,
+          fontSize: '0.8rem',
+          cursor: 'pointer',
+        }}
+      >
+        {t('resume.action')}
+      </button>
+      <button
+        onClick={() => void handleEnd()}
+        data-testid="resume-session-end-button"
+        style={{
+          padding: '0.3rem 0.75rem',
+          borderRadius: '4px',
+          border: '1px solid rgba(255,255,255,0.2)',
+          background: 'transparent',
+          color: '#a1a1aa',
+          fontSize: '0.8rem',
+          cursor: 'pointer',
+        }}
+      >
+        {t('resume.dismiss')}
+      </button>
+    </div>
+  )
+}
diff --git a/apps/web/src/components/RuntimeSettingsPanel.tsx b/apps/web/src/components/RuntimeSettingsPanel.tsx
index ffddb41d..07921149 100644
--- a/apps/web/src/components/RuntimeSettingsPanel.tsx
+++ b/apps/web/src/components/RuntimeSettingsPanel.tsx
@@ -38,7 +38,16 @@ function parseInt2(s: string): number | null {
   return isNaN(n) ? null : n
 }
 
-function settingsToForm(s: RuntimeSettings): Record<keyof RuntimeSettings, string> {
+/** The numeric knobs this panel edits.
+ *
+ *  `reply_speed` is part of the same persisted settings object but is not one
+ *  of these: it is a named plain-language choice with its own control above
+ *  this panel (issue #501 §1), not a number behind an "advanced" toggle. */
+type AdvancedSettingKey = Exclude<keyof RuntimeSettings, 'reply_speed'>
+
+type AdvancedForm = Record<AdvancedSettingKey, string>
+
+function settingsToForm(s: RuntimeSettings): AdvancedForm {
   return {
     context_length: s.context_length !== null ? String(s.context_length) : '',
     gpu_layers: s.gpu_layers !== null ? String(s.gpu_layers) : '',
@@ -49,7 +58,7 @@ function settingsToForm(s: RuntimeSettings): Record<keyof RuntimeSettings, strin
   }
 }
 
-function validateForm(form: Record<keyof RuntimeSettings, string>): FieldError[] {
+function validateForm(form: AdvancedForm): FieldError[] {
   const errs: FieldError[] = []
 
   const cl = parseInt2(form.context_length)
@@ -85,7 +94,7 @@ function validateForm(form: Record<keyof RuntimeSettings, string>): FieldError[]
   return errs
 }
 
-function formToRequest(form: Record<keyof RuntimeSettings, string>): Partial<RuntimeSettings> {
+function formToRequest(form: AdvancedForm): Partial<RuntimeSettings> {
   return {
     context_length: parseInt2(form.context_length),
     gpu_layers: parseInt2(form.gpu_layers),
@@ -206,7 +215,7 @@ export default function RuntimeSettingsPanel() {
   const [basicApplySuccess, setBasicApplySuccess] = useState(false)
 
   const [showAdvanced, setShowAdvanced] = useState(false)
-  const [form, setForm] = useState<Record<keyof RuntimeSettings, string>>({
+  const [form, setForm] = useState<AdvancedForm>({
     context_length: '',
     gpu_layers: '',
     threads: '',
@@ -271,7 +280,7 @@ export default function RuntimeSettingsPanel() {
     loadData()
   }
 
-  function handleFieldChange(field: keyof RuntimeSettings, value: string) {
+  function handleFieldChange(field: AdvancedSettingKey, value: string) {
     setForm((prev) => ({ ...prev, [field]: value }))
     setFieldErrors((prev) => {
       const next = { ...prev }
@@ -480,7 +489,7 @@ export default function RuntimeSettingsPanel() {
       {settingsUnavailable && (
         <div
           role="status"
-          aria-label="runtime advanced settings unavailable"
+          aria-label="advanced engine settings unavailable"
           style={{
             padding: '0.6rem 0.75rem',
             borderRadius: '6px',
@@ -491,7 +500,7 @@ export default function RuntimeSettingsPanel() {
             marginBottom: '1rem',
           }}
         >
-          Advanced runtime settings are not available in this version of ConversationSimulator.
+          Advanced engine settings are not available in this version of ConversationSimulator.
           Update to the latest version to change context length, GPU layers, CPU threads and
           sampling. The provider and model settings above still work.{' '}
           <a
@@ -506,12 +515,17 @@ export default function RuntimeSettingsPanel() {
         </div>
       )}
 
-      {/* Advanced toggle */}
+      {/* Advanced toggle. Named after the section above it ("AI engine") rather
+          than after the runtime: "runtime" is one of the four words the
+          issue #501 playtest named as unexplained jargon, and this label is
+          visible on Settings without expanding anything. The notes inside the
+          disclosure stay in engine terms — that is the "deliberately peek into
+          the settings" the issue asks for. */}
       {!settingsUnavailable && (
         <button
           onClick={() => setShowAdvanced((v) => !v)}
           aria-expanded={showAdvanced}
-          aria-label={showAdvanced ? 'hide runtime advanced settings' : 'show runtime advanced settings'}
+          aria-label={showAdvanced ? 'hide advanced engine settings' : 'show advanced engine settings'}
           style={{
             background: 'none',
             border: 'none',
@@ -522,7 +536,7 @@ export default function RuntimeSettingsPanel() {
             marginBottom: '0.75rem',
           }}
         >
-          {showAdvanced ? '▾ Hide runtime advanced settings' : '▸ Show runtime advanced settings'}
+          {showAdvanced ? '▾ Hide advanced engine settings' : '▸ Show advanced engine settings'}
         </button>
       )}
 
diff --git a/apps/web/src/components/StateMeters.tsx b/apps/web/src/components/StateMeters.tsx
new file mode 100644
index 00000000..ed11abde
--- /dev/null
+++ b/apps/web/src/components/StateMeters.tsx
@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: Apache-2.0
+import { humanizeIdentifier } from '../lib/plainLanguage'
+
+/**
+ * The conversation meters (issue #501 §3).
+ *
+ * What was wrong, from the playtest:
+ *
+ *   - The panel was collapsed behind a summary reading "NPC state variables",
+ *     below the transcript, while the tutorial's opening line says "Notice the
+ *     two meters at the top". The label, the name and the placement all
+ *     disagreed, so "generally confused about meters and where they appear".
+ *   - Each bar showed a number and nothing else. The tutorial says "Engagement
+ *     just ticked up" and "See how Engagement just ticked up?", but nothing on
+ *     screen ever ticked: the number was simply different than the last time
+ *     you looked at it. The change is the whole mechanic, so it is now drawn.
+ *   - The NPC's emotion was rendered right next to the bars, so it read as one
+ *     of them — "unclear which meter (if any) the emotions in parentheses are".
+ *     Emotion now lives in the NPC panel under an explicit "Mood" label and
+ *     never inside this component.
+ *
+ * Caller places this ABOVE the transcript so "the meters at the top" is true.
+ */
+export default function StateMeters({
+  stateVars,
+  deltas,
+  isPlain,
+}: {
+  stateVars: Record<string, number>
+  /** Change applied by the most recent turn, per variable. */
+  deltas: Record<string, number>
+  /** Plain wording hides the raw snake_case variable keys. */
+  isPlain: boolean
+}) {
+  const entries = Object.entries(stateVars)
+  if (entries.length === 0) return null
+
+  return (
+    <section
+      aria-label="Conversation meters"
+      style={{
+        padding: '0.6rem 0.75rem',
+        borderRadius: 8,
+        border: '1px solid #27272a',
+        background: '#18181b',
+      }}
+    >
+      <div style={{ display: 'flex', alignItems: 'baseline', gap: '0.5rem', flexWrap: 'wrap' }}>
+        <h2 style={{ margin: 0, fontSize: '0.8rem', fontWeight: 600, color: '#e4e4e7' }}>
+          Conversation meters
+        </h2>
+        <p style={{ margin: 0, fontSize: '0.72rem', color: '#71717a' }}>
+          These move with every turn. They are not moods.
+        </p>
+      </div>
+      <div
+        data-testid="state-vars"
+        style={{
+          display: 'flex',
+          flexWrap: 'wrap',
+          gap: '0.5rem',
+          marginTop: '0.5rem',
+        }}
+      >
+        {entries.map(([key, value]) => {
+          const delta = deltas[key] ?? 0
+          const label = isPlain ? humanizeIdentifier(key) : key
+          return (
+            <div
+              key={key}
+              data-testid={`state-meter-${key}`}
+              style={{
+                display: 'flex',
+                flexDirection: 'column',
+                minWidth: 112,
+                flex: '1 1 112px',
+                padding: '0.4rem 0.5rem',
+                borderRadius: 4,
+                background: '#111113',
+                fontSize: '0.8rem',
+              }}
+            >
+              <div style={{ display: 'flex', justifyContent: 'space-between', gap: '0.4rem' }}>
+                <span style={{ color: '#a1a1aa' }}>{label}</span>
+                <span style={{ color: '#f4f4f5', fontWeight: 600 }}>{value}</span>
+              </div>
+              <div
+                role="meter"
+                // The accessible name carries the plain label in both wording
+                // levels: a screen-reader user reading "objective_progress" out
+                // loud as a word is the same problem this issue is about.
+                aria-label={`${humanizeIdentifier(key)}: ${value} out of 100`}
+                aria-valuenow={value}
+                aria-valuemin={0}
+                aria-valuemax={100}
+                aria-valuetext={
+                  delta === 0
+                    ? `${value} out of 100`
+                    : `${value} out of 100, ${delta > 0 ? 'up' : 'down'} ${Math.abs(delta)} this turn`
+                }
+                style={{
+                  width: '100%',
+                  height: 5,
+                  borderRadius: 2,
+                  background: '#27272a',
+                  marginTop: 5,
+                }}
+              >
+                <div
+                  aria-hidden="true"
+                  style={{
+                    width: `${value}%`,
+                    height: '100%',
+                    borderRadius: 2,
+                    background: value >= 50 ? '#22c55e' : '#f97316',
+                  }}
+                />
+              </div>
+              {/* The tick the tutorial talks about. aria-hidden because the
+                  meter's aria-valuetext above already says it, and announcing
+                  both would read every change twice. */}
+              <span
+                aria-hidden="true"
+                data-testid={`state-meter-delta-${key}`}
+                style={{
+                  marginTop: 3,
+                  fontSize: '0.7rem',
+                  minHeight: '0.95rem',
+                  color: delta > 0 ? '#4ade80' : delta < 0 ? '#f87171' : 'transparent',
+                }}
+              >
+                {delta > 0 ? `▲ +${delta} this turn` : delta < 0 ? `▼ ${delta} this turn` : '·'}
+              </span>
+            </div>
+          )
+        })}
+      </div>
+    </section>
+  )
+}
diff --git a/apps/web/src/components/WordingPanel.tsx b/apps/web/src/components/WordingPanel.tsx
new file mode 100644
index 00000000..89c06a17
--- /dev/null
+++ b/apps/web/src/components/WordingPanel.tsx
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: Apache-2.0
+import { useTranslation } from '../i18n'
+import { useUiLanguageLevel } from '../hooks/useUiLanguageLevel'
+import type { UiLanguageLevel } from '../lib/plainLanguage'
+
+const LEVELS: UiLanguageLevel[] = ['plain', 'technical']
+
+/**
+ * The "deliberately peek into the settings" half of issue #501 §2.
+ *
+ * The familiarity question sets this on first run and offers to revisit it
+ * after the tutorial; this is where it lives permanently, so a player who
+ * answered "new to this" and then wanted the session id for a bug report is
+ * one switch away from it.
+ */
+export default function WordingPanel() {
+  const { t } = useTranslation()
+  const { level, setLevel } = useUiLanguageLevel()
+
+  return (
+    <div
+      role="radiogroup"
+      aria-label={t('settings.wording.heading')}
+      data-testid="wording-options"
+      style={{ display: 'flex', gap: '0.5rem', flexWrap: 'wrap' }}
+    >
+      {LEVELS.map((option) => {
+        const selected = option === level
+        return (
+          <button
+            key={option}
+            role="radio"
+            aria-checked={selected}
+            data-testid={`wording-${option}`}
+            onClick={() => setLevel(option)}
+            style={{
+              flex: '1 1 10rem',
+              textAlign: 'left',
+              padding: '0.55rem 0.75rem',
+              borderRadius: '6px',
+              border: selected
+                ? '1px solid rgba(99,102,241,0.7)'
+                : '1px solid rgba(255,255,255,0.12)',
+              background: selected ? 'rgba(99,102,241,0.15)' : 'transparent',
+              color: 'inherit',
+              cursor: 'pointer',
+              font: 'inherit',
+            }}
+          >
+            <span
+              style={{
+                display: 'block',
+                fontWeight: 600,
+                fontSize: '0.875rem',
+                color: selected ? '#c7d2fe' : '#e8e8ea',
+              }}
+            >
+              {t(`settings.wording.${option}.label`)}
+            </span>
+            <span style={{ display: 'block', fontSize: '0.78rem', color: '#a1a1aa' }}>
+              {t(`settings.wording.${option}.detail`)}
+            </span>
+          </button>
+        )
+      })}
+    </div>
+  )
+}
diff --git a/apps/web/src/hooks/useResumableSession.ts b/apps/web/src/hooks/useResumableSession.ts
new file mode 100644
index 00000000..a42d1e03
--- /dev/null
+++ b/apps/web/src/hooks/useResumableSession.ts
@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+import { useCallback, useEffect, useState } from 'react'
+import { api } from '../api/client'
+import type { SessionCreateResponse } from '@convsim/shared'
+
+/**
+ * The conversation the player walked away from, if there is one (issue #501 §1).
+ *
+ * A player partway through the tutorial opened Settings to speed the model up,
+ * then "couldn't easily figure out how to resume my ongoing scenario and
+ * resorted to starting a new one" — because nothing in the app knew the session
+ * existed. convsim-core has known all along: the row sits in `turn_sessions`
+ * with a non-terminal `flow_state`. This asks for it.
+ *
+ * Deliberately the *newest* in-progress session rather than a list: more than
+ * one is possible (every abandoned session stays in-progress until it is ended),
+ * but "take me back to what I was just doing" has exactly one answer. The
+ * others remain reachable from Settings → Your sessions.
+ */
+export type ResumableSessionState =
+  | { state: 'loading' }
+  | { state: 'none' }
+  | { state: 'ready'; session: SessionCreateResponse }
+
+export function useResumableSession(enabled = true): {
+  result: ResumableSessionState
+  refetch: () => void
+} {
+  const [result, setResult] = useState<ResumableSessionState>(
+    enabled ? { state: 'loading' } : { state: 'none' },
+  )
+
+  const refetch = useCallback(() => {
+    if (!enabled) {
+      setResult({ state: 'none' })
+      return
+    }
+    void api.listSessions('in_progress', 1).then((r) => {
+      if (!r.ok) {
+        // An unreachable core is reported by the status panel and the startup
+        // guard; a resume affordance that cannot be loaded is simply absent
+        // rather than another error card on top of those.
+        setResult({ state: 'none' })
+        return
+      }
+      // Tolerate a core that answers a shape this build does not expect (an
+      // older bundled runtime, a proxy): no resumable session is the safe read.
+      const session = r.data?.sessions?.[0]
+      setResult(session ? { state: 'ready', session } : { state: 'none' })
+    })
+  }, [enabled])
+
+  useEffect(() => {
+    refetch()
+  }, [refetch])
+
+  // Ending a conversation, or starting one, happens on another screen. Refresh
+  // when the window regains focus so the banner never offers to resume a
+  // session that has since ended (mirrors the setup-status revalidation in
+  // App.tsx, added for the same reason in issue #380).
+  useEffect(() => {
+    if (!enabled) return
+    function onFocus() {
+      refetch()
+    }
+    window.addEventListener('focus', onFocus)
+    document.addEventListener('visibilitychange', onFocus)
+    return () => {
+      window.removeEventListener('focus', onFocus)
+      document.removeEventListener('visibilitychange', onFocus)
+    }
+  }, [enabled, refetch])
+
+  return { result, refetch }
+}
diff --git a/apps/web/src/hooks/useUiLanguageLevel.ts b/apps/web/src/hooks/useUiLanguageLevel.ts
new file mode 100644
index 00000000..df821541
--- /dev/null
+++ b/apps/web/src/hooks/useUiLanguageLevel.ts
@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: Apache-2.0
+import { useCallback, useEffect, useState } from 'react'
+import {
+  UI_LANGUAGE_CHANGE_EVENT,
+  UI_LANGUAGE_KEYS,
+  readUiLanguageLevel,
+  writeUiLanguageLevel,
+  type UiLanguageLevel,
+} from '../lib/plainLanguage'
+
+/**
+ * The player's plain-vs-technical language level, live (issue #501 §2).
+ *
+ * Subscribes to both the in-document change event (a switch flipped in
+ * Settings while a Conversation is mounted behind it) and `storage` (the same
+ * profile open in a second window), so no screen is left showing the old
+ * vocabulary until it happens to re-mount.
+ */
+export function useUiLanguageLevel(): {
+  level: UiLanguageLevel
+  isPlain: boolean
+  setLevel: (level: UiLanguageLevel) => void
+} {
+  const [level, setLevelState] = useState<UiLanguageLevel>(readUiLanguageLevel)
+
+  useEffect(() => {
+    function sync() {
+      setLevelState(readUiLanguageLevel())
+    }
+    function onStorage(e: StorageEvent) {
+      if (e.key === null || e.key === UI_LANGUAGE_KEYS.level) sync()
+    }
+    window.addEventListener(UI_LANGUAGE_CHANGE_EVENT, sync)
+    window.addEventListener('storage', onStorage)
+    return () => {
+      window.removeEventListener(UI_LANGUAGE_CHANGE_EVENT, sync)
+      window.removeEventListener('storage', onStorage)
+    }
+  }, [])
+
+  const setLevel = useCallback((next: UiLanguageLevel) => {
+    writeUiLanguageLevel(next)
+    setLevelState(next)
+  }, [])
+
+  return { level, isPlain: level === 'plain', setLevel }
+}
diff --git a/apps/web/src/i18n/locales/de.ts b/apps/web/src/i18n/locales/de.ts
index 5bd2e632..02f14b7d 100644
--- a/apps/web/src/i18n/locales/de.ts
+++ b/apps/web/src/i18n/locales/de.ts
@@ -13,7 +13,7 @@ export const de: LocaleMessages = {
     modelNotLoaded:
       'Kein KI-Modell geladen. Öffnen Sie die Einstellungen, um ein Modell zu installieren.',
     runtimeUnavailable:
-      'Die lokale Laufzeitumgebung ist nicht verfügbar. Prüfen Sie die Protokolle.',
+      'Die KI-Engine ist nicht verfügbar. Prüfen Sie die Protokolle.',
     safetyViolation: 'Der Inhalt wurde durch die Sicherheitsrichtlinie blockiert.',
     turnLimitExceeded: 'Das Zuglimit für dieses Szenario wurde erreicht.',
     turnTimeout: 'Der Zug hat das Zeitlimit überschritten. Bitte versuchen Sie es erneut.',
@@ -101,11 +101,59 @@ export const de: LocaleMessages = {
       },
     },
   },
+  // "Gespräch läuft" (Issue #501 §1).
+  resume: {
+    label: 'Gespräch läuft.',
+    withTurns_one: '{{title}} — bisher 1 Zug.',
+    withTurns_other: '{{title}} — bisher {{count}} Züge.',
+    withoutTurns: '{{title}} — noch nicht begonnen.',
+    action: 'Fortsetzen',
+    dismiss: 'Beenden',
+  },
+  familiarity: {
+    question: 'Wie gut kennen Sie KI-Sprachmodelle?',
+    reaskQuestion: 'Jetzt, da Sie ein Gespräch gespielt haben — welche Wortwahl passt?',
+    reaskHint: 'Sie können das jederzeit in den Einstellungen ändern.',
+    skip: 'Überspringen',
+    keep: 'So lassen',
+    new: {
+      label: 'Neu für mich',
+      detail: 'Einfache Wortwahl',
+    },
+    some: {
+      label: 'Ich habe KI-Chat-Apps genutzt',
+      detail: 'Einfache Wortwahl',
+    },
+    expert: {
+      label: 'Ich arbeite damit',
+      detail: 'Technische Details anzeigen',
+    },
+    appliedPlain: 'Einfache Wortwahl ist aktiv.',
+    appliedTechnical: 'Technische Details sind aktiv.',
+  },
+  sessionStates: {
+    NotStarted: 'Noch nicht begonnen',
+    LoadingModel: 'Wird vorbereitet',
+    LoadingScenario: 'Wird vorbereitet',
+    Briefing: 'Einweisung',
+    NpcOpening: 'Eröffnet das Gespräch',
+    PlayerTurnListening: 'Sie sind dran',
+    PlayerTurnReview: 'Nachricht prüfen',
+    NpcThinking: 'Schreibt eine Antwort',
+    NpcSpeaking: 'Spricht',
+    ScenarioEvent: 'Etwas verändert sich',
+    DebriefGenerating: 'Nachbesprechung wird erstellt',
+    DebriefReady: 'Nachbesprechung bereit',
+    Ended: 'Beendet',
+    Error: 'Etwas ist schiefgelaufen',
+    unknown: 'Läuft',
+  },
   home: {
     title: 'Gesprächssimulator',
     tagline:
       'Üben Sie Vorstellungsgespräche, Verhandlungen, Sprachen und schwierige Gespräche.',
     primaryActions: 'Hauptaktionen',
+    resumeScenario: 'Gespräch fortsetzen',
     yourTraining: 'Ihr Training',
     training: {
       loading: 'Wird geladen…',
@@ -137,10 +185,10 @@ export const de: LocaleMessages = {
     readDocs: 'Dokumentation lesen',
     status: {
       heading: 'Status',
-      localRuntime: 'Lokale Laufzeitumgebung',
-      llm: 'LLM',
-      stt: 'STT',
-      tts: 'TTS',
+      localRuntime: 'KI-Engine',
+      llm: 'KI-Modell',
+      stt: 'Spracheingabe',
+      tts: 'Sprachausgabe',
       networkRequired: 'Netzwerk zum Spielen erforderlich',
       packs: 'Pakete',
       checking: 'Überprüfe…',
@@ -236,10 +284,47 @@ export const de: LocaleMessages = {
       notSavedWarning:
         'Nicht gespeichert – das Transkript geht verloren, wenn diese Sitzung endet.',
     },
+    replySpeed: {
+      heading: 'Antwortgeschwindigkeit',
+      description:
+        'Wie viel die andere Person pro Zug schreibt. Kürzere Antworten kommen schneller, weil Ihr Computer sie Wort für Wort erzeugt.',
+      label: 'Antwortgeschwindigkeit',
+      saving: 'Wird gespeichert…',
+      saved: 'Gespeichert. Ihre nächste Nachricht nutzt die neue Geschwindigkeit.',
+      noRestart: 'Gilt ab Ihrer nächsten Nachricht — kein Neustart nötig.',
+      biggerWin:
+        'Immer noch langsam? Ein kleineres Modell bringt die größte Verbesserung.',
+      biggerWinLink: 'Modell auswählen →',
+      fast: {
+        label: 'Kurze Antworten',
+        detail: 'Kürzeste Antworten, kürzeste Wartezeit',
+      },
+      balanced: {
+        label: 'Ausgewogen',
+        detail: 'Das Tempo des Szenarios',
+      },
+      detailed: {
+        label: 'Ausführliche Antworten',
+        detail: 'Längere Antworten, längere Wartezeit',
+      },
+    },
+    wording: {
+      heading: 'Wortwahl',
+      description:
+        'Wie viel Technik die App zeigt. Einfache Wortwahl verbirgt Sitzungs-IDs, interne Zustandsnamen und Ereignis-Flags; technische Wortwahl zeigt sie.',
+      plain: {
+        label: 'Einfache Wortwahl',
+        detail: 'Nur Alltagssprache',
+      },
+      technical: {
+        label: 'Technische Wortwahl',
+        detail: 'IDs, Zustände und Flags anzeigen',
+      },
+    },
     runtime: {
-      heading: 'Laufzeitumgebung',
+      heading: 'KI-Modul',
       description:
-        'Wählen Sie den aktiven KI-Anbieter und das Modell. Erweiterte Einstellungen sind standardmäßig ausgeblendet.',
+        'Welches KI-Modell als die andere Person antwortet. Technische Einstellungen sind standardmäßig ausgeblendet.',
       openModelManagerLink: 'Modellverwaltung öffnen →',
       openModelManagerLabel: 'Modellverwaltung öffnen',
     },
@@ -317,12 +402,15 @@ export const de: LocaleMessages = {
     },
     sessions: {
       heading: 'Ihre Sitzungen',
-      description: 'Sitzung als JSON exportieren oder dauerhaft löschen.',
+      description:
+        'Ein unvollendetes Gespräch fortsetzen, eine Sitzung als JSON exportieren oder dauerhaft löschen.',
       loadError: 'Sitzungen konnten nicht geladen werden.',
       deleteError: 'Sitzung konnte nicht gelöscht werden.',
       exportError: 'Sitzung konnte nicht exportiert werden.',
       loading: 'Lade…',
       noSessions: 'Noch keine Sitzungen.',
+      resume: 'Fortsetzen',
+      resumeLabel: 'Sitzung {{id}} fortsetzen',
       export: 'Exportieren',
       exportLabel: 'Sitzung {{id}} exportieren',
       delete: 'Löschen',
@@ -473,6 +561,8 @@ export const de: LocaleMessages = {
       transcriptOnlyNotice:
         'Nachbesprechungserstellung fehlgeschlagen. Zeige nur Transkript.',
       turn: 'Zug {{number}}',
+      opening: 'Eröffnung',
+      moodLabel: 'Stimmung:',
       you: 'Sie',
       npc: 'NPC',
       goToTurn: 'Zu Zug {{number}} gehen',
diff --git a/apps/web/src/i18n/locales/en.ts b/apps/web/src/i18n/locales/en.ts
index cedad1bb..64821af0 100644
--- a/apps/web/src/i18n/locales/en.ts
+++ b/apps/web/src/i18n/locales/en.ts
@@ -8,7 +8,7 @@ export const en = {
     scenarioNotFound: 'The requested scenario was not found.',
     sessionNotFound: 'Session not found.',
     modelNotLoaded: 'No AI model is loaded. Open Settings to install a model.',
-    runtimeUnavailable: 'The local runtime is unavailable. Check the logs for details.',
+    runtimeUnavailable: 'The AI engine is unavailable. Check the logs for details.',
     safetyViolation: 'The content was blocked by the safety policy.',
     turnLimitExceeded: 'The turn limit for this scenario has been reached.',
     turnTimeout: 'The turn timed out. Please try again.',
@@ -96,10 +96,65 @@ export const en = {
       },
     },
   },
+  // "You have a conversation in progress" (issue #501 §1).
+  resume: {
+    label: 'Conversation in progress.',
+    withTurns_one: '{{title}} — 1 turn so far.',
+    withTurns_other: '{{title}} — {{count}} turns so far.',
+    withoutTurns: '{{title}} — not started yet.',
+    action: 'Resume',
+    dismiss: 'End it',
+  },
+  // The initial LLM-familiarity question and its post-tutorial re-ask
+  // (issue #501 §2). Three answers, two wording levels.
+  familiarity: {
+    question: 'How familiar are you with AI language models?',
+    reaskQuestion: 'Now that you have played a conversation — how should we word things?',
+    reaskHint: 'You can change this any time in Settings.',
+    skip: 'Skip',
+    keep: 'Keep it as it is',
+    new: {
+      label: 'New to this',
+      detail: 'Plain wording',
+    },
+    some: {
+      label: 'I have used AI chat apps',
+      detail: 'Plain wording',
+    },
+    expert: {
+      label: 'I work with them',
+      detail: 'Show technical detail',
+    },
+    appliedPlain: 'Plain wording it is.',
+    appliedTechnical: 'Technical detail is on.',
+  },
+  // What a session is doing, in plain language rather than the flow-state
+  // identifier (issue #501 §2). Keyed by the identifier itself; `unknown`
+  // covers a state this build does not know about. Mirrors FLOW_STATE_LABELS
+  // in lib/plainLanguage.ts, which is the English copy the screens that are
+  // not on t() yet use.
+  sessionStates: {
+    NotStarted: 'Not started yet',
+    LoadingModel: 'Getting ready',
+    LoadingScenario: 'Getting ready',
+    Briefing: 'Briefing',
+    NpcOpening: 'Opening the conversation',
+    PlayerTurnListening: 'Your turn',
+    PlayerTurnReview: 'Check your message',
+    NpcThinking: 'Writing a reply',
+    NpcSpeaking: 'Speaking',
+    ScenarioEvent: 'Something is changing',
+    DebriefGenerating: 'Preparing your debrief',
+    DebriefReady: 'Debrief ready',
+    Ended: 'Finished',
+    Error: 'Something went wrong',
+    unknown: 'In progress',
+  },
   home: {
     title: 'Conversation Simulator',
     tagline: 'Practice interviews, negotiations, language, and difficult conversations.',
     primaryActions: 'Primary actions',
+    resumeScenario: 'Resume your conversation',
     yourTraining: 'Your training',
     training: {
       loading: 'Loading…',
@@ -131,10 +186,15 @@ export const en = {
     readDocs: 'Read docs',
     status: {
       heading: 'Status',
-      localRuntime: 'Local runtime',
-      llm: 'LLM',
-      stt: 'STT',
-      tts: 'TTS',
+      // Named in the player's words, not the engine's (issue #501 §2):
+      // 'runtime' is one of the four words the playtest called out, and
+      // 'LLM' / 'STT' / 'TTS' are three acronyms a first-time player has no
+      // way to read. These are the first labels anyone sees — they are on
+      // Home — so the plain names are the only names, at both wording levels.
+      localRuntime: 'AI engine',
+      llm: 'AI model',
+      stt: 'Voice input',
+      tts: 'Voice output',
       networkRequired: 'Network required to play',
       packs: 'Packs',
       checking: 'Checking…',
@@ -227,10 +287,50 @@ export const en = {
         "Transcripts will not be saved. This session's conversation cannot be exported or searched after it ends.",
       notSavedWarning: 'Not saved — transcript will be lost when this session ends.',
     },
+    // Plain-language reply pacing (issue #501 §1): "make the model respond
+    // faster" was not an exposed concept anywhere in Settings.
+    replySpeed: {
+      heading: 'Reply speed',
+      description:
+        'How much the other person writes each turn. Shorter replies arrive sooner, because your computer writes them one word at a time.',
+      label: 'Reply speed',
+      saving: 'Saving…',
+      saved: 'Saved. Your next message uses the new speed.',
+      noRestart: 'Takes effect on your next message — nothing to restart.',
+      biggerWin:
+        'Still slow? A smaller model is the biggest change you can make.',
+      biggerWinLink: 'Choose a model →',
+      fast: {
+        label: 'Quick replies',
+        detail: 'Shortest answers, least waiting',
+      },
+      balanced: {
+        label: 'Balanced',
+        detail: 'The scenario’s own pacing',
+      },
+      detailed: {
+        label: 'Fuller replies',
+        detail: 'Longer answers, more waiting',
+      },
+    },
+    // The buffer between player-facing and technical language (issue #501 §2).
+    wording: {
+      heading: 'Wording',
+      description:
+        'How much of the machinery the app shows you. Plain wording hides session ids, internal state names and event flags; technical wording puts them back.',
+      plain: {
+        label: 'Plain wording',
+        detail: 'Everyday language only',
+      },
+      technical: {
+        label: 'Technical wording',
+        detail: 'Show ids, states and flags',
+      },
+    },
     runtime: {
-      heading: 'Runtime',
+      heading: 'AI engine',
       description:
-        'Select the active AI provider and model. Advanced knobs are hidden by default.',
+        'Which AI model answers as the other person. Technical knobs are hidden by default.',
       openModelManagerLink: 'Open model manager →',
       openModelManagerLabel: 'Open model manager',
     },
@@ -308,12 +408,15 @@ export const en = {
     },
     sessions: {
       heading: 'Your sessions',
-      description: 'Export a session as JSON or delete it permanently.',
+      description:
+        'Pick up an unfinished conversation, export a session as JSON, or delete one permanently.',
       loadError: 'Could not load sessions.',
       deleteError: 'Failed to delete session.',
       exportError: 'Failed to export session.',
       loading: 'Loading…',
       noSessions: 'No sessions yet.',
+      resume: 'Resume',
+      resumeLabel: 'Resume session {{id}}',
       export: 'Export',
       exportLabel: 'Export session {{id}}',
       delete: 'Delete',
@@ -463,6 +566,8 @@ export const en = {
       ariaLabel: 'Conversation transcript',
       transcriptOnlyNotice: 'Debrief generation failed. Showing transcript only.',
       turn: 'Turn {{number}}',
+      opening: 'Opening',
+      moodLabel: 'Mood:',
       you: 'You',
       npc: 'NPC',
       goToTurn: 'Go to turn {{number}}',
diff --git a/apps/web/src/layout/AppLayout.tsx b/apps/web/src/layout/AppLayout.tsx
index fc7259c6..60401c39 100644
--- a/apps/web/src/layout/AppLayout.tsx
+++ b/apps/web/src/layout/AppLayout.tsx
@@ -2,6 +2,7 @@
 import { useEffect, useRef } from 'react'
 import { NavLink, Outlet, useLocation } from 'react-router-dom'
 import OfflineIndicator from '../components/OfflineIndicator'
+import ResumeSessionBanner from '../components/ResumeSessionBanner'
 import { useTranslation } from '../i18n'
 import { useGamepadNavigation } from '../hooks/useGamepadNavigation'
 import { useSteamKeyboard } from '../hooks/useSteamKeyboard'
@@ -181,6 +182,10 @@ export default function AppLayout() {
         <OfflineIndicator />
       </header>
 
+      {/* One click back into a conversation the player navigated away from
+          (issue #501). Renders nothing when there is none. */}
+      <ResumeSessionBanner />
+
       <main
         id="main-content"
         ref={mainRef}
diff --git a/apps/web/src/lib/plainLanguage.ts b/apps/web/src/lib/plainLanguage.ts
new file mode 100644
index 00000000..637cf46a
--- /dev/null
+++ b/apps/web/src/lib/plainLanguage.ts
@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The buffer between player-facing and technical language (issue #501 §2).
+ *
+ * Playtest feedback: the app "feels both too sparse and too technical in the
+ * first few sessions", and named the words that landed badly — "runtime",
+ * "event", "state", "flag". The ask was a customizable buffer, chosen by an
+ * initial question about how familiar the player is with AI language models.
+ *
+ * There are two levels, not a scale. A third intermediate level would have to
+ * pick a different word for every string without a rule saying which words
+ * belong to it, which is how copy drifts; two levels have a clear rule:
+ *
+ *   plain      — the default. No identifiers, no engine vocabulary, no raw
+ *                state names. Everything on screen is a sentence a player can
+ *                read without knowing how the app is built.
+ *   technical  — adds the identifiers back: session ids, flow-state names,
+ *                event flags, raw variable keys. Chosen by players who work
+ *                with language models, and by anyone who goes looking for it
+ *                in Settings.
+ *
+ * `plain` is the default for a never-asked player: being under-informed about
+ * internals is recoverable (Settings is one click away), being confronted with
+ * `PlayerTurnListening` on your first session is what this issue is about.
+ */
+
+export type UiLanguageLevel = 'plain' | 'technical'
+
+/** The three answers the familiarity question offers, in order. */
+export type LlmFamiliarity = 'new' | 'some' | 'expert'
+
+export const UI_LANGUAGE_KEYS = {
+  /** The active level. Absent means "never chosen" → `plain`. */
+  level: 'convsim.ui.languageLevel',
+  /** The answer that produced the level, kept so the re-ask can preselect it. */
+  familiarity: 'convsim.ui.llmFamiliarity',
+  /** Set once the post-tutorial re-ask has been shown, so it appears once. */
+  reaskShown: 'convsim.ui.llmFamiliarityReasked',
+} as const
+
+export const DEFAULT_UI_LANGUAGE_LEVEL: UiLanguageLevel = 'plain'
+
+/** Only the player who says they work with language models gets the identifiers. */
+export function levelForFamiliarity(answer: LlmFamiliarity): UiLanguageLevel {
+  return answer === 'expert' ? 'technical' : 'plain'
+}
+
+export function readUiLanguageLevel(): UiLanguageLevel {
+  if (typeof localStorage === 'undefined') return DEFAULT_UI_LANGUAGE_LEVEL
+  try {
+    return localStorage.getItem(UI_LANGUAGE_KEYS.level) === 'technical'
+      ? 'technical'
+      : DEFAULT_UI_LANGUAGE_LEVEL
+  } catch {
+    return DEFAULT_UI_LANGUAGE_LEVEL
+  }
+}
+
+export function writeUiLanguageLevel(level: UiLanguageLevel): void {
+  if (typeof localStorage === 'undefined') return
+  try {
+    localStorage.setItem(UI_LANGUAGE_KEYS.level, level)
+    // Screens read the level at render, so a change made in Settings has to
+    // reach a Conversation mounted in the same session. `storage` only fires in
+    // *other* documents, so dispatch our own event for this one.
+    window.dispatchEvent(new Event(UI_LANGUAGE_CHANGE_EVENT))
+  } catch {
+    /* ignore storage errors */
+  }
+}
+
+export const UI_LANGUAGE_CHANGE_EVENT = 'convsim:ui-language-level'
+
+export function readLlmFamiliarity(): LlmFamiliarity | null {
+  if (typeof localStorage === 'undefined') return null
+  try {
+    const v = localStorage.getItem(UI_LANGUAGE_KEYS.familiarity)
+    return v === 'new' || v === 'some' || v === 'expert' ? v : null
+  } catch {
+    return null
+  }
+}
+
+/** Record a familiarity answer and apply the level it implies. */
+export function writeLlmFamiliarity(answer: LlmFamiliarity): void {
+  if (typeof localStorage === 'undefined') return
+  try {
+    localStorage.setItem(UI_LANGUAGE_KEYS.familiarity, answer)
+  } catch {
+    /* ignore storage errors */
+  }
+  writeUiLanguageLevel(levelForFamiliarity(answer))
+}
+
+export function hasSeenFamiliarityReask(): boolean {
+  if (typeof localStorage === 'undefined') return false
+  try {
+    return localStorage.getItem(UI_LANGUAGE_KEYS.reaskShown) === 'true'
+  } catch {
+    return false
+  }
+}
+
+export function markFamiliarityReaskShown(): void {
+  if (typeof localStorage === 'undefined') return
+  try {
+    localStorage.setItem(UI_LANGUAGE_KEYS.reaskShown, 'true')
+  } catch {
+    /* ignore storage errors */
+  }
+}
+
+// ── Humanizers ───────────────────────────────────────────────────────────────
+
+/**
+ * "objective_progress" → "Objective progress".
+ *
+ * Scenario packs name their state variables in snake_case because they are
+ * keys in a YAML file; the player never agreed to read keys.
+ */
+export function humanizeIdentifier(raw: string): string {
+  const words = raw.replace(/[_-]+/g, ' ').trim()
+  if (words.length === 0) return raw
+  return words.charAt(0).toUpperCase() + words.slice(1)
+}
+
+/** "player_demonstrates_knowledge" → "Player demonstrates knowledge". */
+export const humanizeFlag = humanizeIdentifier
+
+/** Join several flags into one readable phrase. */
+export function humanizeFlags(flags: readonly string[]): string {
+  return flags.map(humanizeFlag).join(' · ')
+}
+
+/**
+ * Plain-language label per flow state, in English.
+ *
+ * The keys double as locale keys under `sessionStates.` in the i18n catalogs,
+ * so a screen that has been migrated to `t()` can translate the same label this
+ * table spells in English — see `flowStateLabelKey`. `unknown` is the label for
+ * a state this build does not know; an unmapped state is a bug, not a thing to
+ * print raw at a player.
+ */
+export const FLOW_STATE_LABELS: Record<string, string> = {
+  NotStarted: 'Not started yet',
+  LoadingModel: 'Getting ready',
+  LoadingScenario: 'Getting ready',
+  Briefing: 'Briefing',
+  NpcOpening: 'Opening the conversation',
+  PlayerTurnListening: 'Your turn',
+  PlayerTurnReview: 'Check your message',
+  NpcThinking: 'Writing a reply',
+  NpcSpeaking: 'Speaking',
+  ScenarioEvent: 'Something is changing',
+  DebriefGenerating: 'Preparing your debrief',
+  DebriefReady: 'Debrief ready',
+  Ended: 'Finished',
+  Error: 'Something went wrong',
+  unknown: 'In progress',
+}
+
+const UNKNOWN_FLOW_STATE = 'unknown'
+
+/**
+ * What the NPC is doing, in words rather than flow-state identifiers.
+ *
+ * The header used to print the raw identifier (`State: PlayerTurnListening`).
+ * At `technical` the caller still shows the identifier alongside this.
+ *
+ * English only — for the screens that have not been migrated to `t()` yet.
+ * A migrated screen must use `flowStateLabelKey` instead, or a German player
+ * reads "Your turn" in an otherwise German UI.
+ */
+export function plainFlowState(state: string): string {
+  return (
+    (state === UNKNOWN_FLOW_STATE ? undefined : FLOW_STATE_LABELS[state]) ??
+    FLOW_STATE_LABELS[UNKNOWN_FLOW_STATE]
+  )
+}
+
+/** The locale key for a flow state's plain-language label. */
+export function flowStateLabelKey(state: string): string {
+  const known = state !== UNKNOWN_FLOW_STATE && state in FLOW_STATE_LABELS
+  return `sessionStates.${known ? state : UNKNOWN_FLOW_STATE}`
+}
+
+/** "player_exit" → "player exit"; used in the "Outcome: …" lines. */
+export function humanizeEndingType(endingType: string): string {
+  return endingType.replace(/_/g, ' ')
+}
diff --git a/apps/web/src/lib/wholeTurns.ts b/apps/web/src/lib/wholeTurns.ts
new file mode 100644
index 00000000..e28fc598
--- /dev/null
+++ b/apps/web/src/lib/wholeTurns.ts
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Whole-turn numbering for a transcript (issue #501 §4).
+ *
+ * "In the conversational LLM space, the term 'turn' would indicate one message
+ * from the user and one reply from the model. Currently, each response from the
+ * user *and* the model is counted as a turn, when they should constitute halves
+ * of one whole turn."
+ *
+ * One turn is the player's message plus the NPC's reply to it; the NPC's
+ * opening line belongs to neither and is turn 0, labelled rather than numbered.
+ *
+ * This is also the number convsim-core already counts: `turn_count` increments
+ * once per exchange, `duration.max_turns` is measured in it, and the debrief's
+ * key moments point at it. Only the transcript labels disagreed, so "Turn 3" in
+ * a debrief's key moments and "Turn 3" in the transcript below it were
+ * different moments.
+ */
+
+type TurnRole = 'npc_opening' | 'player' | 'npc'
+
+/** Infer the role of one transcript row from an event type or a role field. */
+function roleOf(entry: { event_type?: string; role?: string }): TurnRole {
+  const raw = entry.event_type ?? entry.role ?? ''
+  if (raw === 'npc_opening') return 'npc_opening'
+  if (raw === 'player_turn' || raw === 'player') return 'player'
+  return 'npc'
+}
+
+/**
+ * Whole-turn number per row, aligned with the input array.
+ *
+ * Derived from the sequence rather than from a stored index so it works for
+ * both shapes the UI has to label: `npc_opening` / `player_turn` / `npc_turn`
+ * event rows from the session export, and `npc_opening` / `player` / `npc`
+ * transcript rows. A player message opens a turn; an NPC reply closes the one
+ * that is open, or — if none is (a transcript that somehow starts with a reply)
+ * — opens and closes its own.
+ */
+export function wholeTurnNumbersFor(
+  rows: ReadonlyArray<{ event_type?: string; role?: string }>,
+): number[] {
+  let current = 0
+  let openTurnClosed = true
+  return rows.map((row) => {
+    const role = roleOf(row)
+    if (role === 'npc_opening') return 0
+    if (role === 'player') {
+      current += 1
+      openTurnClosed = false
+      return current
+    }
+    if (openTurnClosed) current += 1
+    openTurnClosed = true
+    return current
+  })
+}
diff --git a/apps/web/src/pages/ScenarioSetup.test.tsx b/apps/web/src/pages/ScenarioSetup.test.tsx
index e172717e..9625f5c0 100644
--- a/apps/web/src/pages/ScenarioSetup.test.tsx
+++ b/apps/web/src/pages/ScenarioSetup.test.tsx
@@ -439,7 +439,7 @@ describe('ScenarioSetupPage', () => {
           input_mode: 'push-to-talk',
           tts_enabled: true,
           tts_voice_id: 'af_heart',
-          show_state_meters: false,
+          show_state_meters: true,
           save_transcript: true,
           seed: null,
         },
@@ -461,7 +461,8 @@ describe('ScenarioSetupPage', () => {
           input_mode: 'push-to-talk',
           tts_enabled: true,
           tts_voice_id: 'af_heart',
-          show_state_meters: false,
+          // On by default wherever the scenario permits them (issue #501 §3).
+          show_state_meters: true,
           save_transcript: true,
           seed: null,
         });
@@ -620,15 +621,33 @@ describe('ScenarioSetupPage', () => {
       );
     });
 
-    it('shows state meters toggle when scenario permits it', async () => {
+    it('names the meters toggle the way the panel it switches on is named', async () => {
+      // Issue #501 §3 is a label/naming mismatch; "Show NPC state meters"
+      // against a panel headed "Conversation meters" is the same mismatch, and
+      // this is the label the player reads first.
       renderSetup();
       await waitFor(() => screen.getByText('Behavioral Interview'));
       expect(
-        screen.getByRole('checkbox', { name: /show npc state meters/i }),
+        screen.getByRole('checkbox', { name: /show the conversation meters/i }),
       ).toBeInTheDocument();
+      expect(
+        screen.queryByRole('checkbox', { name: /state meters/i }),
+      ).not.toBeInTheDocument();
+    });
+
+    it('starts the meters toggle on when the scenario permits them', async () => {
+      // Issue #501 §3. The First Words tutorial opens with "Above this
+      // conversation you'll see two meters" and spends three of its six turns
+      // on them; with the toggle defaulting off, a player on default settings
+      // played that whole tour against a screen with no meters on it.
+      renderSetup();
+      await waitFor(() => screen.getByText('Behavioral Interview'));
+      expect(
+        screen.getByRole('checkbox', { name: /show the conversation meters/i }),
+      ).toBeChecked();
     });
 
-    it('hides state meters toggle and shows note when scenario does not permit it', async () => {
+    it('hides the meters toggle and says so when the scenario does not permit them', async () => {
       mockApi.getScenario.mockResolvedValue({ ok: true as const, data: {
         ...mockScenario,
         state_meters_permitted: false,
@@ -636,10 +655,10 @@ describe('ScenarioSetupPage', () => {
       renderSetup();
       await waitFor(() => screen.getByText('Behavioral Interview'));
       expect(
-        screen.queryByRole('checkbox', { name: /show npc state meters/i }),
+        screen.queryByRole('checkbox', { name: /conversation meters/i }),
       ).not.toBeInTheDocument();
       expect(
-        screen.getByText(/state meters are hidden in this scenario/i),
+        screen.getByText(/the conversation meters are hidden in this scenario/i),
       ).toBeInTheDocument();
     });
   });
diff --git a/apps/web/src/pages/ScenarioSetup.tsx b/apps/web/src/pages/ScenarioSetup.tsx
index 58dfc758..237bc2ef 100644
--- a/apps/web/src/pages/ScenarioSetup.tsx
+++ b/apps/web/src/pages/ScenarioSetup.tsx
@@ -207,7 +207,17 @@ export function ScenarioSetupPage({ scenarioId, onSessionCreated, onBack, onInst
             ? prev.voice_id
             : defaultVoiceId,
           input_mode: rt.stt_ready ? 'push-to-talk' : 'text-only',
-          show_state_meters: scenarioData.state_meters_permitted ? prev.show_state_meters : false,
+          // On by default wherever the scenario permits them (issue #501 §3).
+          // Every other field here is derived from the scenario; this one sat
+          // at a hardcoded `false`, so a player on default settings started the
+          // First Words tutorial — whose opening line is "Above this
+          // conversation you'll see two meters" and three of whose six turns
+          // are about them — with no meters on screen at all. "Generally
+          // confused about meters and where they appear" is the report; a
+          // tutorial narrating a panel that was switched off is the sharpest
+          // version of it. A scenario that withholds them for realism still
+          // forces false, and the toggle is one click away either way.
+          show_state_meters: Boolean(scenarioData.state_meters_permitted),
         }
       })
     })();
@@ -650,14 +660,24 @@ export function ScenarioSetupPage({ scenarioId, onSessionCreated, onBack, onInst
                         checked={form.show_state_meters}
                         onChange={(e) => setField('show_state_meters', e.target.checked)}
                       />
+                      {/* Named to match the panel it switches on — the
+                          conversation screen's "Conversation meters", above the
+                          transcript. It used to read "Show NPC state meters",
+                          so a player ticking it met a differently-named panel
+                          one screen later: the same label/naming mismatch
+                          issue #501 §3 reported, handed over in the other
+                          direction, and the first of the two they read. */}
                       <span className="brief-toggle-text">
-                        Show NPC state meters during conversation
+                        Show the conversation meters
+                        <span className="brief-toggle-note">
+                          {' '}— how engaged and open the other person is, updated every turn
+                        </span>
                       </span>
                     </label>
                   )}
                   {!scenario.state_meters_permitted && (
                     <p className="brief-note">
-                      State meters are hidden in this scenario to preserve realism.
+                      The conversation meters are hidden in this scenario, to keep it realistic.
                     </p>
                   )}
                 </div>
diff --git a/apps/web/src/screens/Conversation.tsx b/apps/web/src/screens/Conversation.tsx
index fa787bff..ea350dfb 100644
--- a/apps/web/src/screens/Conversation.tsx
+++ b/apps/web/src/screens/Conversation.tsx
@@ -1,8 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 import { useEffect, useRef, useState } from 'react'
-import { useParams, useNavigate, useLocation } from 'react-router-dom'
+import { useParams, useNavigate, useLocation, Link } from 'react-router-dom'
 import { api } from '../api/client'
-import type { InputMode, ScenarioInfo, TurnResponse, WsEvent } from '@convsim/shared'
+import type {
+  InputMode,
+  ScenarioInfo,
+  SessionCreateRequest,
+  TurnResponse,
+  WsEvent,
+} from '@convsim/shared'
 import VoiceInput, { type SttReviewMeta } from '../components/VoiceInput'
 import DebugDrawer, { type DebugTurnEntry } from '../components/DebugDrawer'
 import PerformanceWarningBanner from '../components/PerformanceWarning'
@@ -21,6 +27,9 @@ import type { ApiError } from '../api/errors'
 import type { ApiResult } from '../api/client'
 import { ApiErrorView } from '../components/ApiErrorView'
 import { useIsDemo } from '../edition'
+import { useUiLanguageLevel } from '../hooks/useUiLanguageLevel'
+import { humanizeEndingType, humanizeFlags, plainFlowState } from '../lib/plainLanguage'
+import StateMeters from '../components/StateMeters'
 
 // How long a wait is allowed to look normal before the UI says something.
 const SLOW_RESPONSE_MS = 5_000
@@ -69,12 +78,37 @@ type TurnEntry = {
   content: string
   emotion?: string
   eventFlags?: string[]
+  /**
+   * Whole-turn number (issue #501 §4): one turn is the player's message plus
+   * the NPC's reply, so both rows of an exchange carry the same number. The
+   * opening line is turn 0 — it belongs to no exchange and is labelled
+   * "Opening" rather than "Turn 1".
+   *
+   * This is the same number convsim-core counts in `turn_count`, that
+   * `duration.max_turns` is measured in, and that debrief key moments point
+   * at. The transcript used to number half-turns, so "Turn 3" in a debrief and
+   * "Turn 3" in the transcript were different moments.
+   */
   turnNum: number
 }
 
+/** Whole-turn number for a persisted transcript row.
+ *
+ *  convsim-core stores the opening at turn_number 0 and then alternates:
+ *  player at 2n-1, NPC at 2n for whole turn n. */
+function wholeTurnFromRow(rowTurnNumber: number): number {
+  return Math.ceil(rowTurnNumber / 2)
+}
+
 type Phase = 'starting' | 'active' | 'submitting' | 'ending' | 'ended' | 'error'
 
-type Banner = { id: number; kind: 'event' | 'safety'; text: string }
+type Banner = {
+  id: number
+  kind: 'event' | 'safety'
+  /** Pre-formatted text (safety reasons), or raw flags to humanize at render. */
+  text?: string
+  flags?: string[]
+}
 
 /** Result of one post-deadline check of what the session actually recorded. */
 type ReconcileOutcome = 'adopted' | 'pending' | 'unavailable'
@@ -103,11 +137,15 @@ function NpcAvatar() {
   )
 }
 
-function npcStatusLabel(sessionState: string, phase: Phase): string {
+function npcStatusLabel(sessionState: string, phase: Phase, isPlain: boolean): string {
   if (phase === 'submitting') return 'Thinking…'
   if (sessionState === 'NpcThinking') return 'Thinking…'
   if (sessionState === 'NpcSpeaking') return 'Speaking…'
-  if (sessionState === 'ScenarioEvent') return 'Event in progress…'
+  // "Event" is one of the four words the playtest named as unexplained jargon
+  // (issue #501 §2), so the plain level says what is happening instead.
+  if (sessionState === 'ScenarioEvent') {
+    return isPlain ? 'Something is changing…' : 'Event in progress…'
+  }
   if (sessionState === 'PlayerTurnListening') return 'Listening'
   return ''
 }
@@ -126,11 +164,23 @@ export default function Conversation() {
     tts_enabled?: boolean
   } | null
 
-  const language = routeState?.language
-  const showStateMeters = routeState?.show_state_meters ?? true
-  const scenarioIdFromRoute = routeState?.scenario_id
-  const inputMode = routeState?.input_mode ?? 'text-only'
-  const ttsEnabled = routeState?.tts_enabled ?? false
+  // Wording level (issue #501 §2): `plain` keeps session ids, flow-state
+  // identifiers and event flags off this screen entirely.
+  const { isPlain } = useUiLanguageLevel()
+
+  // The setup convsim-core recorded when the session was created. Only fetched
+  // when the route state is missing — which is exactly the resume case
+  // (issue #501 §1): navigating to Settings and back, a reload, or a relaunch
+  // all arrive here with no router state, and before this the screen fell back
+  // to defaults and dropped the scene card, the chosen language and the voice
+  // settings the player had picked.
+  const [serverSetup, setServerSetup] = useState<SessionCreateRequest | null>(null)
+
+  const language = routeState?.language ?? serverSetup?.language
+  const showStateMeters = routeState?.show_state_meters ?? serverSetup?.show_state_meters ?? true
+  const scenarioId = routeState?.scenario_id ?? serverSetup?.scenario_id
+  const inputMode = routeState?.input_mode ?? serverSetup?.input_mode ?? 'text-only'
+  const ttsEnabled = routeState?.tts_enabled ?? serverSetup?.tts_enabled ?? false
 
   // Voice timing preferences (issue #308) — read once at mount from localStorage.
   const voiceTimingPrefs = getVoiceTimingPrefs()
@@ -141,6 +191,14 @@ export default function Conversation() {
   const [turns, setTurns] = useState<TurnEntry[]>([])
   // Populated from the server's visible_state snapshots (scenario-specific).
   const [stateVars, setStateVars] = useState<Record<string, number>>({})
+  // Change the most recent turn applied, per variable — the "tick" the tutorial
+  // talks about and that nothing on screen used to show (issue #501 §3).
+  // Derived by diffing successive snapshots rather than read from the model's
+  // requested state_delta: a delta the reducer clamped at 0 or 100, or asked for
+  // a variable this scenario does not track, did not move the meter, and an
+  // arrow claiming it did is exactly the kind of thing the playtest called
+  // hallucinated.
+  const [stateDeltas, setStateDeltas] = useState<Record<string, number>>({})
   const [allEventFlags, setAllEventFlags] = useState<string[]>([])
   const [error, setError] = useState<ApiError | null>(null)
   const [devMode] = useState(() => isDevModeEnabled())
@@ -149,6 +207,9 @@ export default function Conversation() {
   const [npcEmotion, setNpcEmotion] = useState<string | null>(null)
   const [streamingText, setStreamingText] = useState('')
   const [banners, setBanners] = useState<Banner[]>([])
+  // Scenario events already announced, so one cannot be banner'd twice if it
+  // arrives over both the socket and the REST reply.
+  const announcedEventsRef = useRef<Set<string>>(new Set())
   // Milliseconds the current turn has been waiting on the NPC. Drives the
   // progress indicator and both stages of the slow-response notice, so one clock
   // answers "how long has the player been waiting on this turn" — and, once the
@@ -177,6 +238,14 @@ export default function Conversation() {
   const reconcileWakeRef = useRef<(() => void) | null>(null)
   // False once the screen unmounts, so the reconcile loop stops touching state.
   const mountedRef = useRef(true)
+  // What the meters read at the start of the current exchange. The movement
+  // shown on each meter is measured against THIS, not against the previous
+  // snapshot, because one turn produces two snapshots: the WebSocket npc.final
+  // applies the delta optimistically, and then session.state (and, without a
+  // socket, the REST reply) delivers the authoritative numbers. Diffing
+  // consecutive snapshots makes the second one a move of zero, which wiped the
+  // arrow the first one had just earned.
+  const turnBaselineRef = useRef<Record<string, number> | null>(null)
 
   // TTS audio queue — plays synthesized sentence chunks in order.
   const ttsQueueRef = useRef<string[]>([])
@@ -185,10 +254,20 @@ export default function Conversation() {
   const ttsHoldTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
   // True when the player started recording while TTS was playing (barge-in).
   const bargedInRef = useRef(false)
+  // The WebSocket handler is installed once per session, so it captures the
+  // first render's _enqueueTtsChunk. A resumed session learns it had voice
+  // enabled only when the setup fetch lands, after that render — hence a ref
+  // rather than the render-scope value (issue #501 §1).
+  const ttsEnabledRef = useRef(false)
 
   const transcriptRef = useRef<HTMLDivElement>(null)
   const turnUidRef = useRef(0)
-  const turnNumRef = useRef(0)
+  // Transcript ROWS this view holds (opening + every player and NPC message).
+  // The reconcile loop compares this against the server's row count, so it must
+  // stay a row count even though the labels now number whole turns.
+  const rowCountRef = useRef(0)
+  // Whole turns played — the number shown in the labels (issue #501 §4).
+  const gameTurnRef = useRef(0)
   const bannerUidRef = useRef(0)
   const streamingRef = useRef('')
   const phaseRef = useRef<Phase>('starting')
@@ -199,6 +278,7 @@ export default function Conversation() {
   const sessionStateRef = useRef(sessionState)
   phaseRef.current = phase
   sessionStateRef.current = sessionState
+  ttsEnabledRef.current = ttsEnabled
 
   // Clean up any pending timers and TTS audio when the component unmounts.
   useEffect(() => {
@@ -253,20 +333,39 @@ export default function Conversation() {
     setWaitElapsedMs(0)
   }
 
-  /** Replace the transcript with the server's copy, renumbering from the top. */
+  /** Replace the transcript with the server's copy, renumbering from the top.
+   *
+   *  The server's own `turn_number` is authoritative for the whole-turn labels:
+   *  it stores the opening at 0 and then alternates player (2n-1) / NPC (2n)
+   *  for whole turn n. Deriving the label from it keeps a resumed or reconciled
+   *  transcript numbered identically to one built turn by turn, and identically
+   *  to the debrief's key moments. */
   function _hydrateTurnsFromServer(
-    serverTurns: Array<{ role: TurnEntry['role']; content: string; emotion?: string | null }>,
+    serverTurns: Array<{
+      turn_number?: number
+      role: TurnEntry['role']
+      content: string
+      emotion?: string | null
+    }>,
   ) {
-    turnNumRef.current = 0
-    setTurns(
-      serverTurns.map((t) => ({
+    rowCountRef.current = serverTurns.length
+    let highestTurn = 0
+    const rows = serverTurns.map((t, idx) => {
+      // Fall back to position when a row arrives without its number: the
+      // opening is first, and every pair after it is one whole turn.
+      const rowNumber = t.turn_number ?? idx
+      const turnNum = t.role === 'npc_opening' ? 0 : wholeTurnFromRow(rowNumber)
+      if (turnNum > highestTurn) highestTurn = turnNum
+      return {
         id: ++turnUidRef.current,
         role: t.role,
         content: t.content,
         emotion: t.emotion ?? undefined,
-        turnNum: ++turnNumRef.current,
-      })),
-    )
+        turnNum,
+      }
+    })
+    gameTurnRef.current = highestTurn
+    setTurns(rows)
   }
 
   function _playNextTtsChunk() {
@@ -297,7 +396,7 @@ export default function Conversation() {
   function _enqueueTtsChunk(cachePath: string, thinkingPauseMs?: number) {
     // Only play TTS audio when the session was started with TTS enabled.
     // The text transcript remains authoritative regardless of this flag.
-    if (!ttsEnabled) return
+    if (!ttsEnabledRef.current) return
     const filename = cachePath.replace(/\\/g, '/').split('/').pop()
     if (!filename) return
     const url = `/api/tts/audio/${filename}`
@@ -358,7 +457,7 @@ export default function Conversation() {
   }
 
   function handleBargeIn() {
-    if (!ttsEnabled || !voiceTimingPrefs.bargeInEnabled) return
+    if (!ttsEnabledRef.current || !voiceTimingPrefs.bargeInEnabled) return
     const isTtsActive = ttsPlayingRef.current !== null || ttsHoldTimerRef.current !== null
     // Reset the flag on every recording start so it always reflects whether THIS
     // recording began during NPC playback. Otherwise a barge-in the player then
@@ -372,15 +471,29 @@ export default function Conversation() {
     })
   }
 
+  // Resume (issue #501 §1): with no router state — after a trip to Settings, a
+  // reload, or a relaunch — read the setup back from the session convsim-core
+  // already holds. Best effort: the conversation itself still works from the
+  // defaults if this fails.
+  const hasRouteState = routeState != null
+  useEffect(() => {
+    if (!sessionId || hasRouteState) return
+    let cancelled = false
+    void api.getSession(sessionId).then((r) => {
+      if (!cancelled && r.ok) setServerSetup(r.data.setup)
+    })
+    return () => { cancelled = true }
+  }, [sessionId, hasRouteState])
+
   // Fetch scenario for NPC panel and scene card — best effort
   useEffect(() => {
-    if (!scenarioIdFromRoute) return
+    if (!scenarioId) return
     let cancelled = false
-    api.getScenario(scenarioIdFromRoute).then(
+    api.getScenario(scenarioId).then(
       (r) => { if (!cancelled && r.ok) setScenario(r.data) },
     )
     return () => { cancelled = true }
-  }, [scenarioIdFromRoute])
+  }, [scenarioId])
 
   // Start session
   useEffect(() => {
@@ -404,7 +517,8 @@ export default function Conversation() {
         if (alreadyStarted) {
           const tr = await api.getSessionTranscript(sessionId)
           if (cancelled) return
-          if (tr.ok && tr.data.turns.length > 0) {
+          const hydrated = tr.ok && tr.data.turns.length > 0
+          if (hydrated) {
             _hydrateTurnsFromServer(tr.data.turns)
           }
           const lastState = tr.ok
@@ -412,6 +526,30 @@ export default function Conversation() {
             : null
           setSessionState(lastState ?? 'PlayerTurnListening')
           setPhase('active')
+          // Meter values only ever arrived with a turn, so a resumed session
+          // came back with the meters missing entirely until the player sent
+          // another message — on the very screen whose opening line says
+          // "above this conversation you'll see two meters" (issue #501 §1).
+          // After setPhase so a slow or failing read never holds up the input.
+          const sr = await api.getSession(sessionId)
+          if (!cancelled && sr.ok) {
+            if (sr.data.visible_state) {
+              setStateVars({ ...sr.data.visible_state })
+            }
+            // A session started with transcript saving off answers the
+            // transcript endpoint with no rows, always, so there is nothing to
+            // count the resumed turns from and the labels would restart at
+            // "Turn 1" over a session the server is several turns into — the
+            // debrief-says-3-transcript-says-1 mismatch of issue #501 §4, back
+            // again on the screen resume was added for. `turn_count` is the
+            // same whole-turn number the labels, `max_turns` and the debrief
+            // all use. Skipped once the player has sent a message, which owns
+            // the counter from then on, so a slow read cannot renumber a turn
+            // already in flight.
+            if (!hydrated && gameTurnRef.current === 0 && rowCountRef.current === 0) {
+              gameTurnRef.current = sr.data.turn_count ?? 0
+            }
+          }
         } else {
           setError(e)
           setPhase('error')
@@ -423,13 +561,17 @@ export default function Conversation() {
       const opening = startData.events.find((e) => e.event_type === 'npc_opening')
       if (opening) {
         const uid = ++turnUidRef.current
+        rowCountRef.current = 1
+        gameTurnRef.current = 0
         setTurns([
           {
             id: uid,
             role: 'npc_opening',
             content: opening.payload['content'] as string,
             emotion: opening.payload['emotion'] as string | undefined,
-            turnNum: ++turnNumRef.current,
+            // Turn 0: the opening precedes the first exchange, so it is labelled
+            // "Opening" rather than consuming a turn number (issue #501 §4).
+            turnNum: 0,
           },
         ])
         if (devMode) {
@@ -489,6 +631,7 @@ export default function Conversation() {
               npcTurnCommittedRef.current = true
               const { content, emotion: npcEmotion, state_delta, event_flags } = event.payload
               const flags = event_flags ?? []
+              rowCountRef.current += 1
               setTurns((prev) => [
                 ...prev,
                 {
@@ -497,7 +640,9 @@ export default function Conversation() {
                   content,
                   emotion: npcEmotion !== 'neutral' ? npcEmotion : undefined,
                   eventFlags: flags.length > 0 ? flags : undefined,
-                  turnNum: ++turnNumRef.current,
+                  // The reply closes the turn the player's message opened, so
+                  // it shares that number rather than taking a new one.
+                  turnNum: gameTurnRef.current,
                 },
               ])
               if (Object.keys(state_delta ?? {}).length > 0) {
@@ -521,7 +666,7 @@ export default function Conversation() {
                 {
                   id: ++bannerUidRef.current,
                   kind: 'event',
-                  text: event.payload.flags.join(' · '),
+                  flags: event.payload.flags,
                 },
               ])
             }
@@ -560,6 +705,22 @@ export default function Conversation() {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [sessionId, recordInterval])
 
+  // Recompute this turn's meter movement whenever the meters change.
+  useEffect(() => {
+    const baseline = turnBaselineRef.current
+    // The first snapshot is where the meters start, not a change from anything.
+    if (baseline === null) {
+      turnBaselineRef.current = stateVars
+      return
+    }
+    const moved: Record<string, number> = {}
+    for (const [key, value] of Object.entries(stateVars)) {
+      const was = baseline[key]
+      if (was !== undefined && was !== value) moved[key] = value - was
+    }
+    setStateDeltas(moved)
+  }, [stateVars])
+
   // Auto-scroll transcript
   useEffect(() => {
     const el = transcriptRef.current
@@ -599,9 +760,9 @@ export default function Conversation() {
     if (!tr.data.transcript_saved) return 'unavailable'
     const serverTurns = tr.data.turns
     const last = serverTurns[serverTurns.length - 1]
-    // turnNumRef counts every row this view holds, the optimistic player turn
+    // rowCountRef counts every row this view holds, the optimistic player turn
     // included, so the reply only landed if the server is ahead of that.
-    if (!last || last.role !== 'npc' || serverTurns.length <= turnNumRef.current) return 'pending'
+    if (!last || last.role !== 'npc' || serverTurns.length <= rowCountRef.current) return 'pending'
 
     _hydrateTurnsFromServer(serverTurns)
     setNpcEmotion(last.emotion ?? null)
@@ -649,7 +810,7 @@ export default function Conversation() {
     let askTheTranscript = true
     while (mountedRef.current && !hasAnswered()) {
       // A WebSocket npc.final may already have put the reply on screen, in which
-      // case the turn is done. turnNumRef counts that NPC row too, so the
+      // case the turn is done. rowCountRef counts that NPC row too, so the
       // transcript comparison could never see the server pull ahead: left to the
       // loop this would poll to the ceiling and then report a timeout over a
       // reply the player is looking at.
@@ -689,7 +850,14 @@ export default function Conversation() {
     // Add the player turn immediately so it appears before the NPC response
     // regardless of whether the NPC turn is committed by WebSocket or REST.
     const playerTurnId = ++turnUidRef.current
-    const playerTurnNum = ++turnNumRef.current
+    // The player's message opens a new whole turn; the NPC's reply will close
+    // it under the same number (issue #501 §4).
+    const playerTurnNum = ++gameTurnRef.current
+    // Every meter movement from here belongs to this turn, however many
+    // snapshots arrive to report it.
+    turnBaselineRef.current = stateVars
+    setStateDeltas({})
+    rowCountRef.current += 1
     setTurns((prev) => [
       ...prev,
       {
@@ -788,7 +956,8 @@ export default function Conversation() {
       // retry doesn't leave an orphaned failed message or skip a turn number.
       if (!npcTurnCommittedRef.current) {
         setTurns((prev) => prev.filter((t) => t.id !== playerTurnId))
-        turnNumRef.current -= 1
+        rowCountRef.current -= 1
+        gameTurnRef.current -= 1
       }
       setPhase('active')
       return
@@ -804,6 +973,12 @@ export default function Conversation() {
 
     const npcEvent = turnData.events.find((e) => e.event_type === 'npc_turn')
 
+    // Outside the commit guard below: the reply itself may already be on screen
+    // from the socket, but the scenario events it fired only ever travel on
+    // this payload.
+    const firedEvents = npcEvent?.payload['triggered_scenario_events']
+    if (Array.isArray(firedEvents)) announceScenarioEvents(firedEvents as string[])
+
     // Only commit the NPC turn from REST if the WebSocket npc.final handler
     // has not already done so (to avoid duplicate transcript entries).
     if (npcEvent && !npcTurnCommittedRef.current) {
@@ -815,6 +990,7 @@ export default function Conversation() {
       setNpcEmotion(emotion ?? null)
 
       const uid = ++turnUidRef.current
+      rowCountRef.current += 1
       setTurns((prev) => [
         ...prev,
         {
@@ -823,7 +999,8 @@ export default function Conversation() {
           content: payload['content'] as string,
           emotion: emotion !== 'neutral' ? emotion : undefined,
           eventFlags: flags.length > 0 ? flags : undefined,
-          turnNum: ++turnNumRef.current,
+          // Closes the turn the player's message opened.
+          turnNum: gameTurnRef.current,
         },
       ])
 
@@ -891,6 +1068,27 @@ export default function Conversation() {
     }
   }
 
+  /** Raise the "Something changed" note for scenario events that just fired.
+   *
+   *  The engine's own events — a meter crossing a threshold, a flag being set
+   *  — arrive on the npc_turn payload as `triggered_scenario_events`, and
+   *  nothing read them: the banner was fed only by the WebSocket
+   *  `scenario.event` frame, which carries the NPC's self-declared
+   *  `event_flags` and which convsim-core never sends at all. So the First
+   *  Words tutorial crossed Engagement 60, fired `warm_moment`, and then told
+   *  the player "you would have seen a short note above the transcript saying
+   *  something changed" about a note that never appeared — the tutorial
+   *  claiming something happened that did not, which is issue #501 §3. */
+  function announceScenarioEvents(ids: string[]) {
+    const fresh = ids.filter((id) => !announcedEventsRef.current.has(id))
+    if (fresh.length === 0) return
+    for (const id of fresh) announcedEventsRef.current.add(id)
+    setBanners((prev) => [
+      ...prev,
+      { id: ++bannerUidRef.current, kind: 'event', flags: fresh },
+    ])
+  }
+
   function dismissBanner(id: number) {
     setBanners((prev) => prev.filter((b) => b.id !== id))
   }
@@ -907,7 +1105,11 @@ export default function Conversation() {
   const isAwaitingNpc = phase === 'submitting' && !npcReplyOnScreen
   const isSlowResponse = isAwaitingNpc && waitElapsedMs >= SLOW_RESPONSE_MS
   const isVerySlowResponse = isAwaitingNpc && waitElapsedMs >= VERY_SLOW_RESPONSE_MS
-  const npcStatus = npcStatusLabel(sessionState, phase)
+  const npcStatus = npcStatusLabel(sessionState, phase, isPlain)
+  // The character's name when the pack provides one. "NPC" is the most
+  // technical word on this screen and the only reason it was here is that the
+  // name was never exposed over the API (issue #501 §2).
+  const npcLabel = scenario?.npc_name ?? 'NPC'
 
   return (
     <div
@@ -926,14 +1128,25 @@ export default function Conversation() {
       >
         <div>
           <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem', flexWrap: 'wrap' }}>
-            <h1 style={{ margin: 0 }}>Conversation</h1>
+            <h1 style={{ margin: 0 }}>{scenario?.title ?? 'Conversation'}</h1>
           </div>
-          <p style={{ margin: 0, fontSize: '0.8rem', color: '#71717a' }}>
-            Session: <code>{sessionId}</code> &nbsp;|&nbsp; State:{' '}
-            <code>{sessionState}</code>
+          {/* Plain wording keeps the session id and the raw flow-state
+              identifier off the screen entirely: "Session: sess-a1b2c3d4 |
+              State: PlayerTurnListening" was the first thing a new player read
+              (issue #501 §2). Technical wording puts both back, because the
+              id is what a bug report needs. */}
+          <p data-testid="conversation-subhead" style={{ margin: 0, fontSize: '0.8rem', color: '#71717a' }}>
+            {isPlain ? (
+              <span>{plainFlowState(sessionState)}</span>
+            ) : (
+              <>
+                Session: <code>{sessionId}</code> &nbsp;|&nbsp; State:{' '}
+                <code>{sessionState}</code>
+              </>
+            )}
             {endingType && (
               <span style={{ marginLeft: '0.5rem', color: '#a1a1aa' }}>
-                ({endingType.replace(/_/g, ' ')})
+                ({humanizeEndingType(endingType)})
               </span>
             )}
           </p>
@@ -974,18 +1187,20 @@ export default function Conversation() {
         >
           <NpcAvatar />
           <div>
-            <div style={{ fontWeight: 600, color: '#e4e4e7', fontSize: '0.95rem' }}>NPC</div>
+            <div style={{ fontWeight: 600, color: '#e4e4e7', fontSize: '0.95rem' }}>
+              {scenario?.npc_name ?? 'NPC'}
+            </div>
+            {/* "Mood:" is the whole point: the emotion used to be rendered as a
+                bare parenthetical next to the meters, so it read as one of them
+                — "unclear which meter (if any) the emotions in parentheses
+                are" (issue #501 §3). */}
             {npcEmotion && npcEmotion !== 'neutral' && (
               <div
                 data-testid="npc-emotion"
-                style={{
-                  fontSize: '0.8rem',
-                  color: '#6ee7b7',
-                  textTransform: 'capitalize',
-                  marginTop: 2,
-                }}
+                style={{ fontSize: '0.8rem', color: '#6ee7b7', marginTop: 2 }}
               >
-                {npcEmotion}
+                <span style={{ color: '#71717a' }}>Mood: </span>
+                <span style={{ textTransform: 'capitalize' }}>{npcEmotion}</span>
               </div>
             )}
             {/* Always mounted so screen readers announce status transitions;
@@ -1052,8 +1267,16 @@ export default function Conversation() {
           }}
         >
           <span>
-            {banner.kind === 'safety' ? 'Safety redirect: ' : 'Scenario event: '}
-            {banner.text}
+            {banner.kind === 'safety'
+              ? 'Safety redirect: '
+              : isPlain
+              ? 'Something changed: '
+              : 'Scenario event: '}
+            {banner.flags
+              ? isPlain
+                ? humanizeFlags(banner.flags)
+                : banner.flags.join(' · ')
+              : banner.text}
           </span>
           <button
             onClick={() => dismissBanner(banner.id)}
@@ -1080,6 +1303,13 @@ export default function Conversation() {
         </p>
       )}
 
+      {/* The meters, above the transcript — where the tutorial's opening line
+          has always said they are ("Notice the two meters at the top") and
+          where they were not (issue #501 §3). */}
+      {showStateMeters && (
+        <StateMeters stateVars={stateVars} deltas={stateDeltas} isPlain={isPlain} />
+      )}
+
       {/* Transcript */}
       <div
         ref={transcriptRef}
@@ -1112,12 +1342,12 @@ export default function Conversation() {
                 letterSpacing: '0.05em',
               }}
             >
-              <span>Turn {turn.turnNum}</span>
+              {/* One turn is the player's message plus the reply to it, so
+                  both rows share a number, and the opening — which answers
+                  nothing — is labelled rather than numbered (issue #501 §4). */}
+              <span>{turn.turnNum === 0 ? 'Opening' : `Turn ${turn.turnNum}`}</span>
               {' · '}
-              <span>{turn.role === 'player' ? 'You' : 'NPC'}</span>
-              {turn.emotion && turn.emotion !== 'neutral' && (
-                <span style={{ marginLeft: 6, opacity: 0.7 }}>({turn.emotion})</span>
-              )}
+              <span>{turn.role === 'player' ? 'You' : npcLabel}</span>
             </div>
             <div
               style={{
@@ -1131,7 +1361,22 @@ export default function Conversation() {
             >
               {turn.content}
             </div>
-            {turn.eventFlags && turn.eventFlags.length > 0 && (
+            {/* Labelled, and below the bubble rather than beside the turn
+                number: as a bare parenthetical next to the meters it read as
+                one of them (issue #501 §3). */}
+            {turn.emotion && turn.emotion !== 'neutral' && (
+              <div
+                data-testid="turn-mood"
+                style={{ fontSize: '0.7rem', color: '#71717a', marginTop: 2 }}
+              >
+                Mood: <span style={{ color: '#6ee7b7' }}>{turn.emotion}</span>
+              </div>
+            )}
+            {/* "Flag" is one of the four words the playtest named as
+                unexplained jargon, and the raw identifiers mean nothing to a
+                player, so plain wording leaves them out entirely
+                (issue #501 §2). */}
+            {!isPlain && turn.eventFlags && turn.eventFlags.length > 0 && (
               <div style={{ fontSize: '0.7rem', color: '#fbbf24', marginTop: 2 }}>
                 Flags: {turn.eventFlags.join(', ')}
               </div>
@@ -1151,7 +1396,7 @@ export default function Conversation() {
                 letterSpacing: '0.05em',
               }}
             >
-              NPC · Responding…
+              {npcLabel} · Responding…
             </div>
             <div
               style={{
@@ -1217,9 +1462,26 @@ export default function Conversation() {
             fontSize: '0.8rem',
           }}
         >
-          {isDemo
-            ? 'NPC is taking longer than usual. The model may be slow on this hardware; closing other apps usually helps.'
-            : 'NPC is taking longer than usual. The model may be slow on this hardware. You can adjust settings or try a smaller model.'}
+          {isDemo ? (
+            `${npcLabel} is taking longer than usual. The model may be slow on this hardware; closing other apps usually helps.`
+          ) : (
+            <>
+              {npcLabel} is taking longer than usual. The model may be slow on
+              this hardware.{' '}
+              {/* The moment the player actually wants the speed setting is this
+                  one. Before #501 this sentence said "you can adjust settings"
+                  and left them to find out which — the detour that lost them
+                  their session. Resuming is one click back, via the banner in
+                  the app chrome. */}
+              <Link
+                to="/settings#reply-speed"
+                data-testid="slow-response-speed-link"
+                style={{ color: '#fcd34d', textDecoration: 'underline' }}
+              >
+                Make replies faster →
+              </Link>
+            </>
+          )}
           {isVerySlowResponse && (
             // Past half a minute, say outright that the turn has not been
             // thrown away — the panel above already reports the clock, so
@@ -1231,73 +1493,12 @@ export default function Conversation() {
         </div>
       )}
 
-      {/* State meters — shown only when enabled in setup and hydrated */}
-      {showStateMeters && Object.keys(stateVars).length > 0 && (
-        <details open>
-          <summary
-            style={{ cursor: 'pointer', fontSize: '0.8rem', color: '#71717a', userSelect: 'none' }}
-          >
-            NPC state variables
-          </summary>
-          <div
-            data-testid="state-vars"
-            style={{
-              display: 'flex',
-              flexWrap: 'wrap',
-              gap: '0.5rem',
-              marginTop: '0.5rem',
-              padding: '0.5rem',
-              borderRadius: 6,
-              border: '1px solid #27272a',
-            }}
-          >
-            {Object.entries(stateVars).map(([key, value]) => (
-              <div
-                key={key}
-                style={{
-                  display: 'flex',
-                  flexDirection: 'column',
-                  alignItems: 'center',
-                  minWidth: 80,
-                  padding: '0.4rem 0.5rem',
-                  borderRadius: 4,
-                  background: '#18181b',
-                  fontSize: '0.8rem',
-                }}
-              >
-                <span style={{ color: '#a1a1aa', marginBottom: 2 }}>{key}</span>
-                <span style={{ color: '#f4f4f5', fontWeight: 600 }}>{value}</span>
-                <div
-                  role="meter"
-                  aria-label={`${key.replace(/_/g, ' ')}: ${value} out of 100`}
-                  aria-valuenow={value}
-                  aria-valuemin={0}
-                  aria-valuemax={100}
-                  style={{
-                    width: '100%',
-                    height: 4,
-                    borderRadius: 2,
-                    background: '#27272a',
-                    marginTop: 4,
-                  }}
-                >
-                  <div
-                    aria-hidden="true"
-                    style={{
-                      width: `${value}%`,
-                      height: '100%',
-                      borderRadius: 2,
-                      background: value >= 50 ? '#22c55e' : '#f97316',
-                    }}
-                  />
-                </div>
-              </div>
-            ))}
-          </div>
-        </details>
-      )}
-
-      {allEventFlags.length > 0 && (
+      {/* The running list of raw flag identifiers is a developer's view of the
+          session, not a player's — "Event flags: honesty_demonstrated,
+          player_demonstrates_knowledge" told the playtester nothing. The
+          per-turn "Something changed" banner already reports the ones that
+          matter in words (issue #501 §2). */}
+      {!isPlain && allEventFlags.length > 0 && (
         <div
           role="status"
           aria-live="polite"
@@ -1328,7 +1529,7 @@ export default function Conversation() {
         >
           <p style={{ margin: '0 0 0.75rem', color: '#a1a1aa' }}>
             Session ended.
-            {endingType ? ` Outcome: ${endingType.replace(/_/g, ' ')}.` : ''}
+            {endingType ? ` Outcome: ${humanizeEndingType(endingType)}.` : ''}
           </p>
           <button
             onClick={() => navigate(`/debrief/${sessionId}`)}
diff --git a/apps/web/src/screens/Debrief.tsx b/apps/web/src/screens/Debrief.tsx
index 5b76725e..7d354130 100644
--- a/apps/web/src/screens/Debrief.tsx
+++ b/apps/web/src/screens/Debrief.tsx
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-import { useCallback, useEffect, useRef, useState } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useParams, useNavigate, Link } from 'react-router-dom'
 import type { DebriefTurningPoint, DebriefMetrics, SessionDebriefResponse, SessionCreateRequest, LogbookProfile } from '@convsim/shared'
 import { recommendNext } from '@convsim/shared'
@@ -12,6 +12,8 @@ import { useSteamAchievements, SteamAchievement, SteamStat } from '../hooks/useS
 import { useScenarios } from '../api/useScenarios'
 import { useIsDemo } from '../edition'
 import DemoUpsellCard from '../components/DemoUpsellCard'
+import FamiliarityReaskCard from '../components/FamiliarityReaskCard'
+import { wholeTurnNumbersFor } from '../lib/wholeTurns'
 
 type TranscriptEvent = {
   event_id: number
@@ -170,6 +172,13 @@ export default function Debrief() {
     }
   }, [phase, voiceInviteVisible, isDemo])
 
+  // One whole turn is the player's message plus the NPC's reply, and the
+  // opening belongs to neither (issue #501 §4). The debrief's own key-moment
+  // turn numbers are already whole turns, so labelling the transcript by
+  // position made "#3" in the key moments point at a different moment than
+  // "Turn 3" in the transcript right below it.
+  const wholeTurnNumbers = useMemo(() => wholeTurnNumbersFor(transcript), [transcript])
+
   const scrollToTurn = useCallback((turnNumber: number) => {
     const el = turnRefs.current.get(turnNumber)
     if (el) el.scrollIntoView({ behavior: 'smooth', block: 'center' })
@@ -402,17 +411,29 @@ export default function Debrief() {
                   gap: '0.75rem',
                 }}
               >
-                {transcript.map((event, idx) => (
-                  <TranscriptTurn
-                    key={event.event_id > 0 ? event.event_id : idx}
-                    event={event}
-                    turnNumber={idx + 1}
-                    registerRef={(el) => {
-                      if (el) turnRefs.current.set(idx + 1, el)
-                      else turnRefs.current.delete(idx + 1)
-                    }}
-                  />
-                ))}
+                {transcript.map((event, idx) => {
+                  const turnNumber = wholeTurnNumbers[idx] ?? 0
+                  return (
+                    <TranscriptTurn
+                      key={event.event_id > 0 ? event.event_id : idx}
+                      event={event}
+                      turnNumber={turnNumber}
+                      registerRef={(el) => {
+                        // Keyed by whole turn, and only the first row of each —
+                        // the player's message — so "go to turn 3" lands on the
+                        // start of turn 3 rather than on whichever half-turn
+                        // happened to be third in the list (issue #501 §4).
+                        if (turnNumber === 0) return
+                        const existing = turnRefs.current.get(turnNumber)
+                        if (el) {
+                          if (existing === undefined) turnRefs.current.set(turnNumber, el)
+                        } else if (existing !== undefined) {
+                          turnRefs.current.delete(turnNumber)
+                        }
+                      }}
+                    />
+                  )
+                })}
               </div>
             </section>
           ) : (
@@ -717,17 +738,29 @@ export default function Debrief() {
                   gap: '0.75rem',
                 }}
               >
-                {transcript.map((event, idx) => (
-                  <TranscriptTurn
-                    key={event.event_id > 0 ? event.event_id : idx}
-                    event={event}
-                    turnNumber={idx + 1}
-                    registerRef={(el) => {
-                      if (el) turnRefs.current.set(idx + 1, el)
-                      else turnRefs.current.delete(idx + 1)
-                    }}
-                  />
-                ))}
+                {transcript.map((event, idx) => {
+                  const turnNumber = wholeTurnNumbers[idx] ?? 0
+                  return (
+                    <TranscriptTurn
+                      key={event.event_id > 0 ? event.event_id : idx}
+                      event={event}
+                      turnNumber={turnNumber}
+                      registerRef={(el) => {
+                        // Keyed by whole turn, and only the first row of each —
+                        // the player's message — so "go to turn 3" lands on the
+                        // start of turn 3 rather than on whichever half-turn
+                        // happened to be third in the list (issue #501 §4).
+                        if (turnNumber === 0) return
+                        const existing = turnRefs.current.get(turnNumber)
+                        if (el) {
+                          if (existing === undefined) turnRefs.current.set(turnNumber, el)
+                        } else if (existing !== undefined) {
+                          turnRefs.current.delete(turnNumber)
+                        }
+                      }}
+                    />
+                  )
+                })}
               </div>
             </section>
           )}
@@ -760,6 +793,13 @@ export default function Debrief() {
 
           {isDemo && <DemoUpsellCard compact />}
 
+          {/* The post-tutorial re-ask of the familiarity question
+              (issue #501 §2). Renders nothing outside the tutorial debrief, or
+              once it has been shown. */}
+          {!isDemo && (
+            <FamiliarityReaskCard scenarioId={debrief?.scenario_id ?? exportedScenarioId} />
+          )}
+
           {/* Voice invite card — shown once after the first real AI conversation */}
           {voiceInviteVisible && !isDemo && (
             <div
@@ -1139,12 +1179,13 @@ function TranscriptTurn({
           letterSpacing: '0.05em',
         }}
       >
-        <span>{t('debrief.transcript.turn', { number: turnNumber })}</span>
+        <span>
+          {turnNumber === 0
+            ? t('debrief.transcript.opening')
+            : t('debrief.transcript.turn', { number: turnNumber })}
+        </span>
         {' · '}
         <span>{isPlayer ? t('debrief.transcript.you') : t('debrief.transcript.npc')}</span>
-        {emotion && emotion !== 'neutral' && (
-          <span style={{ marginLeft: 6, opacity: 0.7 }}>({emotion})</span>
-        )}
       </div>
       <div
         style={{
@@ -1158,6 +1199,14 @@ function TranscriptTurn({
       >
         {content}
       </div>
+      {/* Labelled rather than a bare parenthetical: next to a turn number it
+          read as one of the meters (issue #501 §3). */}
+      {emotion && emotion !== 'neutral' && (
+        <div style={{ fontSize: '0.7rem', color: '#71717a', marginTop: 2 }}>
+          {t('debrief.transcript.moodLabel')}{' '}
+          <span style={{ color: '#6ee7b7' }}>{emotion}</span>
+        </div>
+      )}
     </div>
   )
 }
@@ -1255,11 +1304,15 @@ function TelemetryPanel({ metrics }: { metrics: DebriefMetrics }) {
         )}
       </div>
 
-      {/* State arc sparklines */}
+      {/* Meter arc sparklines. Named after the panel the player watched during
+          the conversation — "Conversation meters" — rather than after the state
+          variables behind it: a panel that changes name between the screen it
+          moves on and the screen that reviews it is the label/naming mismatch
+          of issue #501 §3, one screen later. */}
       {stateVarNames.length > 0 && (
         <div>
           <p style={{ margin: '0 0 0.5rem', fontSize: '0.75rem', color: '#71717a' }}>
-            State meters across turns
+            Conversation meters across turns
           </p>
           <div style={{ display: 'flex', flexDirection: 'column', gap: '0.4rem' }}>
             {stateVarNames.map((varName) => (
diff --git a/apps/web/src/screens/Home.tsx b/apps/web/src/screens/Home.tsx
index 9d032b90..9c055318 100644
--- a/apps/web/src/screens/Home.tsx
+++ b/apps/web/src/screens/Home.tsx
@@ -16,6 +16,7 @@ import { useAppUpdate } from '../hooks/useAppUpdate'
 import { useIsDemo } from '../edition'
 import DemoConversations from '../components/DemoConversations'
 import DemoUpsellCard from '../components/DemoUpsellCard'
+import { useResumableSession } from '../hooks/useResumableSession'
 import type { BadgeStatus } from '@convsim/ui'
 
 const DOCS_URL = 'https://docs.conversationsimulator.com/'
@@ -38,6 +39,10 @@ export default function Home() {
   // and model surfaces are not part of the demo.
   const isDemo = useIsDemo()
 
+  // Home had no way back into a conversation the player walked away from
+  // (issue #501 §1) — not here and not in the nav.
+  const resumable = useResumableSession()
+
   const [isRestartingSidecar, setIsRestartingSidecar] = useState(false)
   const [reseeding, setReseeding] = useState(false)
   const [reseedDone, setReseedDone] = useState(false)
@@ -178,6 +183,17 @@ export default function Home() {
         aria-label={t('home.primaryActions')}
         style={{ marginTop: '2rem', display: 'flex', flexDirection: 'column', gap: '0.75rem', maxWidth: '20rem' }}
       >
+        {/* First in the list, and only when there is one: resuming beats
+            starting over, which is what the playtester did instead. */}
+        {resumable.result.state === 'ready' && (
+          <Link
+            to={`/conversation/${resumable.result.session.session_id}`}
+            data-testid="home-resume-link"
+            style={{ fontWeight: 600 }}
+          >
+            {t('home.resumeScenario')}
+          </Link>
+        )}
         <Link to="/library">{t('home.startScenario')}</Link>
         <Link to="/workbench">{t('home.createEdit')}</Link>
         <Link to="/settings">{t('home.installModel')}</Link>
diff --git a/apps/web/src/screens/Logbook.tsx b/apps/web/src/screens/Logbook.tsx
index 2b9a6d5f..3b1b44e5 100644
--- a/apps/web/src/screens/Logbook.tsx
+++ b/apps/web/src/screens/Logbook.tsx
@@ -116,7 +116,7 @@ export default function Logbook() {
       <div>
         <h1>Logbook</h1>
         <p role="alert" style={{ color: '#f87171', display: 'flex', alignItems: 'center', gap: '0.5rem', flexWrap: 'wrap' }}>
-          <span>Could not load logbook data. Check that the local runtime is running.</span>
+          <span>Could not load logbook data. Check that the AI engine is running.</span>
           <CopyDiagnosticsButton context="logbook:load" compact />
         </p>
       </div>
diff --git a/apps/web/src/screens/Settings.tsx b/apps/web/src/screens/Settings.tsx
index a1c80210..ecf5528f 100644
--- a/apps/web/src/screens/Settings.tsx
+++ b/apps/web/src/screens/Settings.tsx
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 import { useState, useEffect, useCallback, useRef, type ReactNode } from 'react'
-import { Link, useNavigate } from 'react-router-dom'
+import { Link, useLocation, useNavigate } from 'react-router-dom'
 import { api, type ImportPackResponse, type PackSummary, type RelationshipRecapSummary } from '../api/client'
 import type { ApiError } from '../api/errors'
 import { errorHeadline } from '../api/errors'
@@ -8,13 +8,21 @@ import { ApiErrorView } from '../components/ApiErrorView'
 import { readPrivacyPref, writePrivacyPref, PRIVACY_KEYS, isDevModeEnabled } from '../privacyPrefs'
 import { useSteamStatus } from '../hooks/useSteamStatus'
 import RuntimeSettingsPanel from '../components/RuntimeSettingsPanel'
+import ReplySpeedPanel from '../components/ReplySpeedPanel'
+import WordingPanel from '../components/WordingPanel'
 import VoiceSettingsPanel from '../components/VoiceSettingsPanel'
 import { useTranslation, formatDate, SUPPORTED_LOCALES } from '../i18n'
+import { useScenarios } from '../api/useScenarios'
+import { useUiLanguageLevel } from '../hooks/useUiLanguageLevel'
+import { flowStateLabelKey } from '../lib/plainLanguage'
 import { RemediationCard } from '../setup/RemediationCard'
 import { openExternal } from '../lib/openExternal'
 import { clearTurnSamples } from '../lib/turnEstimate'
 import { useIsDemo } from '../edition'
 import type { PreflightResponse, PreflightFixAction } from '@convsim/shared'
+// The resumable set lives in @convsim/shared so this list and the
+// `status=in_progress` filter it mirrors cannot drift apart (issue #501 §1).
+import { isResumableSessionState } from '@convsim/shared'
 
 type ClearState = 'idle' | 'confirming' | 'clearing' | 'done' | 'error'
 type PackImportState = 'idle' | 'uploading' | 'success' | 'error'
@@ -91,6 +99,10 @@ const LOCALE_DISPLAY_NAMES: Record<string, string> = {
 export default function Settings() {
   const { t, locale, setLocale } = useTranslation()
   const navigate = useNavigate()
+  const { isPlain } = useUiLanguageLevel()
+  // Titles for the session list, so it does not have to print scenario slugs.
+  const scenariosResult = useScenarios()
+  const { hash } = useLocation()
   // Demo edition (issue #495): Settings keeps language, transcript saving,
   // local folders, sessions and clear-data — the privacy controls every
   // edition must have (gate F-06). Runtime/model tiers, voice, Steam Cloud,
@@ -130,6 +142,18 @@ export default function Settings() {
     }
   }
 
+  // A router navigation to /settings#reply-speed does not scroll on its own, so
+  // the slow-response notice's "Make replies faster" link would land the player
+  // at the top of a long settings page with nothing obviously changed
+  // (issue #501 §1).
+  useEffect(() => {
+    if (!hash) return
+    const target = document.getElementById(hash.slice(1))
+    if (target && typeof target.scrollIntoView === 'function') {
+      target.scrollIntoView({ block: 'start' })
+    }
+  }, [hash])
+
   function handleSaveTranscriptsChange(v: boolean) {
     setSaveTranscripts(v)
     writePrivacyPref(PRIVACY_KEYS.saveTranscripts, v)
@@ -439,6 +463,32 @@ export default function Settings() {
         )}
       </section>
 
+      {/* Wording level — the buffer between player-facing and technical
+          language (issue #501 §2). Above the engine settings on purpose: it
+          changes what the rest of this screen and the conversation screen
+          call things. */}
+      <section style={{ marginBottom: '2rem' }} data-testid="settings-wording-section">
+        <SectionHeading>{t('settings.wording.heading')}</SectionHeading>
+        <p style={{ fontSize: '0.875rem', color: '#a1a1aa', marginBottom: '0.75rem' }}>
+          {t('settings.wording.description')}
+        </p>
+        <WordingPanel />
+      </section>
+
+      {/* Reply speed — the plain-language answer to "make the model respond
+          faster" (issue #501 §1). Deliberately its own section above the
+          engine knobs, and anchored so the conversation screen's slow-response
+          notice can link straight here. */}
+      {!isDemo && (
+      <section id="reply-speed" style={{ marginBottom: '2rem' }} data-testid="settings-reply-speed-section">
+        <SectionHeading>{t('settings.replySpeed.heading')}</SectionHeading>
+        <p style={{ fontSize: '0.875rem', color: '#a1a1aa', marginBottom: '0.75rem' }}>
+          {t('settings.replySpeed.description')}
+        </p>
+        <ReplySpeedPanel />
+      </section>
+      )}
+
       {/* Runtime settings */}
       {!isDemo && (
       <section style={{ marginBottom: '2rem' }}>
@@ -829,7 +879,10 @@ export default function Settings() {
                 }}
               >
                 <span style={{ color: '#d4d4d8', flex: 1, minWidth: 0 }}>
-                  <span style={{ fontWeight: 500 }}>{s.scenario_id}</span>
+                  <span style={{ fontWeight: 500 }}>
+                    {scenariosResult.scenarios.find((sc) => sc.scenario_id === s.scenario_id)
+                      ?.title ?? s.scenario_id}
+                  </span>
                   <span style={{ color: '#71717a', marginLeft: '0.5rem' }}>
                     {formatDate(s.created_at, locale)}
                   </span>
@@ -840,10 +893,33 @@ export default function Settings() {
                       color: s.state === 'Ended' ? '#86efac' : '#fbbf24',
                     }}
                   >
-                    {s.state}
+                    {isPlain ? t(flowStateLabelKey(s.state)) : s.state}
                   </span>
                 </span>
                 <div style={{ display: 'flex', gap: '0.4rem', flexShrink: 0 }}>
+                  {/* The screen the lost player was already standing on
+                      (issue #501 §1): every unfinished conversation is one
+                      click from here, not just the newest one the banner
+                      offers. */}
+                  {isResumableSessionState(s.state) && (
+                    <button
+                      aria-label={t('settings.sessions.resumeLabel', { id: s.session_id })}
+                      data-testid={`settings-resume-${s.session_id}`}
+                      onClick={() => navigate(`/conversation/${s.session_id}`)}
+                      style={{
+                        padding: '0.2rem 0.6rem',
+                        borderRadius: '4px',
+                        border: 'none',
+                        cursor: 'pointer',
+                        background: '#4f46e5',
+                        color: '#fff',
+                        fontSize: '0.8rem',
+                        fontWeight: 600,
+                      }}
+                    >
+                      {t('settings.sessions.resume')}
+                    </button>
+                  )}
                   <button
                     aria-label={t('settings.sessions.exportLabel', { id: s.session_id })}
                     onClick={() => handleExportSession(s.session_id)}
diff --git a/apps/web/src/setup/steps/BenchmarkStep.tsx b/apps/web/src/setup/steps/BenchmarkStep.tsx
index 6529ce9a..931b58b5 100644
--- a/apps/web/src/setup/steps/BenchmarkStep.tsx
+++ b/apps/web/src/setup/steps/BenchmarkStep.tsx
@@ -42,7 +42,7 @@ export function BenchmarkStep({ flow, mode, onComplete }: BenchmarkStepProps) {
                 </tr>
               )}
               <tr>
-                <td style={{ color: '#a1a1aa', paddingTop: '0.4rem', paddingBottom: '0.4rem', paddingRight: '1.5rem', whiteSpace: 'nowrap', verticalAlign: 'top' }}>Runtime</td>
+                <td style={{ color: '#a1a1aa', paddingTop: '0.4rem', paddingBottom: '0.4rem', paddingRight: '1.5rem', whiteSpace: 'nowrap', verticalAlign: 'top' }}>AI engine</td>
                 <td style={{ paddingTop: '0.4rem', paddingBottom: '0.4rem' }}>{flow.benchmarkResult.runtime_id}</td>
               </tr>
             </tbody>
@@ -61,7 +61,7 @@ export function BenchmarkStep({ flow, mode, onComplete }: BenchmarkStepProps) {
                 ))}
               </ul>
               <p style={{ margin: '0.5rem 0 0', fontSize: '0.8rem', color: '#a1a1aa' }}>
-                If generation is slow, try a smaller model or check that GPU acceleration is enabled in your runtime settings.{' '}
+                If generation is slow, try a smaller model or check that GPU acceleration is enabled in your engine settings.{' '}
                 <a href={SETUP_DOCS_URL} target="_blank" rel="noreferrer">Setup docs</a>
               </p>
             </div>
diff --git a/apps/web/src/setup/steps/ConfirmInstallStep.tsx b/apps/web/src/setup/steps/ConfirmInstallStep.tsx
index 0dea4087..5ef766d8 100644
--- a/apps/web/src/setup/steps/ConfirmInstallStep.tsx
+++ b/apps/web/src/setup/steps/ConfirmInstallStep.tsx
@@ -59,7 +59,7 @@ export function ConfirmInstallStep({ flow, mode }: ConfirmInstallStepProps) {
               <span style={{ display: 'block', fontSize: '0.8rem', color: '#fbbf24', marginTop: '0.2rem' }}>
                 {mode === 'wizard'
                   ? 'Checksum not yet confirmed — the download will be rejected if verification fails.'
-                  : 'Checksum not yet confirmed — install may be rejected by the runtime.'}
+                  : 'Checksum not yet confirmed — install may be rejected by the AI engine.'}
               </span>
             ) : mode === 'wizard' ? (
               <span style={{ display: 'block', fontSize: '0.75rem', color: '#71717a', marginTop: '0.2rem' }}>
@@ -97,7 +97,7 @@ export function ConfirmInstallStep({ flow, mode }: ConfirmInstallStepProps) {
               <p style={{ fontSize: '0.875rem', color: '#a1a1aa', marginTop: '0.4rem' }}>
                 {needsMoreVram
                   ? `This model requires ${m.min_vram_gb} GB VRAM. If your hardware is limited, try a smaller model or `
-                  : 'If your hardware or runtime cannot install this model, try a smaller model or '}
+                  : 'If your hardware or AI engine cannot install this model, try a smaller model or '}
                 check the <a href={SETUP_DOCS_URL} target="_blank" rel="noreferrer">setup docs</a>.
               </p>
               <div style={{ marginTop: '0.5rem' }}>
diff --git a/apps/web/src/setup/steps/LoadErrorStep.tsx b/apps/web/src/setup/steps/LoadErrorStep.tsx
index 12371a83..13a0d4fb 100644
--- a/apps/web/src/setup/steps/LoadErrorStep.tsx
+++ b/apps/web/src/setup/steps/LoadErrorStep.tsx
@@ -33,7 +33,7 @@ export function LoadErrorStep({ flow, mode }: LoadErrorStepProps) {
         <>
           <p role="alert" style={{ color: '#f87171' }}>{errMsg}</p>
           <div style={{ marginTop: '0.5rem', padding: '0.85rem 1rem', background: 'rgba(239,68,68,0.08)', border: '1px solid rgba(239,68,68,0.3)', borderRadius: '6px' }}>
-            <p style={{ margin: '0 0 0.4rem', fontWeight: 600, color: '#f87171', fontSize: '0.875rem' }}>Could not connect to the local runtime</p>
+            <p style={{ margin: '0 0 0.4rem', fontWeight: 600, color: '#f87171', fontSize: '0.875rem' }}>Could not connect to the AI engine</p>
             <p style={{ margin: '0 0 0.75rem', fontSize: '0.825rem', color: '#a1a1aa' }}>
               The API server may not be running. Make sure you launched the app correctly, then try again.
             </p>
diff --git a/apps/web/src/setup/steps/WelcomeStep.tsx b/apps/web/src/setup/steps/WelcomeStep.tsx
index d0e2443a..ffe6ab4a 100644
--- a/apps/web/src/setup/steps/WelcomeStep.tsx
+++ b/apps/web/src/setup/steps/WelcomeStep.tsx
@@ -5,6 +5,7 @@ import { ActionButton } from '../primitives'
 import type { UseSetupFlowReturn } from '../useSetupFlow'
 import { SETUP_DOCS_URL } from '../docsUrls'
 import { useIsDemo } from '../../edition'
+import FamiliarityQuestion from '../../components/FamiliarityQuestion'
 
 const cardBase: React.CSSProperties = {
   display: 'flex', flexDirection: 'column', alignItems: 'flex-start',
@@ -49,6 +50,20 @@ export function WelcomeStep({ flow }: { flow: UseSetupFlowReturn }) {
         </p>
       </div>
 
+      {/* The initial LLM-familiarity question (issue #501 §2). One row, three
+          answers, no step of its own: the single road to a first conversation
+          below must stay the single road, so this never blocks it and an
+          unanswered question means plain wording. */}
+      <div
+        style={{
+          marginBottom: '1.5rem', padding: '0.85rem 1rem',
+          background: 'rgba(255,255,255,0.03)', border: '1px solid rgba(255,255,255,0.1)',
+          borderRadius: '10px',
+        }}
+      >
+        <FamiliarityQuestion heading={t('familiarity.question')} compact />
+      </div>
+
       <div style={{ marginBottom: '1.5rem' }}>
         {/* Set me up — the single road to a real first conversation */}
         <button
diff --git a/docs/SPEC.md b/docs/SPEC.md
index 43e19b29..a2058941 100644
--- a/docs/SPEC.md
+++ b/docs/SPEC.md
@@ -492,6 +492,12 @@ pack_readme_fts
 
 The MVP should implement a turn-based spoken conversation loop.
 
+**One turn is one player message plus the NPC's reply to it** — steps 6–13
+below, taken together. The two halves are not counted separately. `turn_count`,
+`duration.max_turns`, the transcript's `Turn N` labels and the debrief's key
+moments all use this one unit, and the NPC's opening (step 5) precedes the
+first turn rather than consuming it.
+
 ## 6.1 Player loop
 
 ```text
@@ -779,7 +785,7 @@ rubric:
   ref: "../rubrics/interview-rubric.yaml"
 
 duration:
-  max_turns: 18
+  max_turns: 18            # whole turns: one player message + one NPC reply
   soft_time_limit_minutes: 20
 
 opening:
@@ -1098,10 +1104,10 @@ Must show:
 Status card example:
 
 ```text
-Local runtime: Ready
-LLM: Qwen3 8B Instruct Q4_K_M
-STT: Whisper small.en
-TTS: Kokoro af_heart
+AI engine: Ready
+AI model: Qwen3 8B Instruct Q4_K_M
+Voice input: Whisper small.en
+Voice output: Kokoro af_heart
 Network required to play: No
 ```
 
@@ -1740,6 +1746,7 @@ GET  /api/scenarios
 GET  /api/scenarios/{scenario_id}
 
 POST /api/sessions
+GET  /api/sessions                       ?status=all|in_progress|ended&limit=1..500
 GET  /api/sessions/{session_id}
 POST /api/sessions/{session_id}/start
 POST /api/sessions/{session_id}/turn
diff --git a/docs/acceptance/player-checklist.md b/docs/acceptance/player-checklist.md
index 2b99164e..8243fcac 100644
--- a/docs/acceptance/player-checklist.md
+++ b/docs/acceptance/player-checklist.md
@@ -83,13 +83,47 @@ Start the selected scenario.
 - [ ] NPC opening line delivered within 10 seconds
 - [ ] Typing a player turn and submitting returns an NPC response within 30 s (fake); with a real model on CPU it can take several minutes, and must not report a timeout error
 - [ ] Transcript updates after each turn
-
-### P-M6 — State meters (optional)
-
-Enable **Show state meters** in session settings.
-
-- [ ] State variables visible during conversation
-- [ ] Values change after turns that trigger state deltas
+- [ ] The NPC's opening is labelled **Opening**, and each exchange after it is
+      labelled **Turn N** on *both* rows — your message and the reply share one
+      number (see [Counting turns](../scenario-authoring.md#counting-turns))
+
+### P-M6 — Conversation meters (optional)
+
+On the Conversation Brief, before starting, check **Show the conversation
+meters**. It is only offered for scenarios that permit them; a scenario that
+does not says so instead ("The conversation meters are hidden in this scenario,
+to keep it realistic"), so pick one that does.
+
+- [ ] The toggle is already **on** without touching it — scenarios that permit
+      meters show them by default, because the scenarios that talk about them
+      (the First Words tutorial opens with "Above this conversation you'll see
+      two meters") have to be telling the truth
+- [ ] A panel headed **Conversation meters** is visible *above* the transcript —
+      the toggle and the panel use the same name
+- [ ] One bar per visible variable, each labelled in everyday words rather than
+      a raw key (`objective_progress` reads as "Objective progress"), with its
+      value out of 100
+- [ ] Values change after turns that trigger state deltas, and the change is
+      shown on the meter that moved (e.g. "▲ +10 this turn")
+- [ ] The NPC's mood is clearly **not** one of the meters: it reads "Mood: warm"
+      in the NPC panel and under each reply, never as a bare parenthetical
+      beside the bars or the turn number
+
+### P-M6b — Leave and resume (issue #501)
+
+Partway through the conversation, without ending it, navigate to **Settings**.
+
+- [ ] A **Conversation in progress** strip is visible under the header, with a
+      **Resume** button
+- [ ] **Settings → Reply speed** is findable without expanding anything, and
+      choosing **Quick replies** reports that it needs no restart
+- [ ] **Settings → Your sessions** lists the unfinished conversation with its
+      own **Resume** button
+- [ ] Resuming returns to the same conversation with the transcript, the meters
+      and the turn numbering intact — not a new session
+- [ ] The scenario's scene card and the language it was started in survive the
+      round trip (these come back from the server, not the browser's history
+      state, so also check after a full page reload)
 
 ### P-M7 — Finish and debrief
 
@@ -125,7 +159,8 @@ During or after a full session:
 | P-M3 Real model | PASS / FAIL / SKIP | | optional |
 | P-M4 Scenario select | PASS / FAIL / SKIP | | | |
 | P-M5 Speak/type | PASS / FAIL / SKIP | | | |
-| P-M6 State meters | PASS / FAIL / SKIP | | | optional |
+| P-M6 Conversation meters | PASS / FAIL / SKIP | | | optional |
+| P-M6b Leave and resume | PASS / FAIL / SKIP | | | |
 | P-M7 Debrief | PASS / FAIL / SKIP | | | |
 | P-M8 Replay | PASS / FAIL / SKIP | | | |
 | P-M9 No cloud | PASS / FAIL / SKIP | | | |
diff --git a/docs/architecture.md b/docs/architecture.md
index 5866dc7e..6fd786b5 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -188,6 +188,27 @@ in the DB, managed client-side):
 | `safety_stop`  | Input safety precheck or NPC output triggered stop    |
 | `player_exit`  | Player called `POST /api/sessions/{id}/end`           |
 
+### What counts as a turn
+
+**One turn is one player message plus the NPC's reply to it.** The two are
+halves of a single turn, not two turns — the sense the term carries elsewhere
+in the conversational-LLM world.
+
+This is the unit everything server-side already counted, and it is now also the
+unit the transcript labels:
+
+- `turn_count` on `turn_sessions` increments once per exchange, so the turn
+  pipeline numbers a turn `turn_count + 1`.
+- `duration.max_turns` and the `max_turns` ending condition are measured in it,
+  so a scenario with `max_turns: 16` allows sixteen exchanges — not eight.
+- Debrief key moments point at it, so a debrief's "turn 3" and the transcript's
+  "Turn 3" are the same moment.
+- The NPC's opening line is part of no exchange. It is stored at turn number 0
+  and labelled rather than numbered, so it does not consume turn 1.
+
+Transcript rows are a finer grain than turns: the opening is stored at row 0,
+and whole turn *n* occupies the player row `2n-1` and the NPC row `2n`.
+
 ---
 
 ## REST API summary
@@ -199,6 +220,7 @@ Base URL: `http://127.0.0.1:7355`
 | Method | Path                              | Description                              |
 |--------|-----------------------------------|------------------------------------------|
 | POST   | `/api/sessions`                   | Create a session (`NotStarted`)          |
+| GET    | `/api/sessions`                   | List this profile's sessions, newest first |
 | GET    | `/api/sessions/{id}`              | Get current state                        |
 | POST   | `/api/sessions/{id}/start`        | Deliver NPC opening; → `PlayerTurnListening` |
 | POST   | `/api/sessions/{id}/turn`         | Submit player turn; runs full pipeline   |
@@ -212,6 +234,45 @@ Base URL: `http://127.0.0.1:7355`
 a network failure, call `GET /api/sessions/{id}` to check whether the turn
 was already recorded.
 
+**Listing sessions.** `GET /api/sessions` takes two optional query parameters:
+
+| Parameter | Values | Default | Meaning |
+|-----------|--------|---------|---------|
+| `status`  | `all`, `in_progress`, `ended` | `all` | `in_progress` is the *resumable* set — started and not ended |
+| `limit`   | 1–500 | 50 | Out-of-range values are rejected with 400 |
+
+Each row carries the session's `setup` (the request it was created with), its
+`turn_count`, and its `ending_type` / `ended_at` when it has finished. `setup`
+is what lets a resumed conversation rebuild the language, meter and voice
+choices it was launched with after the UI has lost them to a navigation or a
+relaunch. `status=in_progress` deliberately excludes `NotStarted`: nothing has
+been said yet, so there is no conversation to pick back up.
+
+`status=ended` covers every state a finished session can sit in, not just
+`Ended`: generating the debrief moves the row to `DebriefGenerating` and then
+`DebriefReady`, and a debrief that fails leaves `Error`. Together with
+`in_progress` and `NotStarted` that accounts for every state, so the two
+filters partition the sessions that were ever started.
+
+The two state lists are also needed client-side — Settings lists every
+unfinished conversation with its own Resume button, picking them out of a full
+listing — so they live in `packages/shared` (`RESUMABLE_SESSION_STATES`,
+`ENDED_SESSION_STATES`) for every TypeScript consumer, with a pytest guard
+asserting they still match convsim-core's `RESUMABLE_FLOW_STATES` and
+`ENDED_FLOW_STATES`.
+
+Creator Workbench preview sessions are excluded from every `status`, including
+`all`. They are written straight into `turn_sessions` under a dynamic
+`__wbtest__<hex>` scenario id and nothing ever ends them, so one preview would
+otherwise sit at the top of the resumable set permanently, pointing at a
+scenario that was only ever registered in memory.
+
+**Reading one session back.** `GET /api/sessions/{id}` returns the same shape
+plus `visible_state`: the session's current meter values, filtered through the
+scenario's own variable visibility so a hidden variable stays hidden. Meter
+values otherwise only ever arrive with a turn, so this is what lets a resumed
+conversation draw its meters before the player sends another message.
+
 ### Other routes
 
 | Prefix          | Description                           |
diff --git a/docs/quickstart.md b/docs/quickstart.md
index 4d0c98df..8442b0a4 100644
--- a/docs/quickstart.md
+++ b/docs/quickstart.md
@@ -19,7 +19,7 @@ This guide walks through your first conversation. Complete [installation](instal
 .\scripts\dev.ps1
 ```
 
-Open <http://127.0.0.1:7354> in your browser. The home screen shows green status indicators when convsim-core and the LLM runtime are ready.
+Open <http://127.0.0.1:7354> in your browser. The home screen's Status panel shows green indicators — **AI engine** and **AI model** — once both are ready.
 
 ---
 
@@ -30,6 +30,14 @@ The app downloads and configures a local AI model automatically. Progress is
 shown per stage; you can also expand **Advanced** (*use Ollama or a local GGUF
 file*) on the welcome screen to use Ollama or a custom GGUF file instead.
 
+The welcome screen also asks **How familiar are you with AI language models?**
+Answering is one click and skipping it is free — it only sets how much
+machinery the app shows you. Say you work with them and the app shows session
+ids, internal state names and event flags; otherwise it keeps everyday
+language only, which is the default if you skip the question. You can change
+it at any time under **Settings → Wording**, and the app offers to revisit it
+once after you finish the tutorial.
+
 The recommended starter is **Qwen3 4B Instruct Q4_K_M** (~2.5 GB, Apache-2.0 licensed). It works on machines with as little as 4 GB of GPU VRAM, or runs on CPU with no GPU at all.
 
 No internet connection is needed after the model is downloaded. See [local-models.md](local-models.md) for all available models and hardware recommendations.
@@ -57,14 +65,38 @@ Click a scenario card to see its description, then click **Start conversation**.
 
 The conversation screen shows:
 
-- The NPC's current dialogue
+- The NPC's current dialogue, with its mood labelled beneath each reply
+- The conversation meters above the transcript, if the scenario defines any —
+  one bar per meter, each showing how far it moved on the last turn
 - A text input at the bottom for your responses
-- A turn counter and scenario progress bar
 
 Type your response and press **Enter** (or click **Send**). The NPC responds in one to five seconds, depending on your hardware and model.
 
+Each exchange is labelled **Turn N**: one turn is your message plus the NPC's
+reply to it, so both carry the same number. The NPC's first line is labelled
+**Opening**, because it comes before the first exchange.
+
 The scenario ends automatically when the NPC reaches a terminal state. You can also click **End conversation** at any time.
 
+### Leaving and coming back
+
+You do not have to finish a conversation in one sitting, and you do not have to
+start over if you leave it. While a conversation is unfinished, a
+**Conversation in progress** strip appears under the header on every other
+screen, with a **Resume** button that takes you straight back to it — including
+from Settings, so you can change something mid-scenario and return. Home lists
+**Resume your conversation** as its first action, and **Settings → Your
+sessions** has a **Resume** button for every unfinished conversation, not just
+the most recent one.
+
+### If replies feel slow
+
+Open **Settings → Reply speed** and choose **Quick replies**. It takes effect
+on your very next message with nothing to restart, so you can change it without
+leaving the conversation behind. See
+[troubleshooting](troubleshooting.md#low-vram-or-slow-inference) if that is not
+enough.
+
 ---
 
 ## 5. Review the debrief
@@ -84,7 +116,8 @@ You can export the transcript to a text file from the debrief screen. Transcript
 
 - **Remix the scenario** — adjust NPC difficulty or starting state from the scenario setup screen before starting.
 - **Create a custom scenario** — see the [scenario authoring guide](scenario-authoring.md).
-- **Upgrade your model** — if responses feel slow or generic, try a larger model; see [local-models.md](local-models.md).
+- **Tune reply speed** — if responses feel slow, **Settings → Reply speed** is the quickest fix and needs no restart.
+- **Upgrade your model** — if responses feel generic, try a larger model; if they feel slow, a *smaller* one is the biggest win. See [local-models.md](local-models.md).
 
 ---
 
diff --git a/docs/scenario-authoring.md b/docs/scenario-authoring.md
index d5eae0e8..0d702768 100644
--- a/docs/scenario-authoring.md
+++ b/docs/scenario-authoring.md
@@ -259,7 +259,7 @@ rubric:
   ref: ../rubrics/interview_rubric.yaml   # The file you edited in place in Step 6
 
 duration:
-  max_turns: 16
+  max_turns: 16            # 16 exchanges — see "Counting turns" below
   soft_time_limit_minutes: 12
 
 opening:
@@ -376,7 +376,7 @@ difficulty:
 
 | Visibility | Who can see it | When to use |
 |------------|---------------|-------------|
-| `visible` | Player (shown as a state meter during the session) | Variables that correspond to something the player can infer from the NPC's responses |
+| `visible` | Player (shown as a conversation meter above the transcript) | Variables that correspond to something the player can infer from the NPC's responses |
 | `hidden` | System prompt only | NPC internal state the player has to discover through experimentation |
 
 **Event trigger types:**
@@ -385,9 +385,34 @@ difficulty:
 |------|--------|--------------|
 | `variable_above` | `variable`, `threshold` | When variable > threshold |
 | `variable_below` | `variable`, `threshold` | When variable < threshold |
-| `max_turns` | `value` | When turn count reaches value |
+| `max_turns` | `value` | When the whole-turn count reaches value |
 | `flag` | `flag_id` | When a named flag is set |
 
+### Counting turns
+
+**One turn is one player message plus the NPC's reply to it.** Both halves
+belong to the same turn, and `duration.max_turns` counts those whole turns —
+so `max_turns: 16` gives the player sixteen messages and the NPC sixteen
+replies, not eight each. A `max_turns` event trigger counts the same way.
+
+The limit is evaluated *after* a turn is processed, so the last turn plays out
+in full: with `max_turns: 16` the player's sixteenth message gets its reply,
+and the session then ends as `timeout` if nothing else has ended it first.
+
+Two consequences worth keeping in mind while you pick a number:
+
+- **The NPC's opening line is free.** It precedes the first exchange and does
+  not consume a turn, so `max_turns: 16` means sixteen exchanges *after* the
+  opening.
+- **Budget for questions.** A player who asks the NPC about something instead
+  of advancing spends a whole turn doing it. A tightly budgeted scenario can
+  time out before it reaches its own ending, so leave headroom above the
+  number of beats you have actually scripted.
+
+The player sees this same unit: the transcript labels each exchange `Turn N`
+on both rows and labels the opening `Opening`, and the debrief's key moments
+use the same numbers, so "turn 3" means one thing everywhere.
+
 ---
 
 ## Step 6: Edit the rubric
diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md
index 51bcb21c..934a5795 100644
--- a/docs/troubleshooting.md
+++ b/docs/troubleshooting.md
@@ -143,9 +143,10 @@ The model is loaded but producing unexpected output. Try:
 
 **Inference is very slow (30+ seconds per turn)**
 
-The model is likely running entirely on CPU. This is expected on machines without a discrete GPU or with insufficient VRAM. Options:
+The model is likely running entirely on CPU. This is expected on machines without a discrete GPU or with insufficient VRAM. Options, easiest first:
 
-- **Switch to the starter model:** Qwen3 4B (~2.6 GB, 4 GB VRAM minimum) is the most practical choice for CPU-only or low-VRAM machines.
+- **Set reply speed to Quick replies:** open **Settings → Reply speed** and choose **Quick replies**. A local model emits one token at a time, so most of the wait is the length of the reply — asking for shorter replies is the one lever that needs no hardware knowledge and no restart. It applies to your very next message, so you can change it mid-conversation and go straight back to it. ("Balanced" is the default and matches how the app behaved before this setting existed; "Fuller replies" trades speed for length.)
+- **Switch to the starter model:** Qwen3 4B (~2.6 GB, 4 GB VRAM minimum) is the most practical choice for CPU-only or low-VRAM machines. On slow hardware a smaller model is a bigger win than any reply-speed setting.
 - **Reduce GPU layers:** if you have some VRAM but not enough for the full model, lower `n_gpu_layers` in **Settings → Advanced**. Partial GPU offload is faster than full CPU.
 - **Reduce context length:** a shorter context (`n_ctx=4096`) uses less memory and allows more model layers to fit on the GPU.
 
diff --git a/packages/shared/src/types/models.ts b/packages/shared/src/types/models.ts
index 01224303..ff013b68 100644
--- a/packages/shared/src/types/models.ts
+++ b/packages/shared/src/types/models.ts
@@ -131,6 +131,17 @@ export interface BenchmarkResponse {
   benchmarked_at: string;
 }
 
+/** Plain-language reply pacing (issue #501). Scales the NPC's word budget and
+ *  the runtime's token budget for a turn; read per turn, so no restart.
+ *  Ordered fastest-first, which is the order the Settings panel offers them. */
+export const REPLY_SPEEDS = ['fast', 'balanced', 'detailed'] as const;
+
+export type ReplySpeed = (typeof REPLY_SPEEDS)[number];
+
+export function isReplySpeed(value: unknown): value is ReplySpeed {
+  return typeof value === 'string' && (REPLY_SPEEDS as readonly string[]).includes(value);
+}
+
 export interface RuntimeSettings {
   context_length: number | null;
   gpu_layers: number | null;
@@ -138,6 +149,8 @@ export interface RuntimeSettings {
   temperature: number | null;
   top_p: number | null;
   repeat_penalty: number | null;
+  /** null means "never chosen"; the backend then applies 'balanced'. */
+  reply_speed: ReplySpeed | null;
 }
 
 export interface RuntimeSettingsResponse {
diff --git a/packages/shared/src/types/scenario.ts b/packages/shared/src/types/scenario.ts
index c33784aa..f24a5597 100644
--- a/packages/shared/src/types/scenario.ts
+++ b/packages/shared/src/types/scenario.ts
@@ -43,6 +43,8 @@ export interface ScenarioInfo {
   scenario_id: string;
   title: string;
   summary: string;
+  /** The NPC's name, resolved from the pack. Absent when the pack has none. */
+  npc_name?: string | null;
   content_rating: string;
   pack_id: string;
   pack_name: string;
diff --git a/packages/shared/src/types/session.ts b/packages/shared/src/types/session.ts
index fd0274de..154c9632 100644
--- a/packages/shared/src/types/session.ts
+++ b/packages/shared/src/types/session.ts
@@ -19,6 +19,39 @@ export type SessionState =
 
 export type EndingType = 'player_exit' | 'success' | 'failure' | 'timeout' | 'safety_stop';
 
+/** States a session can be picked back up from — the resumable set (issue #501
+ *  §1). `NotStarted` is excluded on purpose: nothing has been said yet, so
+ *  there is no conversation to resume.
+ *
+ *  Mirrors `RESUMABLE_FLOW_STATES` in convsim-core's sessions router, which is
+ *  the one copy this cannot import — a pytest guard asserts the two agree.
+ *  Everything on the TypeScript side reads it from here: the proxy's
+ *  `status=in_progress` filter and Settings' per-session Resume button, which
+ *  picks unfinished conversations out of a full listing client-side. A list
+ *  that disagreed with the filter would offer to resume a conversation that
+ *  had already ended, or hide one that had not. */
+export const RESUMABLE_SESSION_STATES = [
+  'PlayerTurnListening',
+  'PlayerTurnReview',
+  'NpcThinking',
+  'NpcSpeaking',
+  'ScenarioEvent',
+] as const satisfies readonly SessionState[];
+
+/** States a session has finished in. `Ended` is only the first: generating the
+ *  debrief moves the row to `DebriefGenerating` and then `DebriefReady`, and a
+ *  failed debrief leaves `Error`. Mirrors `ENDED_FLOW_STATES` in convsim-core. */
+export const ENDED_SESSION_STATES = [
+  'Ended',
+  'DebriefGenerating',
+  'DebriefReady',
+  'Error',
+] as const satisfies readonly SessionState[];
+
+export function isResumableSessionState(state: string): boolean {
+  return (RESUMABLE_SESSION_STATES as readonly string[]).includes(state);
+}
+
 export interface SessionCreateRequest {
   scenario_id: string;
   difficulty: ScenarioDifficulty;
@@ -49,10 +82,22 @@ export interface SessionCreateResponse {
   state: SessionState;
   created_at: string;
   setup: SessionCreateRequest;
-  // Included in list responses (GET /api/sessions) but absent from creation responses
   ending_type?: EndingType | null;
+  /** Whole turns completed — one player message plus the NPC's reply. */
   turn_count?: number;
   ended_at?: string | null;
+  /** Current meter values, minus the variables the scenario keeps hidden.
+   *  Only GET /api/sessions/{id} reports it; a resuming conversation screen
+   *  reads its meters back from here. Absent means "not reported". */
+  visible_state?: Record<string, number> | null;
+}
+
+/** Filter for GET /api/sessions. 'in_progress' is the resumable set: started
+ *  and not ended, which is what the resume entry points offer (issue #501). */
+export type SessionListStatus = 'all' | 'in_progress' | 'ended';
+
+export interface SessionListResponse {
+  sessions: SessionCreateResponse[];
 }
 
 export interface SessionEvent {
diff --git a/packs/official/first-words/scenarios/first_words_tutorial.yaml b/packs/official/first-words/scenarios/first_words_tutorial.yaml
index bbecb836..9e52fc3e 100644
--- a/packs/official/first-words/scenarios/first_words_tutorial.yaml
+++ b/packs/official/first-words/scenarios/first_words_tutorial.yaml
@@ -7,9 +7,10 @@ scenario_id: first_words_tutorial
 title: First Words
 summary: >-
   A 3–5 minute guided tour of Conversation Simulator with Alex Chen, a
-  friendly tutorial guide. Alex walks you through state meters, scenario
-  events, ending conditions, and the debrief rubric using scripted (not AI)
-  responses — so no model download is needed.
+  friendly tutorial guide. Alex shows you the two meters, the turning point
+  mid-conversation, the ways a conversation can end, and the debrief — and
+  answers your questions along the way. The replies are scripted, not AI, so
+  no model download is needed.
 player_role:
   label: New Player
   brief: >-
@@ -21,19 +22,27 @@ npc:
 rubric:
   ref: ../rubrics/tutorial_rubric.yaml
 duration:
+  # One whole turn is the player's message plus Alex's reply — the unit
+  # turn_count increments in, and now the unit the transcript labels
+  # (issue #501 §4). The scripted runtime closes the session on its sixth
+  # turn whether or not the player asked anything along the way, because an
+  # answer rides along with that turn's tour line rather than replacing it.
+  # This cap is only the safety net behind that.
   max_turns: 8
   soft_time_limit_minutes: 5
 opening:
   npc_says: >-
     Welcome! I'm Alex Chen, your tutorial guide. This is Conversation Simulator
-    — a private, offline practice space for conversations that matter. Notice
-    the two meters at the top: Engagement and Confidence. They update every
-    turn based on what you say. Go ahead — say anything to get us started.
+    — a private, offline practice space for conversations that matter. Above
+    this conversation you'll see two meters: Engagement, which is how
+    interested I am, and Confidence, which is how sure of yourself you're
+    coming across. They move every turn, based on what you write. Go ahead —
+    say anything to get us started, or ask me about anything you see.
 goals:
   player_visible:
-    - "Learn how state meters work by watching them change as you talk"
-    - "Trigger a scenario event to see how events reshape a conversation"
-    - "Complete the tutorial and unlock the scenario library"
+    - "See how the two meters move as you talk"
+    - "Reach the turning point where the conversation changes course"
+    - "Finish the tutorial and open the scenario library"
   hidden:
     - "Alex is tracking whether the player seems curious about how the mechanics work"
     - "Alex wants the player to leave feeling ready to try a real scenario"
@@ -69,10 +78,11 @@ events:
       threshold: 60
     npc_instruction: >-
       The player has shown genuine engagement and Engagement has crossed 60.
-      Warmly acknowledge the moment and use it as a teaching point: explain
-      that this is what a scenario event looks like — a threshold crossing that
-      shifts your hidden instructions and changes how you behave for the rest
-      of the session.
+      Warmly acknowledge the moment and use it as a teaching point, in the
+      player's words rather than the simulator's: a meter crossed a mark, your
+      private instructions changed, and you will behave differently for the
+      rest of the conversation. Do not use the words "event", "flag", "state"
+      or "prompt".
     repeat: false
 ending_conditions:
   # The scripted runtime ends the session on its final turn via session_control
diff --git a/packs/official/first-words/tests/smoke_first_words_tutorial.yaml b/packs/official/first-words/tests/smoke_first_words_tutorial.yaml
index ee1d0bee..15079392 100644
--- a/packs/official/first-words/tests/smoke_first_words_tutorial.yaml
+++ b/packs/official/first-words/tests/smoke_first_words_tutorial.yaml
@@ -4,8 +4,9 @@ fixture_id: smoke_first_words_tutorial
 scenario_id: first_words_tutorial
 description: >-
   Verifies that the First Words tutorial scenario loads correctly and that
-  three scripted turns advance the session state without triggering safety
-  stops.  No model is required — uses the scripted runtime.
+  scripted turns advance the session state without triggering safety stops,
+  and that a question about the meters is answered rather than met with the
+  next line of the tour.  No model is required — uses the scripted runtime.
 seed: 1
 input_mode: text
 difficulty: standard
@@ -32,6 +33,15 @@ turns:
         - engagement
       session_control: continue_session
       safety_status: ok
+  # A question must be answered, not met with the next line of the tour
+  # (issue #501 §3).
+  - turn: 4
+    player_input: "Wait, what are the meters?"
+    expect:
+      state_delta_contains:
+        - engagement
+      session_control: continue_session
+      safety_status: ok
 static_assertions:
   - description: Scenario opening line is non-empty
     path: opening.npc_says
diff --git a/scripts/capture-screenshots.mjs b/scripts/capture-screenshots.mjs
index 7576fad8..00c1e4bf 100755
--- a/scripts/capture-screenshots.mjs
+++ b/scripts/capture-screenshots.mjs
@@ -436,13 +436,17 @@ async function main() {
     const startButton = page.getByRole('button', { name: 'Start conversation' })
     await startButton.waitFor({ timeout: 60_000 })
 
-    // The meters are opt-in per session and off by default; the conversation
-    // capture is required to show them (issue #455).
-    const metersToggle = page.getByLabel(/Show NPC state meters/i)
+    // The meters are opt-in per session and now on by default wherever the
+    // scenario permits them (issue #501 §3); the conversation capture is
+    // required to show them (issue #455), so check the toggle regardless —
+    // `check()` is a no-op when it is already on. The label is the Conversation
+    // Brief's, renamed with the panel it switches on, so a miss here means the
+    // name moved again rather than that the toggle is absent.
+    const metersToggle = page.getByLabel(/Show the conversation meters/i)
     if (await metersToggle.count()) {
       await metersToggle.check()
     } else {
-      log('WARNING: state-meter toggle not found — capture will have no meters')
+      log('WARNING: conversation-meters toggle not found — capture may have no meters')
     }
     // A fixed variation seed makes the playthrough re-runnable.
     const seedField = page.getByLabel('Variation seed value')
diff --git a/services/convsim-core/convsim_core/packs/models.py b/services/convsim-core/convsim_core/packs/models.py
index 82d2041b..d40fef96 100644
--- a/services/convsim-core/convsim_core/packs/models.py
+++ b/services/convsim-core/convsim_core/packs/models.py
@@ -131,6 +131,11 @@ class ScenarioCard(BaseModel):
     summary: str = ""
     tags: list[str] = []
     content_rating: Optional[str] = None
+    #: The NPC's name, resolved through the scenario's `npc.ref`. None when the
+    #: pack does not provide one, in which case the UI falls back to a generic
+    #: label (issue #501 §2 — "NPC" is the most technical word on the
+    #: conversation screen).
+    npc_name: Optional[str] = None
 
     # ── Canonical ScenarioInfo contract fields ────────────────────────────────
     player_role: PlayerRoleInfo = PlayerRoleInfo(label="")
diff --git a/services/convsim-core/convsim_core/routers/runtime_settings.py b/services/convsim-core/convsim_core/routers/runtime_settings.py
index 2b1219be..08a0d8d5 100644
--- a/services/convsim-core/convsim_core/routers/runtime_settings.py
+++ b/services/convsim-core/convsim_core/routers/runtime_settings.py
@@ -17,6 +17,7 @@
 from pydantic import BaseModel
 
 from convsim_core.errors import ConvsimError
+from convsim_core.services.reply_speed import DEFAULT_REPLY_SPEED, REPLY_SPEED_PROFILES
 
 router = APIRouter()
 
@@ -29,13 +30,20 @@
     "temperature",
     "top_p",
     "repeat_penalty",
+    # Plain-language reply pacing (issue #501). Stored alongside the numeric
+    # knobs so one Settings screen and one reset path cover all of them.
+    "reply_speed",
 )
 
 # Changing these requires restarting the llama-server sidecar to take effect.
+# reply_speed is deliberately not here: it is read per turn, so a change applies
+# to the player's very next message with no restart.
 _RESTART_REQUIRED = {"context_length", "gpu_layers"}
 
 _INT_KEYS = {"context_length", "gpu_layers", "threads"}
 
+_STR_KEYS = {"reply_speed"}
+
 
 class RuntimeSettings(BaseModel):
     context_length: Optional[int] = None
@@ -44,6 +52,9 @@ class RuntimeSettings(BaseModel):
     temperature: Optional[float] = None
     top_p: Optional[float] = None
     repeat_penalty: Optional[float] = None
+    #: "fast" | "balanced" | "detailed". None means "never chosen", which the
+    #: turn pipeline reads as the default.
+    reply_speed: Optional[str] = None
 
 
 class RuntimeSettingsResponse(BaseModel):
@@ -60,12 +71,17 @@ def load_runtime_settings(conn: sqlite3.Connection) -> RuntimeSettings:
     ).fetchall()
     stored = {row["key"][len(_KEY_PREFIX):]: row["value"] for row in rows}
 
-    values: dict[str, int | float | None] = {}
+    values: dict[str, int | float | str | None] = {}
     for key in _SETTING_KEYS:
         raw = stored.get(key)
         if raw is None or raw == "" or raw == "null":
             values[key] = None
             continue
+        if key in _STR_KEYS:
+            # A value a newer build wrote, or one hand-edited into the database,
+            # must not surface as an option the UI cannot render.
+            values[key] = raw if raw in REPLY_SPEED_PROFILES else None
+            continue
         try:
             values[key] = int(raw) if key in _INT_KEYS else float(raw)
         except ValueError:
@@ -113,13 +129,21 @@ def _check_float(key: str, lo: float, hi: float, label: str) -> None:
     _check_float("temperature", 0.0, 2.0, "Temperature")
     _check_float("top_p", 0.0, 1.0, "Top-P")
     _check_float("repeat_penalty", 1.0, 2.0, "Repeat penalty")
+
+    speed = patch.get("reply_speed")
+    if "reply_speed" in patch and speed is not None and speed not in REPLY_SPEED_PROFILES:
+        options = ", ".join(sorted(REPLY_SPEED_PROFILES))
+        errors.append(f"Reply speed must be one of: {options}.")
     return errors
 
 
 def _recommended() -> RuntimeSettings:
     """Conservative recommendations; None means 'use the runtime default'."""
     cpu = os.cpu_count()
-    return RuntimeSettings(threads=max(1, (cpu or 2) // 2) if cpu else None)
+    return RuntimeSettings(
+        threads=max(1, (cpu or 2) // 2) if cpu else None,
+        reply_speed=DEFAULT_REPLY_SPEED,
+    )
 
 
 @router.get("/api/runtime/settings", response_model=RuntimeSettingsResponse)
diff --git a/services/convsim-core/convsim_core/routers/sessions.py b/services/convsim-core/convsim_core/routers/sessions.py
index b17c5e91..a40a699d 100644
--- a/services/convsim-core/convsim_core/routers/sessions.py
+++ b/services/convsim-core/convsim_core/routers/sessions.py
@@ -3,6 +3,7 @@
 
 Routes:
   POST   /api/sessions                    — create session
+  GET    /api/sessions                    — list sessions (newest first)
   GET    /api/sessions/{session_id}       — get session state
   POST   /api/sessions/{session_id}/start — start session (NPC opening)
   POST   /api/sessions/{session_id}/turn  — submit player turn (full pipeline)
@@ -141,6 +142,22 @@ class SessionResponse(BaseModel):
     state: str
     created_at: str
     setup: Dict[str, Any]
+    #: Only populated by the list endpoint and by sessions that have ended; a
+    #: freshly created session has no outcome and no completed turns yet.
+    ending_type: Optional[str] = None
+    turn_count: int = 0
+    ended_at: Optional[str] = None
+    #: The meter values a resuming player should see, filtered to the ones this
+    #: scenario shows them (issue #501). Only the single-session endpoint fills
+    #: this in: the list endpoint would have to resolve every row's scenario to
+    #: know which variables are hidden, and nothing listing sessions draws
+    #: meters. None means "not reported", which the UI treats as "wait for the
+    #: next turn" rather than "no meters".
+    visible_state: Optional[Dict[str, int]] = None
+
+
+class SessionListResponse(BaseModel):
+    sessions: List[SessionResponse]
 
 
 class SessionEventPayload(BaseModel):
@@ -365,9 +382,46 @@ def _row_to_response(row: Any) -> SessionResponse:
         state=row["flow_state"],
         created_at=row["created_at"],
         setup=json.loads(row["setup_json"]),
+        ending_type=row["ending_type"],
+        turn_count=int(row["turn_count"] or 0),
+        ended_at=row["ended_at"],
     )
 
 
+#: Flow states a session can be picked back up from. ``NotStarted`` is excluded
+#: on purpose: nothing has been said yet, so there is no conversation to resume —
+#: offering one would send the player to a screen that starts from scratch.
+RESUMABLE_FLOW_STATES = (
+    "PlayerTurnListening",
+    "PlayerTurnReview",
+    "NpcThinking",
+    "NpcSpeaking",
+    "ScenarioEvent",
+)
+
+#: Flow states a session has finished in. ``Ended`` is only the first of them:
+#: generating the debrief moves the row to ``DebriefGenerating`` and then
+#: ``DebriefReady``, and a debrief that fails leaves ``Error`` — so a session
+#: the player actually played to the end is almost never still ``Ended`` by the
+#: time anything lists it. Together with RESUMABLE_FLOW_STATES and
+#: ``NotStarted`` this covers every state a row can hold, so the three status
+#: filters partition the table.
+ENDED_FLOW_STATES = (
+    "Ended",
+    "DebriefGenerating",
+    "DebriefReady",
+    "Error",
+)
+
+#: Creator Workbench preview sessions are written straight into
+#: ``turn_sessions`` under a dynamic ``__wbtest__<hex>`` scenario id, and
+#: nothing ever ends or deletes them. Left in this listing they would sit at
+#: the top of the resumable set forever and offer to resume a scenario that was
+#: only ever registered in memory. apps/api's sibling listing has always
+#: excluded them; so does this one.
+_WORKBENCH_SCENARIO_PREFIX = "__wbtest__"
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
@@ -503,6 +557,48 @@ async def create_session(body: SessionCreateRequest, request: Request) -> Sessio
     return _row_to_response(row)
 
 
+@router.get("", response_model=SessionListResponse)
+async def list_sessions(
+    request: Request,
+    status: Literal["all", "in_progress", "ended"] = "all",
+    limit: int = 50,
+) -> SessionListResponse:
+    """List this profile's sessions, newest first.
+
+    ``status=in_progress`` answers the one question the UI could not ask before
+    (issue #501): "is there a conversation I walked away from?". Without it the
+    player who opened Settings mid-scenario had no way back to a live session
+    and started a new one instead. ``status=ended`` is its complement over the
+    sessions that were started at all, which is why it covers the debrief states
+    and not just ``Ended``.
+    """
+    if limit < 1 or limit > 500:
+        raise HTTPException(status_code=400, detail="limit must be between 1 and 500")
+
+    conn = request.app.state.db.connection()
+    # Workbench previews are excluded from every status, including "all": they
+    # are a pack author's scratch session, not part of the player's history.
+    clauses = ["substr(scenario_id, 1, ?) != ?"]
+    params: List[Any] = [len(_WORKBENCH_SCENARIO_PREFIX), _WORKBENCH_SCENARIO_PREFIX]
+    if status == "in_progress":
+        placeholders = ", ".join("?" for _ in RESUMABLE_FLOW_STATES)
+        clauses.append(f"flow_state IN ({placeholders})")
+        params.extend(RESUMABLE_FLOW_STATES)
+    elif status == "ended":
+        placeholders = ", ".join("?" for _ in ENDED_FLOW_STATES)
+        clauses.append(f"flow_state IN ({placeholders})")
+        params.extend(ENDED_FLOW_STATES)
+    sql = "SELECT * FROM turn_sessions WHERE " + " AND ".join(clauses)
+    # created_at is ISO-8601/`datetime('now')` text, so lexical order is
+    # chronological order. session_id breaks ties for sessions created inside the
+    # same second, which the second-resolution SQLite default makes common.
+    sql += " ORDER BY created_at DESC, session_id DESC LIMIT ?"
+    params.append(limit)
+
+    rows = conn.execute(sql, tuple(params)).fetchall()
+    return SessionListResponse(sessions=[_row_to_response(r) for r in rows])
+
+
 @router.get("/{session_id}", response_model=SessionResponse)
 async def get_session(session_id: str, request: Request) -> SessionResponse:
     db = request.app.state.db
@@ -512,7 +608,25 @@ async def get_session(session_id: str, request: Request) -> SessionResponse:
     ).fetchone()
     if row is None:
         raise HTTPException(status_code=404, detail=f"Session {session_id!r} not found")
-    return _row_to_response(row)
+    response = _row_to_response(row)
+    # A resuming conversation screen rebuilds itself from this row (issue #501).
+    # Meter values only ever arrived with a turn, so without them here a player
+    # who stepped out to Settings came back to a conversation with no meters at
+    # all — the one thing the tutorial tells them to watch — until they sent
+    # another message.
+    response.visible_state = _visible_state_for(request, row)
+    return response
+
+
+def _visible_state_for(request: Request, row: Any) -> Dict[str, int]:
+    """The session's meter values, minus the variables it keeps hidden."""
+    state_vars: Dict[str, int] = json.loads(row["state_vars_json"] or "{}")
+    info = _resolve_scenario(request, row["scenario_id"])
+    overrides = info.state_variable_overrides if info is not None else None
+    visible, _ = partition_state_by_visibility(
+        state_vars, build_variable_defs(overrides)
+    )
+    return visible
 
 
 @router.post("/{session_id}/start", response_model=SessionStartResponse)
diff --git a/services/convsim-core/convsim_core/runtime/scripted.py b/services/convsim-core/convsim_core/runtime/scripted.py
index 402e829f..5c81909c 100644
--- a/services/convsim-core/convsim_core/runtime/scripted.py
+++ b/services/convsim-core/convsim_core/runtime/scripted.py
@@ -12,6 +12,7 @@
 
 import asyncio
 import json
+import re
 from datetime import datetime, timezone
 from typing import AsyncGenerator
 
@@ -32,16 +33,33 @@
 # state_delta values are bounded by the scenario's max_delta_per_turn.
 # The final turn sets session_control.continue_session=False to end the session
 # and trigger the debrief.
+#
+# Two rules this script has to obey, both from the issue #501 playtest:
+#
+#  1. No simulator vocabulary. The previous version taught the mechanics in the
+#     engine's own words — "scenario event", "hidden prompt", "rubric
+#     dimensions" — which is exactly the jargon the report named. The mechanics
+#     are the same; only the words are the player's.
+#  2. Never presume the reply. Every line used to assume an engaged, positive
+#     answer ("Great! See how Engagement just ticked up?", "Did you see that?"),
+#     so a player who asked "what are the meters?" got the next canned line as
+#     if they had agreed with something — the behaviour the report attached a
+#     screenshot of and read as hallucination. Questions are answered by
+#     _pick_interjection below — whose answer is prepended to the line for that
+#     turn, so a question costs the player no tour beat — and these lines no
+#     longer claim the player said anything in particular, because any of them
+#     may now follow a question rather than an answer.
 
 _FIRST_WORDS_SCRIPT: list[dict] = [
     # turn 1 — respond to the player's first message (the scenario's opening line
     # already delivered the welcome, so this must NOT repeat it).
     {
         "npc_utterance": (
-            "There you go — you just took your very first turn! Look up at the two "
-            "meters: Engagement and Confidence both nudged the moment you hit send. "
-            "Every message you write moves them a little; that's the heartbeat of "
-            "every scenario. Keep going — tell me what brought you here today."
+            "There you go — you just took your first turn. Look at the two "
+            "meters above our conversation: Engagement and Confidence both "
+            "moved when you hit send, and each one shows how far it moved. "
+            "Every message you write nudges them. Tell me what brought you "
+            "here today — or ask me about anything you see on screen."
         ),
         "npc_emotion": "warm",
         "state_delta": {"engagement": 10, "confidence": 5},
@@ -50,15 +68,17 @@
         "safety": {"status": "ok"},
         "session_control": {"continue_session": True},
     },
-    # turn 2 — explain the meters
+    # turn 2 — what the meters are and what moves them
     {
         "npc_utterance": (
-            "Great! See how Engagement just ticked up? Every message you send shifts "
-            "the conversation state. In real AI-powered scenarios these meters respond "
-            "dynamically to how you phrase things, what you reveal, and whether you "
-            "ask follow-up questions. Right now I'm scripted — not AI-generated — "
-            "but the meter logic is identical. "
-            "Tell me: what kind of conversations are you hoping to practise?"
+            "Here is what those two meters mean. Engagement is how interested "
+            "I am in this conversation. Confidence is how sure of yourself you "
+            "are coming across. They are mine, not yours to set directly — "
+            "they answer to what you write. With a real AI character they "
+            "shift with how you phrase things, what you share, and whether you "
+            "ask anything back. I am following a script right now, not "
+            "thinking, but the meters work the same way. What kind of "
+            "conversations are you hoping to practise?"
         ),
         "npc_emotion": "curious",
         "state_delta": {"engagement": 15, "confidence": 10},
@@ -67,14 +87,14 @@
         "safety": {"status": "ok"},
         "session_control": {"continue_session": True},
     },
-    # turn 3 — introduce events, push engagement past the event threshold (>60)
+    # turn 3 — introduce the turning point, push engagement past the threshold (>60)
     {
         "npc_utterance": (
-            "That sounds like a great goal. Now watch closely — I'm about to trigger "
-            "a *scenario event*. Events fire automatically when a meter crosses a "
-            "threshold or a flag is set. They inject new instructions into the NPC's "
-            "hidden prompt, changing how I behave for the rest of the conversation. "
-            "You're about to see Engagement cross 60 for the first time..."
+            "Keep an eye on the Engagement meter over this next turn. "
+            "When a meter crosses a certain mark, the conversation can change "
+            "course: I get new private instructions, and I behave differently "
+            "from then on. Engagement is about to cross that mark for the "
+            "first time."
         ),
         "npc_emotion": "curious",
         "state_delta": {"engagement": 20, "confidence": 10},
@@ -83,17 +103,17 @@
         "safety": {"status": "ok"},
         "session_control": {"continue_session": True},
     },
-    # turn 4 — warm_moment event has fired; acknowledge it
+    # turn 4 — the turning point has fired; name it, then move to endings
     {
         "npc_utterance": (
-            "Did you see that? The warm_moment event just fired — Engagement crossed "
-            "60 and my hidden instructions shifted. In a live AI scenario that "
-            "would change how I respond to everything you say from here on. "
-            "Events are how pack authors shape narrative beats without scripting every line. "
-            "Now let's talk about how a session ends. There are three ways a "
-            "conversation can finish: success, failure, or timeout. "
-            "Which sounds most interesting to you — winning, recovering from a stumble, "
-            "or seeing what happens when time runs out?"
+            "That was it. Engagement crossed the mark and my instructions "
+            "changed — you would have seen a short note above the transcript "
+            "saying something changed. With a real AI character that shifts "
+            "how I answer everything you say from here. It is how the people "
+            "who write these conversations shape a story without writing out "
+            "every line. Now, endings: a conversation can finish well, finish "
+            "badly, or simply run out of turns. Which of those sounds most "
+            "interesting to you?"
         ),
         "npc_emotion": "warm",
         "state_delta": {"engagement": 10, "confidence": 10},
@@ -102,16 +122,16 @@
         "safety": {"status": "ok"},
         "session_control": {"continue_session": True},
     },
-    # turn 5 — explain endings and the debrief
+    # turn 5 — endings and the debrief
     {
         "npc_utterance": (
-            "After a session ends — however it ends — you get a debrief. "
-            "The debrief scores you against the scenario's rubric dimensions: "
-            "things like Clarity, Genuine Connection, or Assertiveness depending "
-            "on what the pack is testing. Each dimension has a low/medium/high "
-            "scoring guide so you know exactly what 'doing well' looks like. "
-            "We're almost at the end of this tutorial. One last question: "
-            "how are you feeling about trying a real conversation next?"
+            "However a conversation ends, you get a debrief afterwards. It "
+            "scores you on the handful of things that conversation was "
+            "actually about — clarity, say, or genuine connection, or standing "
+            "your ground — and for each one it spells out what doing it well "
+            "looks like, so the score is never a mystery. We are nearly done. "
+            "Last question: how are you feeling about trying a real "
+            "conversation next?"
         ),
         "npc_emotion": "warm",
         "state_delta": {"engagement": 10, "confidence": 15},
@@ -123,10 +143,11 @@
     # turn 6 — keyword-branched ending (override in _pick_ending_turn)
     {
         "npc_utterance": (
-            "That's the spirit! You've covered all the basics: meters, events, "
-            "ending conditions, and the debrief. You're ready for the real thing. "
-            "Head to the scenario library and pick whatever sounds interesting — "
-            "your first real conversation is waiting."
+            "That's the spirit. You have seen all of it: the meters, a turning "
+            "point mid-conversation, how a conversation ends, and the debrief. "
+            "You are ready for the real thing. Head to the scenario library "
+            "and pick whatever sounds interesting — your first real "
+            "conversation is waiting."
         ),
         "npc_emotion": "warm",
         "state_delta": {"engagement": 5, "confidence": 10},
@@ -137,6 +158,125 @@
     },
 ]
 
+# ── Answering the player's questions ─────────────────────────────────────────
+# From the issue: "The model in the Tutorial doesn't seem to be able to give an
+# explanation of what the meters are and hallucinates through the scenario, as
+# if it has given a coherent explanation and received positive feedback from
+# the user."
+#
+# It was not a model at all — the tutorial runs on this script, and the script
+# had no branch for a question, so "what are the meters?" got the next canned
+# line. These answers give it one.
+#
+# An answer is PREPENDED to the tour line the turn was going to deliver, not
+# substituted for it. Replacing it looks tidier and is wrong twice over: the
+# player silently loses that beat of the tour, and — because the tour's
+# state_delta goes with the beat — Engagement stops crossing 60 on schedule,
+# so turn 4's "That was it. Engagement crossed the mark" announces an event
+# that never fired. That is the same false-confidence failure the issue
+# reported, reintroduced by the fix for it. Carrying the tour line along keeps
+# every beat and every delta exactly where the script put them, and costs the
+# player nothing for asking.
+#
+# Checked in order, so the most specific cluster comes first.
+
+#: (keywords, answer). A turn matches a cluster when the player's message reads
+#: as a question — or asks to be told — AND mentions one of the keywords, so
+#: "the meters moved, nice" is not treated as a question about them.
+_INTERJECTIONS: list[tuple[frozenset[str], str]] = [
+    (
+        frozenset(["meter", "meters", "engagement", "confidence", "bar", "bars",
+                   "number", "numbers", "gauge", "gauges"]),
+        "Good question — those two meters are the heart of it. Engagement "
+        "is how interested I am in this conversation. Confidence is how "
+        "sure of yourself you are coming across. They are mine: you do not "
+        "set them, you move them by what you write. Each one shows its "
+        "value out of 100 and how far it just moved, so you can see what a "
+        "single message did.",
+    ),
+    (
+        frozenset(["mood", "feeling", "feelings", "emotion", "emotions",
+                   "parentheses", "parenthesis", "brackets"]),
+        "That is my mood, not a meter — it is the one word under my name "
+        "for how I am taking this, and it changes turn to turn. The meters "
+        "are the two labelled bars above the conversation.",
+    ),
+    (
+        frozenset(["ai", "real", "bot", "robot", "model", "scripted", "script",
+                   "pretend", "pretending"]),
+        "Straight answer: I am scripted. Every line I say in this tutorial "
+        "was written ahead of time, which is why it works before you have "
+        "downloaded anything. Every other conversation here runs on an AI "
+        "model on your own computer — and either way, nothing you type "
+        "leaves this machine.",
+    ),
+    (
+        frozenset(["end", "ends", "ending", "endings", "finish", "finishes",
+                   "over", "long", "quit", "stop", "turns"]),
+        "A conversation finishes in one of three ways: it goes well, it "
+        "goes badly, or it runs out of turns. You can also stop whenever "
+        "you like with End session — you still get the debrief.",
+    ),
+    (
+        frozenset(["debrief", "score", "scored", "scores", "scoring", "grade",
+                   "graded", "rubric", "feedback"]),
+        "The debrief comes after a conversation ends. It scores you on the "
+        "few things that conversation was about, says what it saw you do "
+        "well and what to try differently, and points at the turns it is "
+        "talking about.",
+    ),
+]
+
+#: Markers that a message is asking rather than answering. A question mark
+#: alone misses "tell me what the meters are", and these words alone would
+#: catch "what a good idea" — so a match needs one of these AND a topic word.
+_QUESTION_WORDS = (
+    "what", "whats", "which", "why", "how", "who", "when", "explain",
+    "mean", "means", "meant", "meaning", "confused", "clarify",
+    "tell me", "i don't understand", "i dont understand",
+    "not sure what", "no idea",
+)
+
+#: Matched on word boundaries, never as bare substrings: "explain" contains
+#: "ai" and "show" contains "how", and matching those inside other words is how
+#: a keyword table starts answering questions nobody asked.
+_QUESTION_RE = re.compile(
+    r"\?|\b(?:" + "|".join(re.escape(w) for w in _QUESTION_WORDS) + r")\b"
+)
+
+_INTERJECTION_RES: list[tuple[re.Pattern[str], str]] = [
+    (
+        re.compile(r"\b(?:" + "|".join(re.escape(k) for k in sorted(keywords)) + r")\b"),
+        answer,
+    )
+    for keywords, answer in _INTERJECTIONS
+]
+
+
+def _looks_like_a_question(lower_text: str) -> bool:
+    return _QUESTION_RE.search(lower_text) is not None
+
+
+def _pick_interjection(player_text: str) -> str | None:
+    """Return an answer to the player's question, or None if we have none."""
+    lower = player_text.lower()
+    if not _looks_like_a_question(lower):
+        return None
+    for pattern, answer in _INTERJECTION_RES:
+        if pattern.search(lower):
+            return answer
+    return None
+
+
+def _with_answer(tour_turn: dict, answer: str) -> dict:
+    """The tour turn with the player's answer in front of it.
+
+    Everything else — the state_delta that keeps Engagement on schedule, the
+    emotion, the session_control — is the tour turn's, untouched.
+    """
+    return {**tour_turn, "npc_utterance": f"{answer} {tour_turn['npc_utterance']}"}
+
+
 # Keyword clusters for the three ending branches on turn 6.
 _ENDING_EXCITED_KEYWORDS = frozenset(
     ["love", "excited", "great", "amazing", "awesome", "fantastic",
@@ -171,11 +311,12 @@ def _pick_ending_turn(player_text: str) -> dict:
     if any(kw in lower for kw in _ENDING_CURIOUS_KEYWORDS):
         return {
             "npc_utterance": (
-                "Curiosity is the best starting point. Every scenario has a rubric "
-                "that spells out exactly what's being measured — you can read it "
-                "before you start. And if something surprises you mid-conversation, "
-                "the debrief will explain it. Head to the library and explore — "
-                "the scenarios will answer your questions better than I can."
+                "Curiosity is the best starting point. Every scenario spells out "
+                "what it is looking for before you start, so you always know "
+                "what you are being judged on. And if something surprises you "
+                "mid-conversation, the debrief will explain it. Head to the "
+                "library and explore — the scenarios will answer your questions "
+                "better than I can."
             ),
             "npc_emotion": "curious",
             "state_delta": {"engagement": 5, "confidence": 10},
@@ -202,26 +343,35 @@ def _pick_ending_turn(player_text: str) -> dict:
     }
 
 
+# The debrief the tutorial hands the player at the end of their first session.
+# Written to the same two rules as the script above: no simulator vocabulary,
+# and no claim about what the player said. It is swept by
+# test_tutorial_copy_avoids_simulator_jargon alongside the spoken lines — the
+# last screen of the first session is no place to introduce the words the
+# tutorial just spent six turns avoiding.
 _DEBRIEF_RESPONSE: dict = {
     "summary": (
-        "You completed the First Words tutorial. You learned how state meters track "
-        "conversation dynamics, how scenario events fire at threshold crossings, and "
-        "how the debrief rubric scores your performance on each dimension."
+        "You finished the First Words tutorial. You saw the two meters move with "
+        "what you wrote, watched the conversation change course partway through, "
+        "reached an ending, and you are reading the kind of summary that follows "
+        "every conversation here."
     ),
     "strengths": [
-        "You engaged with the tutorial prompts and advanced through all the concepts.",
-        "You saw a live scenario event fire — a key mechanic in every pack.",
+        "You kept the conversation going all the way to the end of the tour.",
+        "You saw the conversation change course mid-way — that happens in every "
+        "scenario, not just this one.",
     ],
     "improvements": [
-        "In real scenarios, try varying how you phrase things to see how the meters respond differently.",
+        "In a real conversation, try saying the same thing in different ways and "
+        "watch how differently the meters answer.",
     ],
     "missed_opportunities": [],
     "turning_points": [
         {
             "turn_number": 3,
             "description": (
-                "The warm_moment event fired — this is where Engagement crossed 60 "
-                "and the NPC instructions shifted."
+                "Engagement passed the mark that changes a conversation, and "
+                "Alex's private instructions changed from there on."
             ),
             "impact": "positive",
         },
@@ -246,13 +396,36 @@ def _pick_ending_turn(player_text: str) -> dict:
 
 
 def _extract_player_text(request: ChatRequest) -> str:
-    """Best-effort extraction of the player's latest input from the request messages."""
+    """Best-effort extraction of the player's latest input from the request messages.
+
+    The turn pipeline does not hand us the player's bare words: the user message
+    is the composed PLAYER_UTTERANCE layer, which wraps them in a layer tag and
+    two sentinel lines ("=== UNTRUSTED PLAYER INPUT … ===", "=== END PLAYER
+    INPUT ==="). Those lines have to come off before any keyword matching, or
+    the scaffolding matches instead of the player: "=== END PLAYER INPUT ==="
+    contains the word "end", which made the endings interjection fire on every
+    message that read as a question at all — and shadowed the debrief answer
+    entirely, since its cluster is checked later.
+    """
     for msg in reversed(request.messages):
         if msg.role == "user":
-            return msg.content
+            return _strip_prompt_scaffolding(msg.content)
     return ""
 
 
+def _strip_prompt_scaffolding(content: str) -> str:
+    """Drop composer layer tags and sentinel lines, keeping the player's words."""
+    kept = [
+        line
+        for line in content.splitlines()
+        if not line.startswith("--- LAYER:") and not line.startswith("=== ")
+    ]
+    stripped = "\n".join(kept).strip()
+    # A caller that already passed bare text (the runtime's own unit tests, any
+    # adapter that skips the composer) must keep working.
+    return stripped if stripped else content
+
+
 @register("scripted")
 class ScriptedChatRuntime(ChatRuntime):
     """Deterministic scripted NPC runtime — table-driven, zero inference.
@@ -319,11 +492,14 @@ def _pick_npc_turn(self, request: ChatRequest) -> dict:
         """Select the scripted NPC turn for the current game turn."""
         turn_idx = (request.scripted_turn_index or 1) - 1  # 0-based index
         script = _FIRST_WORDS_SCRIPT
+        player_text = _extract_player_text(request)
 
-        # Last script entry: keyword-branch the ending
+        # Last script entry: keyword-branch the ending. Checked before the
+        # interjections because the session has to close here — a player who
+        # asks a question on the final turn gets the curious ending branch,
+        # which answers it and closes, rather than an answer that never does.
         last_idx = len(script) - 1
         if turn_idx >= last_idx:
-            player_text = _extract_player_text(request)
             return _pick_ending_turn(player_text)
 
         # A turn index at or past last_idx already returned above, so here
@@ -331,7 +507,17 @@ def _pick_npc_turn(self, request: ChatRequest) -> dict:
         if turn_idx < 0:
             turn_idx = 0
 
-        return script[turn_idx]
+        # Answer the question first, then carry on with the tour in the same
+        # breath (issue #501 §3). Without the answer the script replied to
+        # "what are the meters?" with the next canned line, as if the player
+        # had said something else; without the tour line the player would pay
+        # for asking, both in content and in the state_delta that has to land
+        # for turn 4's "Engagement crossed the mark" to be true.
+        tour_turn = script[turn_idx]
+        answer = _pick_interjection(player_text)
+        if answer is not None:
+            return _with_answer(tour_turn, answer)
+        return tour_turn
 
     async def health(self) -> RuntimeHealth:
         return RuntimeHealth(
diff --git a/services/convsim-core/convsim_core/scenarios.py b/services/convsim-core/convsim_core/scenarios.py
index 2145033a..b23f7276 100644
--- a/services/convsim-core/convsim_core/scenarios.py
+++ b/services/convsim-core/convsim_core/scenarios.py
@@ -313,6 +313,15 @@ def get_scenario_data(self, difficulty: str) -> ScenarioData:
     # session-create → turn pipeline, exactly like the other built-in scenarios.
     # The matching pack (packs/official/first-words) supplies the library entry,
     # rubric, and safety policy; this entry drives play.
+    #
+    # Because it drives play, every player-facing string here must match the
+    # pack's — and in the full edition only this copy is ever read, since
+    # resolve_scenario_info consults the catalog first (the demo edition passes
+    # prefer_installed_pack=True and gets the pack).  The jargon rewrite and the
+    # widened turn budget of issue #501 therefore have to be applied in both
+    # places; test_tutorial_copy_avoids_simulator_jargon and
+    # test_tutorial_catalog_entry_matches_the_pack sweep both so they cannot
+    # drift apart again.
     "first_words_tutorial": ScenarioInfo(
         scenario_data=ScenarioData(
             scenario_id="first_words_tutorial",
@@ -330,8 +339,8 @@ def get_scenario_data(self, difficulty: str) -> ScenarioData:
                 public_persona=NpcPublicPersona(
                     occupation="Tutorial guide for Conversation Simulator.",
                     speaking_style=(
-                        "Warm, clear, and direct. Uses short sentences. Names the "
-                        "mechanic being demonstrated before showing it."
+                        "Warm, clear, and direct. Uses short sentences. Says what "
+                        "is about to happen before showing it, in everyday words."
                     ),
                     demeanor=(
                         "Encouraging without being patronising. Celebrates small "
@@ -341,7 +350,7 @@ def get_scenario_data(self, difficulty: str) -> ScenarioData:
                 private_persona=NpcPrivatePersona(
                     hidden_agenda=[
                         "Ensure the player leaves feeling confident enough to try a real scenario",
-                        "Demonstrate every core mechanic — meters, events, endings, debrief — exactly once",
+                        "Show each of the four things once — the meters, the turning point, how a conversation ends, the debrief",
                     ],
                     biases_to_simulate=[],
                     boundaries=[
@@ -352,11 +361,15 @@ def get_scenario_data(self, difficulty: str) -> ScenarioData:
                 ),
             ),
             player_visible_goals=[
-                "Learn how state meters work by watching them change as you talk",
-                "Trigger a scenario event to see how events reshape a conversation",
-                "Complete the tutorial and unlock the scenario library",
+                "See how the two meters move as you talk",
+                "Reach the turning point where the conversation changes course",
+                "Finish the tutorial and open the scenario library",
             ],
         ),
+        # Whole turns — one player message plus Alex's reply (issue #501 §4).
+        # The scripted runtime closes the session on its sixth turn either way:
+        # an answer to a player's question rides along with that turn's tour
+        # line rather than replacing it.  This cap is only the safety net.
         max_turns=8,
         supported_languages=["en"],
         difficulty_options={
@@ -365,9 +378,11 @@ def get_scenario_data(self, difficulty: str) -> ScenarioData:
         opening_npc_says=(
             "Welcome! I'm Alex Chen, your tutorial guide. This is Conversation "
             "Simulator — a private, offline practice space for conversations that "
-            "matter. Notice the two meters at the top: Engagement and Confidence. "
-            "They update every turn based on what you say. Go ahead — say anything "
-            "to get us started."
+            "matter. Above this conversation you'll see two meters: Engagement, "
+            "which is how interested I am, and Confidence, which is how sure of "
+            "yourself you're coming across. They move every turn, based on what "
+            "you write. Go ahead — say anything to get us started, or ask me "
+            "about anything you see."
         ),
         state_variable_overrides={
             # The tutorial deliberately shows exactly two meters.  Add
@@ -388,10 +403,11 @@ def get_scenario_data(self, difficulty: str) -> ScenarioData:
                 npc_instruction=(
                     "The player has shown genuine engagement and Engagement has "
                     "crossed 60. Warmly acknowledge the moment and use it as a "
-                    "teaching point: explain that this is what a scenario event "
-                    "looks like — a threshold crossing that shifts your hidden "
-                    "instructions and changes how you behave for the rest of the "
-                    "session."
+                    "teaching point, in the player's words rather than the "
+                    "simulator's: a meter crossed a mark, your private "
+                    "instructions changed, and you will behave differently for "
+                    "the rest of the conversation. Do not use the words "
+                    '"event", "flag", "state" or "prompt".'
                 ),
                 repeat=False,
             ),
diff --git a/services/convsim-core/convsim_core/services/debrief_engine.py b/services/convsim-core/convsim_core/services/debrief_engine.py
index 2e2b5100..a71f66d9 100644
--- a/services/convsim-core/convsim_core/services/debrief_engine.py
+++ b/services/convsim-core/convsim_core/services/debrief_engine.py
@@ -320,6 +320,19 @@ def _compute_overall_score(scores: Dict[str, float]) -> Optional[float]:
     return round(sum(scores.values()) / len(scores), 1)
 
 
+def whole_turn_of(row_turn_number: int) -> int:
+    """Map a transcript row number to the whole turn it belongs to.
+
+    Rows are stored as the opening at 0 and then player ``2n-1`` / NPC ``2n``
+    for whole turn ``n``. A whole turn is one player message plus the reply to
+    it (issue #501 §4), which is the unit ``turn_count`` counts, that
+    ``duration.max_turns`` is measured in, and that the transcript labels — so
+    it is the only number a debrief may quote at a player. The opening belongs
+    to no turn and maps to 0.
+    """
+    return (row_turn_number + 1) // 2
+
+
 def _identify_key_turns(
     npc_turns: List[sqlite3.Row],
 ) -> List[Dict[str, Any]]:
@@ -327,11 +340,15 @@ def _identify_key_turns(
 
     Returns a list of dicts ready for fallback narrative generation,
     each containing turn_number, description, and impact.
+
+    ``turn_number`` is a whole turn, not the NPC row's stored number: these
+    reach the player as "#3" next to a transcript labelled "Turn 3", and before
+    issue #501 the two counted differently.
     """
     key: List[Dict[str, Any]] = []
 
     for turn in npc_turns:
-        turn_number = turn["turn_number"]
+        turn_number = whole_turn_of(turn["turn_number"])
         state_delta: Dict[str, int] = {}
         if turn["state_delta_json"]:
             try:
@@ -386,7 +403,12 @@ def _identify_key_turns(
 def _build_debrief_turn_records(
     all_turns: List[sqlite3.Row],
 ) -> List[DebriefTurnRecord]:
-    """Convert DB rows into DebriefTurnRecord objects for the prompt composer."""
+    """Convert DB rows into DebriefTurnRecord objects for the prompt composer.
+
+    Numbered in whole turns, so both halves of an exchange are "[Turn 3]" in
+    the prompt and a turning point the model cites is a number the player can
+    find in the transcript (issue #501 §4).
+    """
     records: List[DebriefTurnRecord] = []
     for turn in all_turns:
         obs = _parse_rubric_observations(turn["raw_output_json"])
@@ -403,7 +425,7 @@ def _build_debrief_turn_records(
             except json.JSONDecodeError:
                 pass
         records.append(DebriefTurnRecord(
-            turn_number=turn["turn_number"],
+            turn_number=whole_turn_of(turn["turn_number"]),
             role=turn["role"],
             content=turn["content"],
             rubric_observations=obs,
@@ -552,8 +574,13 @@ async def generate_debrief(
         )
         raw_text = await _collect_runtime_output(runtime, request)
 
-        # Build set of turn numbers actually stored for this session.
-        stored_turn_numbers = {r["turn_number"] for r in all_turn_rows}
+        # Whole turns actually played in this session. The opening maps to 0 and
+        # is excluded: a turning point has to point at an exchange the player
+        # can be shown, and the transcript labels the opening rather than
+        # numbering it (issue #501 §4).
+        stored_turn_numbers = {
+            n for n in (whole_turn_of(r["turn_number"]) for r in all_turn_rows) if n > 0
+        }
 
         # Validate / repair / fallback.
         narrative: DebriefNarrative = parse_debrief_narrative(
diff --git a/services/convsim-core/convsim_core/services/reply_speed.py b/services/convsim-core/convsim_core/services/reply_speed.py
new file mode 100644
index 00000000..a1e4c13e
--- /dev/null
+++ b/services/convsim-core/convsim_core/services/reply_speed.py
@@ -0,0 +1,111 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Reply speed — the plain-language front for "make the model respond faster".
+
+Issue #501: a player partway through the tutorial went to Settings to speed the
+model up and was "a little unclear on how to do that". Nothing in the settings
+panel was named after the thing they wanted; the knobs that exist (context
+length, GPU layers, CPU threads, sampling) are all written in runtime terms and
+none of them is the dominant cost of a turn on local hardware.
+
+The dominant cost is how many tokens the NPC generates. A local model emits
+them one at a time, so halving the length of a reply roughly halves the wait.
+This module turns that into one named choice with three settings:
+
+    fast      — shorter replies, the quickest option
+    balanced  — the scenario's own pacing (default; matches pre-#501 behaviour)
+    detailed  — longer replies, slower on most machines
+
+``fast`` and ``detailed`` *scale* the scenario's authored word cap rather than
+replacing it, so a pack that deliberately writes terse NPCs stays terse relative
+to a pack that writes expansive ones, and ``balanced`` leaves the author's
+number exactly as written. The token budget moves with it: the
+structured turn output lands in the 300–600 token range at the default 90-word
+cap, so a shorter reply needs less headroom and a longer one needs more.
+"""
+from __future__ import annotations
+
+import sqlite3
+from dataclasses import dataclass
+from typing import Literal
+
+ReplySpeed = Literal["fast", "balanced", "detailed"]
+
+#: Persisted under the same ``runtime_setting.`` namespace as the numeric runtime
+#: settings, so one Settings screen and one reset path cover all of them.
+REPLY_SPEED_SETTING_KEY = "runtime_setting.reply_speed"
+
+DEFAULT_REPLY_SPEED: ReplySpeed = "balanced"
+
+
+@dataclass(frozen=True)
+class ReplySpeedProfile:
+    """How one reply-speed choice changes a turn."""
+
+    #: Multiplier applied to the scenario's authored ``response_style.max_words``.
+    word_scale: float
+    #: Ceiling for the runtime's generation budget for the structured turn JSON.
+    max_tokens: int
+
+
+#: Floors and ceilings on what *scaling* may do. The floor keeps "fast" from
+#: cutting an NPC down to a grunt; the ceiling keeps "detailed" from inviting
+#: the monologues RESPONSE_STYLE forbids.
+#:
+#: Neither one overrides the author. ``scenario.schema.json`` allows
+#: ``max_words`` anywhere in 10–500, so applied as plain bounds these would
+#: rewrite a cap outside them at every speed: a pack that writes 10-word
+#: replies came out at 30 under all three — "Quick replies" *tripling* the cap
+#: it was asked to shorten, and the three options indistinguishable — and a
+#: pack that writes 300 came out at 200 on `balanced`, which is supposed to be
+#: the pre-#501 behaviour exactly. They now only bound the distance scaling may
+#: travel from the authored value.
+MIN_SCALED_MAX_WORDS = 30
+MAX_SCALED_MAX_WORDS = 200
+
+REPLY_SPEED_PROFILES: dict[str, ReplySpeedProfile] = {
+    "fast": ReplySpeedProfile(word_scale=0.5, max_tokens=640),
+    # Unchanged from the hardcoded pre-#501 behaviour, so the default player
+    # experience is byte-for-byte what it was.
+    "balanced": ReplySpeedProfile(word_scale=1.0, max_tokens=1024),
+    "detailed": ReplySpeedProfile(word_scale=1.5, max_tokens=1536),
+}
+
+
+def normalize_reply_speed(value: object) -> ReplySpeed:
+    """Coerce a stored/incoming value to a known reply speed.
+
+    Anything unrecognised (a null row, a value written by a newer build, a typo
+    in a hand-edited database) falls back to the default rather than failing a
+    turn: reply pacing is a preference, not a correctness guarantee.
+    """
+    if isinstance(value, str) and value in REPLY_SPEED_PROFILES:
+        return value  # type: ignore[return-value]
+    return DEFAULT_REPLY_SPEED
+
+
+def profile_for(speed: object) -> ReplySpeedProfile:
+    return REPLY_SPEED_PROFILES[normalize_reply_speed(speed)]
+
+
+def load_reply_speed(conn: sqlite3.Connection) -> ReplySpeed:
+    """Read the persisted reply speed, defaulting when unset."""
+    row = conn.execute(
+        "SELECT value FROM user_settings WHERE key = ?", (REPLY_SPEED_SETTING_KEY,)
+    ).fetchone()
+    return normalize_reply_speed(row["value"] if row is not None else None)
+
+
+def scaled_max_words(authored_max_words: int, speed: object) -> int:
+    """Apply the reply-speed scale to a scenario's authored NPC word cap.
+
+    The result always sits between the authored cap and the clamp bound in the
+    direction the speed scales, so "fast" can only ever shorten and "detailed"
+    can only ever lengthen — and the default leaves the author's number alone.
+    """
+    scale = profile_for(speed).word_scale
+    if scale == 1.0:
+        return authored_max_words
+    scaled = round(authored_max_words * scale)
+    if scale < 1.0:
+        return max(min(MIN_SCALED_MAX_WORDS, authored_max_words), scaled)
+    return min(max(MAX_SCALED_MAX_WORDS, authored_max_words), scaled)
diff --git a/services/convsim-core/convsim_core/services/turn_pipeline.py b/services/convsim-core/convsim_core/services/turn_pipeline.py
index 0e3b8537..a6d48828 100644
--- a/services/convsim-core/convsim_core/services/turn_pipeline.py
+++ b/services/convsim-core/convsim_core/services/turn_pipeline.py
@@ -20,7 +20,7 @@
 import json
 import logging
 import sqlite3
-from dataclasses import dataclass
+from dataclasses import dataclass, replace as dataclass_replace
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Set
 
@@ -35,7 +35,7 @@
     compose_turn_prompt,
     parse_turn_output,
 )
-from convsim_prompt.types import ScenarioData
+from convsim_prompt.types import ResponseStyleOverrides, ScenarioData
 
 from convsim_core.input_router import (
     DEFAULT_REDIRECT_MESSAGE,
@@ -55,10 +55,33 @@
     initialize_state,
     partition_state_by_visibility,
 )
+from convsim_core.services.reply_speed import (
+    load_reply_speed,
+    profile_for,
+    scaled_max_words,
+)
 from convsim_core.storage.repositories.relationship_repo import get_relationship_recap
 
 logger = logging.getLogger(__name__)
 
+
+def _apply_reply_speed(scenario_data: ScenarioData, speed: str) -> ScenarioData:
+    """Return *scenario_data* with its NPC word cap scaled for *speed*.
+
+    A copy, not a mutation: ``scenario_data`` is resolved once per scenario and
+    handed to every session playing it, so writing the current player's pacing
+    preference into it would leak across sessions.
+    """
+    authored = scenario_data.response_style or ResponseStyleOverrides()
+    target = scaled_max_words(authored.max_words, speed)
+    if target == authored.max_words:
+        return scenario_data
+    return dataclass_replace(
+        scenario_data,
+        response_style=dataclass_replace(authored, max_words=target),
+    )
+
+
 MAX_TURN_CONTENT_CHARS = 2000
 
 # Default safety policy used when no scenario-specific policy is configured.
@@ -436,7 +459,11 @@ async def process_turn(
     pack_id: str = setup.get("pack_id") or scenario_data.scenario_id
     relationship_recap = get_relationship_recap(conn, npc_id, pack_id)
 
-    # 6. Build prompt.
+    # 6. Build prompt. The player's reply-speed preference (issue #501) scales
+    #    the NPC's word budget here and its token budget at step 7, so a choice
+    #    made in Settings mid-scenario applies to this very turn.
+    reply_speed = load_reply_speed(conn)
+    scenario_data = _apply_reply_speed(scenario_data, reply_speed)
     prompt_safety_policy = (
         _safety_policy_config_to_prompt_policy(safety_policy_config)
         if safety_policy_config is not None
@@ -467,8 +494,9 @@ async def process_turn(
         # regularly lands in the 300-600 token range; the 512 default left no
         # headroom and a truncated JSON object degrades to the fallback
         # utterance. Reasoning is disabled at the engine level, so the extra
-        # budget costs nothing when unused.
-        max_tokens=1024,
+        # budget costs nothing when unused. "balanced" keeps the 1024 this was
+        # hardcoded to before reply speed became a setting.
+        max_tokens=profile_for(reply_speed).max_tokens,
     )
     logger.debug(
         "Calling runtime %s for session %s turn %d (estimated %d tokens, truncated=%s)",
diff --git a/services/convsim-core/convsim_core/storage/repositories/scenario_repo.py b/services/convsim-core/convsim_core/storage/repositories/scenario_repo.py
index bdc0e509..0bb801a9 100644
--- a/services/convsim-core/convsim_core/storage/repositories/scenario_repo.py
+++ b/services/convsim-core/convsim_core/storage/repositories/scenario_repo.py
@@ -3,7 +3,7 @@
 import json
 import os
 import sqlite3
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Optional
 
 import yaml
@@ -234,6 +234,7 @@ def _row_to_card(row: sqlite3.Row) -> ScenarioCard:
     yaml_data = _load_scenario_yaml(row["pack_source_path"], row["rel_path"])
     return ScenarioCard(
         scenario_id=row["scenario_id"],
+        npc_name=_npc_display_name(row["pack_source_path"], row["rel_path"], yaml_data),
         pack_id=row["pack_id"],
         pack_name=row["pack_name"],
         title=row["title"] or row["scenario_id"],
@@ -267,6 +268,7 @@ def _row_to_detail(row: sqlite3.Row, *, include_hidden: bool) -> ScenarioDetail:
 
     return ScenarioDetail(
         scenario_id=row["scenario_id"],
+        npc_name=_npc_display_name(row["pack_source_path"], row["rel_path"], yaml_data),
         pack_id=row["pack_id"],
         pack_name=row["pack_name"],
         title=row["title"] or row["scenario_id"],
@@ -294,6 +296,11 @@ def _row_to_detail(row: sqlite3.Row, *, include_hidden: bool) -> ScenarioDetail:
 
 def _load_scenario_yaml(pack_source_path: Optional[str], rel_path: Optional[str]) -> dict:
     """Load scenario YAML from disk. Returns {} if path is unavailable or parse fails."""
+    return _load_pack_yaml(pack_source_path, rel_path)
+
+
+def _load_pack_yaml(pack_source_path: Optional[str], rel_path: Optional[str]) -> dict:
+    """Load any YAML file inside a pack. Returns {} when unavailable or unparseable."""
     if not pack_source_path or not rel_path:
         return {}
     try:
@@ -311,3 +318,41 @@ def _load_scenario_yaml(pack_source_path: Optional[str], rel_path: Optional[str]
         return data
     except Exception:
         return {}
+
+
+def _npc_display_name(
+    pack_source_path: Optional[str],
+    rel_path: Optional[str],
+    yaml_data: dict,
+) -> Optional[str]:
+    """Resolve the scenario's NPC `display_name` through its `npc.ref`.
+
+    The conversation screen labelled every NPC line "NPC" because the name was
+    never exposed over the API — it lives in a separate file the scenario only
+    points at. "NPC" is the most technical word on that screen, and issue #501
+    is about exactly that gap, so the name travels with the scenario now.
+
+    Best effort: a missing, malformed or nameless NPC file leaves this None and
+    the caller falls back to its generic label.
+    """
+    npc = yaml_data.get("npc")
+    if not isinstance(npc, dict):
+        return None
+    ref = npc.get("ref")
+    if not isinstance(ref, str) or not ref:
+        return None
+    if not rel_path:
+        return None
+    # `npc.ref` is relative to the scenario file, not to the pack root. Joining
+    # through the scenario's parent keeps `../npcs/alex_chen.yaml` resolving the
+    # way the pack author wrote it; _load_pack_yaml still refuses any result
+    # outside the pack directory.
+    scenario_dir = PurePosixPath(rel_path.replace("\\", "/")).parent
+    return _display_name_of(
+        _load_pack_yaml(pack_source_path, str(scenario_dir / ref))
+    )
+
+
+def _display_name_of(npc_data: dict) -> Optional[str]:
+    name = npc_data.get("display_name")
+    return name if isinstance(name, str) and name.strip() else None
diff --git a/services/convsim-core/tests/test_debrief_engine.py b/services/convsim-core/tests/test_debrief_engine.py
index 46f0017a..5b854d5b 100644
--- a/services/convsim-core/tests/test_debrief_engine.py
+++ b/services/convsim-core/tests/test_debrief_engine.py
@@ -784,11 +784,12 @@ def test_rubric_scores_reflect_observations(self, tmp_config):
     def test_debrief_turning_points_reference_real_turns(self, tmp_config):
         """Golden fixture: all turning_point turn_numbers must exist in the transcript.
 
-        _RubricRuntime always returns turn_number=3 in its debrief. With 1 player turn
-        the stored transcript is {1, 2} (player_turn=2n-1, npc_turn=2n), so turn 3 would
-        be filtered out and the assertion loop would trivially pass over an empty list.
-        Two player turns produce stored turns {1, 2, 3, 4}, so turn 3 survives the filter
-        and the non-empty assertion below ensures the loop actually runs.
+        Turning points are numbered in whole turns — one player message plus the
+        reply to it (issue #501 §4) — because that is what the transcript labels
+        and what the player is asked to click. _RubricRuntime always returns
+        turn_number=3, so the session has to play three whole turns for it to
+        survive the filter; the non-empty assertion below ensures the loop
+        actually runs.
         """
         app = create_app(tmp_config)
         with TestClient(app) as client:
@@ -799,10 +800,11 @@ def test_debrief_turning_points_reference_real_turns(self, tmp_config):
 
             app.state.runtime = _RubricRuntime()
 
-            # Two turns so stored turn numbers include 3 (second player turn = 2*2-1).
+            # Three whole turns so turn 3 is a turn the player actually played.
             for msg in [
                 "I led a cross-functional team at my last company.",
                 "The biggest challenge was keeping everyone aligned on priorities.",
+                "We shipped it a week early in the end.",
             ]:
                 client.post(
                     f"/api/sessions/{session_id}/turn",
@@ -812,10 +814,13 @@ def test_debrief_turning_points_reference_real_turns(self, tmp_config):
 
             debrief_res = client.post(f"/api/sessions/{session_id}/debrief")
 
-            # Collect all turn numbers stored in the transcript (must be inside with block).
+            # Collect the whole turns stored in the transcript (must be inside
+            # the with block). The opening is row 0 and belongs to no turn.
             transcript_res = client.get(f"/api/sessions/{session_id}/transcript")
             stored_turn_numbers = {
-                t["turn_number"] for t in transcript_res.json()["turns"]
+                (t["turn_number"] + 1) // 2
+                for t in transcript_res.json()["turns"]
+                if t["turn_number"] > 0
             }
 
         assert debrief_res.status_code == 200
@@ -1223,3 +1228,45 @@ def _spy(inp):
             "turn pipeline read None — write/read pack_id keys diverged"
         )
         assert expected_obs in recap["key_observations"]
+
+
+# ── Whole-turn numbering of a debrief's turn references (issue #501 §4) ───────
+# One turn is the player's message plus the reply to it. The transcript labels
+# that number, so it is the only number a debrief may quote at a player: a
+# turning point reported as the NPC's row number sent "go to turn N" a whole
+# turn past the moment it named, and the badge disagreed with the label beside
+# the message it pointed at.
+
+
+class TestDebriefTurnReferencesAreWholeTurns:
+    def test_whole_turn_of_maps_both_halves_to_one_number(self):
+        from convsim_core.services.debrief_engine import whole_turn_of
+
+        # The opening belongs to no exchange.
+        assert whole_turn_of(0) == 0
+        # player 2n-1 and NPC 2n are both turn n.
+        assert [whole_turn_of(n) for n in (1, 2, 3, 4, 5, 6)] == [1, 1, 2, 2, 3, 3]
+
+    def test_key_turns_are_numbered_in_whole_turns(self):
+        from convsim_core.services.debrief_engine import _identify_key_turns
+
+        key = _identify_key_turns([
+            _make_turn_row(turn_number=2, role="npc", state_delta_json='{"trust": 12}'),
+            _make_turn_row(turn_number=4, role="npc", state_delta_json='{"trust": -9}'),
+        ])
+        assert [k["turn_number"] for k in key] == [1, 2]
+        # The description quotes the same number, so the prose and the badge
+        # cannot disagree.
+        assert "turn 1" in key[0]["description"]
+        assert "turn 2" in key[1]["description"]
+
+    def test_prompt_records_number_both_halves_the_same(self):
+        from convsim_core.services.debrief_engine import _build_debrief_turn_records
+
+        records = _build_debrief_turn_records(list(_GOLDEN_TURNS))
+        numbered = [(r.role, r.turn_number) for r in records]
+        assert numbered[0] == ("npc_opening", 0)
+        # The player's message and the reply to it are one turn to the model
+        # too, so a turning point it cites is a number the player can find.
+        assert numbered[1] == ("player", 1)
+        assert numbered[2] == ("npc", 1)
diff --git a/services/convsim-core/tests/test_reply_speed.py b/services/convsim-core/tests/test_reply_speed.py
new file mode 100644
index 00000000..8059a0b9
--- /dev/null
+++ b/services/convsim-core/tests/test_reply_speed.py
@@ -0,0 +1,252 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Reply speed — the plain-language "make the model respond faster" setting.
+
+Issue #501 §1: the knobs that existed were all written in runtime terms and
+none of them named the thing the player wanted. Reply speed names it, and it
+has to actually do something: scale the NPC's word budget in the prompt and the
+runtime's generation budget for the turn.
+"""
+import pytest
+
+from convsim_core.services.reply_speed import (
+    DEFAULT_REPLY_SPEED,
+    MAX_SCALED_MAX_WORDS,
+    MIN_SCALED_MAX_WORDS,
+    REPLY_SPEED_PROFILES,
+    normalize_reply_speed,
+    profile_for,
+    scaled_max_words,
+)
+
+
+# ── The profiles themselves ──────────────────────────────────────────────────
+
+
+def test_three_named_speeds():
+    assert set(REPLY_SPEED_PROFILES) == {"fast", "balanced", "detailed"}
+
+
+def test_balanced_is_the_default():
+    assert DEFAULT_REPLY_SPEED == "balanced"
+
+
+def test_balanced_preserves_pre_change_behaviour():
+    """'balanced' must leave the turn exactly as it was before this setting."""
+    assert profile_for("balanced").max_tokens == 1024
+    assert scaled_max_words(90, "balanced") == 90
+
+
+def test_fast_shortens_and_detailed_lengthens():
+    assert scaled_max_words(90, "fast") < 90 < scaled_max_words(90, "detailed")
+    assert (
+        profile_for("fast").max_tokens
+        < profile_for("balanced").max_tokens
+        < profile_for("detailed").max_tokens
+    )
+
+
+def test_scaling_is_relative_to_the_authored_cap():
+    """A pack that writes terse NPCs stays terser than one that writes long ones."""
+    assert scaled_max_words(120, "fast") > scaled_max_words(80, "fast")
+
+
+def test_scaled_cap_is_clamped_at_both_ends():
+    # Unclamped, halving 90 and 50 gives 45 and 25; the floor bites on the
+    # second.
+    assert scaled_max_words(90, "fast") == 45
+    assert scaled_max_words(50, "fast") == MIN_SCALED_MAX_WORDS
+    # Unclamped, 1.5× of 120 and 180 gives 180 and 270; the ceiling bites on
+    # the second.
+    assert scaled_max_words(120, "detailed") == 180
+    assert scaled_max_words(180, "detailed") == MAX_SCALED_MAX_WORDS
+
+
+def test_clamps_never_override_the_authored_cap():
+    """``scenario.schema.json`` allows max_words anywhere in 10–500.
+
+    Applied as plain bounds the clamps rewrote any cap outside them at every
+    speed: a pack writing 10-word replies came out at 30 under all three, so
+    "Quick replies" tripled the cap it was asked to shorten and the three
+    options were indistinguishable; a pack writing 300 came out at 200 on
+    `balanced`, which is meant to be the pre-#501 behaviour exactly.
+    """
+    # Already terser than the floor: nothing to shorten, nothing to lengthen.
+    assert scaled_max_words(10, "fast") == 10
+    assert scaled_max_words(10, "balanced") == 10
+    # Already longer than the ceiling: `detailed` may not shorten it, and the
+    # default may not touch it at all.
+    assert scaled_max_words(300, "balanced") == 300
+    assert scaled_max_words(300, "detailed") == 300
+    assert scaled_max_words(500, "balanced") == 500
+
+
+@pytest.mark.parametrize("authored", [10, 20, 40, 90, 150, 300, 500])
+def test_fast_never_lengthens_and_detailed_never_shortens(authored):
+    assert scaled_max_words(authored, "fast") <= authored
+    assert scaled_max_words(authored, "balanced") == authored
+    assert scaled_max_words(authored, "detailed") >= authored
+
+
+@pytest.mark.parametrize("value", [None, "", "turbo", 3, "FAST"])
+def test_unknown_values_fall_back_to_the_default(value):
+    """Reply pacing is a preference; a bad value must never fail a turn."""
+    assert normalize_reply_speed(value) == DEFAULT_REPLY_SPEED
+
+
+# ── The settings endpoint ────────────────────────────────────────────────────
+
+
+def test_reply_speed_is_exposed_by_the_settings_endpoint(client):
+    body = client.get("/api/runtime/settings").json()
+    assert "reply_speed" in body["settings"]
+    assert body["settings"]["reply_speed"] is None
+    assert body["recommended"]["reply_speed"] == DEFAULT_REPLY_SPEED
+
+
+def test_reply_speed_persists(client):
+    resp = client.put("/api/runtime/settings", json={"reply_speed": "fast"})
+    assert resp.status_code == 200
+    assert resp.json()["settings"]["reply_speed"] == "fast"
+    assert client.get("/api/runtime/settings").json()["settings"]["reply_speed"] == "fast"
+
+
+def test_reply_speed_needs_no_restart(client):
+    """It is read per turn, so the next message already uses it."""
+    resp = client.put("/api/runtime/settings", json={"reply_speed": "detailed"})
+    assert resp.json()["requires_restart"] is False
+
+
+def test_unknown_reply_speed_is_rejected(client):
+    resp = client.put("/api/runtime/settings", json={"reply_speed": "ludicrous"})
+    assert resp.status_code == 422
+    assert "Reply speed" in resp.text
+
+
+def test_reply_speed_survives_a_partial_update_of_other_fields(client):
+    client.put("/api/runtime/settings", json={"reply_speed": "fast"})
+    client.put("/api/runtime/settings", json={"threads": 4})
+    settings = client.get("/api/runtime/settings").json()["settings"]
+    assert settings["reply_speed"] == "fast"
+    assert settings["threads"] == 4
+
+
+def test_reset_clears_reply_speed(client):
+    client.put("/api/runtime/settings", json={"reply_speed": "fast"})
+    body = client.post("/api/runtime/settings/reset").json()
+    assert body["settings"]["reply_speed"] is None
+
+
+def test_stored_garbage_reads_back_as_unset(client):
+    """A value a newer build wrote must not surface as an option the UI can't render."""
+    from convsim_core.services.reply_speed import REPLY_SPEED_SETTING_KEY
+
+    conn = client.app.state.db.connection()
+    conn.execute(
+        "INSERT INTO user_settings (key, value, updated_at) VALUES (?, ?, datetime('now'))",
+        (REPLY_SPEED_SETTING_KEY, "hypersonic"),
+    )
+    conn.commit()
+    assert client.get("/api/runtime/settings").json()["settings"]["reply_speed"] is None
+
+
+# ── End-to-end through a real turn ───────────────────────────────────────────
+
+
+_SETUP = {
+    "scenario_id": "behavioral_interview",
+    "difficulty": "standard",
+    "player_role_name": "Test Player",
+    "save_transcript": True,
+    "runtime_id": "fake",
+}
+
+
+def _play_one_turn(client) -> dict:
+    """Create → start → one turn; returns the recorded prompt metadata."""
+    session_id = client.post("/api/sessions", json=_SETUP).json()["session_id"]
+    client.post(f"/api/sessions/{session_id}/start")
+    resp = client.post(f"/api/sessions/{session_id}/turn", json={"content": "Hello."})
+    assert resp.status_code == 200, resp.text
+
+    conn = client.app.state.db.connection()
+    row = conn.execute(
+        "SELECT content FROM turn_session_turns "
+        "WHERE session_id = ? AND role = 'player' ORDER BY turn_number DESC LIMIT 1",
+        (session_id,),
+    ).fetchone()
+    assert row is not None
+    return {"session_id": session_id}
+
+
+def test_word_cap_reaches_the_prompt(client, monkeypatch):
+    """The scaled cap must land in the RESPONSE_STYLE layer the model reads."""
+    captured: list[str] = []
+
+    from convsim_core.services import turn_pipeline as tp
+
+    real_compose = tp.compose_turn_prompt
+
+    def _spy(inp):
+        bundle = real_compose(inp)
+        captured.append(bundle.system_prompt)
+        return bundle
+
+    monkeypatch.setattr(tp, "compose_turn_prompt", _spy)
+
+    client.put("/api/runtime/settings", json={"reply_speed": "fast"})
+    _play_one_turn(client)
+    assert captured, "compose_turn_prompt was never called"
+    assert "NPC utterance must be at most 45 words." in captured[0]
+
+
+def test_balanced_prompt_keeps_the_authored_cap(client, monkeypatch):
+    captured: list[str] = []
+
+    from convsim_core.services import turn_pipeline as tp
+
+    real_compose = tp.compose_turn_prompt
+
+    def _spy(inp):
+        bundle = real_compose(inp)
+        captured.append(bundle.system_prompt)
+        return bundle
+
+    monkeypatch.setattr(tp, "compose_turn_prompt", _spy)
+
+    _play_one_turn(client)
+    assert "NPC utterance must be at most 90 words." in captured[0]
+
+
+def test_token_budget_reaches_the_runtime(client, monkeypatch):
+    captured: list[int] = []
+
+    from convsim_core.services import turn_pipeline as tp
+
+    real_collect = tp._collect_runtime_output
+
+    async def _spy(runtime, request):
+        captured.append(request.max_tokens)
+        return await real_collect(runtime, request)
+
+    monkeypatch.setattr(tp, "_collect_runtime_output", _spy)
+
+    client.put("/api/runtime/settings", json={"reply_speed": "fast"})
+    _play_one_turn(client)
+    assert captured[0] == REPLY_SPEED_PROFILES["fast"].max_tokens
+
+
+def test_scenario_data_is_not_mutated_across_sessions(client):
+    """The preference belongs to the player, not to the shared scenario object."""
+    from convsim_core.scenarios import resolve_scenario_info
+
+    client.put("/api/runtime/settings", json={"reply_speed": "fast"})
+    _play_one_turn(client)
+
+    info = resolve_scenario_info("behavioral_interview")
+    assert info is not None
+    data = info.get_scenario_data("standard")
+    authored = data.response_style.max_words if data.response_style else 90
+    assert authored == 90, (
+        "process_turn must copy the scenario data before scaling its word cap; "
+        f"the shared object came back with max_words={authored}"
+    )
diff --git a/services/convsim-core/tests/test_scenario_contract.py b/services/convsim-core/tests/test_scenario_contract.py
index 1d7a7f5f..668c7f8b 100644
--- a/services/convsim-core/tests/test_scenario_contract.py
+++ b/services/convsim-core/tests/test_scenario_contract.py
@@ -122,9 +122,29 @@ def test_tutorial_scenario_canonical_fields(seeded_client):
     s = resp.json()
     _assert_canonical(s)
     assert s["difficulty"]["default"]
+    # Whole turns — one player message plus Alex's reply (issue #501 §4). The
+    # scripted runtime ends the session on its sixth turn; this is the safety
+    # net behind that.
     assert s["duration"]["max_turns"] == 8
     assert s["taught_dimensions"], "tutorial declares taught_dimensions"
     assert s["opening_npc_says"], "tutorial must carry its scripted opening"
+    assert s["npc_name"] == "Alex Chen", "the tutorial guide is named, not 'NPC'"
+
+
+def test_tutorial_turn_budget_is_the_one_that_actually_plays():
+    """The library card's budget must be the budget the session enforces.
+
+    The card comes from the installed pack; play comes from the hardcoded
+    catalog entry, which resolve_scenario_info consults first outside the demo
+    edition. They drifted apart during issue #501, so the card promised a
+    budget the session did not give.
+    """
+    from convsim_core.scenarios import resolve_scenario_info
+
+    info = resolve_scenario_info("first_words_tutorial")
+    assert info is not None
+    assert info.max_turns == 8
+    assert info.ending_conditions["timeout"]["value"] == 8
 
 
 def test_language_cafe_languages_come_from_pack_manifest(seeded_client):
diff --git a/services/convsim-core/tests/test_scenarios_api.py b/services/convsim-core/tests/test_scenarios_api.py
index dfdd9935..f3371567 100644
--- a/services/convsim-core/tests/test_scenarios_api.py
+++ b/services/convsim-core/tests/test_scenarios_api.py
@@ -1,5 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 """Integration tests for the scenario library API."""
+from pathlib import Path
+
 import pytest
 from fastapi.testclient import TestClient
 
@@ -7,10 +9,30 @@
 from convsim_core.config import ServiceConfig
 from tests.helpers import make_pack_zip, make_pack_dir
 
+_REPO_ROOT = Path(__file__).resolve().parents[3]
+_OFFICIAL_PACKS = _REPO_ROOT / "packs" / "official"
+
 
 # ── helpers ───────────────────────────────────────────────────────────────────
 
 
+@pytest.fixture()
+def seeded_client(tmp_path):
+    """A client whose profile has the official packs seeded from the repo."""
+    config = ServiceConfig(
+        host="127.0.0.1",
+        port=7355,
+        data_dir=str(tmp_path / "data"),
+        log_dir=str(tmp_path / "logs"),
+        db_dir=str(tmp_path / "db"),
+        packs_dir=str(tmp_path / "packs"),
+        official_packs_dir=str(_OFFICIAL_PACKS),
+    )
+    app = create_app(config)
+    with TestClient(app) as c:
+        yield c
+
+
 @pytest.fixture()
 def dev_client(tmp_path):
     config = ServiceConfig(
@@ -555,3 +577,28 @@ def test_validate_yaml_manifest_schema_violation_returns_schema_violation_rule(c
     errors = ["manifest.yaml [name]: 'Foo Bar' does not match '^[a-z]'"]
     rule_ids = errors_to_rule_ids(errors)
     assert "SCHEMA_VIOLATION" in rule_ids
+
+
+# ── NPC name (issue #501 §2) ─────────────────────────────────────────────────
+# "NPC" was the most technical word on the conversation screen, and the only
+# reason it was there is that the character's name was never exposed: it lives
+# in a separate pack file the scenario points at with `npc.ref`.
+
+
+def test_scenario_card_carries_the_npc_name(seeded_client):
+    cards = seeded_client.get("/api/scenarios").json()
+    by_id = {c["scenario_id"]: c for c in cards}
+    assert by_id["first_words_tutorial"]["npc_name"] == "Alex Chen"
+
+
+def test_scenario_detail_carries_the_npc_name(seeded_client):
+    detail = seeded_client.get("/api/scenarios/first_words_tutorial").json()
+    assert detail["npc_name"] == "Alex Chen"
+
+
+def test_every_seeded_scenario_resolves_an_npc_name(seeded_client):
+    """A scenario whose name does not resolve falls back to "NPC" in the UI."""
+    cards = seeded_client.get("/api/scenarios").json()
+    assert cards, "expected the official packs to be seeded"
+    missing = [c["scenario_id"] for c in cards if not c.get("npc_name")]
+    assert missing == [], f"scenarios with no resolvable NPC name: {missing}"
diff --git a/services/convsim-core/tests/test_scripted_runtime.py b/services/convsim-core/tests/test_scripted_runtime.py
index eee7a0d9..cdb0ba23 100644
--- a/services/convsim-core/tests/test_scripted_runtime.py
+++ b/services/convsim-core/tests/test_scripted_runtime.py
@@ -507,3 +507,386 @@ def test_session_without_runtime_id_stores_no_runtime_key(tmp_config):
         res = client.post("/api/sessions", json=_TUTORIAL_SESSION_SETUP)
         assert res.status_code == 201, res.text
         assert "runtime_id" not in res.json()["setup"]
+
+
+# ── Answering questions instead of talking past them (issue #501 §3) ─────────
+# "The model in the Tutorial doesn't seem to be able to give an explanation of
+# what the meters are and hallucinates through the scenario, as if it has given
+# a coherent explanation and received positive feedback from the user."
+#
+# It is not a model — it is this script, which had no branch for a question, so
+# "what are the meters?" got the next canned line.
+
+
+def _script_utterance(turn: int) -> str:
+    from convsim_core.runtime.scripted import _FIRST_WORDS_SCRIPT
+
+    return _FIRST_WORDS_SCRIPT[turn - 1]["npc_utterance"]
+
+
+def _script_delta(turn: int) -> dict:
+    from convsim_core.runtime.scripted import _FIRST_WORDS_SCRIPT
+
+    return _FIRST_WORDS_SCRIPT[turn - 1]["state_delta"]
+
+
+def _structured_for(runtime: ScriptedChatRuntime, text: str, turn: int) -> dict:
+    import asyncio
+
+    async def run() -> dict:
+        request = ChatRequest(
+            messages=[ChatMessage(role="user", content=text)],
+            json_schema={
+                "type": "object",
+                "properties": {"npc_utterance": {}, "session_control": {}},
+            },
+            scripted_turn_index=turn,
+        )
+        async for chunk in runtime.chat_stream(request):
+            if isinstance(chunk, ChatFinal):
+                assert chunk.structured is not None
+                return chunk.structured
+        raise AssertionError("no ChatFinal received")
+
+    return asyncio.run(run())
+
+
+def _utterance_for(runtime: ScriptedChatRuntime, text: str, turn: int) -> str:
+    return _structured_for(runtime, text, turn)["npc_utterance"]
+
+
+@pytest.mark.parametrize(
+    "question",
+    [
+        "What are the meters?",
+        "what does engagement mean?",
+        "I'm confused about the two bars",
+        "tell me what confidence means",
+        "Wait — which meter is which?",
+    ],
+)
+def test_a_meter_question_is_answered(runtime, question):
+    text = _utterance_for(runtime, question, turn=2).lower()
+    assert "engagement is how interested" in text, (
+        f"a meter question must be answered, got: {text!r}"
+    )
+
+
+def test_a_meter_question_is_answered_on_any_tour_turn(runtime):
+    """The question can come at any point, not only where the tour explains them."""
+    for turn in (1, 2, 3, 4, 5):
+        text = _utterance_for(runtime, "what are the meters?", turn=turn).lower()
+        assert "engagement is how interested" in text, f"turn {turn} talked past the question"
+
+
+def test_a_mood_question_separates_mood_from_the_meters(runtime):
+    text = _utterance_for(runtime, "what is the mood in brackets?", turn=3).lower()
+    assert "not a meter" in text
+
+
+def test_an_is_this_ai_question_gets_a_straight_answer(runtime):
+    text = _utterance_for(runtime, "are you a real AI?", turn=2).lower()
+    assert "scripted" in text
+
+
+def test_an_ending_question_is_answered(runtime):
+    text = _utterance_for(runtime, "how does this conversation end?", turn=2).lower()
+    assert "three ways" in text
+
+
+def test_a_debrief_question_is_answered(runtime):
+    text = _utterance_for(runtime, "what is the debrief?", turn=2).lower()
+    assert "after a conversation ends" in text
+
+
+def test_a_statement_about_the_meters_follows_the_tour(runtime):
+    """Not every mention of a meter is a question about one."""
+    text = _utterance_for(runtime, "The engagement meter went up, nice.", turn=3)
+    assert text == _script_utterance(3), "a statement must not be interjected on"
+
+
+def test_an_unrelated_question_follows_the_tour(runtime):
+    """A question the script has no answer for must not derail the tour."""
+    text = _utterance_for(runtime, "What is the weather like?", turn=3)
+    assert text == _script_utterance(3)
+
+
+def test_an_answer_carries_the_tour_line_along(runtime):
+    """Asking must not cost the player the beat that turn was going to deliver.
+
+    Substituting the answer for the tour line drops a beat AND drops that
+    turn's state_delta, so Engagement stops crossing 60 on schedule and turn
+    4's "Engagement crossed the mark" announces an event that never fired —
+    the issue's own complaint, reintroduced by the fix for it.
+    """
+    structured = _structured_for(runtime, "what are the meters?", turn=3)
+    assert structured["npc_utterance"].endswith(_script_utterance(3))
+    assert structured["state_delta"] == _script_delta(3)
+
+
+def test_the_tour_reaches_the_turning_point_even_if_every_turn_is_a_question(runtime):
+    """Engagement must still cross 60 by the turn that announces it has.
+
+    The scenario starts Engagement at 30 and the event threshold is "above 60";
+    the script's deltas are what get it there, so they have to land whether or
+    not the player asked something.
+    """
+    engagement = 30
+    for turn in (1, 2, 3):
+        structured = _structured_for(runtime, "what are the meters?", turn=turn)
+        engagement += structured["state_delta"]["engagement"]
+    assert engagement > 60, (
+        f"Engagement reached only {engagement}; turn 4 claims it crossed 60"
+    )
+
+
+def test_question_keywords_are_matched_on_word_boundaries(runtime):
+    """'explain' contains 'ai' and 'show' contains 'how'.
+
+    Matching bare substrings would answer "can you explain that again?" with
+    the is-this-AI answer.
+    """
+    text = _utterance_for(runtime, "Can you explain that again?", turn=3)
+    assert "i am scripted" not in text.lower(), (
+        f"'ai' was matched inside another word: {text!r}"
+    )
+
+
+def test_an_answered_question_still_continues_the_session(runtime):
+    structured = _structured_for(runtime, "what are the meters?", turn=2)
+    assert structured["session_control"]["continue_session"] is True
+
+
+def test_a_question_on_the_final_turn_still_ends_the_session(runtime):
+    """The last turn has to close, so the ending branch outranks an answer."""
+    structured = _structured_for(runtime, "but what are the meters?", turn=6)
+    assert structured["session_control"]["continue_session"] is False
+
+
+def test_interjections_pass_npc_output_validation():
+    """The answers go through the same validators as the scripted turns."""
+    from convsim_prompt.turn_output import _validate as validate_turn_output
+    from convsim_core.runtime.scripted import (
+        _FIRST_WORDS_SCRIPT,
+        _INTERJECTIONS,
+        _with_answer,
+    )
+
+    for keywords, answer in _INTERJECTIONS:
+        composed = _with_answer(_FIRST_WORDS_SCRIPT[0], answer)
+        validate_turn_output(composed), f"interjection for {sorted(keywords)} failed validation"
+
+
+def test_the_prompt_scaffolding_is_not_matched_as_player_words(runtime):
+    """The runtime is handed the composed PLAYER_UTTERANCE layer, not bare words.
+
+    That layer ends with "=== END PLAYER INPUT ===", which contains "end" — so
+    matching the message as received answered any question at all with the
+    endings answer, and made the debrief answer (a later cluster) unreachable.
+    These go through the runtime, not _pick_interjection, precisely because the
+    unwrapping is the thing under test.
+    """
+    from convsim_prompt.layers import build_player_utterance_layer
+
+    def utterance(player_text: str, turn: int) -> str:
+        return _utterance_for(runtime, build_player_utterance_layer(player_text), turn)
+
+    assert utterance("Tell me about yourself", 3) == _script_utterance(3)
+    assert utterance("What is the weather like?", 3) == _script_utterance(3)
+    assert "debrief comes after" in utterance("How am I scored?", 3)
+    assert "engagement is how interested" in utterance("What are the meters?", 3).lower()
+
+
+# ── Plain language in the tutorial copy (issue #501 §2) ──────────────────────
+# The report named the words that landed badly: 'runtime', 'event', 'state',
+# 'flag'. The tutorial itself used three of them plus "hidden prompt" and
+# "rubric dimensions" — while teaching a player who by definition does not know
+# them yet.
+
+_FORBIDDEN_TUTORIAL_WORDS = (
+    "scenario event",
+    "event flag",
+    "hidden prompt",
+    "hidden instructions",
+    "rubric",
+    "state variable",
+    "state meter",
+    "runtime",
+    "threshold",
+)
+
+
+def _tutorial_scenario_strings() -> list[tuple[str, str]]:
+    """Every player-facing string of the tutorial scenario, from BOTH copies.
+
+    The tutorial is defined twice: as a pack (packs/official/first-words) and
+    as a hardcoded catalog entry. resolve_scenario_info consults the catalog
+    first, so in the full edition — the playtester's "default settings" — the
+    catalog entry is the one that plays, and the pack only supplies the library
+    card, rubric and safety policy. A rewrite applied to one and not the other
+    is invisible to a reader and invisible to a player of the other edition.
+    """
+    import yaml
+    from pathlib import Path
+
+    from convsim_core.scenarios import SCENARIOS
+
+    out: list[tuple[str, str]] = []
+
+    info = SCENARIOS["first_words_tutorial"]
+    out.append(("catalog opening_npc_says", info.opening_npc_says or ""))
+    out += [
+        (f"catalog player_visible_goals[{i}]", g)
+        for i, g in enumerate(info.scenario_data.player_visible_goals)
+    ]
+    out += [
+        (f"catalog event {e.id} npc_instruction", e.npc_instruction)
+        for e in (info.events or [])
+    ]
+    out.append(("catalog player_role_brief", info.scenario_data.player_role_brief))
+    npc = info.scenario_data.npc
+    out.append(("catalog npc speaking_style", npc.public_persona.speaking_style))
+    out += [
+        (f"catalog npc hidden_agenda[{i}]", a)
+        for i, a in enumerate(npc.private_persona.hidden_agenda)
+    ]
+
+    pack_yaml = (
+        Path(__file__).resolve().parents[3]
+        / "packs"
+        / "official"
+        / "first-words"
+        / "scenarios"
+        / "first_words_tutorial.yaml"
+    )
+    data = yaml.safe_load(pack_yaml.read_text(encoding="utf-8"))
+    out.append(("pack summary", data.get("summary") or ""))
+    out.append(("pack opening.npc_says", (data.get("opening") or {}).get("npc_says") or ""))
+    out += [
+        (f"pack player_visible[{i}]", g)
+        for i, g in enumerate(((data.get("goals") or {}).get("player_visible")) or [])
+    ]
+    out += [
+        (f"pack event {e.get('id')} npc_instruction", e.get("npc_instruction") or "")
+        for e in (data.get("events") or [])
+    ]
+    return out
+
+
+def _tutorial_debrief_strings() -> list[tuple[str, str]]:
+    """Every player-facing string of the tutorial's scripted debrief.
+
+    The debrief is the last screen of the first session, and it reaches the
+    player as prose — so it is tutorial copy exactly as much as the spoken
+    lines are. Left out of this sweep it kept the whole vocabulary the script
+    had dropped ("state meters", "scenario events fire at threshold
+    crossings", "the debrief rubric ... each dimension", and the raw event id
+    `warm_moment`).
+    """
+    from convsim_core.runtime.scripted import _DEBRIEF_RESPONSE as d
+
+    out = [("debrief summary", d["summary"])]
+    for field in ("strengths", "improvements", "missed_opportunities", "replay_suggestions"):
+        out += [(f"debrief {field}[{i}]", s) for i, s in enumerate(d[field])]
+    out += [
+        (f"debrief turning_points[{i}] description", tp["description"])
+        for i, tp in enumerate(d["turning_points"])
+    ]
+    return out
+
+
+def _all_tutorial_utterances() -> list[tuple[str, str]]:
+    from convsim_core.runtime.scripted import (
+        _FIRST_WORDS_SCRIPT,
+        _INTERJECTIONS,
+        _pick_ending_turn,
+    )
+
+    out = [(f"script turn {i}", t["npc_utterance"]) for i, t in enumerate(_FIRST_WORDS_SCRIPT, 1)]
+    out += [(f"interjection {sorted(k)[0]}", answer) for k, answer in _INTERJECTIONS]
+    out += [
+        (f"ending branch {text!r}", _pick_ending_turn(text)["npc_utterance"])
+        for text in ("I'm so excited!", "how does this work?", "ok")
+    ]
+    return out + _tutorial_debrief_strings() + _tutorial_scenario_strings()
+
+
+def test_the_tutorial_debrief_does_not_name_a_raw_event_id():
+    """`warm_moment` is a pack author's identifier, not a thing to show a player."""
+    offenders = [
+        where
+        for where, text in _tutorial_debrief_strings()
+        if "warm_moment" in text
+    ]
+    assert offenders == [], f"a raw identifier reaches the player in: {offenders}"
+
+
+@pytest.mark.parametrize("forbidden", _FORBIDDEN_TUTORIAL_WORDS)
+def test_tutorial_copy_avoids_simulator_jargon(forbidden):
+    offenders = [
+        where for where, text in _all_tutorial_utterances() if forbidden in text.lower()
+    ]
+    assert offenders == [], (
+        f"the tutorial must not teach the mechanics in the engine's own words; "
+        f"{forbidden!r} appears in: {offenders}"
+    )
+
+
+def test_tutorial_catalog_entry_matches_the_pack():
+    """The two definitions of the tutorial must agree on what the player gets.
+
+    The catalog entry is what plays in the full edition and the pack is what
+    plays in the demo, so a divergence means two editions run two different
+    tutorials — which is exactly what happened to the issue #501 rewrite until
+    this test existed.
+    """
+    import yaml
+    from pathlib import Path
+
+    from convsim_core.scenarios import SCENARIOS
+
+    info = SCENARIOS["first_words_tutorial"]
+    pack_yaml = (
+        Path(__file__).resolve().parents[3]
+        / "packs"
+        / "official"
+        / "first-words"
+        / "scenarios"
+        / "first_words_tutorial.yaml"
+    )
+    data = yaml.safe_load(pack_yaml.read_text(encoding="utf-8"))
+
+    def _collapse(text: str) -> str:
+        return " ".join((text or "").split())
+
+    assert info.max_turns == data["duration"]["max_turns"], (
+        "the played turn budget and the pack's must match"
+    )
+    assert (
+        info.ending_conditions["timeout"]["value"] == data["ending_conditions"]["timeout"]["value"]
+    ), "the played timeout and the pack's must match"
+    assert _collapse(info.opening_npc_says or "") == _collapse(
+        data["opening"]["npc_says"]
+    ), "the opening line the player reads differs between the two definitions"
+    assert info.scenario_data.player_visible_goals == data["goals"]["player_visible"], (
+        "the player-visible goals differ between the two definitions"
+    )
+    pack_events = {e["id"]: _collapse(e["npc_instruction"]) for e in data["events"]}
+    catalog_events = {e.id: _collapse(e.npc_instruction) for e in (info.events or [])}
+    assert catalog_events == pack_events, "the event instructions differ between the two definitions"
+
+
+def test_tutorial_copy_does_not_claim_the_player_said_something():
+    """No line may presume an engaged, positive reply it never received.
+
+    The screenshot in the issue is the script congratulating a player who had
+    asked a question.
+    """
+    presumptive = ("great! see how", "did you see that?", "that sounds like a great goal")
+    offenders = [
+        (where, phrase)
+        for where, text in _all_tutorial_utterances()
+        for phrase in presumptive
+        if phrase in text.lower()
+    ]
+    assert offenders == [], f"presumptive copy survives in: {offenders}"
diff --git a/services/convsim-core/tests/test_session_listing.py b/services/convsim-core/tests/test_session_listing.py
new file mode 100644
index 00000000..9c5d9ddd
--- /dev/null
+++ b/services/convsim-core/tests/test_session_listing.py
@@ -0,0 +1,239 @@
+# SPDX-License-Identifier: Apache-2.0
+"""GET /api/sessions — the list the resume entry point is built on (issue #501).
+
+The web client already called this endpoint (``api.listSessions``) and the
+shared ``SessionCreateResponse`` type already documented it ("Included in list
+responses (GET /api/sessions)"), but the route was never registered: the
+request answered 405, so Settings' "Your sessions" list only ever showed an
+error and nothing in the app could find a conversation to resume.
+"""
+
+# The Creator Workbench fixtures build a profile with a loadable local pack,
+# which is what makes a preview session possible at all.
+from tests.test_workbench_api import ts_client  # noqa: F401
+
+_SETUP = {
+    "scenario_id": "behavioral_interview",
+    "difficulty": "standard",
+    "player_role_name": "Test Player",
+    "save_transcript": True,
+    # Explicit model-free pin (issue #473) so no model install is needed.
+    "runtime_id": "fake",
+}
+
+
+def _create(client, **overrides) -> str:
+    resp = client.post("/api/sessions", json={**_SETUP, **overrides})
+    assert resp.status_code == 201, resp.text
+    return resp.json()["session_id"]
+
+
+def test_list_sessions_returns_200(client):
+    assert client.get("/api/sessions").status_code == 200
+
+
+def test_list_sessions_empty_profile(client):
+    assert client.get("/api/sessions").json() == {"sessions": []}
+
+
+def test_list_sessions_includes_created_session(client):
+    session_id = _create(client)
+    sessions = client.get("/api/sessions").json()["sessions"]
+    assert [s["session_id"] for s in sessions] == [session_id]
+    entry = sessions[0]
+    assert entry["scenario_id"] == "behavioral_interview"
+    assert entry["state"] == "NotStarted"
+    assert entry["turn_count"] == 0
+    assert entry["ending_type"] is None
+    assert entry["ended_at"] is None
+    # The setup is what lets the Conversation screen rehydrate a resumed
+    # session without the route state it was originally launched with.
+    assert entry["setup"]["player_role_name"] == "Test Player"
+
+
+def test_list_sessions_newest_first(client):
+    first = _create(client)
+    second = _create(client)
+    ids = [s["session_id"] for s in client.get("/api/sessions").json()["sessions"]]
+    # created_at has one-second resolution, so ordering must not depend on the
+    # two inserts landing in different seconds.
+    assert ids == [second, first]
+
+
+def test_in_progress_excludes_unstarted_sessions(client):
+    """A NotStarted session has nothing to go back to, so it is not resumable."""
+    _create(client)
+    body = client.get("/api/sessions", params={"status": "in_progress"}).json()
+    assert body["sessions"] == []
+
+
+def test_in_progress_includes_started_session(client):
+    session_id = _create(client)
+    assert client.post(f"/api/sessions/{session_id}/start").status_code == 200
+    sessions = client.get("/api/sessions", params={"status": "in_progress"}).json()["sessions"]
+    assert [s["session_id"] for s in sessions] == [session_id]
+    assert sessions[0]["state"] == "PlayerTurnListening"
+
+
+def test_in_progress_excludes_ended_session(client):
+    session_id = _create(client)
+    client.post(f"/api/sessions/{session_id}/start")
+    assert client.post(f"/api/sessions/{session_id}/end").status_code == 200
+
+    in_progress = client.get("/api/sessions", params={"status": "in_progress"}).json()
+    assert in_progress["sessions"] == []
+
+    ended = client.get("/api/sessions", params={"status": "ended"}).json()["sessions"]
+    assert [s["session_id"] for s in ended] == [session_id]
+    assert ended[0]["ending_type"] == "player_exit"
+    assert ended[0]["ended_at"] is not None
+
+
+def test_turn_count_reflects_whole_turns(client):
+    """turn_count counts player+NPC exchanges, not transcript rows (issue #501 §4)."""
+    session_id = _create(client)
+    client.post(f"/api/sessions/{session_id}/start")
+    client.post(f"/api/sessions/{session_id}/turn", json={"content": "Hello there."})
+
+    sessions = client.get("/api/sessions").json()["sessions"]
+    assert sessions[0]["turn_count"] == 1
+
+    rows = client.get(f"/api/sessions/{session_id}/transcript").json()["turns"]
+    # One opening + one player row + one NPC row = three rows for one turn.
+    assert len(rows) == 3
+
+
+def test_limit_caps_the_result(client):
+    for _ in range(3):
+        _create(client)
+    sessions = client.get("/api/sessions", params={"limit": 2}).json()["sessions"]
+    assert len(sessions) == 2
+
+
+def test_limit_out_of_range_is_rejected(client):
+    assert client.get("/api/sessions", params={"limit": 0}).status_code == 400
+    assert client.get("/api/sessions", params={"limit": 501}).status_code == 400
+
+
+def test_unknown_status_is_rejected(client):
+    assert client.get("/api/sessions", params={"status": "nonsense"}).status_code == 422
+
+
+def test_get_single_session_still_carries_setup(client):
+    """Resume after a relaunch reads the setup back from this endpoint."""
+    session_id = _create(client, show_state_meters=True, language="en")
+    body = client.get(f"/api/sessions/{session_id}").json()
+    assert body["setup"]["show_state_meters"] is True
+    assert body["setup"]["language"] == "en"
+
+
+def test_ended_includes_a_session_whose_debrief_was_generated(client):
+    """`Ended` is only the first state a finished session passes through.
+
+    Generating the debrief moves the row to DebriefReady, so a session the
+    player actually played to the end is almost never still `Ended` by the time
+    anything lists it. Matching only `Ended` left those sessions in neither
+    filter.
+    """
+    session_id = _create(client)
+    client.post(f"/api/sessions/{session_id}/start")
+    client.post(f"/api/sessions/{session_id}/turn", json={"content": "Hello there."})
+    client.post(f"/api/sessions/{session_id}/end")
+    assert client.post(f"/api/sessions/{session_id}/debrief").status_code == 200
+    assert client.get(f"/api/sessions/{session_id}").json()["state"] == "DebriefReady"
+
+    ended = client.get("/api/sessions", params={"status": "ended"}).json()["sessions"]
+    assert [s["session_id"] for s in ended] == [session_id]
+    # And it is still not offered as something to pick back up.
+    in_progress = client.get("/api/sessions", params={"status": "in_progress"}).json()
+    assert in_progress["sessions"] == []
+
+
+def test_single_session_reports_the_visible_meters(client):
+    """A resuming conversation screen reads its meters back from here.
+
+    Meter values only ever arrived with a turn, so without this a player who
+    stepped out to Settings came back to a conversation with no meters at all
+    until they sent another message (issue #501 §1 and §3).
+    """
+    session_id = _create(client)
+    client.post(f"/api/sessions/{session_id}/start")
+    client.post(f"/api/sessions/{session_id}/turn", json={"content": "Hello there."})
+
+    body = client.get(f"/api/sessions/{session_id}").json()
+    assert body["visible_state"], "expected the scenario's meter values"
+    assert all(isinstance(v, int) for v in body["visible_state"].values())
+
+
+def test_visible_meters_exclude_hidden_variables(client):
+    """Hidden state variables are hidden from the player, resume included."""
+    from convsim_core.scenario_state import build_variable_defs
+    from convsim_core.scenario_state import VariableVisibility
+
+    session_id = _create(client)
+    client.post(f"/api/sessions/{session_id}/start")
+    client.post(f"/api/sessions/{session_id}/turn", json={"content": "Hello there."})
+
+    hidden = {
+        name
+        for name, defn in build_variable_defs().items()
+        if defn.visibility == VariableVisibility.HIDDEN
+    }
+    reported = set(client.get(f"/api/sessions/{session_id}").json()["visible_state"])
+    assert reported.isdisjoint(hidden)
+
+
+def test_workbench_preview_is_never_offered_for_resume(ts_client):
+    """A pack author's preview session is not the player's conversation.
+
+    Workbench previews are written straight into `turn_sessions` under a
+    dynamic `__wbtest__<hex>` scenario id and nothing ever ends them, so left
+    in this listing one would sit at the top of the resumable set forever and
+    offer to resume a scenario that only ever existed in memory.
+    """
+    assert ts_client.post(
+        "/api/workbench/packs/local-dev/ts-pack/test-session"
+    ).status_code == 200
+
+    assert ts_client.get(
+        "/api/sessions", params={"status": "in_progress"}
+    ).json()["sessions"] == []
+    assert ts_client.get("/api/sessions").json()["sessions"] == []
+
+
+# ── The copy in TypeScript must agree with this one ──────────────────────────
+# `status=in_progress` is the filter, but it is not the only place the resumable
+# set is decided: Settings lists every unfinished conversation with its own
+# Resume button and picks them out client-side. That copy lives in
+# packages/shared so the web app and the TypeScript proxy share one list — but
+# nothing can make it import this one, and a flow state added here without being
+# added there silently loses its Resume button on the screen the lost player of
+# issue #501 was standing on.
+
+
+def _typescript_state_list(name: str) -> list[str]:
+    """The string literals in a `const <name> = [...]` block in shared's types."""
+    import re
+    from pathlib import Path
+
+    source = (
+        Path(__file__).resolve().parents[3]
+        / "packages" / "shared" / "src" / "types" / "session.ts"
+    ).read_text(encoding="utf-8")
+    match = re.search(rf"export const {name} = \[(.*?)\]", source, re.DOTALL)
+    assert match is not None, f"{name} not found in packages/shared/src/types/session.ts"
+    return re.findall(r"'([^']+)'", match.group(1))
+
+
+def test_resumable_states_match_the_typescript_copy():
+    from convsim_core.routers.sessions import RESUMABLE_FLOW_STATES
+
+    assert _typescript_state_list("RESUMABLE_SESSION_STATES") == list(
+        RESUMABLE_FLOW_STATES
+    )
+
+
+def test_ended_states_match_the_typescript_copy():
+    from convsim_core.routers.sessions import ENDED_FLOW_STATES
+
+    assert _typescript_state_list("ENDED_SESSION_STATES") == list(ENDED_FLOW_STATES)