a2acalling 0.6.75 → 0.6.76

package/docs/plans/2026-03-06-a2a-103-standalone-e2e-tests.md

@@ -0,0 +1,810 @@
+# A2A-103: Standalone App E2E Test Suite Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Build an end-to-end test suite validating the full standalone app experience: first launch onboarding, core dashboard workflows, sidecar lifecycle, and update detection — all via HTTP API, no macOS GUI required.
+
+**Architecture:** Four test files covering distinct user journeys, plus a shared environment helper. Tests use the existing `test/run.js` runner (E2E tier), `createE2EEnv` for isolated config, and real Express server instances. Update tests use a local mock HTTP server for the manifest endpoint.
+
+**Tech Stack:** Node.js, existing test runner (`test/run.js`), Express, `child_process` for sidecar simulation, `http` module for mock update server.
+
+**Dependencies:** A2A-99 (onboarding API endpoints), A2A-100 (updater events). Both must be merged first.
+
+---
+
+## Task 1: Create Standalone E2E Environment Helper
+
+**Files:**
+- Create: `test/e2e/helpers/standalone-env.js`
+
+**Step 1: Create the shared helper**
+
+Builds on the existing `test/e2e/env.js` pattern. Provides:
+- `createStandaloneEnv()` — creates temp config dir, starts an Express server with all dashboard routes, returns `{ server, port, baseUrl, configDir, cleanup }`
+- Server binds to port 0 (OS-assigned) for conflict-free testing
+- Uses `A2A_CONFIG_DIR` env var for isolated config
+- Cleanup kills server and removes temp files
+
+```js
+/**
+ * Standalone E2E environment helper (A2A-103)
+ *
+ * Spins up an isolated server instance with temp config for testing
+ * the full standalone app user journey via HTTP API.
+ */
+const http = require('http');
+const path = require('path');
+const { createE2EEnv } = require('../env');
+
+/**
+ * Create a standalone test environment with a running server.
+ * Returns { server, port, baseUrl, configDir, env, request, cleanup }
+ */
+async function createStandaloneEnv(opts = {}) {
+  const e2e = createE2EEnv('standalone');
+
+  // Point config to temp dir
+  process.env.A2A_CONFIG_DIR = e2e.configDir;
+  process.env.A2A_RUNTIME = 'test';
+
+  // Bust module caches so each test gets fresh state
+  const cacheBust = [
+    '../../src/routes/dashboard',
+    '../../src/lib/logger',
+    '../../src/lib/tokens',
+    '../../src/lib/config',
+    '../../src/lib/disclosure',
+    '../../src/lib/conversations',
+    '../../src/lib/callbook',
+    '../../src/lib/dashboard-events'
+  ];
+  for (const mod of cacheBust) {
+    try { delete require.cache[require.resolve(mod)]; } catch (_) {}
+  }
+
+  const express = require('express');
+  const { createDashboardApiRouter } = require('../../src/routes/dashboard');
+  const loggerModule = require('../../src/lib/logger');
+
+  const app = express();
+  const logger = loggerModule.createLogger({
+    component: 'test.standalone',
+    configDir: e2e.configDir,
+    stdout: false
+  });
+
+  const routerOpts = { logger };
+  if (typeof opts.getUpdateManager === 'function') {
+    routerOpts.getUpdateManager = opts.getUpdateManager;
+  }
+  app.use('/api/a2a/dashboard', createDashboardApiRouter(routerOpts));
+
+  const port = await e2e.findAvailablePort();
+  const server = await new Promise((resolve, reject) => {
+    const srv = app.listen(port, '127.0.0.1', () => resolve(srv));
+    srv.on('error', reject);
+  });
+
+  const baseUrl = `http://127.0.0.1:${port}/api/a2a/dashboard`;
+
+  /**
+   * Simple HTTP request helper.
+   * NOTE: urlPath must be an absolute path (e.g. '/api/a2a/dashboard/status').
+   * new URL(absolutePath, baseUrl) discards the base path — this is intentional.
+   */
+  function request(method, urlPath, body) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(urlPath, baseUrl);
+      const data = body ? JSON.stringify(body) : null;
+      const req = http.request({
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+          ...(data ? { 'Content-Length': Buffer.byteLength(data) } : {})
+        }
+      }, (res) => {
+        let chunks = '';
+        res.on('data', c => chunks += c);
+        res.on('end', () => {
+          try { resolve({ status: res.statusCode, headers: res.headers, body: JSON.parse(chunks) }); }
+          catch { resolve({ status: res.statusCode, headers: res.headers, body: chunks }); }
+        });
+      });
+      req.on('error', reject);
+      if (data) req.write(data);
+      req.end();
+    });
+  }
+
+  function cleanup() {
+    try { server.close(); } catch (_) {}
+    try { loggerModule.closeAllLoggerStores(); } catch (_) {}
+    e2e.cleanup();
+    delete process.env.A2A_CONFIG_DIR;
+    delete process.env.A2A_RUNTIME;
+  }
+
+  return { server, port, baseUrl, configDir: e2e.configDir, env: e2e.env, request, cleanup };
+}
+
+module.exports = { createStandaloneEnv };
+```
+
+**Step 2: Commit**
+
+```bash
+mkdir -p test/e2e/helpers
+git add test/e2e/helpers/standalone-env.js
+git commit -m "feat(a2a-103): add standalone E2E environment helper"
+```
+
+---
+
+## Task 2: Onboarding E2E Tests
+
+**Files:**
+- Create: `test/e2e/standalone-onboarding.test.js`
+
+**Step 1: Create onboarding flow tests**
+
+Tests the full first-run experience: fresh config → wizard API → config written → dashboard accessible.
+
+```js
+/**
+ * Standalone Onboarding E2E Tests (A2A-103)
+ *
+ * Tests the first-run onboarding flow:
+ *   - Fresh install shows not-onboarded status
+ *   - Port detection returns available port
+ *   - Completing onboarding writes config and disclosure
+ *   - After onboarding, status shows complete
+ *   - Dashboard endpoints become accessible
+ */
+
+module.exports = function (test, assert, helpers, ctx) {
+  const { createStandaloneEnv } = require('./helpers/standalone-env');
+  let env;
+
+  ctx.afterEach(async () => {
+    if (env) { env.cleanup(); env = null; }
+  });
+
+  test('standalone: fresh install shows not-onboarded', async () => {
+    env = await createStandaloneEnv();
+    const res = await env.request('GET', '/api/a2a/dashboard/onboarding/status');
+    assert.equal(res.status, 200);
+    assert.equal(res.body.success, true);
+    assert.equal(res.body.onboarded, false);
+  });
+
+  test('standalone: port detection returns candidates', async () => {
+    env = await createStandaloneEnv();
+    const res = await env.request('GET', '/api/a2a/dashboard/onboarding/detect-port');
+    assert.equal(res.status, 200);
+    assert.equal(res.body.success, true);
+    assert.ok(Array.isArray(res.body.candidates));
+  });
+
+  test('standalone: complete onboarding writes config', async () => {
+    env = await createStandaloneEnv();
+    const res = await env.request('POST', '/api/a2a/dashboard/onboarding/complete', {
+      agentName: 'E2E Test Agent',
+      defaultTier: 'public',
+      port: 3099,
+      hostname: 'localhost:3099',
+      topics: ['coding', 'research']
+    });
+    assert.equal(res.status, 200);
+    assert.equal(res.body.success, true);
+
+    // Verify status now shows onboarded
+    const status = await env.request('GET', '/api/a2a/dashboard/onboarding/status');
+    assert.equal(status.body.onboarded, true);
+  });
+
+  test('standalone: full onboarding → dashboard flow', async () => {
+    env = await createStandaloneEnv();
+
+    // Step 1: Complete onboarding
+    await env.request('POST', '/api/a2a/dashboard/onboarding/complete', {
+      agentName: 'Flow Test Agent',
+      defaultTier: 'friends',
+      port: 3098,
+      topics: ['general']
+    });
+
+    // Step 2: Dashboard settings should reflect onboarding
+    const settings = await env.request('GET', '/api/a2a/dashboard/settings');
+    assert.equal(settings.status, 200);
+    assert.ok(settings.body.success !== false, 'Settings endpoint accessible after onboarding');
+  });
+
+  test('standalone: onboarding rejects empty agent name', async () => {
+    env = await createStandaloneEnv();
+    const res = await env.request('POST', '/api/a2a/dashboard/onboarding/complete', {
+      agentName: '',
+      defaultTier: 'public',
+      port: 3099
+    });
+    assert.equal(res.status, 400);
+    assert.equal(res.body.success, false);
+  });
+};
+```
+
+**Step 2: Run tests**
+
+```bash
+node test/run.js --e2e --filter standalone-onboarding
+```
+
+Expected: All pass.
+
+**Step 3: Commit**
+
+```bash
+git add test/e2e/standalone-onboarding.test.js
+git commit -m "test(a2a-103): add standalone onboarding E2E tests"
+```
+
+---
+
+## Task 3: Core Workflow E2E Tests
+
+**Files:**
+- Create: `test/e2e/standalone-workflows.test.js`
+
+**Step 1: Create workflow tests**
+
+After onboarding, exercise core dashboard workflows: tokens, contacts, logs.
+
+```js
+/**
+ * Standalone Workflow E2E Tests (A2A-103)
+ *
+ * Tests core dashboard workflows after onboarding:
+ *   - Create token → list tokens → verify token
+ *   - Settings accessible and modifiable
+ *   - Logs endpoint returns data
+ */
+
+module.exports = function (test, assert, helpers, ctx) {
+  const { createStandaloneEnv } = require('./helpers/standalone-env');
+  let env;
+
+  async function setupOnboarded() {
+    env = await createStandaloneEnv();
+    await env.request('POST', '/api/a2a/dashboard/onboarding/complete', {
+      agentName: 'Workflow Agent',
+      defaultTier: 'public',
+      port: 3097,
+      topics: ['coding']
+    });
+    return env;
+  }
+
+  ctx.afterEach(async () => {
+    if (env) { env.cleanup(); env = null; }
+  });
+
+  test('standalone workflow: create and list tokens', async () => {
+    await setupOnboarded();
+
+    // Create a token
+    const create = await env.request('POST', '/api/a2a/dashboard/tokens', {
+      name: 'E2E-Token',
+      permissions: 'public',
+      expires: '1h'
+    });
+    assert.equal(create.status, 200);
+    assert.equal(create.body.success, true);
+    assert.ok(create.body.token);
+
+    // List tokens
+    const list = await env.request('GET', '/api/a2a/dashboard/tokens');
+    assert.equal(list.status, 200);
+    assert.ok(Array.isArray(list.body.tokens));
+    assert.ok(list.body.tokens.length >= 1, 'Should have at least 1 token');
+  });
+
+  test('standalone workflow: create and list contacts', async () => {
+    await setupOnboarded();
+
+    // Create a contact via invite URL
+    const create = await env.request('POST', '/api/a2a/dashboard/contacts', {
+      invite_url: 'a2a://localhost:9999/fed_test_contact_123',
+      name: 'E2E Contact',
+      owner: 'Test Owner'
+    });
+    assert.equal(create.status, 200);
+    assert.equal(create.body.success, true);
+    assert.ok(create.body.contact, 'Should return created contact');
+    assert.equal(create.body.contact.name, 'E2E Contact');
+
+    // List contacts — should include the one we just created
+    const list = await env.request('GET', '/api/a2a/dashboard/contacts');
+    assert.equal(list.status, 200);
+    assert.ok(Array.isArray(list.body.contacts));
+    assert.ok(list.body.contacts.length >= 1, 'Should have at least 1 contact');
+    const found = list.body.contacts.find(c => c.name === 'E2E Contact');
+    assert.ok(found, 'Created contact should appear in list');
+  });
+
+  test('standalone workflow: contact creation requires invite_url', async () => {
+    await setupOnboarded();
+    const res = await env.request('POST', '/api/a2a/dashboard/contacts', {
+      name: 'No URL Contact'
+    });
+    assert.equal(res.status, 400);
+    assert.equal(res.body.success, false);
+    assert.equal(res.body.error, 'invite_url_required');
+  });
+
+  test('standalone workflow: settings endpoint works', async () => {
+    await setupOnboarded();
+    const res = await env.request('GET', '/api/a2a/dashboard/settings');
+    assert.equal(res.status, 200);
+  });
+
+  test('standalone workflow: logs endpoint returns data', async () => {
+    await setupOnboarded();
+    const res = await env.request('GET', '/api/a2a/dashboard/logs');
+    assert.equal(res.status, 200);
+    assert.ok(res.body.success !== false);
+  });
+
+  test('standalone workflow: events endpoint returns data', async () => {
+    await setupOnboarded();
+    const res = await env.request('GET', '/api/a2a/dashboard/events');
+    assert.equal(res.status, 200);
+  });
+};
+```
+
+**Step 2: Run tests**
+
+```bash
+node test/run.js --e2e --filter standalone-workflows
+```
+
+**Step 3: Commit**
+
+```bash
+git add test/e2e/standalone-workflows.test.js
+git commit -m "test(a2a-103): add standalone workflow E2E tests"
+```
+
+---
+
+## Task 4: Sidecar Lifecycle E2E Tests
+
+**Files:**
+- Create: `test/e2e/standalone-sidecar.test.js`
+
+**Step 1: Create sidecar lifecycle tests**
+
+Tests server start, health check, and crash recovery simulation via child_process.
+
+```js
+/**
+ * Standalone Sidecar Lifecycle E2E Tests (A2A-103)
+ *
+ * Tests server lifecycle without requiring the native Tauri app:
+ *   - Server starts on expected port and health endpoint responds
+ *   - Server shutdown is graceful
+ *   - Crash recovery: kill server, verify it can be restarted
+ */
+
+module.exports = function (test, assert, helpers, ctx) {
+  const { spawn } = require('child_process');
+  const http = require('http');
+  const { createE2EEnv } = require('./env');
+  const path = require('path');
+
+  let env;
+  let serverProc;
+
+  function httpGet(port, urlPath) {
+    return new Promise((resolve, reject) => {
+      const req = http.get({ hostname: '127.0.0.1', port, path: urlPath, timeout: 3000 }, (res) => {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => {
+          try { resolve({ status: res.statusCode, body: JSON.parse(data) }); }
+          catch { resolve({ status: res.statusCode, body: data }); }
+        });
+      });
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+    });
+  }
+
+  function waitForServer(port, maxWait = 5000) {
+    const start = Date.now();
+    return new Promise((resolve, reject) => {
+      function check() {
+        httpGet(port, '/api/a2a/status')
+          .then(res => {
+            if (res.status === 200) return resolve(res);
+            if (Date.now() - start > maxWait) return reject(new Error('Server did not start'));
+            setTimeout(check, 200);
+          })
+          .catch(() => {
+            if (Date.now() - start > maxWait) return reject(new Error('Server did not start'));
+            setTimeout(check, 200);
+          });
+      }
+      check();
+    });
+  }
+
+  ctx.afterEach(async () => {
+    if (serverProc && !serverProc.killed) {
+      serverProc.kill('SIGTERM');
+      serverProc = null;
+    }
+    if (env) { env.cleanup(); env = null; }
+  });
+
+  test('standalone sidecar: server starts and responds to health check', async () => {
+    env = createE2EEnv('sidecar');
+    const port = await env.findAvailablePort();
+
+    serverProc = spawn(process.execPath, [
+      path.join(__dirname, '../../bin/cli.js'), 'server', '--port', String(port)
+    ], {
+      env: { ...env.env, A2A_RUNTIME: 'test' },
+      stdio: 'pipe'
+    });
+
+    // try/finally ensures process cleanup even if assertions fail
+    // (the test runner's afterEach only fires on success)
+    try {
+      const res = await waitForServer(port);
+      assert.equal(res.status, 200, 'Health endpoint responds 200');
+    } catch (err) {
+      if (serverProc && !serverProc.killed) { serverProc.kill('SIGKILL'); serverProc = null; }
+      throw err;
+    }
+  });
+
+  test('standalone sidecar: server handles SIGTERM gracefully', async () => {
+    env = createE2EEnv('sidecar-term');
+    const port = await env.findAvailablePort();
+
+    serverProc = spawn(process.execPath, [
+      path.join(__dirname, '../../bin/cli.js'), 'server', '--port', String(port)
+    ], {
+      env: { ...env.env, A2A_RUNTIME: 'test' },
+      stdio: 'pipe'
+    });
+
+    try {
+      await waitForServer(port);
+
+      // Send SIGTERM and wait for exit
+      const exitPromise = new Promise(resolve => {
+        serverProc.on('exit', (code, signal) => resolve({ code, signal }));
+      });
+      serverProc.kill('SIGTERM');
+      const result = await exitPromise;
+      serverProc = null;
+
+      // Server should exit cleanly (code 0 or signal SIGTERM)
+      assert.ok(
+        result.code === 0 || result.signal === 'SIGTERM',
+        'Server should exit gracefully on SIGTERM'
+      );
+    } catch (err) {
+      if (serverProc && !serverProc.killed) { serverProc.kill('SIGKILL'); serverProc = null; }
+      throw err;
+    }
+  });
+
+  test('standalone sidecar: restart after crash', async () => {
+    env = createE2EEnv('sidecar-crash');
+    const port = await env.findAvailablePort();
+
+    try {
+      // Start server
+      serverProc = spawn(process.execPath, [
+        path.join(__dirname, '../../bin/cli.js'), 'server', '--port', String(port)
+      ], {
+        env: { ...env.env, A2A_RUNTIME: 'test' },
+        stdio: 'pipe'
+      });
+
+      await waitForServer(port);
+
+      // Kill with SIGKILL (simulate crash)
+      serverProc.kill('SIGKILL');
+      await new Promise(resolve => serverProc.on('exit', resolve));
+
+      // Restart on same port
+      serverProc = spawn(process.execPath, [
+        path.join(__dirname, '../../bin/cli.js'), 'server', '--port', String(port)
+      ], {
+        env: { ...env.env, A2A_RUNTIME: 'test' },
+        stdio: 'pipe'
+      });
+
+      const res = await waitForServer(port);
+      assert.equal(res.status, 200, 'Server restarts after crash');
+    } catch (err) {
+      if (serverProc && !serverProc.killed) { serverProc.kill('SIGKILL'); serverProc = null; }
+      throw err;
+    }
+  });
+};
+```
+
+**Step 2: Run tests**
+
+```bash
+node test/run.js --e2e --filter standalone-sidecar
+```
+
+**Step 3: Commit**
+
+```bash
+git add test/e2e/standalone-sidecar.test.js
+git commit -m "test(a2a-103): add standalone sidecar lifecycle E2E tests"
+```
+
+---
+
+## Task 5: Updater E2E Tests
+
+**Files:**
+- Create: `test/e2e/standalone-updater.test.js`
+
+**Step 1: Create updater tests with mock UpdateManager**
+
+These tests verify the update detection and notification flow through the dashboard API endpoints (`GET /update/status`, `POST /update/check`). A mock `UpdateManager` is wired into `createStandaloneEnv` via the `getUpdateManager` option, simulating the state transitions that the real manager produces.
+
+NOTE: The actual Tauri updater plugin runs in the native app. These tests verify the server-side update check infrastructure that the dashboard UI communicates with.
+
+```js
+/**
+ * Standalone Updater E2E Tests (A2A-103)
+ *
+ * Tests update detection via the dashboard API using a mock UpdateManager:
+ *   - Update status returns current version and state
+ *   - Manual check transitions state from up_to_date → available when newer version exists
+ *   - Manual check stays up_to_date when version is current
+ *   - Update check without manager returns 503
+ */
+
+module.exports = function (test, assert, helpers, ctx) {
+  const { createStandaloneEnv } = require('./helpers/standalone-env');
+  const pkg = require('../../package.json');
+  let env;
+
+  ctx.afterEach(async () => {
+    if (env) { env.cleanup(); env = null; }
+  });
+
+  /**
+   * Create a mock UpdateManager that simulates the real manager's interface.
+   * triggerCheck() updates internal state based on the configured latestVersion.
+   */
+  function createMockUpdateManager(latestVersion) {
+    const state = {
+      enabled: true,
+      state: 'up_to_date',
+      current_version: pkg.version,
+      latest_version: null,
+      target_version: null,
+      active_calls: 0,
+      interval_ms: 3600000,
+      allow_major: false,
+      last_checked_at: null,
+      last_success_at: null,
+      last_error: null,
+      defer_reason: null
+    };
+
+    return {
+      getStatus() { return { ...state }; },
+      async triggerCheck() {
+        state.last_checked_at = new Date().toISOString();
+        state.last_success_at = state.last_checked_at;
+        state.latest_version = latestVersion;
+        // Compare versions: if latest > current, state becomes 'available'
+        const { compareVersions } = require('../../src/lib/update-checker');
+        if (compareVersions(pkg.version, latestVersion) < 0) {
+          state.state = 'available';
+          state.target_version = latestVersion;
+        } else {
+          state.state = 'up_to_date';
+          state.target_version = null;
+        }
+      },
+      async triggerUpdate() {
+        state.state = 'updating';
+      }
+    };
+  }
+
+  test('standalone updater: status returns current version before check', async () => {
+    const mockManager = createMockUpdateManager(pkg.version);
+    env = await createStandaloneEnv({ getUpdateManager: () => mockManager });
+    await env.request('POST', '/api/a2a/dashboard/onboarding/complete', {
+      agentName: 'Update Test Agent',
+      defaultTier: 'public',
+      port: 3096
+    });
+
+    const res = await env.request('GET', '/api/a2a/dashboard/update/status');
+    assert.equal(res.status, 200);
+    assert.equal(res.body.success, true);
+    assert.equal(res.body.auto_update.current_version, pkg.version);
+    assert.equal(res.body.auto_update.state, 'up_to_date');
+    assert.equal(res.body.auto_update.latest_version, null, 'No latest version before check');
+  });
+
+  test('standalone updater: check with newer version transitions to available', async () => {
+    const mockManager = createMockUpdateManager('99.0.0');
+    env = await createStandaloneEnv({ getUpdateManager: () => mockManager });
+    await env.request('POST', '/api/a2a/dashboard/onboarding/complete', {
+      agentName: 'Update Test Agent',
+      defaultTier: 'public',
+      port: 3096
+    });
+
+    // Trigger manual check
+    const checkRes = await env.request('POST', '/api/a2a/dashboard/update/check');
+    assert.equal(checkRes.status, 200);
+    assert.equal(checkRes.body.success, true);
+    assert.equal(checkRes.body.auto_update.state, 'available', 'State should be available after finding newer version');
+    assert.equal(checkRes.body.auto_update.latest_version, '99.0.0');
+    assert.equal(checkRes.body.auto_update.target_version, '99.0.0');
+    assert.ok(checkRes.body.auto_update.last_checked_at, 'last_checked_at should be set');
+  });
+
+  test('standalone updater: check with current version stays up_to_date', async () => {
+    const mockManager = createMockUpdateManager(pkg.version);
+    env = await createStandaloneEnv({ getUpdateManager: () => mockManager });
+    await env.request('POST', '/api/a2a/dashboard/onboarding/complete', {
+      agentName: 'Update Test Agent',
+      defaultTier: 'public',
+      port: 3096
+    });
+
+    const checkRes = await env.request('POST', '/api/a2a/dashboard/update/check');
+    assert.equal(checkRes.status, 200);
+    assert.equal(checkRes.body.auto_update.state, 'up_to_date', 'State should remain up_to_date');
+    assert.equal(checkRes.body.auto_update.latest_version, pkg.version);
+    assert.equal(checkRes.body.auto_update.target_version, null, 'No target when up to date');
+  });
+
+  test('standalone updater: check without manager returns 503', async () => {
+    env = await createStandaloneEnv(); // No getUpdateManager provided
+    await env.request('POST', '/api/a2a/dashboard/onboarding/complete', {
+      agentName: 'Update Test Agent',
+      defaultTier: 'public',
+      port: 3096
+    });
+
+    const res = await env.request('POST', '/api/a2a/dashboard/update/check');
+    assert.equal(res.status, 503);
+    assert.equal(res.body.success, false);
+    assert.equal(res.body.error, 'updater_unavailable');
+  });
+};
+```
+
+**Step 2: Run tests**
+
+```bash
+node test/run.js --e2e --filter standalone-updater
+```
+
+**Step 3: Commit**
+
+```bash
+git add test/e2e/standalone-updater.test.js
+git commit -m "test(a2a-103): add standalone updater E2E tests"
+```
+
+---
+
+## Task 6: Add npm Script and Update CI
+
+**Files:**
+- Modify: `package.json` — add `test:e2e:standalone` script
+- Modify: `scripts/run-e2e.sh` — add standalone lane
+- Modify: `.github/workflows/tauri-build.yml` — run standalone E2E before artifacts
+
+**Step 1: Add npm script to package.json**
+
+```json
+"test:e2e:standalone": "node test/run.js --e2e --filter standalone"
+```
+
+**Step 2: Add standalone lane to run-e2e.sh**
+
+Add a `--standalone` flag that runs only standalone tests:
+
+```bash
+# After existing argument parsing
+for arg in "$@"; do
+  case "$arg" in
+    --alert) ALERT_ON_FAILURE=true ;;
+    --standalone) RUN_STANDALONE=true ;;
+  esac
+done
+
+# Before existing orchestrator, add:
+if [ "${RUN_STANDALONE:-false}" = true ]; then
+  echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] Running standalone E2E tests..."
+  node test/run.js --e2e --filter standalone
+  exit $?
+fi
+```
+
+**Step 3: Add standalone E2E step to tauri-build.yml**
+
+After "Run test suite" step, add:
+
+```yaml
+      - name: Run standalone E2E tests
+        run: npm run test:e2e:standalone
+        env:
+          A2A_RUNTIME: test
+```
+
+**Step 4: Run full test suite**
+
+```bash
+npm test
+npm run test:e2e:standalone
+```
+
+**Step 5: Commit**
+
+```bash
+git add package.json scripts/run-e2e.sh .github/workflows/tauri-build.yml
+git commit -m "feat(a2a-103): add standalone E2E npm script and CI integration"
+```
+
+---
+
+## Task 7: Update CONVENTIONS.md
+
+**Files:**
+- Modify: `CONVENTIONS.md`
+
+**Step 1: Add standalone E2E section**
+
+Add after the last Tauri-related section:
+
+```markdown
+## Standalone App E2E Tests (A2A-103)
+
+End-to-end tests for the standalone app user journey live in `test/e2e/standalone-*.test.js`:
+- `standalone-onboarding` — first-run wizard flow via API
+- `standalone-workflows` — core dashboard operations after onboarding
+- `standalone-sidecar` — server lifecycle and crash recovery
+- `standalone-updater` — update manifest detection with mock server
+- Shared env: `test/e2e/helpers/standalone-env.js` creates isolated server instances with temp config
+- Run with `npm run test:e2e:standalone` or `node test/run.js --e2e --filter standalone`
+- All tests use `A2A_CONFIG_DIR` for isolation — no interference with real config
+- Tests must clean up spawned processes and temp files in afterEach
+```
+
+**Step 2: Run full test suite**
+
+```bash
+npm test
+```
+
+**Step 3: Commit**
+
+```bash
+git add CONVENTIONS.md
+git commit -m "docs(a2a-103): add standalone E2E test conventions"
+```