diff --git a/e2e/helpers/probe.ts b/e2e/helpers/probe.ts
new file mode 100644
index 0000000..912facd
--- /dev/null
+++ b/e2e/helpers/probe.ts
@@ -0,0 +1,67 @@
+import { expect, Page } from '@playwright/test';
+import { probe } from './selectors';
+
+/**
+ * Probe panel call line (activities/inputs/shared/ProbePanel.vue).
+ *
+ * The student edits only the argument list between `name(` and `)`: one
+ * contenteditable #probe-args holding Python-style arguments, positional or
+ * keyword (`7`, `n=7`, `["a", "b"], prefix="x"`).
+ */
+
+/**
+ * Replace the argument list with `text` and wait until the editable holds it.
+ *
+ * Locator.fill selects the current contents and inserts the text as one input
+ * event, which a contenteditable accepts, brackets and quotes included.
+ */
+export async function fillProbeArgs(page: Page, text: string): Promise<void> {
+  const line = page.locator(probe.argsLine);
+  await line.fill(text);
+  await expect(line).toHaveJSProperty('textContent', text);
+}
+
+/** Text of the result slot after the arrow ('?' until a result). */
+export async function readProbeResult(page: Page): Promise<string> {
+  return (await page.locator(probe.result).innerText()).trim();
+}
+
+/** Text of the remaining-probe badge, e.g. '· ∞' or '· 2 left'. */
+export async function readBadge(page: Page): Promise<string> {
+  return (await page.locator(probe.badge).innerText()).trim();
+}
+
+/**
+ * Assert the error shown for one argument. `name` is a parameter name, or
+ * 'line' for a line-level error (unknown, duplicate, extra or empty argument).
+ */
+export async function expectArgError(page: Page, name: string, text: string | RegExp): Promise<void> {
+  await expect(page.locator(probe.fieldError(name))).toHaveText(text);
+}
+
+/**
+ * Assert whether the argument list can be edited. Locked means
+ * contenteditable="false" plus aria-disabled, as when probes are exhausted.
+ */
+export async function expectArgsEditable(page: Page, editable: boolean): Promise<void> {
+  const line = page.locator(probe.argsLine);
+  if (editable) {
+    // The e2e project is Chromium-only, which supports plaintext-only; the 'true'
+    // fallback for other browsers is covered in Vitest (probeArgsLine.test.ts)
+    await expect(line).toHaveAttribute('contenteditable', 'plaintext-only');
+    await expect(line).toBeEnabled();
+  } else {
+    await expect(line).toHaveAttribute('contenteditable', 'false');
+    await expect(line).toHaveAttribute('aria-disabled', 'true');
+    await expect(line).toBeDisabled();
+  }
+}
+
+/** The placeholder actually painted in the empty call line (CSS :empty::before). */
+export async function readArgsPlaceholder(page: Page): Promise<string> {
+  return page.locator(probe.argsLine).evaluate((el) => {
+    const content = getComputedStyle(el, '::before').content;
+    // 'none' when the line is not empty; otherwise a quoted CSS string
+    return content === 'none' ? '' : JSON.parse(content);
+  });
+}
diff --git a/e2e/helpers/selectors.ts b/e2e/helpers/selectors.ts
index 9190597..b2673b1 100644
--- a/e2e/helpers/selectors.ts
+++ b/e2e/helpers/selectors.ts
@@ -247,8 +247,16 @@ export const common = {
 export const probe = {
   /** Panel root */
   panel: '.probe-panel',
-  /** Input for one parameter (Enter triggers a probe) */
-  paramInput: (name: string) => `input#probe-${name}.param-input`,
+  /** Row holding the call and the History button (wraps on narrow screens) */
+  row: '.probe-panel .probe-row',
+  /** Box around the call line: `name(` + arguments + `)` (.has-error / .is-disabled) */
+  callShell: '.probe-panel .call-shell',
+  /** Editable argument list between the parentheses (Enter probes, Tab fills names) */
+  argsLine: '#probe-args',
+  /** Closing parenthesis after the argument list */
+  closeParen: '.probe-panel .call-shell .fn-paren:last-of-type',
+  /** 'Fill in argument names' button: inserts `name=, name=` */
+  fillArgsButton: 'button.fill-args-btn',
   /** Result slot ('?' until a result; .has-result / .is-cached) */
   result: '.probe-panel .fn-result',
   /** Probe button ('Probe' | 'Probing' | 'Already probed', .is-duplicate) */
@@ -263,6 +271,8 @@ export const probe = {
   fieldErrors: 'ul.probe-field-errors',
   /** One parameter's field error */
   fieldError: (name: string) => `li#probe-err-${name}`,
+  /** Line-level error (unknown keyword, duplicate/empty argument, too many arguments) */
+  lineError: 'li#probe-err-line',
   /** 'History (N)' button, rendered only when history is non-empty */
   historyButton: '.probe-panel .history-btn',
   /** History modal (teleported to body) */
diff --git a/e2e/student/probeable-budget.spec.ts b/e2e/student/probeable-budget.spec.ts
index 875c554..a15fab0 100644
--- a/e2e/student/probeable-budget.spec.ts
+++ b/e2e/student/probeable-budget.spec.ts
@@ -17,12 +17,15 @@
  *     keep their values, so the button switches to "Already probed"; the spec
  *     enters new values before it reads the badge.
  *   - A duplicate input is answered from the client-side history: no request.
+ *   - The arguments are typed into one call line (#probe-args) as `a=1, b=2`;
+ *     once probes are exhausted it is contenteditable="false" + aria-disabled.
  */
 
 import { test, expect, Page, Response } from '@playwright/test';
 import { navigateAsFreshStudent, freshStudent, injectUser, enrollUser } from '../helpers/users';
 import { submitCodeAndWait } from '../helpers/submission';
 import { probe } from '../helpers/selectors';
+import { expectArgsEditable, fillProbeArgs } from '../helpers/probe';
 
 const SET_URL = '/courses/CS101-2024/problem-set/e2e-probeable';
 const BLOCK_URL = `${SET_URL}?p=0`;
@@ -37,16 +40,16 @@ function isProbePost(resp: Response, slug: string): boolean {
   );
 }
 
-/** Wait until the probe panel and its add(a, b) inputs are on screen. */
+/** Wait until the probe panel and its add(a, b) call line are on screen. */
 async function waitForProbePanel(page: Page): Promise<void> {
   await expect(page.locator(probe.panel)).toBeVisible({ timeout: 15_000 });
-  await expect(page.locator(probe.paramInput('a'))).toBeVisible();
-  await expect(page.locator(probe.paramInput('b'))).toBeVisible();
+  await expect(page.locator('.probe-panel .fn-name')).toHaveText('add');
+  await expect(page.locator(probe.argsLine)).toBeVisible();
 }
 
+/** Type add(a=<a>, b=<b>) into the call line. */
 async function fillArgs(page: Page, a: string, b: string): Promise<void> {
-  await page.locator(probe.paramInput('a')).fill(a);
-  await page.locator(probe.paramInput('b')).fill(b);
+  await fillProbeArgs(page, `a=${a}, b=${b}`);
 }
 
 /**
@@ -128,7 +131,7 @@ test.describe('Probe budget: block mode', () => {
     await expect(page.locator(probe.result)).toHaveClass(/is-cached/);
 
     // Confirming the duplicate from the keyboard must not probe either.
-    await page.locator(probe.paramInput('b')).press('Enter');
+    await page.locator(probe.argsLine).press('Enter');
 
     // The duplicate was free: one probe is still left.
     await fillArgs(page, '3', '3');
@@ -144,8 +147,7 @@ test.describe('Probe budget: block mode', () => {
     // Exhausted state without a reload.
     await expect(page.locator(probe.hint)).toHaveText('No probes remaining.');
     await expect(page.locator(probe.button)).toBeDisabled();
-    await expect(page.locator(probe.paramInput('a'))).toBeDisabled();
-    await expect(page.locator(probe.paramInput('b'))).toBeDisabled();
+    await expectArgsEditable(page, false);
     await expect(page.locator(probe.historyButton)).toHaveText('History (3)');
 
     // Server-side state survives a fresh load (second tab, same student).
@@ -157,8 +159,7 @@ test.describe('Probe budget: block mode', () => {
       await expectBadge(freshTab, 0, 'status-exhausted');
       await expect(freshTab.locator(probe.hint)).toHaveText('No probes remaining.');
       await expect(freshTab.locator(probe.button)).toBeDisabled();
-      await expect(freshTab.locator(probe.paramInput('a'))).toBeDisabled();
-      await expect(freshTab.locator(probe.paramInput('b'))).toBeDisabled();
+      await expectArgsEditable(freshTab, false);
       await expect(freshTab.locator(probe.result)).toHaveText('6');
 
       // Earlier results stay readable from the history after exhaustion.
@@ -206,9 +207,9 @@ test.describe('Probe budget: block mode', () => {
     await expect(page.locator(probe.result)).toHaveClass(/is-cached/);
     await expect(page.locator(probe.result)).toHaveText('3');
 
-    // Enter in a parameter field is the keyboard path to "Probe". On a
+    // Enter in the call line is the keyboard path to "Probe". On a
     // duplicate it must do nothing, like the disabled button.
-    await page.locator(probe.paramInput('b')).press('Enter');
+    await page.locator(probe.argsLine).press('Enter');
 
     // Budget is server-side: a fresh load shows whether anything was spent.
     await page.reload({ waitUntil: 'networkidle' });
@@ -283,8 +284,7 @@ test.describe('Probe budget: cooldown mode', () => {
 
     await expect(page.locator(probe.hint)).toHaveText(refillHint);
     await expect(page.locator(probe.button)).toBeDisabled();
-    await expect(page.locator(probe.paramInput('a'))).toBeDisabled();
-    await expect(page.locator(probe.paramInput('b'))).toBeDisabled();
+    await expectArgsEditable(page, false);
 
     // One submission earns the refill.
     await submitCodeAndWait(page, ADD_SOLUTION);
@@ -298,8 +298,7 @@ test.describe('Probe budget: cooldown mode', () => {
       await waitForProbePanel(freshTab);
       await expectBadge(freshTab, 2, 'status-available');
       await expect(freshTab.locator(probe.hint)).toHaveCount(0);
-      await expect(freshTab.locator(probe.paramInput('a'))).toBeEnabled();
-      await expect(freshTab.locator(probe.paramInput('b'))).toBeEnabled();
+      await expectArgsEditable(freshTab, true);
     } finally {
       await freshTab.close();
     }
@@ -307,8 +306,7 @@ test.describe('Probe budget: cooldown mode', () => {
     // Without a reload, the page the student submitted from must show the
     // refilled budget too.
     await expect(page.locator(probe.hint)).toHaveCount(0);
-    await expect(page.locator(probe.paramInput('a'))).toBeEnabled();
-    await expect(page.locator(probe.paramInput('b'))).toBeEnabled();
+    await expectArgsEditable(page, true);
     await fillArgs(page, '3', '3');
     await expectBadge(page, 2, 'status-available');
 
@@ -337,21 +335,21 @@ test.describe('Probe budget: cooldown mode', () => {
     await expect(page.locator(probe.hint)).toHaveText(
       'No probes remaining. Submit 2 more times to unlock more probes.',
     );
-    await expect(page.locator(probe.paramInput('a'))).toBeDisabled();
+    await expectArgsEditable(page, false);
 
     // First submission: one more is still needed, and the budget stays empty.
     await submitCodeAndWait(page, ADD_SOLUTION);
     await expect(page.locator(probe.hint)).toHaveText(
       'No probes remaining. Submit 1 more time to unlock more probes.',
     );
-    await expect(page.locator(probe.paramInput('a'))).toBeDisabled();
+    await expectArgsEditable(page, false);
     await expect(page.locator(probe.button)).toBeDisabled();
     await expectBadge(page, 0, 'status-exhausted');
 
     // Second submission earns the refill.
     await submitCodeAndWait(page, ADD_SOLUTION);
     await expect(page.locator(probe.hint)).toHaveCount(0);
-    await expect(page.locator(probe.paramInput('a'))).toBeEnabled();
+    await expectArgsEditable(page, true);
     await fillArgs(page, '2', '2');
     await expectBadge(page, 1, 'status-available');
 
diff --git a/e2e/student/probeable-probing.spec.ts b/e2e/student/probeable-probing.spec.ts
index cd0ed0f..4aa97be 100644
--- a/e2e/student/probeable-probing.spec.ts
+++ b/e2e/student/probeable-probing.spec.ts
@@ -5,14 +5,25 @@
  *   p=2 e2e-probeable-locked  clamp(n: int) -> max(0, min(n, 10)), explore mode
  *   p=3 e2e-probeable-errors  recip(x: int) -> 10 // x, block mode, 3 probes
  *   p=4 e2e-probeable-hidden  recip(x) with the signature hidden, explore mode
+ *   p=7 e2e-probeable-list    tag(items: list[str], prefix: str), explore mode
  *
  * Probe budgets and history live in Redis per (problem, user) with no reset,
  * so every test runs as a fresh student.
+ *
+ * The probe panel is a call line: `name(` and `)` are fixed text and the
+ * student types the argument list (#probe-args), positional or keyword.
  */
 
 import { test, expect, Page, Request } from '@playwright/test';
 import { apiAsUser, navigateAsFreshStudent, FreshUser } from '../helpers/users';
 import { probe } from '../helpers/selectors';
+import {
+  expectArgError,
+  expectArgsEditable,
+  fillProbeArgs,
+  readArgsPlaceholder,
+  readBadge,
+} from '../helpers/probe';
 
 const SET_PATH = '/courses/CS101-2024/problem-set/e2e-probeable';
 const PROBE_POST_PATH = /^\/api\/problems\/[^/]+\/probe\/$/;
@@ -37,20 +48,14 @@ async function openAsFreshStudent(
 }
 
 /**
- * Fill one parameter, trigger a probe (button click or Enter in the field),
- * and return the probe response body. Fails unless the API answers 200.
+ * Type the argument list, trigger a probe (button click or Enter in the call
+ * line), and return the probe response body. Fails unless the API answers 200.
  */
-async function probeWith(
-  page: Page,
-  param: string,
-  value: string,
-  via: 'click' | 'enter' = 'click',
-): Promise<any> {
-  const input = page.locator(probe.paramInput(param));
-  await input.fill(value);
+async function probeWith(page: Page, args: string, via: 'click' | 'enter' = 'click'): Promise<any> {
+  await fillProbeArgs(page, args);
   const responsePromise = page.waitForResponse((resp) => isProbePost(resp.request()));
   if (via === 'enter') {
-    await input.press('Enter');
+    await page.locator(probe.argsLine).press('Enter');
   } else {
     await page.locator(probe.button).click();
   }
@@ -63,13 +68,17 @@ test.describe('A Probing the oracle', () => {
   test('A1 first probe shows the result, the explore badge and History (1)', async ({ page }) => {
     await openAsFreshStudent(page, 'a1-first-probe', 2, 'clamp');
 
-    const input = page.locator(probe.paramInput('n'));
+    const line = page.locator(probe.argsLine);
     const result = page.locator(probe.result);
     const button = page.locator(probe.button);
 
-    // Fresh state: empty input, no result, no history, unlimited badge
-    await expect(input).toHaveValue('');
-    await expect(input).toHaveAttribute('placeholder', 'int');
+    // Fresh state: empty call line showing the parameter name and its declared
+    // type (the signature is visible here; A10 covers names only), no result,
+    // no history, unlimited badge
+    await expect(line).toHaveJSProperty('textContent', '');
+    await expect(line).toHaveAttribute('role', 'textbox');
+    await expect(line).toHaveAttribute('aria-label', 'Arguments for clamp');
+    expect(await readArgsPlaceholder(page)).toBe('n: int');
     await expect(result).toHaveText('?');
     await expect(result).not.toHaveClass(/has-result/);
     await expect(page.locator(probe.historyButton)).toHaveCount(0);
@@ -78,7 +87,7 @@ test.describe('A Probing the oracle', () => {
     // No value yet: nothing to probe
     await expect(button).toBeDisabled();
 
-    const body = await probeWith(page, 'n', '7');
+    const body = await probeWith(page, '7');
     expect(body.success).toBe(true);
     expect(body.result).toBe(7);
     expect(body.probe_status.mode).toBe('explore');
@@ -89,7 +98,7 @@ test.describe('A Probing the oracle', () => {
     await expect(page.locator(probe.error)).toHaveCount(0);
 
     // A new value brings the Probe button back with the unlimited badge
-    await input.fill('8');
+    await fillProbeArgs(page, '8');
     await expect(button).toBeEnabled();
     await expect(page.locator(probe.badge)).toHaveText('· ∞');
   });
@@ -97,12 +106,12 @@ test.describe('A Probing the oracle', () => {
   test('A2 repeat probe with a new input (Enter key) replaces the result', async ({ page }) => {
     await openAsFreshStudent(page, 'a2-repeat-probe', 2, 'clamp');
 
-    await probeWith(page, 'n', '7');
+    await probeWith(page, '7');
     await expect(page.locator(probe.result)).toHaveText('7');
     await expect(page.locator(probe.historyButton)).toHaveText('History (1)');
 
-    // Enter in the field triggers the probe
-    const body = await probeWith(page, 'n', '20', 'enter');
+    // Enter in the call line triggers the probe
+    const body = await probeWith(page, '20', 'enter');
     expect(body.success).toBe(true);
     expect(body.result).toBe(10);
 
@@ -113,8 +122,8 @@ test.describe('A Probing the oracle', () => {
   test('A3 duplicate probe returns the cached result without a request', async ({ page }) => {
     await openAsFreshStudent(page, 'a3-duplicate-probe', 2, 'clamp');
 
-    await probeWith(page, 'n', '7');
-    await probeWith(page, 'n', '20');
+    await probeWith(page, '7');
+    await probeWith(page, '20');
     await expect(page.locator(probe.result)).toHaveText('10');
     await expect(page.locator(probe.historyButton)).toHaveText('History (2)');
 
@@ -125,11 +134,11 @@ test.describe('A Probing the oracle', () => {
       }
     });
 
-    const input = page.locator(probe.paramInput('n'));
+    const line = page.locator(probe.argsLine);
     const result = page.locator(probe.result);
     const button = page.locator(probe.button);
 
-    await input.fill('7');
+    await fillProbeArgs(page, '7');
     await expect(result).toHaveClass(/is-cached/);
     await expect(result).toHaveText('7');
     await expect(button).toHaveClass(/is-duplicate/);
@@ -137,12 +146,12 @@ test.describe('A Probing the oracle', () => {
     await expect(button).toBeDisabled();
     await expect(page.locator(probe.badge)).toHaveCount(0);
 
-    // Enter in the field is the other way to probe; it must not re-send either
-    await input.press('Enter');
+    // Enter in the call line is the other way to probe; it must not re-send either
+    await line.press('Enter');
 
     // A real probe afterwards orders the request stream: if the duplicate had
     // been sent, it would be recorded before this one.
-    const body = await probeWith(page, 'n', '3');
+    const body = await probeWith(page, '3');
     expect(body.result).toBe(3);
     expect(probePosts).toEqual([JSON.stringify({ input: { n: 3 } })]);
     await expect(page.locator(probe.historyButton)).toHaveText('History (3)');
@@ -158,25 +167,27 @@ test.describe('A Probing the oracle', () => {
       }
     });
 
-    const input = page.locator(probe.paramInput('n'));
+    const line = page.locator(probe.argsLine);
+    const shell = page.locator(probe.callShell);
     const button = page.locator(probe.button);
     const fieldError = page.locator(probe.fieldError('n'));
 
-    await input.fill('abc');
-    await expect(fieldError).toHaveText('n: Must be a whole number (e.g. 5)');
-    await expect(input).toHaveClass(/has-error/);
-    await expect(input).toHaveAttribute('aria-invalid', 'true');
-    await expect(input).toHaveAttribute('aria-describedby', 'probe-err-n');
+    await fillProbeArgs(page, 'abc');
+    await expectArgError(page, 'n', 'n: Must be a whole number (e.g. 5)');
+    await expect(shell).toHaveClass(/has-error/);
+    await expect(line).toHaveAttribute('aria-invalid', 'true');
+    await expect(line).toHaveAttribute('aria-describedby', 'probe-field-errors probe-args-help');
     await expect(button).toBeDisabled();
     // Enter with an invalid value sends nothing
-    await input.press('Enter');
+    await line.press('Enter');
 
-    await input.fill('3');
+    await fillProbeArgs(page, '3');
     await expect(fieldError).toHaveCount(0);
-    await expect(input).not.toHaveClass(/has-error/);
+    await expect(shell).not.toHaveClass(/has-error/);
+    await expect(line).not.toHaveAttribute('aria-invalid', 'true');
     await expect(button).toBeEnabled();
 
-    const body = await probeWith(page, 'n', '3');
+    const body = await probeWith(page, '3');
     expect(body.result).toBe(3);
     expect(probePosts).toBe(1);
     await expect(page.locator(probe.result)).toHaveText('3');
@@ -185,9 +196,9 @@ test.describe('A Probing the oracle', () => {
   test('A5 history modal lists every probe, most recent first, and closes', async ({ page }) => {
     await openAsFreshStudent(page, 'a5-history-modal', 2, 'clamp');
 
-    await probeWith(page, 'n', '7');
-    await probeWith(page, 'n', '20');
-    await probeWith(page, 'n', '-3');
+    await probeWith(page, '7');
+    await probeWith(page, '20');
+    await probeWith(page, '-3');
     await expect(page.locator(probe.result)).toHaveText('0');
 
     const historyButton = page.locator(probe.historyButton);
@@ -212,8 +223,8 @@ test.describe('A Probing the oracle', () => {
   test('A6 reload restores the probe history from the server', async ({ page }) => {
     const user = await openAsFreshStudent(page, 'a6-reload', 2, 'clamp');
 
-    await probeWith(page, 'n', '7');
-    await probeWith(page, 'n', '20');
+    await probeWith(page, '7');
+    await probeWith(page, '20');
     await expect(page.locator(probe.historyButton)).toHaveText('History (2)');
 
     const server = await apiAsUser(
@@ -237,10 +248,10 @@ test.describe('A Probing the oracle', () => {
     await historyLoaded;
     await expect(page.locator(probe.panel)).toBeVisible();
 
-    // Both probes restored from the server, the latest result shown, inputs cleared
+    // Both probes restored from the server, the latest result shown, call line cleared
     await expect(page.locator(probe.historyButton)).toHaveText('History (2)');
     await expect(page.locator(probe.result)).toHaveText('10');
-    await expect(page.locator(probe.paramInput('n'))).toHaveValue('');
+    await expect(page.locator(probe.argsLine)).toHaveJSProperty('textContent', '');
     await expect(page.locator(probe.badge)).toHaveText('· ∞');
 
     await page.locator(probe.historyButton).click();
@@ -250,7 +261,7 @@ test.describe('A Probing the oracle', () => {
     await page.locator(probe.close).click();
 
     // Re-entering a value probed before the reload is still recognised
-    await page.locator(probe.paramInput('n')).fill('7');
+    await fillProbeArgs(page, '7');
     await expect(page.locator(probe.result)).toHaveClass(/is-cached/);
     await expect(page.locator(probe.result)).toHaveText('7');
     await expect(page.locator(probe.button)).toContainText('Already probed');
@@ -264,7 +275,7 @@ test.describe('A Probing the oracle', () => {
     await expect(badge).toHaveClass(/status-explore/);
 
     for (let n = 1; n <= 15; n += 1) {
-      const body = await probeWith(page, 'n', String(n));
+      const body = await probeWith(page, String(n));
       expect(body.success).toBe(true);
       expect(body.result).toBe(Math.min(n, 10));
       expect(body.probe_status.mode).toBe('explore');
@@ -274,15 +285,14 @@ test.describe('A Probing the oracle', () => {
 
     await expect(page.locator(probe.historyButton)).toHaveText('History (15)');
 
-    const input = page.locator(probe.paramInput('n'));
-    await input.fill('16');
-    await expect(input).toBeEnabled();
+    await fillProbeArgs(page, '16');
+    await expectArgsEditable(page, true);
     await expect(page.locator(probe.button)).toBeEnabled();
     await expect(badge).toHaveText('· ∞');
     await expect(badge).toHaveClass(/status-explore/);
     await expect(page.locator(probe.hint)).toHaveCount(0);
 
-    const body = await probeWith(page, 'n', '16');
+    const body = await probeWith(page, '16');
     expect(body.success).toBe(true);
     expect(body.result).toBe(10);
     await expect(page.locator(probe.historyButton)).toHaveText('History (16)');
@@ -291,10 +301,10 @@ test.describe('A Probing the oracle', () => {
   test('A10 hidden signature hides types and sanitises oracle errors', async ({ page }) => {
     const user = await openAsFreshStudent(page, 'a10-hidden', 4, 'recip');
 
-    const input = page.locator(probe.paramInput('x'));
-    await expect(page.locator('.probe-panel .param-name')).toHaveText(['x']);
-    await expect(input).toHaveAttribute('placeholder', 'value — quote text: "abc"');
-    await expect(input).toHaveAttribute('aria-label', 'Enter value for x');
+    // Parameter names are not secret: the empty call line still shows them
+    const line = page.locator(probe.argsLine);
+    expect(await readArgsPlaceholder(page)).toBe('x');
+    await expect(line).toHaveAttribute('aria-label', 'Arguments for recip');
 
     // The types never reach the browser: the problem payload the page loads
     // carries no signature, untyped parameters and no oracle source.
@@ -307,15 +317,28 @@ test.describe('A Probing the oracle', () => {
     expect(hidden.reference_solution).toBeNull();
     await expect(page.locator(probe.badge)).toHaveText('· ∞');
 
-    const failed = await probeWith(page, 'x', '0');
-    expect(failed.success).toBe(false);
+    // Without the types the browser cannot pre-check 'abc', so only the backend
+    // can reject it: a 400 (not charged) whose generic message reaches the UI
     const error = page.locator(probe.error);
+    await fillProbeArgs(page, 'abc');
+    await expect(page.locator(probe.fieldError('x'))).toHaveCount(0);
+    const rejectedPromise = page.waitForResponse((resp) => isProbePost(resp.request()));
+    await page.locator(probe.button).click();
+    const rejected = await rejectedPromise;
+    expect(rejected.status()).toBe(400);
+    await expect(error).toHaveText("That value is not valid for parameter 'x'");
+    await expect(error).not.toContainText('int');
+    await expect(page.locator(probe.historyButton)).toHaveCount(0);
+    await expect(page.locator(probe.badge)).toHaveText('· ∞');
+
+    const failed = await probeWith(page, '0');
+    expect(failed.success).toBe(false);
     await expect(error).toHaveText('These inputs could not be evaluated. Try different values.');
     await expect(error).not.toContainText('division');
     await expect(page.locator(probe.result)).toHaveText('?');
     await expect(page.locator(probe.historyButton)).toHaveCount(0);
 
-    const ok = await probeWith(page, 'x', '5');
+    const ok = await probeWith(page, '5');
     expect(ok.success).toBe(true);
     expect(ok.result).toBe(2);
     await expect(page.locator(probe.result)).toHaveText('2');
@@ -330,7 +353,7 @@ test.describe('A Probing the oracle', () => {
     await expect(badge).toHaveText('· 3 left');
     await expect(badge).toHaveClass(/status-available/);
 
-    const failed = await probeWith(page, 'x', '0');
+    const failed = await probeWith(page, '0');
     expect(failed.success).toBe(false);
     expect(failed.probe_status.remaining).toBe(3);
     // Exactly the exception text, nothing else (no traceback, no type name).
@@ -344,7 +367,7 @@ test.describe('A Probing the oracle', () => {
     await expect(page.locator(probe.result)).toHaveText('?');
     await expect(page.locator(probe.historyButton)).toHaveCount(0);
 
-    const ok = await probeWith(page, 'x', '5');
+    const ok = await probeWith(page, '5');
     expect(ok.success).toBe(true);
     expect(ok.result).toBe(2);
     expect(ok.probe_status.remaining).toBe(2);
@@ -352,10 +375,244 @@ test.describe('A Probing the oracle', () => {
     await expect(page.locator(probe.error)).toHaveCount(0);
     await expect(page.locator(probe.historyButton)).toHaveText('History (1)');
 
-    // The input still holds the probed value (duplicate state hides the badge);
-    // a new value shows the charged budget
-    await page.locator(probe.paramInput('x')).fill('6');
+    // The call line still holds the probed value (duplicate state hides the
+    // badge); a new value shows the charged budget
+    await fillProbeArgs(page, '6');
     await expect(badge).toHaveText('· 2 left');
     await expect(badge).toHaveClass(/status-available/);
   });
+
+  test('A12 list[str] given integers shows the item-type error and disables Probe', async ({
+    page,
+  }) => {
+    await openAsFreshStudent(page, 'a12-list-items', 7, 'tag');
+
+    const probePosts: string[] = [];
+    page.on('request', (req) => {
+      if (isProbePost(req)) {
+        probePosts.push(req.postData() ?? '');
+      }
+    });
+
+    const line = page.locator(probe.argsLine);
+    const button = page.locator(probe.button);
+
+    // Integers are not str: the item type is checked, not just the list shape
+    await fillProbeArgs(page, '[1, 2, 3], "x"');
+    await expectArgError(page, 'items', 'items: Every item must be str');
+    await expect(page.locator(probe.fieldError('prefix'))).toHaveCount(0);
+    await expect(page.locator(probe.callShell)).toHaveClass(/has-error/);
+    await expect(button).toBeDisabled();
+    // Enter with an invalid value sends nothing
+    await line.press('Enter');
+
+    await fillProbeArgs(page, '["a", "b"], "x"');
+    await expect(page.locator(`${probe.fieldErrors} li`)).toHaveCount(0);
+    await expect(button).toBeEnabled();
+    await expect.poll(() => readBadge(page)).toBe('· ∞');
+
+    const body = await probeWith(page, '["a", "b"], "x"');
+    expect(body.success).toBe(true);
+    expect(body.result).toEqual(['xa', 'xb']);
+    await expect(page.locator(probe.result)).toHaveText('["xa","xb"]');
+    expect(probePosts).toEqual([JSON.stringify({ input: { items: ['a', 'b'], prefix: 'x' } })]);
+  });
+
+  test('A13 keyword and positional arguments map onto the signature', async ({ page }) => {
+    await openAsFreshStudent(page, 'a13-arg-mapping', 2, 'clamp');
+
+    const probePosts: string[] = [];
+    page.on('request', (req) => {
+      if (isProbePost(req)) {
+        probePosts.push(req.postData() ?? '');
+      }
+    });
+
+    const result = page.locator(probe.result);
+    const button = page.locator(probe.button);
+    const lineError = page.locator(probe.lineError);
+
+    // Positional: the first argument is n
+    const body = await probeWith(page, '7');
+    expect(body.result).toBe(7);
+    await expect(result).toHaveText('7');
+
+    // Keyword: n=7 is the same call, so the cached result answers it
+    await fillProbeArgs(page, 'n=7');
+    await expect(lineError).toHaveCount(0);
+    await expect(result).toHaveClass(/is-cached/);
+    await expect(result).toHaveText('7');
+    await expect(button).toContainText('Already probed');
+
+    await fillProbeArgs(page, 'n=7, n=8');
+    await expectArgError(page, 'line', 'Argument n given twice');
+    await expect(page.locator(probe.callShell)).toHaveClass(/has-error/);
+    await expect(button).toBeDisabled();
+
+    await fillProbeArgs(page, 'm=7');
+    await expectArgError(page, 'line', 'Unknown argument m');
+    await expect(button).toBeDisabled();
+
+    await fillProbeArgs(page, '7, 8');
+    await expectArgError(page, 'line', 'Too many arguments for clamp');
+    await expect(button).toBeDisabled();
+
+    // A clean line clears the line error
+    await fillProbeArgs(page, 'n=8');
+    await expect(lineError).toHaveCount(0);
+    await expect(button).toBeEnabled();
+
+    // Only the one positional probe reached the server, as {"n": 7}
+    expect(probePosts).toEqual([JSON.stringify({ input: { n: 7 } })]);
+  });
+
+  test('A14 Tab on an empty line fills in the argument names', async ({ page }) => {
+    await openAsFreshStudent(page, 'a14-tab-template', 7, 'tag');
+
+    const line = page.locator(probe.argsLine);
+    await expect(line).toHaveJSProperty('textContent', '');
+    await line.focus();
+    await page.keyboard.press('Tab');
+
+    await expect(line).toHaveJSProperty('textContent', 'items=, prefix=');
+    await expect(line).toBeFocused();
+    // The caret sits right after the first '=', collapsed
+    const caret = await line.evaluate((el) => {
+      const selection = window.getSelection();
+      if (!selection || selection.rangeCount === 0) {
+        return null;
+      }
+      const range = selection.getRangeAt(0);
+      const before = document.createRange();
+      before.selectNodeContents(el);
+      before.setEnd(range.startContainer, range.startOffset);
+      return {
+        inside: el.contains(range.startContainer),
+        collapsed: range.collapsed,
+        offset: before.toString().length,
+      };
+    });
+    expect(caret).toEqual({ inside: true, collapsed: true, offset: 'items='.length });
+
+    // Typing continues from the caret
+    await page.keyboard.type('["a", "b"]');
+    await expect(line).toHaveJSProperty('textContent', 'items=["a", "b"], prefix=');
+    await page.keyboard.press('End');
+    await page.keyboard.type('"x"');
+    await expect(line).toHaveJSProperty('textContent', 'items=["a", "b"], prefix="x"');
+    // Shift+Enter inserts nothing: the call is one logical line
+    await page.keyboard.press('Shift+Enter');
+    await expect(line).toHaveJSProperty('textContent', 'items=["a", "b"], prefix="x"');
+    await expect(line).toBeFocused();
+
+    const responsePromise = page.waitForResponse((resp) => isProbePost(resp.request()));
+    await page.keyboard.press('Enter');
+    const response = await responsePromise;
+    expect(response.status()).toBe(200);
+    expect(response.request().postData()).toBe(
+      JSON.stringify({ input: { items: ['a', 'b'], prefix: 'x' } }),
+    );
+    await expect(page.locator(probe.result)).toHaveText('["xa","xb"]');
+    // Enter probes; it never adds a line break
+    await expect(line).toHaveJSProperty('textContent', 'items=["a", "b"], prefix="x"');
+    // Focus comes back to the line, so the next probe needs no Tab back
+    await expect(line).toBeFocused();
+    await expect(line).toHaveAttribute('contenteditable', 'plaintext-only');
+
+    // Tab on a non-empty line is ordinary focus navigation: it leaves the line
+    // and changes nothing, so the editable is never a keyboard trap
+    await page.keyboard.press('Tab');
+    await expect(line).not.toBeFocused();
+    await expect(line).toHaveJSProperty('textContent', 'items=["a", "b"], prefix="x"');
+  });
+
+  test('A15 the closing parenthesis trails the arguments', async ({ page }) => {
+    await openAsFreshStudent(page, 'a15-close-paren', 7, 'tag');
+
+    const words = Array.from({ length: 40 }, (_, i) => `"word${String(i).padStart(2, '0')}"`);
+    const args = `[${words.join(', ')}], "x"`;
+    await fillProbeArgs(page, args);
+    await expect(page.locator(probe.button)).toBeEnabled();
+
+    const line = page.locator(probe.argsLine);
+    const lineRects = await line.evaluate((el) =>
+      Array.from(el.getClientRects()).map((r) => ({
+        top: r.top,
+        bottom: r.bottom,
+        right: r.right,
+      })),
+    );
+    // The long argument list wraps over several lines
+    expect(lineRects.length).toBeGreaterThan(1);
+    const last = lineRects[lineRects.length - 1];
+
+    const paren = await page.locator(probe.closeParen).boundingBox();
+    expect(paren).not.toBeNull();
+    await expect(page.locator(probe.closeParen)).toHaveText(')');
+    // ')' sits on the editable's last line, right after its last character
+    const parenMiddle = paren!.y + paren!.height / 2;
+    expect(parenMiddle).toBeGreaterThan(last.top);
+    expect(parenMiddle).toBeLessThan(last.bottom);
+    expect(paren!.x).toBeGreaterThanOrEqual(last.right - 1);
+  });
+
+  test('A16 the backend rejects a list[str] with integers too', async ({ page }) => {
+    const user = await openAsFreshStudent(page, 'a16-backend-list', 7, 'tag');
+
+    const { status, data } = await apiAsUser(
+      page,
+      user,
+      'POST',
+      '/api/problems/e2e-probeable-list/probe/',
+      { input: { items: [1, 2], prefix: 'x' } },
+    );
+    expect(status).toBe(400);
+    expect(data.error).toBe("Parameter 'items' must be a list of str");
+  });
+
+  test('A17 a quoted str argument is a Python string literal', async ({ page }) => {
+    await openAsFreshStudent(page, 'a17-str-quotes', 7, 'tag');
+
+    const probePosts: string[] = [];
+    page.on('request', (req) => {
+      if (isProbePost(req)) {
+        probePosts.push(req.postData() ?? '');
+      }
+    });
+    const button = page.locator(probe.button);
+
+    // An unterminated quote is not a string: error, and Probe stays disabled
+    await fillProbeArgs(page, `['a'], "abc`);
+    await expectArgError(page, 'prefix', 'prefix: Not a valid Python value');
+    await expect(button).toBeDisabled();
+    await page.locator(probe.argsLine).press('Enter');
+
+    // An empty argument between commas is a line error, not a skipped parameter
+    await fillProbeArgs(page, `['a'],, 'x'`);
+    await expectArgError(page, 'line', 'Empty argument between commas');
+    await expect(button).toBeDisabled();
+
+    // Single quotes delimit the str exactly as double quotes do
+    const body = await probeWith(page, `['a', 'b'], 'x'`, 'enter');
+    expect(body.success).toBe(true);
+    expect(body.result).toEqual(['xa', 'xb']);
+    await expect(page.locator(probe.result)).toHaveText('["xa","xb"]');
+    expect(probePosts).toEqual([JSON.stringify({ input: { items: ['a', 'b'], prefix: 'x' } })]);
+  });
+
+  test('A18 on a narrow screen History wraps below the call line', async ({ page }) => {
+    await page.setViewportSize({ width: 320, height: 800 });
+    await openAsFreshStudent(page, 'a18-narrow', 7, 'tag');
+
+    await probeWith(page, '["a"], "x"');
+    await expect(page.locator(probe.historyButton)).toHaveText('History (1)');
+
+    const row = await page.locator(probe.row).boundingBox();
+    const shell = await page.locator(probe.callShell).boundingBox();
+    const history = await page.locator(probe.historyButton).boundingBox();
+    expect(row && shell && history).toBeTruthy();
+    // The call line gets the full row width; History sits on a line of its own
+    expect(shell!.width).toBeGreaterThanOrEqual(row!.width - 1);
+    expect(history!.y).toBeGreaterThanOrEqual(shell!.y + shell!.height);
+  });
 });
diff --git a/e2e/student/probeable-spec.spec.ts b/e2e/student/probeable-spec.spec.ts
index 63d38e2..3d3f353 100644
--- a/e2e/student/probeable-spec.spec.ts
+++ b/e2e/student/probeable-spec.spec.ts
@@ -23,6 +23,7 @@
 import { test, expect, Page } from '@playwright/test';
 import { setAceEditorValue } from '../helpers/ace-editor';
 import { probe, feedback, problemSet } from '../helpers/selectors';
+import { fillProbeArgs } from '../helpers/probe';
 import {
   FreshUser,
   apiAsUser,
@@ -64,9 +65,9 @@ async function openSpecProblem(
   return user;
 }
 
-/** Probe square(x=value) and wait for the oracle response. */
+/** Probe square(value) through the call line and wait for the oracle response. */
 async function probeX(page: Page, value: string): Promise<void> {
-  await page.locator(probe.paramInput('x')).fill(value);
+  await fillProbeArgs(page, value);
   const button = page.locator(probe.button);
   await expect(button).toBeEnabled();
   const responsePromise = page.waitForResponse(
@@ -110,13 +111,13 @@ test.describe('C24 Probeable Spec', () => {
     await probeX(page, '-2');
     await expect(page.locator(probe.result)).toHaveText('4');
     await expect(page.locator(probe.historyButton)).toHaveText('History (2)');
-    // The input still holds the last probed value, so the button reports it
+    // The call line still holds the last probed value, so the button reports it
     // as already probed (no badge while duplicate).
     await expect(page.locator(probe.button)).toHaveText(/Already probed/);
     await expect(page.locator(probe.button)).toHaveClass(/is-duplicate/);
     await expect(page.locator(probe.button)).toBeDisabled();
     // A new value re-enables probing; explore mode keeps the badge unlimited.
-    await page.locator(probe.paramInput('x')).fill('7');
+    await fillProbeArgs(page, 'x=7');
     await expect(page.locator(probe.button)).toBeEnabled();
     await expect(page.locator(probe.badge)).toHaveText('· ∞');
     await expect(page.locator(probe.badge)).toHaveClass(/status-explore/);
diff --git a/e2e/student/submission-probeable.spec.ts b/e2e/student/submission-probeable.spec.ts
index ce3df4e..039363c 100644
--- a/e2e/student/submission-probeable.spec.ts
+++ b/e2e/student/submission-probeable.spec.ts
@@ -41,6 +41,7 @@ import { apiAs } from '../helpers/api';
 import { apiAsUser, enrollUser, freshStudent, injectUser, navigateAsFreshStudent } from '../helpers/users';
 import { submitCodeAndWait } from '../helpers/submission';
 import { codeFeedback, probe } from '../helpers/selectors';
+import { expectArgError, expectArgsEditable, fillProbeArgs } from '../helpers/probe';
 
 const PROBEABLE_PATH = '/courses/CS101-2024/problem-set/e2e-code?p=1';
 const TYPED_PROBEABLE_PATH = '/courses/CS101-2024/problem-set/e2e-code?p=2';
@@ -160,7 +161,6 @@ test.describe('Probeable Code Submission', () => {
     await expect(page.locator(probe.historyButton)).toHaveCount(0);
 
     // e2e-probeable-code-1 has signature: mystery(lst: list[int]) -> list[int]
-    const lstInput = page.locator(probe.paramInput('lst'));
     const probeBtn = page.locator(probe.button);
     const probes: Array<[string, number[]]> = [
       ['[3, 1, 2]', [1, 2, 3]],
@@ -168,7 +168,7 @@ test.describe('Probeable Code Submission', () => {
     ];
 
     for (const [value, expected] of probes) {
-      await lstInput.fill(value);
+      await fillProbeArgs(page, value);
       await expect(probeBtn).toBeEnabled();
       const responsePromise = page.waitForResponse(
         (resp) =>
@@ -207,22 +207,22 @@ test.describe('Probe Input Type Validation', () => {
     await waitForProbeableInput(page);
 
     // e2e-probeable-code-typed has signature: double(n: int) -> int
-    const nInput = page.locator(probe.paramInput('n'));
-    await expect(nInput).toBeVisible();
-    await expect(nInput).toBeEnabled();
+    await expect(page.locator(probe.argsLine)).toBeVisible();
+    await expectArgsEditable(page, true);
 
     const fieldErrors = page.locator(probe.fieldErrors);
+    const callShell = page.locator(probe.callShell);
     const probeBtn = page.locator(probe.button);
 
-    await nInput.fill('abc');
+    await fillProbeArgs(page, 'abc');
     await expect(fieldErrors).toBeVisible();
-    await expect(page.locator(probe.fieldError('n'))).toHaveText('n: Must be a whole number (e.g. 5)');
-    await expect(nInput).toHaveClass(/has-error/);
+    await expectArgError(page, 'n', 'n: Must be a whole number (e.g. 5)');
+    await expect(callShell).toHaveClass(/has-error/);
     await expect(probeBtn).toBeDisabled();
 
-    await nInput.fill('5');
+    await fillProbeArgs(page, '5');
     await expect(fieldErrors).toBeHidden();
-    await expect(nInput).not.toHaveClass(/has-error/);
+    await expect(callShell).not.toHaveClass(/has-error/);
     await expect(probeBtn).toBeEnabled();
   });
 });
diff --git a/purplex/client/src/components/activities/inputs/ProbeableCodeInput.vue b/purplex/client/src/components/activities/inputs/ProbeableCodeInput.vue
index bf01991..21ea9b6 100644
--- a/purplex/client/src/components/activities/inputs/ProbeableCodeInput.vue
+++ b/purplex/client/src/components/activities/inputs/ProbeableCodeInput.vue
@@ -19,7 +19,9 @@
       :probe-count-display="probeCountDisplay"
       :probe-status-text="probeStatusHint"
       :probe-params="parameters"
-      :probe-inputs="probeInputs"
+      :args-line="argsLine"
+      :args-template="argsTemplate"
+      :line-error="lineError"
       :can-probe="canProbe"
       :is-executing="probing"
       :has-valid-inputs="hasValidInputs"
@@ -31,7 +33,7 @@
       :format-function-call="formatFunctionCall"
       :format-output="formatOutput"
       @execute-probe="executeProbe"
-      @update-input="updateProbeInput"
+      @update-args="setArgsLine"
     />
 
     <!-- Divider between probe and editor -->
@@ -140,7 +142,7 @@ const {
   probing,
   probeError,
   probeHistory,
-  probeInputs,
+  argsLine,
   functionName,
   parameters,
   canProbe,
@@ -149,12 +151,14 @@ const {
   probeStatusClass,
   hasValidInputs,
   inputErrors,
+  lineError,
+  argsTemplate,
   isDuplicate,
   cachedResult,
   executeProbe,
   formatFunctionCall,
   formatOutput,
-  updateProbeInput,
+  setArgsLine,
 } = useProbeState(() => props.problem, { isSubmitting: () => props.disabled })
 
 const { t } = useI18n()
diff --git a/purplex/client/src/components/activities/inputs/ProbeableSpecInput.vue b/purplex/client/src/components/activities/inputs/ProbeableSpecInput.vue
index b2503e3..b59e111 100644
--- a/purplex/client/src/components/activities/inputs/ProbeableSpecInput.vue
+++ b/purplex/client/src/components/activities/inputs/ProbeableSpecInput.vue
@@ -19,7 +19,9 @@
       :probe-count-display="probeCountDisplay"
       :probe-status-text="probeStatusHint"
       :probe-params="parameters"
-      :probe-inputs="probeInputs"
+      :args-line="argsLine"
+      :args-template="argsTemplate"
+      :line-error="lineError"
       :can-probe="canProbe"
       :is-executing="probing"
       :has-valid-inputs="hasValidInputs"
@@ -31,7 +33,7 @@
       :format-function-call="formatFunctionCall"
       :format-output="formatOutput"
       @execute-probe="executeProbe"
-      @update-input="updateProbeInput"
+      @update-args="setArgsLine"
     />
 
     <!-- NL Description Input -->
@@ -142,7 +144,7 @@ const {
   probing,
   probeError,
   probeHistory,
-  probeInputs,
+  argsLine,
   functionName,
   parameters,
   canProbe,
@@ -151,12 +153,14 @@ const {
   probeStatusClass,
   hasValidInputs,
   inputErrors,
+  lineError,
+  argsTemplate,
   isDuplicate,
   cachedResult,
   executeProbe,
   formatFunctionCall,
   formatOutput,
-  updateProbeInput,
+  setArgsLine,
 } = useProbeState(() => props.problem, { isSubmitting: () => props.disabled })
 
 const { t } = useI18n()
diff --git a/purplex/client/src/components/activities/inputs/shared/ProbePanel.vue b/purplex/client/src/components/activities/inputs/shared/ProbePanel.vue
index 2687eaf..e67a4ee 100644
--- a/purplex/client/src/components/activities/inputs/shared/ProbePanel.vue
+++ b/purplex/client/src/components/activities/inputs/shared/ProbePanel.vue
@@ -3,36 +3,35 @@
     <div class="probe-input-wrapper">
       <div class="probe-row">
         <div class="probe-call">
-          <span class="fn-name">{{ functionName }}</span>
-          <span class="fn-paren">(</span>
-          <template
-            v-for="(param, i) in probeParams"
-            :key="param.name"
+          <!-- Call line: only the argument list between the parentheses is editable -->
+          <!-- Whitespace between these spans contains newlines, so Vue drops it -->
+          <div
+            class="call-shell"
+            :class="{ 'has-error': hasErrors, 'is-disabled': !editable }"
+            @click="focusArgs"
           >
+            <span class="fn-name">{{ functionName }}</span>
+            <span class="fn-paren">(</span>
             <span
-              v-if="i > 0"
-              class="fn-comma"
-            >, </span>
-            <span class="param-name">{{ param.name }}</span>
-            <span class="param-eq">=</span>
-            <input
-              :id="`probe-${param.name}`"
-              :value="probeInputs[param.name]"
-              type="text"
-              class="param-input"
-              :class="{ 'has-error': !!inputErrors[param.name] }"
-              :placeholder="param.type || $t('problems.probe.valuePlaceholderHint')"
-              :aria-label="param.type
-                ? $t('problems.probe.paramAriaLabel', { name: param.name, type: param.type })
-                : $t('problems.probe.paramAriaLabelNoType', { name: param.name })"
-              :aria-invalid="inputErrors[param.name] ? 'true' : undefined"
-              :aria-describedby="inputErrors[param.name] ? `probe-err-${param.name}` : undefined"
-              :disabled="!canProbe || isExecuting"
-              @input="$emit('update-input', param.name, ($event.target as HTMLInputElement).value)"
-              @keydown.enter="!isExecuting && canProbe && hasValidInputs && !isDuplicate && $emit('execute-probe')"
-            >
-          </template>
-          <span class="fn-paren">)</span>
+              id="probe-args"
+              ref="argsRef"
+              class="call-args"
+              :contenteditable="editable ? EDITABLE_MODE : 'false'"
+              role="textbox"
+              aria-multiline="false"
+              spellcheck="false"
+              :data-placeholder="argsPlaceholder"
+              :aria-placeholder="argsPlaceholder"
+              :aria-label="$t('problems.probe.argsAriaLabel', { name: functionName })"
+              :aria-disabled="editable ? undefined : 'true'"
+              :aria-invalid="hasErrors ? 'true' : undefined"
+              :aria-describedby="hasErrors ? 'probe-field-errors probe-args-help' : 'probe-args-help'"
+              @input="onArgsInput"
+              @keydown="onArgsKeydown"
+              @paste="onArgsPaste"
+            />
+            <span class="fn-paren">)</span>
+          </div>
           <span class="fn-arrow">→</span>
           <span
             class="fn-result"
@@ -57,11 +56,28 @@
         </button>
       </div>
 
-      <!-- Per-field type errors -->
+      <button
+        v-if="argsTemplate"
+        type="button"
+        class="fill-args-btn"
+        :disabled="!editable"
+        @click="fillArgs"
+      >
+        {{ $t('problems.probe.fillArgs') }}
+      </button>
+
+      <!-- Line-level and per-parameter errors -->
       <ul
+        id="probe-field-errors"
         class="probe-field-errors"
         aria-live="polite"
       >
+        <li
+          v-if="lineError"
+          id="probe-err-line"
+        >
+          {{ lineError }}
+        </li>
         <li
           v-for="(message, name) in inputErrors"
           :id="`probe-err-${name}`"
@@ -102,6 +118,14 @@
         </template>
       </button>
 
+      <!-- Keyboard instructions for the call line (visually hidden, via aria-describedby) -->
+      <div
+        id="probe-args-help"
+        class="sr-only"
+      >
+        {{ $t('problems.probe.argsHelp') }}
+      </div>
+
       <!-- Screen reader announcement (visually hidden) -->
       <div
         class="sr-only"
@@ -174,10 +198,11 @@
 </template>
 
 <script setup lang="ts">
-import { computed, ref, watch } from 'vue'
+import { computed, nextTick, onMounted, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import type { ProbeHistoryEntry, ProbeParameter } from '../../types'
 import { useFocusTrap } from '@/composables/useFocusTrap'
+import { stableStringify } from './probeArgs'
 
 const { t } = useI18n()
 
@@ -187,7 +212,9 @@ interface Props {
   probeCountDisplay: string
   probeStatusText?: string
   probeParams: ProbeParameter[]
-  probeInputs: Record<string, string>
+  argsLine: string
+  argsTemplate: string
+  lineError: string | null
   canProbe: boolean
   isExecuting: boolean
   hasValidInputs: boolean
@@ -202,11 +229,175 @@ interface Props {
 
 const props = defineProps<Props>()
 
-defineEmits<{
+const emit = defineEmits<{
   (e: 'execute-probe'): void
-  (e: 'update-input', paramName: string, value: string): void
+  (e: 'update-args', text: string): void
 }>()
 
+/** 'plaintext-only' where supported; older browsers reject it and get plain 'true'. */
+function detectEditableMode(): 'plaintext-only' | 'true' {
+  try {
+    const probe = document.createElement('span')
+    probe.contentEditable = 'plaintext-only'
+    return probe.contentEditable === 'plaintext-only' ? 'plaintext-only' : 'true'
+  } catch {
+    return 'true'
+  }
+}
+
+const EDITABLE_MODE = detectEditableMode()
+
+const argsRef = ref<HTMLElement | null>(null)
+
+const editable = computed(() => props.canProbe && !props.isExecuting)
+const hasErrors = computed(() => !!props.lineError || Object.keys(props.inputErrors).length > 0)
+// Parameter names are not secret, so they show even when the signature is hidden
+// Types show only when the signature is visible: the backend sends '' otherwise
+const argsPlaceholder = computed(() =>
+  props.probeParams.map(p => (p.type ? `${p.name}: ${p.type}` : p.name)).join(', ')
+)
+
+// Keep the DOM in step when the line changes from outside (e.g. reset on a new
+// problem); while typing the two already match, so the caret is left alone.
+watch(
+  () => props.argsLine,
+  (line) => {
+    const el = argsRef.value
+    if (el && (el.textContent ?? '') !== line) {
+      el.textContent = line
+    }
+  },
+)
+
+// The line is not editable while a probe runs, which drops focus; give it back
+// afterwards so a keyboard user can keep probing with Enter. This watcher runs
+// before the DOM update, so focus is still on the line when a probe starts.
+let argsFocusedBeforeProbe = false
+watch(
+  () => props.isExecuting,
+  (executing) => {
+    if (executing) {
+      argsFocusedBeforeProbe = !!argsRef.value && document.activeElement === argsRef.value
+      return
+    }
+    if (!argsFocusedBeforeProbe) {
+      return
+    }
+    argsFocusedBeforeProbe = false
+    nextTick(() => {
+      const el = argsRef.value
+      if (el && editable.value) {
+        el.focus()
+        placeCaret(el, null)
+      }
+    })
+  },
+)
+
+onMounted(() => {
+  if (argsRef.value && props.argsLine) {
+    argsRef.value.textContent = props.argsLine
+  }
+})
+
+function emitArgs() {
+  const el = argsRef.value
+  if (!el) {
+    return
+  }
+  const text = el.textContent ?? ''
+  // A browser may leave a stray <br> once emptied; clear it so :empty shows the placeholder
+  if (text === '' && el.childNodes.length > 0) {
+    el.replaceChildren()
+  }
+  emit('update-args', text)
+}
+
+function onArgsInput() {
+  emitArgs()
+}
+
+function placeCaret(el: HTMLElement, offset: number | null) {
+  const selection = window.getSelection()
+  if (!selection) {
+    return
+  }
+  const range = document.createRange()
+  const textNode = el.firstChild
+  if (offset !== null && textNode?.nodeType === Node.TEXT_NODE) {
+    range.setStart(textNode, Math.min(offset, textNode.textContent?.length ?? 0))
+    range.collapse(true)
+  } else {
+    range.selectNodeContents(el)
+    range.collapse(false)
+  }
+  selection.removeAllRanges()
+  selection.addRange(range)
+}
+
+/** Insert `name=, name=, ...` with the caret after the first `=`. */
+function fillArgs() {
+  const el = argsRef.value
+  if (!el || !editable.value || !props.argsTemplate) {
+    return
+  }
+  el.textContent = props.argsTemplate
+  emitArgs()
+  el.focus()
+  placeCaret(el, props.argsTemplate.indexOf('=') + 1)
+}
+
+function focusArgs(event: MouseEvent) {
+  const el = argsRef.value
+  if (el && editable.value && event.target !== el) {
+    el.focus()
+    placeCaret(el, null)
+  }
+}
+
+function onArgsKeydown(event: KeyboardEvent) {
+  if (event.key === 'Enter') {
+    // One logical line: Enter probes, Shift+Enter does nothing
+    event.preventDefault()
+    if (!event.shiftKey && !props.isExecuting && props.canProbe && props.hasValidInputs && !props.isDuplicate) {
+      emit('execute-probe')
+    }
+    return
+  }
+  if (event.key === 'Tab' && !event.shiftKey && (argsRef.value?.textContent ?? '').trim() === '' && props.argsTemplate) {
+    event.preventDefault()
+    fillArgs()
+  }
+}
+
+/** Paste as plain text on one line, for browsers that ignore plaintext-only. */
+function onArgsPaste(event: ClipboardEvent) {
+  event.preventDefault()
+  const text = (event.clipboardData?.getData('text/plain') ?? '').replace(/\r?\n/g, ' ')
+  if (!text) {
+    return
+  }
+  // execCommand keeps the native undo stack; it is deprecated but still the only way to
+  // do that, so fall back to a Selection edit where it is unsupported
+  if (document.execCommand?.('insertText', false, text)) {
+    return
+  }
+  const selection = window.getSelection()
+  if (!selection || selection.rangeCount === 0) {
+    return
+  }
+  const range = selection.getRangeAt(0)
+  range.deleteContents()
+  const node = document.createTextNode(text)
+  range.insertNode(node)
+  range.setStartAfter(node)
+  range.collapse(true)
+  selection.removeAllRanges()
+  selection.addRange(range)
+  argsRef.value?.normalize()
+  emitArgs()
+}
+
 const showModal = ref(false)
 const showResultFlash = ref(false)
 
@@ -217,7 +408,7 @@ const { modalContentRef } = useFocusTrap(showModal)
 const uniqueHistory = computed(() => {
   const seen = new Set<string>()
   return props.probeHistory.filter(entry => {
-    const key = JSON.stringify(entry.input)
+    const key = stableStringify(entry.input)
     if (seen.has(key)) {return false}
     seen.add(key)
     return true
@@ -296,9 +487,11 @@ watch(() => props.probeHistory.length, () => {
   border-color: var(--color-primary-gradient-start);
 }
 
-/* Row containing probe-call and history button */
+/* Row containing probe-call and history button; wraps so a narrow screen
+   gives the call line the full width */
 .probe-row {
   display: flex;
+  flex-wrap: wrap;
   align-items: center;
   justify-content: space-between;
   gap: var(--spacing-md);
@@ -312,7 +505,9 @@ watch(() => props.probeHistory.length, () => {
   font-size: var(--font-size-base);
   color: var(--color-text-primary);
   flex-wrap: wrap;
-  flex: 1;
+
+  /* A real basis (not 0) so the history button wraps below on narrow screens */
+  flex: 1 1 16rem;
   min-width: 0;
 }
 
@@ -348,60 +543,101 @@ watch(() => props.probeHistory.length, () => {
   font-weight: 600;
 }
 
-.fn-paren,
-.fn-comma {
-  color: var(--color-text-muted);
-}
-
-.param-name {
-  color: var(--color-text-secondary);
-}
-
-.param-eq {
+.fn-paren {
   color: var(--color-text-muted);
-  margin: 0 2px;
+  font-weight: 400;
 }
 
-.param-input {
-  width: 72px;
-  height: 28px;
-  padding: 0 var(--spacing-sm);
+/* Call line: inline flow, so the closing paren trails the last argument character */
+.call-shell {
+  flex: 1 1 16rem;
+  min-width: 0;
+  min-height: 32px;
+  padding: var(--spacing-xs) var(--spacing-sm);
   background: var(--color-bg-input);
   border: 1px solid var(--color-bg-border);
   border-radius: var(--radius-sm);
-  color: var(--color-text-primary);
-  font-family: var(--font-family-mono);
+  font-family: var(--font-family-mono, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace);
   font-size: var(--font-size-sm);
-  text-align: center;
+  line-height: 1.6;
+  text-align: left;
+  overflow-wrap: anywhere;
+  cursor: text;
   transition: border-color 0.2s ease, box-shadow 0.2s ease;
 }
 
-.param-input::placeholder {
-  color: var(--color-text-muted);
-  opacity: 0.5;
-  font-size: var(--font-size-xs);
+.call-shell .fn-name,
+.call-shell .fn-paren {
+  user-select: none;
 }
 
-.param-input:focus {
-  outline: none;
+.call-shell:focus-within {
   border-color: var(--color-primary);
   box-shadow: 0 0 0 2px var(--color-primary-overlay);
 }
 
-.param-input.has-error {
-  border-color: var(--color-error);
+/* Forced-colors mode drops box-shadow and recolours borders: keep a visible focus ring */
+@media (forced-colors: active) {
+  .call-shell:focus-within {
+    outline: 2px solid CanvasText;
+    outline-offset: 2px;
+  }
 }
 
-.param-input.has-error:focus {
+.call-shell.has-error {
   border-color: var(--color-error);
+}
+
+.call-shell.has-error:focus-within {
   box-shadow: 0 0 0 2px var(--color-error-overlay);
 }
 
-.param-input:disabled {
+.call-shell.is-disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.call-args {
+  padding: 0 2px;
+  color: var(--color-text-primary);
+  white-space: pre-wrap;
+  outline: none;
+}
+
+.call-args:empty::before {
+  content: attr(data-placeholder);
+  color: var(--color-text-muted);
+  pointer-events: none;
+}
+
+.fill-args-btn {
+  display: block;
+  margin-top: var(--spacing-xs);
+  padding: 2px var(--spacing-sm);
+  background: var(--color-bg-hover);
+  border: 1px solid var(--color-bg-border);
+  border-radius: var(--radius-sm);
+  color: var(--color-text-secondary);
+  font-size: var(--font-size-xs);
+  cursor: pointer;
+  transition: border-color 0.2s ease, color 0.2s ease;
+}
+
+.fill-args-btn:focus-visible {
+  outline: 2px solid var(--color-primary-gradient-start);
+  outline-offset: 2px;
+}
+
+.fill-args-btn:disabled {
   opacity: 0.5;
   cursor: not-allowed;
 }
 
+.fill-args-btn:hover:not(:disabled) {
+  border-color: var(--color-primary-gradient-start);
+  color: var(--color-text-primary);
+}
+
 .fn-arrow {
   color: var(--color-text-muted);
   margin: 0 var(--spacing-sm);
diff --git a/purplex/client/src/components/activities/inputs/shared/__tests__/parseInputValue.test.ts b/purplex/client/src/components/activities/inputs/shared/__tests__/parseInputValue.test.ts
index 05c00ca..d7c038c 100644
--- a/purplex/client/src/components/activities/inputs/shared/__tests__/parseInputValue.test.ts
+++ b/purplex/client/src/components/activities/inputs/shared/__tests__/parseInputValue.test.ts
@@ -2,7 +2,13 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import { nextTick } from 'vue'
 import { flushPromises } from '@vue/test-utils'
 import axios from 'axios'
-import { normalizePrimitiveType, parseInputValue, useProbeState } from '../useProbeState'
+import {
+  normalizeContainerType,
+  normalizePrimitiveType,
+  parseInputValue,
+  parseSignatureParams,
+} from '../probeArgs'
+import { useProbeState } from '../useProbeState'
 import type { ActivityProblem } from '../../../types'
 import { withSetup } from '@/test/setup'
 
@@ -28,7 +34,8 @@ const EXPECTED: Record<string, Record<(typeof INPUTS)[number], unknown>> = {
     '5': '5',
     abc: 'abc',
     '"abc"': 'abc',
-    "'abc'": "'abc'",
+    // A quoted str is a Python string literal, single or double quotes alike
+    "'abc'": 'abc',
     True: 'True',
     None: 'None',
     '1.5': '1.5',
@@ -58,7 +65,8 @@ const EXPECTED: Record<string, Record<(typeof INPUTS)[number], unknown>> = {
     '5': 5,
     abc: 'abc',
     '"abc"': 'abc',
-    "'abc'": "'abc'",
+    // Untyped values are Python literals, so single quotes delimit a string
+    "'abc'": 'abc',
     True: true,
     None: null,
     '1.5': 1.5,
@@ -145,19 +153,180 @@ describe('parseInputValue', () => {
     expect(parseInputValue('', 'str')).toEqual({ value: '', error: null })
   })
 
-  it('keeps malformed quoted strings as raw text', () => {
-    expect(parseInputValue('"a" + "b"', 'str')).toEqual({ value: '"a" + "b"', error: null })
+  it('rejects quoted str text that is not one string literal', () => {
+    for (const text of ['"a" + "b"', '"abc', "'abc", `'it's'`, '"x" 1']) {
+      expect(parseInputValue(text, 'str')).toEqual({ value: text, error: 'literal' })
+    }
+  })
+
+  it('unquotes single- and double-quoted str literals, escapes included', () => {
+    expect(parseInputValue("'x'", 'str')).toEqual({ value: 'x', error: null })
+    expect(parseInputValue(`"it's"`, 'str')).toEqual({ value: "it's", error: null })
+    expect(parseInputValue(`'a\\'b'`, 'str')).toEqual({ value: "a'b", error: null })
+    expect(parseInputValue("''", 'str')).toEqual({ value: '', error: null })
+    // Unquoted text is still taken as typed, quotes inside included
+    expect(parseInputValue(`it's`, 'str')).toEqual({ value: "it's", error: null })
   })
 
-  it('does not check unknown or compound types', () => {
-    for (const type of ['Any', 'list', 'list[int]', 'Optional[int]', 'dict', 'MyClass']) {
+  it('decodes Python octal and \\U escapes, and rejects \\N{...}', () => {
+    expect(parseInputValue(`"\\012"`, 'str')).toEqual({ value: '\n', error: null })
+    expect(parseInputValue(`"\\0"`, 'str')).toEqual({ value: '\0', error: null })
+    expect(parseInputValue(`"\\1019"`, 'str')).toEqual({ value: 'A9', error: null })
+    expect(parseInputValue(`"\\U0001F600"`, 'str')).toEqual({ value: '\u{1F600}', error: null })
+    expect(parseInputValue(`["\\x41\\u0042"]`, 'list[str]')).toEqual({ value: ['AB'], error: null })
+    expect(parseInputValue(`["\\N{EM DASH}"]`, 'list[str]').error).toBe('list')
+    expect(parseInputValue(`["\\U00110000"]`, 'list[str]').error).toBe('list')
+  })
+
+  it('does not check unknown types, Optionals or unions', () => {
+    for (const type of ['Any', 'Optional[int]', 'Optional[list[int]]', 'list[int] | None', 'list[int] = None', 'MyClass']) {
       expect(normalizePrimitiveType(type)).toBeNull()
+      expect(normalizeContainerType(type)).toBeNull()
       expect(parseInputValue('abc', type)).toEqual({ value: 'abc', error: null })
     }
     expect(parseInputValue('False', 'Any')).toEqual({ value: false, error: null })
   })
 })
 
+describe('parseInputValue container types', () => {
+  it('rejects integers in a list[str] (the item type is checked)', () => {
+    expect(parseInputValue('[1, 2]', 'list[str]')).toEqual({
+      value: '[1, 2]',
+      error: 'listItems',
+      errorParams: { kind: 'str' },
+    })
+    expect(parseInputValue('["a", 2]', 'list[str]').error).toBe('listItems')
+    expect(parseInputValue(`['a', "b"]`, 'list[str]')).toEqual({ value: ['a', 'b'], error: null })
+  })
+
+  it('does not accept a bool or a float literal as an int item', () => {
+    expect(parseInputValue('[1, True]', 'list[int]').error).toBe('listItems')
+    expect(parseInputValue('[1, 2.0]', 'list[int]').error).toBe('listItems')
+    expect(parseInputValue('[1, -2, +3]', 'list[int]')).toEqual({ value: [1, -2, 3], error: null })
+  })
+
+  it('accepts int items for float, as the backend does', () => {
+    expect(parseInputValue('[1, 2.5, .5]', 'list[float]')).toEqual({ value: [1, 2.5, 0.5], error: null })
+    expect(parseInputValue('[True]', 'list[float]').error).toBe('listItems')
+  })
+
+  it('accepts Python literals: tuples, trailing commas, True/False/None', () => {
+    expect(parseInputValue('(1, 2)', 'list[int]')).toEqual({ value: [1, 2], error: null })
+    expect(parseInputValue('[1, 2,]', 'list[int]')).toEqual({ value: [1, 2], error: null })
+    expect(parseInputValue('(5,)', 'tuple[int, ...]')).toEqual({ value: [5], error: null })
+    expect(parseInputValue('{3, 1}', 'set[int]')).toEqual({ value: [3, 1], error: null })
+    expect(parseInputValue('[True, False]', 'List[bool]')).toEqual({ value: [true, false], error: null })
+    expect(parseInputValue('[None, "x", 1]', 'list')).toEqual({ value: [null, 'x', 1], error: null })
+  })
+
+  it('requires a list shape for list, tuple and set types', () => {
+    for (const type of ['list', 'list[int]', 'tuple', 'set[str]', 'tuple[int, str]']) {
+      expect(parseInputValue('abc', type).error).toBe('list')
+      expect(parseInputValue('{"a": 1}', type).error).toBe('list')
+      expect(parseInputValue('[1, 2', type).error).toBe('list')
+      expect(parseInputValue('5', type).error).toBe('list')
+    }
+  })
+
+  it('checks dict keys and values', () => {
+    expect(parseInputValue(`{'a': 1, "b": 2,}`, 'dict[str, int]')).toEqual({ value: { a: 1, b: 2 }, error: null })
+    expect(parseInputValue(`{'a': 'x'}`, 'Dict[str, int]')).toEqual({
+      value: `{'a': 'x'}`,
+      error: 'dictItems',
+      errorParams: { key: 'str', value: 'int' },
+    })
+    expect(parseInputValue('{1: 2}', 'dict[str, int]').error).toBe('dictItems')
+    expect(parseInputValue('{1: "a"}', 'dict[int, str]')).toEqual({ value: { 1: 'a' }, error: null })
+    expect(parseInputValue('{}', 'dict[str, int]')).toEqual({ value: {}, error: null })
+  })
+
+  it('requires a dict shape for dict types', () => {
+    for (const type of ['dict', 'dict[str, int]']) {
+      expect(parseInputValue('[1]', type).error).toBe('dict')
+      expect(parseInputValue('abc', type).error).toBe('dict')
+      expect(parseInputValue('{1, 2}', type).error).toBe('dict')
+    }
+    expect(parseInputValue(`{'a': [1, 'x']}`, 'dict')).toEqual({ value: { a: [1, 'x'] }, error: null })
+  })
+
+  it('checks only the outer shape of nested containers', () => {
+    expect(parseInputValue('[[1], ["a"]]', 'list[list[int]]')).toEqual({ value: [[1], ['a']], error: null })
+    expect(parseInputValue('[1]', 'dict[str, list[int]]').error).toBe('dict')
+    expect(parseInputValue(`{'a': 'x'}`, 'dict[str, list[int]]')).toEqual({ value: { a: 'x' }, error: null })
+  })
+
+  it('refuses ints too large for JSON inside a container', () => {
+    expect(parseInputValue('[12345678901234567891]', 'list[int]').error).toBe('intRange')
+  })
+
+  it('keeps a "__proto__" key as plain data', () => {
+    const { value } = parseInputValue('{"__proto__": 1}', 'dict[str, int]')
+    expect(Object.keys(value as object)).toEqual(['__proto__'])
+    expect(Object.getPrototypeOf(value)).toBe(Object.prototype)
+  })
+})
+
+describe('parseInputValue untyped literals', () => {
+  it('rejects text that starts like a literal but does not parse', () => {
+    for (const raw of ['[1, 2', '(1, 2', '{"a": 1', '"abc', "'abc", '[1 2]', '[1,, 2]']) {
+      expect(parseInputValue(raw, '')).toEqual({ value: raw, error: 'literal' })
+    }
+  })
+
+  it('parses Python literals and keeps other text as a string', () => {
+    expect(parseInputValue('[True, None, \'x\']', 'Any')).toEqual({ value: [true, null, 'x'], error: null })
+    expect(parseInputValue('(1,)', '')).toEqual({ value: [1], error: null })
+    expect(parseInputValue('(1)', '')).toEqual({ value: 1, error: null })
+    expect(parseInputValue(`'it\\'s'`, '')).toEqual({ value: "it's", error: null })
+    expect(parseInputValue('"tab\\there"', '')).toEqual({ value: 'tab\there', error: null })
+    expect(parseInputValue('hello world', '')).toEqual({ value: 'hello world', error: null })
+    expect(parseInputValue('0x10', '')).toEqual({ value: '0x10', error: null })
+  })
+})
+
+describe('normalizeContainerType', () => {
+  it('recognises one-level containers and their primitive items', () => {
+    expect(normalizeContainerType('list[str]')).toEqual({ container: 'list', item: 'str' })
+    expect(normalizeContainerType('Tuple[Integer, ...]')).toEqual({ container: 'list', item: 'int' })
+    expect(normalizeContainerType('tuple[int, str]')).toEqual({ container: 'list', item: null })
+    expect(normalizeContainerType('set')).toEqual({ container: 'list', item: null })
+    expect(normalizeContainerType('list[Any] = []')).toEqual({ container: 'list', item: null })
+    expect(normalizeContainerType('dict[str, int]')).toMatchObject({ container: 'dict', key: 'str', value: 'int' })
+    expect(normalizeContainerType('dict')).toMatchObject({ container: 'dict', key: null, value: null })
+  })
+
+  it('returns null for non-containers', () => {
+    for (const type of ['int', 'str', 'Any', 'listing', 'Optional[list[int]]', 'dict[str, int] | None']) {
+      expect(normalizeContainerType(type)).toBeNull()
+    }
+  })
+})
+
+describe('parseSignatureParams', () => {
+  it('keeps bracketed types and defaults as one parameter (#160)', () => {
+    expect(
+      parseSignatureParams(
+        `def schedule(tasks: list[str], weights: dict[str, int], pair: tuple[int, str] = (1, "a,b"), opts={'k': 1}) -> int`
+      )
+    ).toEqual([
+      { name: 'tasks', type: 'list[str]' },
+      { name: 'weights', type: 'dict[str, int]' },
+      { name: 'pair', type: 'tuple[int, str] = (1, "a,b")' },
+      { name: 'opts', type: 'Any' },
+    ])
+  })
+
+  it('handles empty and trailing-comma parameter lists', () => {
+    expect(parseSignatureParams('def f() -> int')).toEqual([])
+    expect(parseSignatureParams('def f(x: int,) -> int')).toEqual([{ name: 'x', type: 'int' }])
+    expect(parseSignatureParams('no parens')).toEqual([])
+    expect(parseSignatureParams(`def f(open: str = '(', x: int) -> int`)).toEqual([
+      { name: 'open', type: "str = '('" },
+      { name: 'x', type: 'int' },
+    ])
+  })
+})
+
 describe('normalizePrimitiveType', () => {
   it('maps the alias table to canonical types', () => {
     expect(normalizePrimitiveType('int')).toBe('int')
@@ -195,12 +364,12 @@ describe('useProbeState input validation', () => {
   it('flags a non-integer value for an int parameter and clears once fixed', async () => {
     const state = setup('def f(x: int) -> int')
 
-    state.updateProbeInput('x', 'abc')
+    state.setArgsLine('abc')
     await nextTick()
     expect(state.hasValidInputs.value).toBe(false)
     expect(state.inputErrors.value.x).toBe('Must be a whole number (e.g. 5)')
 
-    state.updateProbeInput('x', '5')
+    state.setArgsLine('5')
     await nextTick()
     expect(state.hasValidInputs.value).toBe(true)
     expect(state.inputErrors.value).toEqual({})
@@ -220,17 +389,29 @@ describe('useProbeState input validation', () => {
     ])
   })
 
+  it('translates container errors with their expected kinds', () => {
+    const state = setup('def f(tasks: list[str], weights: dict[str, int]) -> int')
+    state.setArgsLine('[1, 2], [1]')
+    expect(state.inputErrors.value).toEqual({
+      tasks: 'Every item must be str',
+      weights: 'Must be a dict, e.g. {"a": 1}',
+    })
+    state.setArgsLine(`[1, 2], {'a': 'b'}`)
+    expect(state.inputErrors.value.weights).toBe('Keys must be str and values int')
+    expect(state.hasValidInputs.value).toBe(false)
+  })
+
   it('posts only type-valid, parsed inputs', async () => {
     vi.mocked(axios.post).mockResolvedValue({ data: { success: true, result: 10 } })
     const state = setup('def f(x: int) -> int')
     await flushPromises()
     expect(state.canProbe.value).toBe(true)
 
-    state.updateProbeInput('x', 'abc')
+    state.setArgsLine('abc')
     await state.executeProbe()
     expect(axios.post).not.toHaveBeenCalled()
 
-    state.updateProbeInput('x', '5')
+    state.setArgsLine('5')
     await state.executeProbe()
     expect(axios.post).toHaveBeenCalledWith('/api/problems/typed-probe/probe/', { input: { x: 5 } })
   })
diff --git a/purplex/client/src/components/activities/inputs/shared/__tests__/probeArgsLine.test.ts b/purplex/client/src/components/activities/inputs/shared/__tests__/probeArgsLine.test.ts
new file mode 100644
index 0000000..d9e3c2b
--- /dev/null
+++ b/purplex/client/src/components/activities/inputs/shared/__tests__/probeArgsLine.test.ts
@@ -0,0 +1,484 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { nextTick } from 'vue'
+import { flushPromises, mount } from '@vue/test-utils'
+import axios from 'axios'
+import { parseArgsLine, splitTopLevel, stableStringify } from '../probeArgs'
+import { useProbeState } from '../useProbeState'
+import ProbePanel from '../ProbePanel.vue'
+import type { ActivityProblem } from '../../../types'
+import { withSetup } from '@/test/setup'
+
+vi.mock('axios')
+
+afterEach(() => {
+  vi.clearAllMocks()
+})
+
+const PARAMS = ['tasks', 'start', 'label']
+
+describe('splitTopLevel', () => {
+  it('ignores commas nested in brackets or inside strings', () => {
+    expect(splitTopLevel(`[1, 2], (3, 4), {'a': 1, 'b': 2}, "x, y", 'p\\', q'`)).toEqual([
+      '[1, 2]',
+      ' (3, 4)',
+      ` {'a': 1, 'b': 2}`,
+      ' "x, y"',
+      ` 'p\\', q'`,
+    ])
+  })
+})
+
+describe('stableStringify', () => {
+  it('ignores object key order at every level but keeps list order', () => {
+    expect(stableStringify({ b: 2, a: { d: 1, c: [2, 1] } })).toBe(stableStringify({ a: { c: [2, 1], d: 1 }, b: 2 }))
+    expect(stableStringify([1, 2])).not.toBe(stableStringify([2, 1]))
+  })
+})
+
+describe('parseArgsLine', () => {
+  it('maps positional arguments in signature order', () => {
+    expect(parseArgsLine('["a", "b"], 9, "ci"', PARAMS)).toEqual({
+      raw: { tasks: '["a", "b"]', start: '9', label: '"ci"' },
+      lineError: null,
+    })
+  })
+
+  it('maps keyword arguments by name, in any order', () => {
+    expect(parseArgsLine('label="ci", tasks=[1, 2], start = 9', PARAMS)).toEqual({
+      raw: { tasks: '[1, 2]', start: '9', label: '"ci"' },
+      lineError: null,
+    })
+  })
+
+  it('mixes positional and keyword arguments, keyword first included', () => {
+    expect(parseArgsLine('[1], label="x", 3', PARAMS).raw).toEqual({ tasks: '[1]', start: '3', label: '"x"' })
+    expect(parseArgsLine('label="x", [1], 3', PARAMS)).toEqual({
+      raw: { tasks: '[1]', start: '3', label: '"x"' },
+      lineError: null,
+    })
+  })
+
+  it('keeps commas inside brackets and strings within one argument', () => {
+    expect(parseArgsLine(`{'a': 1, 'b': 2}, (1, 2), "x, y=3"`, PARAMS).raw).toEqual({
+      tasks: `{'a': 1, 'b': 2}`,
+      start: '(1, 2)',
+      label: '"x, y=3"',
+    })
+  })
+
+  it('does not treat == or a string containing = as a keyword', () => {
+    expect(parseArgsLine('x == 1, "a=b"', PARAMS).raw).toEqual({ tasks: 'x == 1', start: '"a=b"', label: '' })
+  })
+
+  it('allows a trailing comma', () => {
+    expect(parseArgsLine('[1], 2, "z",', PARAMS)).toEqual({
+      raw: { tasks: '[1]', start: '2', label: '"z"' },
+      lineError: null,
+    })
+  })
+
+  it('reports an unknown keyword', () => {
+    expect(parseArgsLine('[1], stop=3', PARAMS).lineError).toEqual({ code: 'unknownKeyword', name: 'stop' })
+  })
+
+  it('reports an argument given twice, by keyword or by position', () => {
+    expect(parseArgsLine('start=1, start=2', PARAMS).lineError).toEqual({ code: 'duplicateArgument', name: 'start' })
+    expect(parseArgsLine('1, tasks=[2]', PARAMS).lineError).toEqual({ code: 'duplicateArgument', name: 'tasks' })
+  })
+
+  it('reports a positional argument whose slot a keyword already took', () => {
+    expect(parseArgsLine('tasks=[1], [2]', PARAMS).lineError).toEqual({
+      code: 'positionalAfterKeyword',
+      name: 'tasks',
+    })
+    expect(parseArgsLine('x=1, 2', ['x', 'y']).lineError).toEqual({ code: 'positionalAfterKeyword', name: 'x' })
+    // A keyword for a later parameter leaves the earlier slots to positionals
+    expect(parseArgsLine('label="c", [1], 2', PARAMS)).toEqual({
+      raw: { tasks: '[1]', start: '2', label: '"c"' },
+      lineError: null,
+    })
+  })
+
+  it('accepts non-ASCII parameter names as keywords', () => {
+    expect(parseArgsLine('número=1', ['número'])).toEqual({ raw: { número: '1' }, lineError: null })
+    expect(parseArgsLine('café = 2', ['x', 'café']).raw).toEqual({ x: '', café: '2' })
+  })
+
+  it('reports too many positional arguments', () => {
+    expect(parseArgsLine('1, 2, 3, 4', PARAMS)).toEqual({
+      raw: { tasks: '1', start: '2', label: '3' },
+      lineError: { code: 'tooManyPositional', name: '' },
+    })
+  })
+
+  it('reports an empty argument between commas without using a slot', () => {
+    expect(parseArgsLine('1,,2', PARAMS)).toEqual({
+      raw: { tasks: '1', start: '2', label: '' },
+      lineError: { code: 'emptyArgument', name: '' },
+    })
+    expect(parseArgsLine('1, ,2', ['x', 'y']).lineError).toEqual({ code: 'emptyArgument', name: '' })
+    expect(parseArgsLine(',1', ['x']).lineError).toEqual({ code: 'emptyArgument', name: '' })
+  })
+
+  it('maps empty text to empty values with no error', () => {
+    for (const text of ['', '   ']) {
+      expect(parseArgsLine(text, PARAMS)).toEqual({
+        raw: { tasks: '', start: '', label: '' },
+        lineError: null,
+      })
+    }
+  })
+
+  it('leaves the values of the template empty', () => {
+    expect(parseArgsLine('tasks=, start=, label=', PARAMS)).toEqual({
+      raw: { tasks: '', start: '', label: '' },
+      lineError: null,
+    })
+  })
+})
+
+describe('useProbeState call line', () => {
+  function setup(signature: string) {
+    vi.mocked(axios.get).mockResolvedValue({ data: { can_probe: true, mode: 'explore' } })
+    const problem = {
+      slug: 'line-probe',
+      function_name: 'schedule',
+      probe_config: { function_signature: signature, function_name: 'schedule' },
+    } as unknown as ActivityProblem
+    return withSetup(() => useProbeState(problem))
+  }
+
+  it('builds the keyword template from the parameters', () => {
+    const state = setup('def schedule(tasks: list[str], start: int) -> int')
+    expect(state.argsTemplate.value).toBe('tasks=, start=')
+  })
+
+  it('posts the parsed values of a valid line', async () => {
+    vi.mocked(axios.post).mockResolvedValue({ data: { success: true, result: 3 } })
+    const state = setup('def schedule(tasks: list[str], start: int) -> int')
+    await flushPromises()
+
+    state.setArgsLine(`['a', "b"], start=9`)
+    await nextTick()
+    expect(state.argsLine.value).toBe(`['a', "b"], start=9`)
+    expect(state.probeInputs).toEqual({ tasks: `['a', "b"]`, start: '9' })
+    expect(state.hasValidInputs.value).toBe(true)
+
+    await state.executeProbe()
+    expect(axios.post).toHaveBeenCalledWith('/api/problems/line-probe/probe/', {
+      input: { tasks: ['a', 'b'], start: 9 },
+    })
+  })
+
+  it('posts a single-quoted str argument without its quotes', async () => {
+    vi.mocked(axios.post).mockResolvedValue({ data: { success: true, result: ['xa'] } })
+    const state = setup('def schedule(tasks: list[str], prefix: str) -> list[str]')
+    await flushPromises()
+    state.setArgsLine(`['a'], 'x'`)
+    expect(state.hasValidInputs.value).toBe(true)
+    await state.executeProbe()
+    expect(axios.post).toHaveBeenCalledWith('/api/problems/line-probe/probe/', {
+      input: { tasks: ['a'], prefix: 'x' },
+    })
+  })
+
+  it('blocks an unterminated str literal with a per-parameter error', async () => {
+    const state = setup('def schedule(tasks: list[str], prefix: str) -> list[str]')
+    await flushPromises()
+    state.setArgsLine(`['a'], "abc`)
+    expect(state.inputErrors.value).toEqual({ prefix: 'Not a valid Python value' })
+    expect(state.hasValidInputs.value).toBe(false)
+  })
+
+  it('blocks a list[str] given integers, with a per-parameter error', async () => {
+    const state = setup('def schedule(tasks: list[str], start: int) -> int')
+    await flushPromises()
+    state.setArgsLine('[1, 2], 9')
+    expect(state.inputErrors.value).toEqual({ tasks: 'Every item must be str' })
+    expect(state.hasValidInputs.value).toBe(false)
+    await state.executeProbe()
+    expect(axios.post).not.toHaveBeenCalled()
+  })
+
+  it('translates line errors and blocks the probe while one is present', async () => {
+    const state = setup('def schedule(start: int) -> int')
+    await flushPromises()
+
+    state.setArgsLine('5, stop=3')
+    expect(state.lineError.value).toBe('Unknown argument stop')
+    expect(state.hasValidInputs.value).toBe(false)
+
+    state.setArgsLine('5, start=3')
+    expect(state.lineError.value).toBe('Argument start given twice')
+
+    state.setArgsLine('5, 6')
+    expect(state.lineError.value).toBe('Too many arguments for schedule')
+    expect(state.probeInputs.start).toBe('5')
+    await state.executeProbe()
+    expect(axios.post).not.toHaveBeenCalled()
+
+    state.setArgsLine('5,,')
+    expect(state.lineError.value).toBe('Empty argument between commas')
+
+    state.setArgsLine('5')
+    expect(state.lineError.value).toBeNull()
+    expect(state.hasValidInputs.value).toBe(true)
+  })
+
+  it('requires every parameter to have a value', () => {
+    const state = setup('def schedule(tasks: list[str], start: int) -> int')
+    state.setArgsLine('tasks=["a"]')
+    expect(state.probeInputs.start).toBe('')
+    expect(state.lineError.value).toBeNull()
+    expect(state.hasValidInputs.value).toBe(false)
+  })
+
+  it('treats a matching probe as a duplicate regardless of argument style', async () => {
+    vi.mocked(axios.post).mockResolvedValue({ data: { success: true, result: 3 } })
+    const state = setup('def schedule(tasks: list[str], start: int) -> int')
+    await flushPromises()
+    state.setArgsLine('["a"], 9')
+    await state.executeProbe()
+    state.setArgsLine(`start=9, tasks=['a']`)
+    await nextTick()
+    expect(state.isDuplicate.value).toBe(true)
+  })
+
+  it('treats a dict with its keys in another order as a duplicate', async () => {
+    vi.mocked(axios.post).mockResolvedValue({ data: { success: true, result: 3 } })
+    const state = setup('def total(m: dict[str, int]) -> int')
+    await flushPromises()
+    state.setArgsLine(`{'a': 1, 'b': 2}`)
+    await state.executeProbe()
+    state.setArgsLine(`{'b': 2, 'a': 1}`)
+    await nextTick()
+    expect(state.isDuplicate.value).toBe(true)
+    state.setArgsLine(`{'b': 2, 'a': 3}`)
+    await nextTick()
+    expect(state.isDuplicate.value).toBe(false)
+  })
+})
+
+function mountPanel(overrides: Record<string, unknown> = {}) {
+  return mount(ProbePanel, {
+    attachTo: document.body,
+    props: {
+      functionName: 'schedule',
+      probeStatusClass: 'status-available',
+      probeCountDisplay: '2 left',
+      probeStatusText: '',
+      probeParams: [
+        { name: 'tasks', type: 'list[str]' },
+        { name: 'start', type: 'int' },
+      ],
+      argsLine: '',
+      argsTemplate: 'tasks=, start=',
+      lineError: null,
+      canProbe: true,
+      isExecuting: false,
+      hasValidInputs: false,
+      inputErrors: {},
+      probeHistory: [],
+      probeError: null,
+      isDuplicate: false,
+      cachedResult: null,
+      formatFunctionCall: (input: Record<string, unknown>) => `schedule(${Object.values(input).join(', ')})`,
+      formatOutput: (output: unknown) => JSON.stringify(output),
+      ...overrides,
+    },
+  })
+}
+
+describe('ProbePanel call line', () => {
+  it('renders the function name and parentheses around one accessible argument editor', () => {
+    const wrapper = mountPanel()
+    const args = wrapper.find('#probe-args')
+    expect(wrapper.find('.call-shell').text().replace(/\s/g, '')).toBe('schedule()')
+    expect(args.attributes('role')).toBe('textbox')
+    // Enter probes rather than breaking the line, so it is single-line to AT
+    expect(args.attributes('aria-multiline')).toBe('false')
+    // The keyboard behaviour (Enter probes, Tab fills names) is described to AT
+    expect(args.attributes('aria-describedby')).toBe('probe-args-help')
+    expect(wrapper.find('#probe-args-help').text()).toBe(
+      'Enter probes. Tab on an empty line fills in the argument names.'
+    )
+    expect(args.attributes('aria-label')).toBe('Arguments for schedule')
+    // Signature visible: the placeholder carries each parameter's declared type
+    expect(args.attributes('data-placeholder')).toBe('tasks: list[str], start: int')
+    expect(args.attributes('contenteditable')).toBe('plaintext-only')
+    expect(args.attributes('aria-invalid')).toBeUndefined()
+    // ")" follows the editor directly, with no whitespace text between them
+    expect(args.element.nextSibling).toBe(wrapper.findAll('.fn-paren')[1].element)
+    wrapper.unmount()
+  })
+
+  it('shows parameter names in the placeholder even when types are hidden', () => {
+    const wrapper = mountPanel({ probeParams: [{ name: 'a', type: '' }, { name: 'b', type: '' }] })
+    expect(wrapper.find('#probe-args').attributes('data-placeholder')).toBe('a, b')
+    wrapper.unmount()
+  })
+
+  it('emits the typed text', async () => {
+    const wrapper = mountPanel()
+    const args = wrapper.find('#probe-args')
+    args.element.textContent = '[1], 2'
+    await args.trigger('input')
+    expect(wrapper.emitted('update-args')).toEqual([['[1], 2']])
+    wrapper.unmount()
+  })
+
+  it('inserts the template on Tab only when the line is empty', async () => {
+    const wrapper = mountPanel()
+    const args = wrapper.find('#probe-args')
+    await args.trigger('keydown', { key: 'Tab' })
+    expect(args.element.textContent).toBe('tasks=, start=')
+    expect(wrapper.emitted('update-args')).toEqual([['tasks=, start=']])
+    // Caret sits after the first "="
+    const range = window.getSelection()?.getRangeAt(0)
+    expect(range?.startOffset).toBe('tasks='.length)
+
+    await args.trigger('keydown', { key: 'Tab' })
+    expect(wrapper.emitted('update-args')).toHaveLength(1)
+    wrapper.unmount()
+  })
+
+  it('inserts the template from the fill button', async () => {
+    const wrapper = mountPanel()
+    await wrapper.find('button.fill-args-btn').trigger('click')
+    expect(wrapper.find('#probe-args').element.textContent).toBe('tasks=, start=')
+    expect(wrapper.emitted('update-args')).toEqual([['tasks=, start=']])
+    wrapper.unmount()
+  })
+
+  it('probes on Enter only when valid, and never on Shift+Enter', async () => {
+    const wrapper = mountPanel()
+    const args = wrapper.find('#probe-args')
+    await args.trigger('keydown', { key: 'Enter' })
+    expect(wrapper.emitted('execute-probe')).toBeUndefined()
+
+    await wrapper.setProps({ hasValidInputs: true })
+    await args.trigger('keydown', { key: 'Enter', shiftKey: true })
+    expect(wrapper.emitted('execute-probe')).toBeUndefined()
+    await args.trigger('keydown', { key: 'Enter' })
+    expect(wrapper.emitted('execute-probe')).toHaveLength(1)
+
+    await wrapper.setProps({ isExecuting: true })
+    await args.trigger('keydown', { key: 'Enter' })
+    expect(wrapper.emitted('execute-probe')).toHaveLength(1)
+    wrapper.unmount()
+  })
+
+  it('gives focus back to the line after a probe started from it', async () => {
+    const wrapper = mountPanel({ hasValidInputs: true })
+    const el = wrapper.find('#probe-args').element as HTMLElement
+    el.focus()
+    await wrapper.setProps({ isExecuting: true })
+    // A browser drops focus from an element that stops being editable
+    el.blur()
+    expect(document.activeElement).not.toBe(el)
+    await wrapper.setProps({ isExecuting: false })
+    await nextTick()
+    expect(document.activeElement).toBe(el)
+    wrapper.unmount()
+  })
+
+  it('does not steal focus after a probe started from elsewhere', async () => {
+    const wrapper = mountPanel({ hasValidInputs: true })
+    const el = wrapper.find('#probe-args').element as HTMLElement
+    await wrapper.setProps({ isExecuting: true })
+    await wrapper.setProps({ isExecuting: false })
+    await nextTick()
+    expect(document.activeElement).not.toBe(el)
+    wrapper.unmount()
+  })
+
+  it('pastes plain text on one line', () => {
+    const wrapper = mountPanel()
+    const args = wrapper.find('#probe-args')
+    const el = args.element as HTMLElement
+    el.focus()
+    const range = document.createRange()
+    range.selectNodeContents(el)
+    window.getSelection()?.removeAllRanges()
+    window.getSelection()?.addRange(range)
+
+    const event = new Event('paste', { bubbles: true, cancelable: true }) as ClipboardEvent
+    Object.defineProperty(event, 'clipboardData', { value: { getData: () => '[1,\n2]' } })
+    el.dispatchEvent(event)
+
+    expect(event.defaultPrevented).toBe(true)
+    expect(el.textContent).toBe('[1, 2]')
+    expect(wrapper.emitted('update-args')?.slice(-1)).toEqual([['[1, 2]']])
+    wrapper.unmount()
+  })
+
+  it('shows line and per-parameter errors and marks the editor invalid', () => {
+    const wrapper = mountPanel({
+      lineError: 'Unknown argument stop',
+      inputErrors: { tasks: 'Every item must be str' },
+    })
+    expect(wrapper.find('li#probe-err-line').text()).toBe('Unknown argument stop')
+    expect(wrapper.find('li#probe-err-tasks').text()).toBe('tasks: Every item must be str')
+    const args = wrapper.find('#probe-args')
+    expect(args.attributes('aria-invalid')).toBe('true')
+    expect(args.attributes('aria-describedby')).toBe('probe-field-errors probe-args-help')
+    expect(wrapper.find('ul#probe-field-errors').exists()).toBe(true)
+    wrapper.unmount()
+  })
+
+  it('locks the editor and the fill button when probing is not allowed', () => {
+    const wrapper = mountPanel({ canProbe: false })
+    const args = wrapper.find('#probe-args')
+    expect(args.attributes('contenteditable')).toBe('false')
+    expect(args.attributes('aria-disabled')).toBe('true')
+    expect(wrapper.find('button.fill-args-btn').attributes('disabled')).toBeDefined()
+    wrapper.unmount()
+  })
+
+  it('follows a reset of the line from outside', async () => {
+    const wrapper = mountPanel({ argsLine: '[1], 2' })
+    const args = wrapper.find('#probe-args')
+    expect(args.element.textContent).toBe('[1], 2')
+    await wrapper.setProps({ argsLine: '' })
+    expect(args.element.textContent).toBe('')
+    wrapper.unmount()
+  })
+
+  it('falls back to contenteditable="true" and still pastes plain text where plaintext-only is unsupported', () => {
+    // A browser without plaintext-only keeps its previous contentEditable value
+    const descriptor = Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'contentEditable')
+    Object.defineProperty(HTMLElement.prototype, 'contentEditable', {
+      configurable: true,
+      get: () => 'inherit',
+      set: () => {},
+    })
+    let wrapper: ReturnType<typeof mountPanel> | undefined
+    try {
+      wrapper = mountPanel()
+    } finally {
+      if (descriptor) {
+        Object.defineProperty(HTMLElement.prototype, 'contentEditable', descriptor)
+      } else {
+        delete (HTMLElement.prototype as { contentEditable?: string }).contentEditable
+      }
+    }
+    const el = wrapper.find('#probe-args').element as HTMLElement
+    expect(el.getAttribute('contenteditable')).toBe('true')
+
+    el.focus()
+    const range = document.createRange()
+    range.selectNodeContents(el)
+    window.getSelection()?.removeAllRanges()
+    window.getSelection()?.addRange(range)
+    const event = new Event('paste', { bubbles: true, cancelable: true }) as ClipboardEvent
+    Object.defineProperty(event, 'clipboardData', { value: { getData: () => '<b>[1,</b>\r\n2]' } })
+    el.dispatchEvent(event)
+
+    expect(event.defaultPrevented).toBe(true)
+    // Inserted as text: markup stays literal, line breaks become spaces
+    expect(el.children).toHaveLength(0)
+    expect(el.textContent).toBe('<b>[1,</b> 2]')
+    expect(wrapper.emitted('update-args')?.slice(-1)).toEqual([['<b>[1,</b> 2]']])
+    wrapper.unmount()
+  })
+})
diff --git a/purplex/client/src/components/activities/inputs/shared/__tests__/probeBudgetGuards.test.ts b/purplex/client/src/components/activities/inputs/shared/__tests__/probeBudgetGuards.test.ts
index 1f11487..1295ef6 100644
--- a/purplex/client/src/components/activities/inputs/shared/__tests__/probeBudgetGuards.test.ts
+++ b/purplex/client/src/components/activities/inputs/shared/__tests__/probeBudgetGuards.test.ts
@@ -25,7 +25,7 @@ describe('useProbeState budget guards', () => {
     const state = withSetup(() => useProbeState(problem))
     await flushPromises()
 
-    state.updateProbeInput('x', '5')
+    state.setArgsLine('5')
     await state.executeProbe()
     expect(axios.post).toHaveBeenCalledTimes(1)
 
@@ -66,7 +66,9 @@ function mountPanel(overrides: Record<string, unknown>) {
       probeCountDisplay: '2 left',
       probeStatusText: '',
       probeParams: [{ name: 'x', type: 'int' }],
-      probeInputs: { x: '5' },
+      argsLine: '5',
+      argsTemplate: 'x=',
+      lineError: null,
       canProbe: true,
       isExecuting: false,
       hasValidInputs: true,
@@ -85,11 +87,11 @@ function mountPanel(overrides: Record<string, unknown>) {
 describe('ProbePanel duplicate and exhausted states', () => {
   it('does not emit a probe when Enter is pressed on a duplicate input', async () => {
     const wrapper = mountPanel({})
-    await wrapper.find('#probe-x').trigger('keydown', { key: 'Enter' })
+    await wrapper.find('#probe-args').trigger('keydown', { key: 'Enter' })
     expect(wrapper.emitted('execute-probe')).toBeUndefined()
 
     await wrapper.setProps({ isDuplicate: false, cachedResult: null })
-    await wrapper.find('#probe-x').trigger('keydown', { key: 'Enter' })
+    await wrapper.find('#probe-args').trigger('keydown', { key: 'Enter' })
     expect(wrapper.emitted('execute-probe')).toHaveLength(1)
   })
 
diff --git a/purplex/client/src/components/activities/inputs/shared/probeArgs.ts b/purplex/client/src/components/activities/inputs/shared/probeArgs.ts
new file mode 100644
index 0000000..03a0fe1
--- /dev/null
+++ b/purplex/client/src/components/activities/inputs/shared/probeArgs.ts
@@ -0,0 +1,393 @@
+/**
+ * probeArgs - Parsing for the probe call line.
+ *
+ * Splits the argument list on top-level commas, maps positional and keyword
+ * arguments onto the signature's parameters, and parses each value as a
+ * Python literal checked against its declared type. Pure functions, no Vue.
+ */
+import type { ProbeParameter } from '../../types'
+import { hasUnsafeInt, parsePythonLiteral, type PyNode, toValue } from './pythonLiteral'
+
+/** Canonical primitive parameter types that probe inputs are validated against. */
+export type PrimitiveType = 'int' | 'float' | 'bool' | 'str'
+
+/** Error code for a probe input that does not match its declared type. */
+export type ProbeInputError =
+  | 'int'
+  | 'intRange'
+  | 'float'
+  | 'bool'
+  | 'list'
+  | 'listItems'
+  | 'dict'
+  | 'dictItems'
+  | 'literal'
+
+export interface ParsedProbeInput {
+  value: unknown
+  error: ProbeInputError | null
+  /** Interpolation values for the error message (e.g. the expected item kind). */
+  errorParams?: Record<string, string>
+}
+
+/** A declared one-level container type: list/tuple/set[T] or dict[K, V]. */
+export type ContainerType =
+  | { container: 'list'; item: PrimitiveType | null }
+  | {
+      container: 'dict'
+      key: PrimitiveType | null
+      value: PrimitiveType | null
+      keyLabel: string
+      valueLabel: string
+    }
+
+// Must stay identical to _PRIMITIVE_ALIASES in
+// purplex/problems_app/services/probe_service.py (issue #135).
+const PRIMITIVE_ALIASES = new Map<string, PrimitiveType>([
+  ['int', 'int'],
+  ['integer', 'int'],
+  ['float', 'float'],
+  ['number', 'float'],
+  ['bool', 'bool'],
+  ['boolean', 'bool'],
+  ['str', 'str'],
+  ['string', 'str'],
+])
+
+const INT_PATTERN = /^[+-]?\d+$/
+const BOOL_PATTERN = /^(true|false)$/i
+// Python float literal syntax: no hex/binary/octal, which Number() would otherwise accept
+const FLOAT_PATTERN = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/
+
+const OPENERS: Record<string, string> = { '(': ')', '[': ']', '{': '}' }
+const CLOSERS = new Set([')', ']', '}'])
+
+/**
+ * Split text on a separator (default a comma) that is not nested in (), [], {}
+ * or inside a quoted string. Mirrors _split_top_level in probe_service.py.
+ *
+ * Parts are returned untrimmed; a backslash escapes the next character inside
+ * quotes, and an unbalanced closer never takes the depth below zero.
+ */
+export function splitTopLevel(text: string, sep = ','): string[] {
+  const parts: string[] = []
+  let depth = 0
+  let quote: string | null = null
+  let current = ''
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]
+    current += ch
+    if (quote) {
+      if (ch === '\\' && i + 1 < text.length) {
+        current += text[++i]
+      } else if (ch === quote) {
+        quote = null
+      }
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch
+    } else if (ch in OPENERS) {
+      depth++
+    } else if (CLOSERS.has(ch)) {
+      depth = Math.max(depth - 1, 0)
+    } else if (ch === sep && depth === 0) {
+      parts.push(current.slice(0, -1))
+      current = ''
+    }
+  }
+  parts.push(current)
+  return parts
+}
+
+/** Strip a trailing `= default` from a type hint; null when the default is None (implicit Optional). */
+function stripTypeDefault(type: string): string | null {
+  const [base, ...defaultParts] = type.split('=')
+  if (defaultParts.join('=').trim() === 'None') {
+    return null
+  }
+  return base.trim()
+}
+
+/**
+ * Map a declared parameter type hint to its canonical primitive type.
+ *
+ * Strips a trailing ` = default`, trims, lowercases, and resolves aliases.
+ * A `= None` default is an implicit Optional and is not checked.
+ * Returns null for anything that is not a primitive (missing hint, Any,
+ * list[int], Optional[int], dict, custom classes, ...).
+ */
+export function normalizePrimitiveType(type: string | null | undefined): PrimitiveType | null {
+  if (!type) {
+    return null
+  }
+  const base = stripTypeDefault(type)
+  return base === null ? null : PRIMITIVE_ALIASES.get(base.toLowerCase()) ?? null
+}
+
+/**
+ * Map a declared parameter type hint to a one-level container type.
+ *
+ * Recognises list/tuple/set (bare, [T] or tuple[T, ...]) and dict (bare or [K, V]),
+ * case-insensitively. Item types that are not primitives (Any, nested containers,
+ * heterogeneous tuples) are left unchecked; only the container shape is checked.
+ * Returns null for everything else, including Optional[...], unions and `= None`
+ * defaults. Mirrors normalize_container_type in probe_service.py.
+ */
+export function normalizeContainerType(type: string | null | undefined): ContainerType | null {
+  if (!type) {
+    return null
+  }
+  const base = stripTypeDefault(type)
+  // Unions such as `list[int] | None` are not checked
+  if (base === null || splitTopLevel(base, '|').length > 1) {
+    return null
+  }
+  const match = base.match(/^(list|tuple|set|dict)\s*(?:\[([\s\S]*)\])?$/i)
+  if (!match) {
+    return null
+  }
+  const kind = match[1].toLowerCase()
+  const args = match[2] === undefined ? [] : splitTopLevel(match[2]).map(a => a.trim())
+  if (kind === 'dict') {
+    const [keyLabel = 'Any', valueLabel = 'Any'] = args.length === 2 ? args : []
+    return {
+      container: 'dict',
+      key: args.length === 2 ? normalizePrimitiveType(keyLabel) : null,
+      value: args.length === 2 ? normalizePrimitiveType(valueLabel) : null,
+      keyLabel,
+      valueLabel,
+    }
+  }
+  const homogeneous = args.length === 1 || (kind === 'tuple' && args.length === 2 && args[1] === '...')
+  return { container: 'list', item: homogeneous ? normalizePrimitiveType(args[0]) : null }
+}
+
+/**
+ * JSON with object keys sorted at every level. Python dicts are unordered, so two
+ * probe inputs that differ only in key order are the same call. Lists keep order.
+ */
+export function stableStringify(value: unknown): string {
+  return JSON.stringify(value, (_key, v: unknown) =>
+    v !== null && typeof v === 'object' && !Array.isArray(v)
+      ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)))
+      : v
+  )
+}
+
+/** Mirrors _matches_primitive: bool is not an int, an int is accepted for float. */
+function matchesPrimitive(node: PyNode, kind: PrimitiveType): boolean {
+  switch (kind) {
+    case 'int':
+      return node.k === 'int'
+    case 'float':
+      return node.k === 'int' || node.k === 'float'
+    case 'bool':
+      return node.k === 'bool'
+    case 'str':
+      return node.k === 'str'
+  }
+}
+
+function parseContainer(text: string, spec: ContainerType): ParsedProbeInput {
+  const node = parsePythonLiteral(text)
+  if (spec.container === 'dict') {
+    if (node?.k !== 'dict') {
+      return { value: text, error: 'dict' }
+    }
+    if (hasUnsafeInt(node)) {
+      return { value: text, error: 'intRange' }
+    }
+    const { key, value } = spec
+    const itemsMatch = node.entries.every(
+      ([k, v]) => (!key || matchesPrimitive(k, key)) && (!value || matchesPrimitive(v, value))
+    )
+    return itemsMatch
+      ? { value: toValue(node), error: null }
+      : { value: text, error: 'dictItems', errorParams: { key: spec.keyLabel, value: spec.valueLabel } }
+  }
+  if (node?.k !== 'list') {
+    return { value: text, error: 'list' }
+  }
+  if (hasUnsafeInt(node)) {
+    return { value: text, error: 'intRange' }
+  }
+  const { item } = spec
+  return !item || node.items.every(n => matchesPrimitive(n, item))
+    ? { value: toValue(node), error: null }
+    : { value: text, error: 'listItems', errorParams: { kind: item } }
+}
+
+/**
+ * Parse a raw probe input string according to its declared parameter type.
+ *
+ * Primitive types (int/float/bool/str) are validated strictly; a str is either a
+ * quoted Python string literal or, unquoted, the bare text as typed.
+ * One-level containers (list/tuple/set[T], dict[K, V]) must be Python literals of
+ * that shape whose items match T (or K and V). Unknown or missing types accept any
+ * Python literal and fall back to the raw text, unless the text starts like a
+ * literal (a bracket or a quote) and does not parse as one.
+ */
+export function parseInputValue(rawValue: string, type: string | null | undefined): ParsedProbeInput {
+  const text = rawValue.trim()
+
+  switch (normalizePrimitiveType(type)) {
+    case 'int':
+      if (!INT_PATTERN.test(text)) {
+        return { value: text, error: 'int' }
+      }
+      // JSON cannot carry ints above 2^53 losslessly, so refuse rather than corrupt
+      return Number.isSafeInteger(Number(text))
+        ? { value: Number(text), error: null }
+        : { value: text, error: 'intRange' }
+    case 'float': {
+      const num = Number(text)
+      return FLOAT_PATTERN.test(text) && Number.isFinite(num)
+        ? { value: num, error: null }
+        : { value: text, error: 'float' }
+    }
+    case 'bool':
+      return BOOL_PATTERN.test(text)
+        ? { value: text.toLowerCase() === 'true', error: null }
+        : { value: text, error: 'bool' }
+    case 'str': {
+      // A quoted value is a Python string literal ('x' or "x"); bare text stays as typed
+      if (!/^["']/.test(text)) {
+        return { value: text, error: null }
+      }
+      const node = parsePythonLiteral(text)
+      return node?.k === 'str' ? { value: node.v, error: null } : { value: text, error: 'literal' }
+    }
+    default: {
+      const container = normalizeContainerType(type)
+      if (container) {
+        return parseContainer(text, container)
+      }
+      // Untyped / unchecked: any Python literal, else the raw text
+      const node = parsePythonLiteral(text)
+      if (node) {
+        return hasUnsafeInt(node) ? { value: text, error: 'intRange' } : { value: toValue(node), error: null }
+      }
+      return /^[[({"']/.test(text) ? { value: text, error: 'literal' } : { value: text, error: null }
+    }
+  }
+}
+
+/** Line-level problem in the argument list, independent of any one parameter's value. */
+export interface ArgsLineError {
+  code: 'unknownKeyword' | 'duplicateArgument' | 'positionalAfterKeyword' | 'tooManyPositional' | 'emptyArgument'
+  /**
+   * The offending argument name ('' for tooManyPositional and emptyArgument); for
+   * positionalAfterKeyword, the keyword that already took the positional's slot.
+   */
+  name: string
+}
+
+const KEYWORD_ARG = /^([\p{L}\p{Nl}_][\p{L}\p{Nl}\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*)\s*=(?!=)([\s\S]*)$/u
+
+/**
+ * Map a call's argument list text (Python-style, positional or keyword) to raw
+ * per-parameter strings.
+ *
+ * Positional arguments fill parameters in signature order; `name=value` sets that
+ * parameter. A trailing comma is allowed. Every parameter appears in `raw`, with ''
+ * when not given. The first line-level error is reported.
+ */
+export function parseArgsLine(
+  text: string,
+  paramNames: string[]
+): { raw: Record<string, string>; lineError: ArgsLineError | null } {
+  const raw: Record<string, string> = Object.fromEntries(paramNames.map(name => [name, '']))
+  const parts = splitTopLevel(text).map(part => part.trim())
+  if (parts[parts.length - 1] === '') {
+    parts.pop()
+  }
+
+  const given = new Set<string>()
+  let lineError: ArgsLineError | null = null
+  let position = 0
+  for (const part of parts) {
+    if (part === '') {
+      // `1,,2` is a syntax error in Python; it must not consume a positional slot
+      lineError ??= { code: 'emptyArgument', name: '' }
+      continue
+    }
+    const keyword = part.match(KEYWORD_ARG)
+    let name: string
+    let value: string
+    if (keyword) {
+      name = keyword[1]
+      value = keyword[2].trim()
+      if (!paramNames.includes(name)) {
+        lineError ??= { code: 'unknownKeyword', name }
+        continue
+      }
+    } else {
+      if (position >= paramNames.length) {
+        lineError ??= { code: 'tooManyPositional', name: '' }
+        continue
+      }
+      name = paramNames[position++]
+      value = part
+      if (given.has(name)) {
+        // Only a keyword can have taken a positional slot already: `x=1, 2`
+        lineError ??= { code: 'positionalAfterKeyword', name }
+        continue
+      }
+    }
+    if (given.has(name)) {
+      lineError ??= { code: 'duplicateArgument', name }
+      continue
+    }
+    given.add(name)
+    raw[name] = value
+  }
+  return { raw, lineError }
+}
+
+/**
+ * Parameters of a `def name(...)` signature, splitting only on top-level commas so
+ * `dict[str, int]` or a `(1, 2)` default stays one parameter (issue #160).
+ *
+ * The default stays on the type (e.g. "int = None") so normalizePrimitiveType can
+ * see it; it is stripped from the name for untyped defaults like "x=3".
+ */
+export function parseSignatureParams(signature: string): ProbeParameter[] {
+  const open = signature.indexOf('(')
+  if (open === -1) {
+    return []
+  }
+  // Find the matching close paren, skipping nested brackets and quoted defaults
+  // (mirrors _extract_params_str in probe_service.py)
+  let depth = 0
+  let quote: string | null = null
+  let close = -1
+  for (let i = open; i < signature.length && close === -1; i++) {
+    const ch = signature[i]
+    if (quote) {
+      if (ch === '\\') {
+        i++
+      } else if (ch === quote) {
+        quote = null
+      }
+    } else if (ch === '"' || ch === "'") {
+      quote = ch
+    } else if (ch in OPENERS) {
+      depth++
+    } else if (CLOSERS.has(ch) && --depth === 0) {
+      close = i
+    }
+  }
+  const inner = signature.slice(open + 1, close === -1 ? undefined : close)
+  return splitTopLevel(inner)
+    .map(part => part.trim())
+    .filter(part => part !== '')
+    .map(part => {
+      const colon = part.indexOf(':')
+      const equals = part.indexOf('=')
+      if (colon === -1 || (equals !== -1 && equals < colon)) {
+        return { name: part.split('=')[0].trim(), type: 'Any' }
+      }
+      return { name: part.slice(0, colon).trim(), type: part.slice(colon + 1).trim() || 'Any' }
+    })
+}
diff --git a/purplex/client/src/components/activities/inputs/shared/pythonLiteral.ts b/purplex/client/src/components/activities/inputs/shared/pythonLiteral.ts
new file mode 100644
index 0000000..0783c15
--- /dev/null
+++ b/purplex/client/src/components/activities/inputs/shared/pythonLiteral.ts
@@ -0,0 +1,266 @@
+/**
+ * pythonLiteral - Parse a Python literal (or JSON) typed in the probe call line.
+ *
+ * Keeps int vs float apart so probeArgs can check container item types, and
+ * converts the result to the JSON value the probe API receives. Pure functions.
+ */
+
+/** A parsed Python literal, keeping int vs float so item types can be checked. */
+export type PyNode =
+  | { k: 'int'; v: number }
+  | { k: 'float'; v: number }
+  | { k: 'str'; v: string }
+  | { k: 'bool'; v: boolean }
+  | { k: 'none' }
+  | { k: 'list'; items: PyNode[] }
+  | { k: 'dict'; entries: [PyNode, PyNode][] }
+
+const NAME_LITERALS: Record<string, PyNode> = {
+  True: { k: 'bool', v: true },
+  False: { k: 'bool', v: false },
+  None: { k: 'none' },
+  // JSON spellings, accepted as before
+  true: { k: 'bool', v: true },
+  false: { k: 'bool', v: false },
+  null: { k: 'none' },
+}
+
+const STRING_ESCAPES: Record<string, string> = {
+  n: '\n', t: '\t', r: '\r', b: '\b', f: '\f', v: '\v', a: '\x07', '\\': '\\', "'": "'", '"': '"', '/': '/',
+}
+
+const OCTAL_ESCAPE = /[0-7]{1,3}/y
+
+const NUMBER_TOKEN = /[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?/y
+// Python identifiers are Unicode (PEP 3131), so `número` is a valid name
+const NAME_TOKEN = /[\p{L}\p{Nl}_][\p{L}\p{Nl}\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*/uy
+
+/**
+ * Parse a Python literal (or JSON): numbers, quoted strings, True/False/None,
+ * lists, tuples and sets (all become lists), and dicts with scalar keys.
+ * Trailing commas are accepted. Returns null when the text is not a literal.
+ */
+export function parsePythonLiteral(text: string): PyNode | null {
+  let pos = 0
+
+  const skipSpace = () => {
+    while (pos < text.length && /\s/.test(text[pos])) {
+      pos++
+    }
+  }
+
+  const parseString = (): PyNode | null => {
+    const quote = text[pos++]
+    let out = ''
+    while (pos < text.length) {
+      const ch = text[pos++]
+      if (ch === quote) {
+        return { k: 'str', v: out }
+      }
+      if (ch !== '\\') {
+        out += ch
+        continue
+      }
+      const esc = text[pos++]
+      if (esc === undefined) {
+        return null
+      }
+      if (esc === 'N') {
+        // \N{NAME} needs Python's Unicode name table; reject rather than mis-decode
+        return null
+      }
+      if (/[0-7]/.test(esc)) {
+        // \0 .. \377: one to three octal digits, as in Python
+        OCTAL_ESCAPE.lastIndex = pos - 1
+        const octal = OCTAL_ESCAPE.exec(text)?.[0] ?? esc
+        out += String.fromCharCode(parseInt(octal, 8))
+        pos += octal.length - 1
+        continue
+      }
+      const hexLength = esc === 'U' ? 8 : esc === 'u' ? 4 : esc === 'x' ? 2 : 0
+      if (hexLength) {
+        const hex = text.slice(pos, pos + hexLength)
+        if (!new RegExp(`^[0-9a-fA-F]{${hexLength}}$`).test(hex)) {
+          return null
+        }
+        const code = parseInt(hex, 16)
+        if (code > 0x10ffff) {
+          return null
+        }
+        out += String.fromCodePoint(code)
+        pos += hexLength
+      } else {
+        // Python keeps unknown escapes verbatim
+        out += STRING_ESCAPES[esc] ?? `\\${esc}`
+      }
+    }
+    return null
+  }
+
+  // Items up to `close`, separated by commas, trailing comma allowed
+  const parseItems = (close: string, first: PyNode[] = []): { items: PyNode[]; sawComma: boolean } | null => {
+    const items = first
+    // Called with a first item only once its trailing comma is consumed
+    let sawComma = first.length > 0
+    for (;;) {
+      skipSpace()
+      if (text[pos] === close) {
+        pos++
+        return { items, sawComma }
+      }
+      if (items.length > 0 && !sawComma) {
+        return null
+      }
+      const item = parseValue()
+      if (!item) {
+        return null
+      }
+      items.push(item)
+      skipSpace()
+      if (text[pos] === ',') {
+        pos++
+        sawComma = true
+      } else if (text[pos] !== close) {
+        return null
+      } else {
+        sawComma = false
+      }
+    }
+  }
+
+  const parseBrace = (): PyNode | null => {
+    pos++
+    skipSpace()
+    if (text[pos] === '}') {
+      pos++
+      return { k: 'dict', entries: [] }
+    }
+    const first = parseValue()
+    if (!first) {
+      return null
+    }
+    skipSpace()
+    if (text[pos] !== ':') {
+      // A set literal: the first item is parsed, continue as a sequence
+      if (text[pos] === ',') {
+        pos++
+        const rest = parseItems('}', [first])
+        return rest && { k: 'list', items: rest.items }
+      }
+      return text[pos++] === '}' ? { k: 'list', items: [first] } : null
+    }
+    const entries: [PyNode, PyNode][] = []
+    let key: PyNode | null = first
+    for (;;) {
+      // Keys must be scalars: a JSON object can only carry those
+      if (!key || key.k === 'list' || key.k === 'dict') {
+        return null
+      }
+      skipSpace()
+      if (text[pos++] !== ':') {
+        return null
+      }
+      const value = parseValue()
+      if (!value) {
+        return null
+      }
+      entries.push([key, value])
+      skipSpace()
+      const sep = text[pos++]
+      if (sep === '}') {
+        return { k: 'dict', entries }
+      }
+      if (sep !== ',') {
+        return null
+      }
+      skipSpace()
+      if (text[pos] === '}') {
+        pos++
+        return { k: 'dict', entries }
+      }
+      key = parseValue()
+    }
+  }
+
+  const parseValue = (): PyNode | null => {
+    skipSpace()
+    const ch = text[pos]
+    if (ch === '"' || ch === "'") {
+      return parseString()
+    }
+    if (ch === '[') {
+      pos++
+      const seq = parseItems(']')
+      return seq && { k: 'list', items: seq.items }
+    }
+    if (ch === '(') {
+      pos++
+      const seq = parseItems(')')
+      if (!seq) {
+        return null
+      }
+      // (x) is just x; (x,) and () are tuples
+      return seq.items.length === 1 && !seq.sawComma ? seq.items[0] : { k: 'list', items: seq.items }
+    }
+    if (ch === '{') {
+      return parseBrace()
+    }
+    NUMBER_TOKEN.lastIndex = pos
+    const num = NUMBER_TOKEN.exec(text)
+    if (num) {
+      pos = NUMBER_TOKEN.lastIndex
+      const v = Number(num[0])
+      if (num[1].includes('.') || num[2]) {
+        return Number.isFinite(v) ? { k: 'float', v } : null
+      }
+      return { k: 'int', v }
+    }
+    NAME_TOKEN.lastIndex = pos
+    const name = NAME_TOKEN.exec(text)
+    if (name && Object.prototype.hasOwnProperty.call(NAME_LITERALS, name[0])) {
+      pos = NAME_TOKEN.lastIndex
+      return NAME_LITERALS[name[0]]
+    }
+    return null
+  }
+
+  const node = parseValue()
+  skipSpace()
+  return node && pos === text.length ? node : null
+}
+
+/** Whether any int in the literal is too large to survive JSON losslessly. */
+export function hasUnsafeInt(node: PyNode): boolean {
+  switch (node.k) {
+    case 'int':
+      return !Number.isSafeInteger(node.v)
+    case 'list':
+      return node.items.some(hasUnsafeInt)
+    case 'dict':
+      return node.entries.some(([key, value]) => hasUnsafeInt(key) || hasUnsafeInt(value))
+    default:
+      return false
+  }
+}
+
+/** Python json.dumps spelling of a scalar dict key. */
+function keyToString(node: PyNode): string {
+  if (node.k === 'none') {
+    return 'null'
+  }
+  return 'v' in node ? String(node.v) : ''
+}
+
+export function toValue(node: PyNode): unknown {
+  switch (node.k) {
+    case 'none':
+      return null
+    case 'list':
+      return node.items.map(toValue)
+    case 'dict':
+      // fromEntries defines own properties, so a "__proto__" key stays data
+      return Object.fromEntries(node.entries.map(([key, value]) => [keyToString(key), toValue(value)]))
+    default:
+      return node.v
+  }
+}
diff --git a/purplex/client/src/components/activities/inputs/shared/useProbeState.ts b/purplex/client/src/components/activities/inputs/shared/useProbeState.ts
index ba9acdd..1ce5c1b 100644
--- a/purplex/client/src/components/activities/inputs/shared/useProbeState.ts
+++ b/purplex/client/src/components/activities/inputs/shared/useProbeState.ts
@@ -8,105 +8,14 @@ import { computed, onMounted, reactive, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import axios from 'axios'
 import type { ActivityProblem, ProbeHistoryEntry, ProbeParameter, ProbeStatus } from '../../types'
-
-/** Canonical primitive parameter types that probe inputs are validated against. */
-export type PrimitiveType = 'int' | 'float' | 'bool' | 'str'
-
-/** Error code for a probe input that does not match its declared primitive type. */
-export type ProbeInputError = 'int' | 'intRange' | 'float' | 'bool'
-
-export interface ParsedProbeInput {
-  value: unknown
-  error: ProbeInputError | null
-}
-
-// Must stay identical to _PRIMITIVE_ALIASES in
-// purplex/problems_app/services/probe_service.py (issue #135).
-const PRIMITIVE_ALIASES = new Map<string, PrimitiveType>([
-  ['int', 'int'],
-  ['integer', 'int'],
-  ['float', 'float'],
-  ['number', 'float'],
-  ['bool', 'bool'],
-  ['boolean', 'bool'],
-  ['str', 'str'],
-  ['string', 'str'],
-])
-
-const INT_PATTERN = /^[+-]?\d+$/
-const BOOL_PATTERN = /^(true|false)$/i
-// Python float literal syntax: no hex/binary/octal, which Number() would otherwise accept
-const FLOAT_PATTERN = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/
-
-/**
- * Map a declared parameter type hint to its canonical primitive type.
- *
- * Strips a trailing ` = default`, trims, lowercases, and resolves aliases.
- * A `= None` default is an implicit Optional and is not checked.
- * Returns null for anything that is not checked (missing hint, Any, list[int],
- * Optional[int], dict, custom classes, ...).
- */
-export function normalizePrimitiveType(type: string | null | undefined): PrimitiveType | null {
-  if (!type) {
-    return null
-  }
-  const [base, ...defaultParts] = type.split('=')
-  if (defaultParts.join('=').trim() === 'None') {
-    return null
-  }
-  return PRIMITIVE_ALIASES.get(base.trim().toLowerCase()) ?? null
-}
-
-/**
- * Parse a raw probe input string according to its declared parameter type.
- *
- * Primitive types (int/float/bool/str) are validated strictly; str never errors.
- * Unknown or missing types fall back to JSON parsing, accepting Python-style
- * bare True/False/None, and fall back to the raw text when that fails.
- */
-export function parseInputValue(rawValue: string, type: string | null | undefined): ParsedProbeInput {
-  const text = rawValue.trim()
-
-  switch (normalizePrimitiveType(type)) {
-    case 'int':
-      if (!INT_PATTERN.test(text)) {
-        return { value: text, error: 'int' }
-      }
-      // JSON cannot carry ints above 2^53 losslessly, so refuse rather than corrupt
-      return Number.isSafeInteger(Number(text))
-        ? { value: Number(text), error: null }
-        : { value: text, error: 'intRange' }
-    case 'float': {
-      const num = Number(text)
-      return FLOAT_PATTERN.test(text) && Number.isFinite(num)
-        ? { value: num, error: null }
-        : { value: text, error: 'float' }
-    }
-    case 'bool':
-      return BOOL_PATTERN.test(text)
-        ? { value: text.toLowerCase() === 'true', error: null }
-        : { value: text, error: 'bool' }
-    case 'str':
-      if (text.length >= 2 && text.startsWith('"') && text.endsWith('"')) {
-        try {
-          return { value: JSON.parse(text), error: null }
-        } catch {
-          // Not a valid JSON string literal - keep the raw text
-        }
-      }
-      return { value: text, error: null }
-    default: {
-      // Untyped / unchecked: JSON first, accepting Python-style literals
-      const pythonLiterals: Record<string, string> = { True: 'true', False: 'false', None: 'null' }
-      const jsonText = pythonLiterals[text] ?? text
-      try {
-        return { value: JSON.parse(jsonText), error: null }
-      } catch {
-        return { value: text, error: null }
-      }
-    }
-  }
-}
+import {
+  type ArgsLineError,
+  parseArgsLine,
+  type ParsedProbeInput,
+  parseInputValue,
+  parseSignatureParams,
+  stableStringify,
+} from './probeArgs'
 
 export interface UseProbeStateOptions {
   /** Whether a submission is in flight; status is re-fetched when it ends (cooldown refills). */
@@ -124,6 +33,9 @@ export function useProbeState(
   const probeHistory = ref<ProbeHistoryEntry[]>([])
   const probeStatus = ref<ProbeStatus | null>(null)
   const probeInputs = reactive<Record<string, string>>({})
+  // The argument list as typed in the call line, and its line-level error
+  const argsLine = ref('')
+  const argsLineError = ref<ArgsLineError | null>(null)
 
   // Support both direct problem object and computed problem
   const getProblem = () => typeof problem === 'function' ? problem() : problem
@@ -163,25 +75,7 @@ export function useProbeState(
       return []
     }
 
-    const match = sig.match(/\(([^)]*)\)/)
-    if (!match) {
-      return []
-    }
-
-    const paramsStr = match[1].trim()
-    if (!paramsStr) {
-      return []
-    }
-
-    return paramsStr.split(',').map((p: string) => {
-      // Keep the default on the type (e.g. "int = None") so normalizePrimitiveType
-      // can see it; strip it from the name for untyped defaults like "x=3"
-      const [namePart, ...typeParts] = p.split(':')
-      return {
-        name: namePart.split('=')[0].trim(),
-        type: typeParts.join(':').trim() || 'Any'
-      }
-    })
+    return parseSignatureParams(sig)
   })
 
   const canProbe = computed(() => {
@@ -232,16 +126,19 @@ export function useProbeState(
     return 'status-exhausted'
   })
 
+  // Template for the call line: every parameter as a keyword with no value yet
+  const argsTemplate = computed(() => parameters.value.map(p => `${p.name}=`).join(', '))
+
   // Parse every current input once; shared by validation, duplicate detection and execution
   const parsedInputs = computed(() => {
     const values: Record<string, unknown> = {}
-    const errors: Record<string, ProbeInputError> = {}
+    const errors: Record<string, Pick<ParsedProbeInput, 'error' | 'errorParams'>> = {}
     for (const param of parameters.value) {
       const rawValue = probeInputs[param.name] ?? ''
-      const { value, error } = parseInputValue(rawValue, param.type)
+      const { value, error, errorParams } = parseInputValue(rawValue, param.type)
       values[param.name] = value
       if (error && rawValue !== '') {
-        errors[param.name] = error
+        errors[param.name] = { error, errorParams }
       }
     }
     return { values, errors }
@@ -250,28 +147,39 @@ export function useProbeState(
   // Translated per-field type errors, keyed by parameter name (non-empty fields only)
   const inputErrors = computed((): Record<string, string> => {
     const messages: Record<string, string> = {}
-    for (const [name, code] of Object.entries(parsedInputs.value.errors)) {
-      messages[name] = t(`problems.probe.invalidType.${code}`)
+    for (const [name, { error, errorParams }] of Object.entries(parsedInputs.value.errors)) {
+      messages[name] = t(`problems.probe.invalidType.${error}`, errorParams ?? {})
     }
     return messages
   })
 
+  // Translated line-level error of the argument list (unknown/duplicate/extra/empty argument)
+  const lineError = computed((): string | null => {
+    const error = argsLineError.value
+    if (!error) {
+      return null
+    }
+    const name = error.code === 'tooManyPositional' ? functionName.value : error.name
+    return t(`problems.probe.lineError.${error.code}`, { name })
+  })
+
   const hasValidInputs = computed(() => {
-    // Every parameter has a value and none fails its declared type
+    // Every parameter has a value, none fails its declared type, and the line maps cleanly
     const allFilled = parameters.value.every(p => {
       const value = probeInputs[p.name]
       return value !== undefined && value !== ''
     })
-    return allFilled && Object.keys(parsedInputs.value.errors).length === 0
+    return allFilled && Object.keys(parsedInputs.value.errors).length === 0 && !argsLineError.value
   })
 
   // Check if current inputs match any previous query (real-time duplicate detection)
   const duplicateEntry = computed(() => {
     if (!hasValidInputs.value) {return null}
 
-    const inputKey = JSON.stringify(parsedInputs.value.values)
+    // Key order is irrelevant: {'a': 1, 'b': 2} and {'b': 2, 'a': 1} are one call
+    const inputKey = stableStringify(parsedInputs.value.values)
     return probeHistory.value.find(
-      entry => JSON.stringify(entry.input) === inputKey
+      entry => stableStringify(entry.input) === inputKey
     ) || null
   })
 
@@ -302,6 +210,8 @@ export function useProbeState(
     Object.keys(probeInputs).forEach(key => {
       probeInputs[key] = ''
     })
+    argsLine.value = ''
+    argsLineError.value = null
   })
 
   // A completed submission can refill a cooldown budget server-side
@@ -341,7 +251,7 @@ export function useProbeState(
     if (!canProbe.value || probing.value || isDuplicate.value) {
       return
     }
-    if (Object.keys(parsedInputs.value.errors).length > 0) {
+    if (!hasValidInputs.value) {
       return
     }
 
@@ -398,8 +308,14 @@ export function useProbeState(
     return JSON.stringify(output)
   }
 
-  function updateProbeInput(paramName: string, value: string) {
-    probeInputs[paramName] = value
+  /** Set the call line's argument list and map it onto the per-parameter inputs. */
+  function setArgsLine(text: string) {
+    argsLine.value = text
+    const { raw, lineError: error } = parseArgsLine(text, parameters.value.map(p => p.name))
+    for (const param of parameters.value) {
+      probeInputs[param.name] = raw[param.name] ?? ''
+    }
+    argsLineError.value = error
   }
 
   function formatFunctionCall(input: Record<string, unknown>): string {
@@ -414,6 +330,7 @@ export function useProbeState(
     probeHistory,
     probeStatus,
     probeInputs,
+    argsLine,
     // Computed
     probeConfig,
     functionSignature,
@@ -426,6 +343,8 @@ export function useProbeState(
     probeStatusClass,
     hasValidInputs,
     inputErrors,
+    lineError,
+    argsTemplate,
     isDuplicate,
     cachedResult,
     // Methods
@@ -436,6 +355,6 @@ export function useProbeState(
     formatInput,
     formatOutput,
     formatFunctionCall,
-    updateProbeInput,
+    setArgsLine,
   }
 }
diff --git a/purplex/client/src/i18n/locales/en/problems.json b/purplex/client/src/i18n/locales/en/problems.json
index 6b4a218..08b6d44 100644
--- a/purplex/client/src/i18n/locales/en/problems.json
+++ b/purplex/client/src/i18n/locales/en/problems.json
@@ -217,15 +217,27 @@
       "tooltipExhausted": "No probes remaining",
       "tooltipDefault": "Query the oracle with these inputs",
       "srDuplicate": "These inputs were already probed. Result: {result}",
-      "paramAriaLabel": "Enter value for {name} (type: {type})",
-      "paramAriaLabelNoType": "Enter value for {name}",
       "cachedResultAriaLabel": "Cached result: {result}",
-      "valuePlaceholderHint": "value — quote text: \"abc\"",
+      "argsAriaLabel": "Arguments for {name}",
+      "argsHelp": "Enter probes. Tab on an empty line fills in the argument names.",
+      "fillArgs": "Fill in argument names",
+      "lineError": {
+        "unknownKeyword": "Unknown argument {name}",
+        "duplicateArgument": "Argument {name} given twice",
+        "positionalAfterKeyword": "Positional argument after {name}=; put positional arguments first",
+        "tooManyPositional": "Too many arguments for {name}",
+        "emptyArgument": "Empty argument between commas"
+      },
       "invalidType": {
         "int": "Must be a whole number (e.g. 5)",
         "intRange": "Whole number is too large (at most 15 digits)",
         "float": "Must be a number (e.g. 1.5)",
-        "bool": "Must be true or false"
+        "bool": "Must be true or false",
+        "list": "Must be a list, e.g. [1, 2, 3]",
+        "listItems": "Every item must be {kind}",
+        "dict": "Must be a dict, e.g. {'{'}\"a\": 1{'}'}",
+        "dictItems": "Keys must be {key} and values {value}",
+        "literal": "Not a valid Python value"
       }
     },
     "refute": {
diff --git a/purplex/client/src/i18n/locales/es/problems.json b/purplex/client/src/i18n/locales/es/problems.json
index 4ca3c30..c652d84 100644
--- a/purplex/client/src/i18n/locales/es/problems.json
+++ b/purplex/client/src/i18n/locales/es/problems.json
@@ -217,15 +217,27 @@
       "tooltipExhausted": "No quedan sondeos",
       "tooltipDefault": "Consultar el oráculo con estas entradas",
       "srDuplicate": "Estas entradas ya fueron sondeadas. Resultado: {result}",
-      "paramAriaLabel": "Ingresa valor para {name} (tipo: {type})",
-      "paramAriaLabelNoType": "Ingresa valor para {name}",
       "cachedResultAriaLabel": "Resultado en caché: {result}",
-      "valuePlaceholderHint": "valor — texto entre comillas: \"abc\"",
+      "argsAriaLabel": "Argumentos para {name}",
+      "argsHelp": "Enter sondea. Tab en una línea vacía rellena los nombres de los argumentos.",
+      "fillArgs": "Rellenar nombres de argumentos",
+      "lineError": {
+        "unknownKeyword": "Argumento desconocido {name}",
+        "duplicateArgument": "El argumento {name} se dio dos veces",
+        "positionalAfterKeyword": "Argumento posicional después de {name}=; pon primero los argumentos posicionales",
+        "tooManyPositional": "Demasiados argumentos para {name}",
+        "emptyArgument": "Argumento vacío entre comas"
+      },
       "invalidType": {
         "int": "Debe ser un número entero (p. ej. 5)",
         "intRange": "El número entero es demasiado grande (máximo 15 dígitos)",
         "float": "Debe ser un número (p. ej. 1.5)",
-        "bool": "Debe ser true o false"
+        "bool": "Debe ser true o false",
+        "list": "Debe ser una lista, p. ej. [1, 2, 3]",
+        "listItems": "Cada elemento debe ser {kind}",
+        "dict": "Debe ser un diccionario, p. ej. {'{'}\"a\": 1{'}'}",
+        "dictItems": "Las claves deben ser {key} y los valores {value}",
+        "literal": "No es un valor de Python válido"
       }
     },
     "refute": {
diff --git a/purplex/problems_app/handlers/probeable_code/handler.py b/purplex/problems_app/handlers/probeable_code/handler.py
index 47740c5..12f4e07 100644
--- a/purplex/problems_app/handlers/probeable_code/handler.py
+++ b/purplex/problems_app/handlers/probeable_code/handler.py
@@ -15,7 +15,6 @@
 """
 
 import logging
-import re
 from typing import TYPE_CHECKING, Any
 
 from .. import register_handler
@@ -34,22 +33,17 @@
 
 
 def _parse_function_params(signature: str) -> list[dict[str, str]]:
-    """Parse function signature to extract parameter names and types."""
-    match = re.search(r"\(([^)]*)\)", signature)
-    if not match:
-        return []
-    params_str = match.group(1).strip()
-    if not params_str:
-        return []
-    params = []
-    for param in params_str.split(","):
-        param = param.strip()
-        if ":" in param:
-            name, type_hint = param.split(":", 1)
-            params.append({"name": name.strip(), "type": type_hint.strip()})
-        else:
-            params.append({"name": param, "type": "Any"})
-    return params
+    """Parse function signature to extract parameter names and types.
+
+    Delegates to probe_service.parse_function_signature so the probe panel and
+    the probe validator agree on how parameters are split.
+    """
+    # Imported here: the services package imports the handler registry.
+    from purplex.problems_app.services.probe_service import (
+        parse_function_signature,
+    )
+
+    return parse_function_signature(signature)
 
 
 @register_handler("probeable_code")
diff --git a/purplex/problems_app/handlers/probeable_spec/handler.py b/purplex/problems_app/handlers/probeable_spec/handler.py
index fb6ae16..881b33f 100644
--- a/purplex/problems_app/handlers/probeable_spec/handler.py
+++ b/purplex/problems_app/handlers/probeable_spec/handler.py
@@ -16,7 +16,6 @@
 """
 
 import logging
-import re
 from typing import TYPE_CHECKING, Any
 
 from .. import register_handler
@@ -34,22 +33,17 @@
 
 
 def _parse_function_params(signature: str) -> list[dict[str, str]]:
-    """Parse function signature to extract parameter names and types."""
-    match = re.search(r"\(([^)]*)\)", signature)
-    if not match:
-        return []
-    params_str = match.group(1).strip()
-    if not params_str:
-        return []
-    params = []
-    for param in params_str.split(","):
-        param = param.strip()
-        if ":" in param:
-            name, type_hint = param.split(":", 1)
-            params.append({"name": name.strip(), "type": type_hint.strip()})
-        else:
-            params.append({"name": param, "type": "Any"})
-    return params
+    """Parse function signature to extract parameter names and types.
+
+    Delegates to probe_service.parse_function_signature so the probe panel and
+    the probe validator agree on how parameters are split.
+    """
+    # Imported here: the services package imports the handler registry.
+    from purplex.problems_app.services.probe_service import (
+        parse_function_signature,
+    )
+
+    return parse_function_signature(signature)
 
 
 @register_handler("probeable_spec")
diff --git a/purplex/problems_app/management/commands/seed_e2e_data.py b/purplex/problems_app/management/commands/seed_e2e_data.py
index 8643061..4638e09 100644
--- a/purplex/problems_app/management/commands/seed_e2e_data.py
+++ b/purplex/problems_app/management/commands/seed_e2e_data.py
@@ -755,6 +755,7 @@ def handle(self, *args, **options):
         #   p=4  e2e-probeable-hidden     code, explore, hidden signature
         #   p=5  e2e-probeable-spec-open  spec, explore, no segmentation
         #   p=6  e2e-probeable-cooldown-2 code, cooldown 1 probe, +1 per 2 submits
+        #   p=7  e2e-probeable-list       code, explore, tag(items: list[str], prefix)
         #
         # These slugs are separate from the older probeable problems so their
         # defaults can be relied on (get_or_create ignores changed defaults).
@@ -1066,6 +1067,26 @@ def _seed_probeable_workflows(self, course, instructor, now):
                 },
                 [([1, 2], 3, True)],
             ),
+            (
+                # list[str] parameter: item types are validated on both sides.
+                ProbeableCodeProblem,
+                "e2e-probeable-list",
+                {
+                    "title": "E2E Probeable: List of Strings",
+                    "description": "Probe the function, then write it.",
+                    "function_signature": (
+                        "def tag(items: list[str], prefix: str) -> list[str]"
+                    ),
+                    "function_name": "tag",
+                    "reference_solution": (
+                        "def tag(items, prefix):\n"
+                        "    return [prefix + item for item in items]"
+                    ),
+                    "show_function_signature": True,
+                    "probe_mode": "explore",
+                },
+                [([["a", "b"], "x"], ["xa", "xb"], True)],
+            ),
         ]
 
         problem_set, created = ProblemSet.objects.get_or_create(
diff --git a/purplex/problems_app/services/probe_service.py b/purplex/problems_app/services/probe_service.py
index f1ca709..5147ac9 100644
--- a/purplex/problems_app/services/probe_service.py
+++ b/purplex/problems_app/services/probe_service.py
@@ -9,7 +9,6 @@
 
 import json
 import logging
-import re
 from typing import TYPE_CHECKING, Any
 
 from django.conf import settings
@@ -468,33 +467,135 @@ def _build_cooldown_message(
             return f"No probes remaining. Submit {submissions_to_next} more times to unlock more probes."
 
 
+_OPENERS = {"(": ")", "[": "]", "{": "}"}
+_CLOSERS = frozenset(_OPENERS.values())
+
+
+def _split_top_level(text: str, sep: str = ",") -> list[str]:
+    """Split ``text`` on ``sep`` where it is not nested or quoted.
+
+    Brackets ``()``, ``[]`` and ``{}`` raise the nesting depth; single- and
+    double-quoted strings (with backslash escapes) are skipped. Unbalanced
+    input is tolerated: depth never drops below zero.
+
+    Args:
+        text: Text to split, such as a parameter list.
+        sep: Single-character separator.
+
+    Returns:
+        The pieces between top-level separators, unstripped.
+    """
+    parts: list[str] = []
+    depth = 0
+    quote: str | None = None
+    current: list[str] = []
+    i = 0
+    while i < len(text):
+        ch = text[i]
+        if quote:
+            current.append(ch)
+            if ch == "\\" and i + 1 < len(text):
+                current.append(text[i + 1])
+                i += 1
+            elif ch == quote:
+                quote = None
+        elif ch in ("'", '"'):
+            quote = ch
+            current.append(ch)
+        elif ch in _OPENERS:
+            depth += 1
+            current.append(ch)
+        elif ch in _CLOSERS:
+            depth = max(depth - 1, 0)
+            current.append(ch)
+        elif ch == sep and depth == 0:
+            parts.append("".join(current))
+            current = []
+        else:
+            current.append(ch)
+        i += 1
+    parts.append("".join(current))
+    return parts
+
+
+def _extract_params_str(signature: str) -> str | None:
+    """Return the text between the signature's outermost parentheses.
+
+    Scans from the first ``(`` to its matching ``)``, so parentheses inside
+    defaults (``x: tuple = (1, 2)``) do not end the parameter list early.
+
+    Args:
+        signature: Function signature like ``"f(x: int) -> bool"``.
+
+    Returns:
+        The parameter list text, or None when there is no ``(``.
+    """
+    open_idx = signature.find("(")
+    if open_idx == -1:
+        return None
+    depth = 0
+    quote: str | None = None
+    i = open_idx
+    while i < len(signature):
+        ch = signature[i]
+        if quote:
+            if ch == "\\":
+                i += 1
+            elif ch == quote:
+                quote = None
+        elif ch in ("'", '"'):
+            quote = ch
+        elif ch in _OPENERS:
+            depth += 1
+        elif ch in _CLOSERS:
+            depth -= 1
+            if depth == 0:
+                return signature[open_idx + 1 : i]
+        i += 1
+    # Unterminated: take everything after "(".
+    return signature[open_idx + 1 :]
+
+
 def parse_function_signature(signature: str) -> list[dict[str, str]]:
     """
     Parse function signature to extract parameter names and types.
 
+    Parameters are split on top-level commas only, so bracketed annotations
+    such as ``dict[str, int]`` or ``tuple[int, str]`` and bracketed defaults
+    stay one parameter (issue #160). The type keeps any default text
+    (``"int = 3"``); normalize_primitive_type and normalize_container_type
+    strip it.
+
     Args:
         signature: Function signature like "f(x: int, y: str) -> bool"
 
     Returns:
         List of dicts with 'name' and 'type' keys
     """
-    # Extract the part between parentheses
-    match = re.search(r"\(([^)]*)\)", signature)
-    if not match:
+    params_str = _extract_params_str(signature)
+    if params_str is None:
         return []
 
-    params_str = match.group(1).strip()
+    params_str = params_str.strip()
     if not params_str:
         return []
 
     params = []
-    for param in params_str.split(","):
+    for param in _split_top_level(params_str):
         param = param.strip()
-        if ":" in param:
-            name, type_hint = param.split(":", 1)
+        if not param:
+            continue  # trailing comma
+        # Typed only when the colon comes before any default, so an untyped
+        # default containing a colon (sep="a:b") stays one name (mirrors
+        # parseSignatureParams in probeArgs.ts)
+        colon = param.find(":")
+        equals = param.find("=")
+        if colon != -1 and (equals == -1 or colon < equals):
+            name, type_hint = param[:colon], param[colon + 1 :]
             params.append({"name": name.strip(), "type": type_hint.strip()})
         else:
-            params.append({"name": param, "type": "Any"})
+            name = param.split("=", 1)[0]
+            params.append({"name": name.strip(), "type": "Any"})
 
     return params
 
@@ -545,15 +646,167 @@ def _matches_primitive(value: Any, kind: str) -> bool:
     return True
 
 
+_CONTAINER_ALIASES: dict[str, str] = {
+    "list": "list",
+    "tuple": "tuple",
+    "set": "set",
+    "dict": "dict",
+}
+
+
+def _split_type_hint(type_hint: str | None) -> str | None:
+    """Drop a default from a type hint; None for missing or implicit Optional.
+
+    Args:
+        type_hint: Raw type hint such as ``"list[int] = []"``.
+
+    Returns:
+        The stripped annotation, or None when the hint is empty or the default
+        is ``None`` (an implicit ``Optional``, which is not checked).
+    """
+    if not type_hint:
+        return None
+    # "=" never appears inside an annotation, but may appear in a default
+    # string, so split at the first top-level "=" only.
+    base = _split_top_level(type_hint, "=")[0]
+    default = type_hint[len(base) + 1 :] if len(base) < len(type_hint) else ""
+    if default.strip() == "None":
+        return None
+    base = base.strip()
+    return base or None
+
+
+def normalize_container_type(type_hint: str | None) -> dict[str, Any] | None:
+    """Map a parameter type hint to a one-level container description.
+
+    Recognises ``list``, ``tuple``, ``set`` and ``dict`` (and the ``typing``
+    aliases ``List``, ``Tuple``, ``Set``, ``Dict``; case-insensitive), bare or
+    subscripted. Item, key and value kinds are canonical primitive kinds from
+    the alias table, or None when the argument is not a primitive (nested
+    containers, ``Any``, classes), in which case only the shape is checked.
+
+    ``tuple[T]`` and ``tuple[T, ...]`` are treated as homogeneous tuples of
+    ``T``. A fixed-shape tuple such as ``tuple[int, str]`` is checked as shape
+    only (no per-position checks).
+
+    ``Optional[...]``, ``X | None`` and a ``None`` default are not containers
+    here, so they stay unchecked.
+
+    Args:
+        type_hint: Raw type hint such as ``"list[int]"`` or ``"Dict[str, int]"``.
+
+    Returns:
+        None when the hint is not a checked container, otherwise
+        ``{"kind": "list"|"tuple"|"set", "item": kind|None}`` or
+        ``{"kind": "dict", "key": kind|None, "value": kind|None}``.
+    """
+    base = _split_type_hint(type_hint)
+    if base is None:
+        return None
+    if len(_split_top_level(base, "|")) > 1:
+        return None
+
+    bracket = base.find("[")
+    if bracket == -1:
+        head, args = base, None
+    else:
+        if not base.endswith("]"):
+            return None
+        head, args = base[:bracket], base[bracket + 1 : -1]
+
+    kind = _CONTAINER_ALIASES.get(head.strip().lower())
+    if kind is None:
+        return None
+
+    arg_list = [a.strip() for a in _split_top_level(args)] if args is not None else []
+
+    def _primitive(arg: str) -> str | None:
+        return _PRIMITIVE_ALIASES.get(arg.lower())
+
+    if kind == "dict":
+        if len(arg_list) == 2:
+            return {
+                "kind": "dict",
+                "key": _primitive(arg_list[0]),
+                "value": _primitive(arg_list[1]),
+            }
+        return {"kind": "dict", "key": None, "value": None}
+
+    item = None
+    if len(arg_list) == 1 or (
+        kind == "tuple" and len(arg_list) == 2 and arg_list[1] == "..."
+    ):
+        item = _primitive(arg_list[0])
+    return {"kind": kind, "item": item}
+
+
+def _matches_container(value: Any, spec: dict[str, Any]) -> bool:
+    """Check a JSON-decoded value against a normalize_container_type spec.
+
+    list, tuple and set values arrive as JSON arrays. Dict keys arrive as JSON
+    object keys, which are always strings, so keys are only checked against a
+    ``str`` key kind; other key kinds are not checkable on the wire.
+
+    Args:
+        value: The probe value.
+        spec: Output of normalize_container_type.
+
+    Returns:
+        True if the value has the container shape and every checked item,
+        key and value matches its primitive kind.
+    """
+    if spec["kind"] == "dict":
+        if not isinstance(value, dict):
+            return False
+        key_kind, value_kind = spec["key"], spec["value"]
+        if key_kind == "str" and not all(_matches_primitive(k, "str") for k in value):
+            return False
+        if value_kind and not all(
+            _matches_primitive(v, value_kind) for v in value.values()
+        ):
+            return False
+        return True
+
+    if not isinstance(value, list):
+        return False
+    item_kind = spec["item"]
+    if item_kind and not all(_matches_primitive(v, item_kind) for v in value):
+        return False
+    return True
+
+
+def _container_description(spec: dict[str, Any]) -> str:
+    """Describe a container spec for a revealed-type error message.
+
+    Args:
+        spec: Output of normalize_container_type.
+
+    Returns:
+        Text such as ``"a list of str"``, ``"a dict of str to int"`` or
+        ``"a list"`` when the item kinds are unchecked.
+    """
+    kind = spec["kind"]
+    if kind == "dict":
+        if spec["key"] and spec["value"]:
+            return f"a dict of {spec['key']} to {spec['value']}"
+        return "a dict"
+    if spec["item"]:
+        return f"a {kind} of {spec['item']}"
+    return f"a {kind}"
+
+
 def validate_probe_input(
     signature: str, probe_input: dict[str, Any], *, reveal_types: bool = True
 ) -> tuple[bool, str | None]:
     """
     Validate probe input against function signature.
 
-    Parameter names are checked first (missing, then unknown). Then each
-    parameter with a primitive type hint (int, float, bool, str and their
-    aliases) is checked against its value; other hints are not checked.
+    Parameter names are checked first (missing, then unknown). Then, in
+    signature order, each parameter with a primitive type hint (int, float,
+    bool, str and their aliases) is checked against its value, and each
+    one-level container hint (list/tuple/set/dict, see
+    normalize_container_type) is checked for shape and primitive items.
+    Other hints (Any, Optional, nested item types, classes) are not checked.
 
     Args:
         signature: The function signature
@@ -583,15 +836,22 @@ def validate_probe_input(
     if extra:
         return False, f"Unknown parameters: {', '.join(extra)}"
 
-    # Check primitive types in signature order
+    # Check primitive and container types in signature order
     for param in params:
-        kind = normalize_primitive_type(param["type"])
-        if kind is None:
-            continue
         name = param["name"]
-        if not _matches_primitive(probe_input[name], kind):
+        value = probe_input[name]
+        kind = normalize_primitive_type(param["type"])
+        if kind is not None:
+            if _matches_primitive(value, kind):
+                continue
             if not reveal_types:
                 return False, f"That value is not valid for parameter '{name}'"
             return False, f"Parameter '{name}' must be {_KIND_ARTICLES[kind]} {kind}"
+        spec = normalize_container_type(param["type"])
+        if spec is None or _matches_container(value, spec):
+            continue
+        if not reveal_types:
+            return False, f"That value is not valid for parameter '{name}'"
+        return False, f"Parameter '{name}' must be {_container_description(spec)}"
 
     return True, None
diff --git a/tests/unit/test_probe_input_containers.py b/tests/unit/test_probe_input_containers.py
new file mode 100644
index 0000000..bfd3740
--- /dev/null
+++ b/tests/unit/test_probe_input_containers.py
@@ -0,0 +1,285 @@
+"""Unit tests for container probe input validation and signature parsing.
+
+Covers bracket-aware ``parse_function_signature`` (issue #160) and the
+one-level container checks in ``validate_probe_input``: ``list[str]`` used to
+accept integers silently. No database access.
+
+Fixed-shape tuples such as ``tuple[int, str]`` are checked as shape only
+(must be a JSON array); per-position checks are deliberately not done.
+"""
+
+import pytest
+
+from purplex.problems_app.services.probe_service import (
+    normalize_container_type,
+    parse_function_signature,
+    validate_probe_input,
+)
+
+pytestmark = [pytest.mark.unit]
+
+HIDDEN = "That value is not valid for parameter '{}'"
+
+
+class TestSignatureParsing:
+    def test_dict_annotation_is_one_parameter(self):
+        assert parse_function_signature("def f(m: dict[str, int], k: str)") == [
+            {"name": "m", "type": "dict[str, int]"},
+            {"name": "k", "type": "str"},
+        ]
+
+    def test_tuple_annotation_is_one_parameter(self):
+        assert parse_function_signature("def f(p: tuple[int, str]) -> int") == [
+            {"name": "p", "type": "tuple[int, str]"}
+        ]
+
+    def test_bracketed_defaults(self):
+        sig = "def f(items: list[int] = [], pair: tuple = (1, 2), x: int = 5)"
+        assert parse_function_signature(sig) == [
+            {"name": "items", "type": "list[int] = []"},
+            {"name": "pair", "type": "tuple = (1, 2)"},
+            {"name": "x", "type": "int = 5"},
+        ]
+
+    def test_quoted_comma_in_default(self):
+        assert parse_function_signature('def f(sep: str = ",", n: int)') == [
+            {"name": "sep", "type": 'str = ","'},
+            {"name": "n", "type": "int"},
+        ]
+
+    def test_untyped_default_keeps_bare_name(self):
+        assert parse_function_signature("def f(x=5, y)") == [
+            {"name": "x", "type": "Any"},
+            {"name": "y", "type": "Any"},
+        ]
+
+    def test_untyped_default_with_colon_keeps_bare_name(self):
+        assert parse_function_signature('def f(sep="a:b", n: int)') == [
+            {"name": "sep", "type": "Any"},
+            {"name": "n", "type": "int"},
+        ]
+
+    def test_trailing_comma_and_empty(self):
+        assert parse_function_signature("def f(a: int,)") == [
+            {"name": "a", "type": "int"}
+        ]
+        assert parse_function_signature("def f()") == []
+        assert parse_function_signature("no parens") == []
+
+
+class TestNormalizeContainer:
+    @pytest.mark.parametrize(
+        ("hint", "expected"),
+        [
+            ("list[int]", {"kind": "list", "item": "int"}),
+            ("List[String]", {"kind": "list", "item": "str"}),
+            ("set[float]", {"kind": "set", "item": "float"}),
+            ("tuple[int]", {"kind": "tuple", "item": "int"}),
+            ("tuple[int, ...]", {"kind": "tuple", "item": "int"}),
+            ("tuple[int, str]", {"kind": "tuple", "item": None}),
+            ("list", {"kind": "list", "item": None}),
+            ("list[list[int]]", {"kind": "list", "item": None}),
+            ("list[Any]", {"kind": "list", "item": None}),
+            ("Dict[str, int]", {"kind": "dict", "key": "str", "value": "int"}),
+            ("dict", {"kind": "dict", "key": None, "value": None}),
+            ("list[int] = []", {"kind": "list", "item": "int"}),
+        ],
+    )
+    def test_containers(self, hint, expected):
+        assert normalize_container_type(hint) == expected
+
+    @pytest.mark.parametrize(
+        "hint",
+        [
+            None,
+            "",
+            "int",
+            "Any",
+            "Optional[list[int]]",
+            "list[int] | None",
+            "list[int] = None",
+            "MyClass[int]",
+        ],
+    )
+    def test_not_checked(self, hint):
+        assert normalize_container_type(hint) is None
+
+
+class TestListItems:
+    def test_list_int_accepts_ints(self):
+        assert validate_probe_input("def f(x: list[int])", {"x": [1, -2, 3]}) == (
+            True,
+            None,
+        )
+
+    def test_empty_list_accepted(self):
+        assert validate_probe_input("def f(x: list[str])", {"x": []}) == (True, None)
+
+    def test_list_int_rejects_string_item(self):
+        assert validate_probe_input("def f(x: list[int])", {"x": [1, "2"]}) == (
+            False,
+            "Parameter 'x' must be a list of int",
+        )
+
+    def test_list_str_rejects_int_item(self):
+        """The maintainer's bug: list[str] silently accepted integers."""
+        ok, err = validate_probe_input(
+            "def schedule(tasks: list[str])", {"tasks": ["a", 2]}
+        )
+        assert ok is False
+        assert err == "Parameter 'tasks' must be a list of str"
+
+    def test_list_int_rejects_bool_item(self):
+        assert validate_probe_input("def f(x: list[int])", {"x": [1, True]}) == (
+            False,
+            "Parameter 'x' must be a list of int",
+        )
+
+    def test_list_float_accepts_ints(self):
+        assert validate_probe_input("def f(x: list[float])", {"x": [1, 2.5]}) == (
+            True,
+            None,
+        )
+
+    @pytest.mark.parametrize("value", ["[1, 2]", 5, None, {"a": 1}])
+    def test_list_rejects_non_array(self, value):
+        assert validate_probe_input("def f(x: list[int])", {"x": value}) == (
+            False,
+            "Parameter 'x' must be a list of int",
+        )
+
+    def test_typing_alias(self):
+        assert validate_probe_input("def f(x: List[str])", {"x": [1]}) == (
+            False,
+            "Parameter 'x' must be a list of str",
+        )
+
+
+class TestTupleAndSet:
+    def test_tuple_of_int(self):
+        assert validate_probe_input("def f(x: tuple[int, ...])", {"x": [1, 2]}) == (
+            True,
+            None,
+        )
+        assert validate_probe_input("def f(x: tuple[int])", {"x": ["a"]}) == (
+            False,
+            "Parameter 'x' must be a tuple of int",
+        )
+
+    def test_set_of_str(self):
+        assert validate_probe_input("def f(x: set[str])", {"x": ["a", 1]}) == (
+            False,
+            "Parameter 'x' must be a set of str",
+        )
+
+    def test_fixed_shape_tuple_is_shape_only(self):
+        sig = "def f(p: tuple[int, str], n: int)"
+        assert validate_probe_input(sig, {"p": [1, "a"], "n": 2}) == (True, None)
+        # Positions are not checked, only that the value is an array.
+        assert validate_probe_input(sig, {"p": ["a", 1], "n": 2}) == (True, None)
+        assert validate_probe_input(sig, {"p": "1,a", "n": 2}) == (
+            False,
+            "Parameter 'p' must be a tuple",
+        )
+
+
+class TestBareAndNested:
+    def test_bare_list_rejects_dict(self):
+        assert validate_probe_input("def f(x: list)", {"x": {"a": 1}}) == (
+            False,
+            "Parameter 'x' must be a list",
+        )
+
+    def test_bare_list_accepts_mixed_items(self):
+        assert validate_probe_input("def f(x: list)", {"x": [1, "a", None]}) == (
+            True,
+            None,
+        )
+
+    def test_bare_dict_rejects_list(self):
+        assert validate_probe_input("def f(x: dict)", {"x": [1]}) == (
+            False,
+            "Parameter 'x' must be a dict",
+        )
+
+    def test_nested_list_checked_for_shape_only(self):
+        sig = "def f(x: list[list[int]])"
+        assert validate_probe_input(sig, {"x": [["a"], [1]]}) == (True, None)
+        assert validate_probe_input(sig, {"x": [1, 2]}) == (True, None)
+        assert validate_probe_input(sig, {"x": "nope"}) == (
+            False,
+            "Parameter 'x' must be a list",
+        )
+
+
+class TestDict:
+    SIG = "def f(counts: dict[str, int], label: str)"
+
+    def test_accepts_matching(self):
+        assert validate_probe_input(
+            self.SIG, {"counts": {"a": 1, "b": 2}, "label": "x"}
+        ) == (True, None)
+
+    def test_rejects_bad_value(self):
+        assert validate_probe_input(self.SIG, {"counts": {"a": "1"}, "label": "x"}) == (
+            False,
+            "Parameter 'counts' must be a dict of str to int",
+        )
+
+    def test_rejects_non_object(self):
+        assert validate_probe_input(self.SIG, {"counts": [], "label": "x"}) == (
+            False,
+            "Parameter 'counts' must be a dict of str to int",
+        )
+
+    def test_non_str_keys_not_checkable_on_the_wire(self):
+        """JSON object keys are always strings, so int keys are not checked."""
+        sig = "def f(m: dict[int, str])"
+        assert validate_probe_input(sig, {"m": {"1": "a"}}) == (True, None)
+        assert validate_probe_input(sig, {"m": {"1": 2}}) == (
+            False,
+            "Parameter 'm' must be a dict of int to str",
+        )
+
+    def test_signature_order_first_mismatch(self):
+        assert validate_probe_input(
+            "def f(a: list[int], b: str)", {"b": 5, "a": ["x"]}
+        ) == (False, "Parameter 'a' must be a list of int")
+
+
+class TestHiddenAndDefaults:
+    @pytest.mark.parametrize(
+        ("hint", "bad_value"),
+        [
+            ("list[str]", [1]),
+            ("list", {"a": 1}),
+            ("dict[str, int]", {"a": "b"}),
+            ("tuple[int, str]", "x"),
+        ],
+    )
+    def test_hidden_message_is_generic(self, hint, bad_value):
+        ok, err = validate_probe_input(
+            f"def f(tasks: {hint})", {"tasks": bad_value}, reveal_types=False
+        )
+        assert ok is False
+        assert err == HIDDEN.format("tasks")
+        for word in ("list", "dict", "tuple", "int", "str"):
+            assert word not in err
+
+    def test_default_with_brackets_still_checked(self):
+        sig = "def f(items: list[int] = [], n: int = 0)"
+        assert validate_probe_input(sig, {"items": [1], "n": 2}) == (True, None)
+        assert validate_probe_input(sig, {"items": ["a"], "n": 2}) == (
+            False,
+            "Parameter 'items' must be a list of int",
+        )
+
+    def test_none_default_is_unchecked(self):
+        sig = "def f(items: list[int] = None)"
+        assert validate_probe_input(sig, {"items": None}) == (True, None)
+        assert validate_probe_input(sig, {"items": ["a"]}) == (True, None)
+
+    def test_name_checks_still_first(self):
+        assert validate_probe_input(
+            "def f(m: dict[str, int], k: str)", {"m": "bad"}
+        ) == (False, "Missing required parameters: k")
diff --git a/tests/unit/test_probe_input_validation.py b/tests/unit/test_probe_input_validation.py
index af2a740..4352dba 100644
--- a/tests/unit/test_probe_input_validation.py
+++ b/tests/unit/test_probe_input_validation.py
@@ -129,14 +129,14 @@ class TestUncheckedHints:
         [
             "def f(x)",
             "def f(x: Any)",
-            "def f(x: list[int])",
-            "def f(x: dict)",
             "def f(x: Optional[int])",
             "def f(x: MyClass)",
         ],
     )
     @pytest.mark.parametrize("value", ["abc", 5, None, [1, 2], {"k": 1}])
     def test_non_primitive_hints_skipped(self, signature, value):
+        # Container hints (list[int], dict, ...) are checked since the call
+        # line; see test_probe_input_containers.py.
         assert _valid(signature, {"x": value}) == (True, None)
 
     @pytest.mark.parametrize("hint", [None, "", "Any", "list[int]", "Optional[int]"])