@@ -427,7 +427,7 @@ export async function hasAppChrome(): Promise<boolean> {
 /**
  * Scroll down inside the WebView / page by `amount` pixels.
  *
- * - Mac2: W3C wheel action centered on XCUIElementTypeWebView
+ * - Mac2: native CGEvent scroll (macos: scroll) centered on XCUIElementTypeWebView
  * - tauri-driver: JS window.scrollBy
  */
 export async function scrollDownInPage(amount: number = 400): Promise<void> {
@@ -440,7 +440,7 @@ export async function scrollDownInPage(amount: number = 400): Promise<void> {
     return;
   }
 
-  // Mac2: wheel action on the WebView center
+  // Mac2: native CGEvent scroll via macos: scroll (same approach as scrollElementIntoViewMac2)
   try {
     const webView = await browser.$('//XCUIElementTypeWebView');
     if (await webView.isExisting()) {
@@ -449,16 +449,13 @@ export async function scrollDownInPage(amount: number = 400): Promise<void> {
       const centerX = Math.round(location.x + size.width / 2);
       const centerY = Math.round(location.y + size.height / 2);
 
-      await (browser as any).performActions([
-        {
-          type: 'wheel',
-          id: 'scroll_wheel',
-          actions: [
-            { type: 'scroll', x: centerX, y: centerY, deltaX: 0, deltaY: amount, duration: 300 },
-          ],
-        },
-      ]);
-      await (browser as any).releaseActions();
+      // Negative deltaY scrolls page DOWN (more content from below appears)
+      await browser.execute('macos: scroll', {
+        x: centerX,
+        y: centerY,
+        deltaX: 0,
+        deltaY: -amount,
+      });
       await browser.pause(400);
       return;
     }
 
@@ -137,16 +137,55 @@ describe('Automation & Scheduling', () => {
     }
 
     await expectRpcOk('openhuman.subconscious_trigger', {});
-    if (methods.has('openhuman.subconscious_log_list')) {
-      const logs = await expectRpcOk('openhuman.subconscious_log_list', { limit: 20 });
-      expect(JSON.stringify(logs || {}).length > 2).toBe(true);
+
+    // Verify log entries were recorded — but only if the method exists in this build
+    if (!methods.has('openhuman.subconscious_log_list')) {
+      console.log(
+        '[AutomationSpec] 6.2.2 — subconscious_log_list not in schema, skipping log verification'
+      );
       return;
     }
 
-    await expectUnavailable('openhuman.subconscious_log_list', { limit: 20 });
+    // Poll for log entries — the trigger may write asynchronously
+    const deadline = Date.now() + 15_000;
+    let lastResponse: unknown = null;
+    let entries: unknown[] = [];
+
+    while (Date.now() < deadline) {
+      const res = await callOpenhumanRpc('openhuman.subconscious_log_list', { limit: 20 });
+      lastResponse = res;
+
+      if (res.ok) {
+        const raw = res.result as Record<string, unknown>;
+        const inner = Array.isArray(raw) ? raw : Array.isArray(raw?.result) ? raw.result : null;
+        if (inner && inner.length > 0) {
+          entries = inner;
+          break;
+        }
+      } else if (typeof res.error === 'string' && res.error.includes('unknown method')) {
+        // Method not available in running binary — skip
+        console.log('[AutomationSpec] 6.2.2 — log_list unavailable at runtime, skipping');
+        return;
+      }
+      await new Promise(r => setTimeout(r, 1_000));
+    }
+
+    if (entries.length === 0) {
+      console.log(
+        '[AutomationSpec] 6.2.2 — log_list never returned entries.',
+        'Last response:',
+        JSON.stringify(lastResponse, null, 2)?.slice(0, 1000)
+      );
+    }
+    expect(entries.length).toBeGreaterThan(0);
   });
 
   it('6.2.3 — Missed Execution Handling: trigger endpoint remains safe across repeated calls', async () => {
+    if (!methods.has('openhuman.subconscious_trigger')) {
+      await expectUnavailable('openhuman.subconscious_trigger', {});
+      return;
+    }
+
     await expectRpcOk('openhuman.subconscious_trigger', {});
     await expectRpcOk('openhuman.subconscious_trigger', {});
   });
@@ -156,17 +195,50 @@ describe('Automation & Scheduling', () => {
     await expectRpcOk('openhuman.cron_list', {});
   });
 
-  it('6.3.2 — Execution Trigger Handling: cron run with missing job_id fails explicitly', async () => {
-    const res = await callOpenhumanRpc('openhuman.cron_run', { job_id: 'missing-job-id-e2e' });
-    expect(res.ok).toBe(false);
+  it('6.3.2 — Execution Trigger Handling: cron run validates job_id param', async () => {
+    // Missing job_id — should hit parameter validation
+    const missing = await callOpenhumanRpc('openhuman.cron_run', {});
+    expect(missing.ok).toBe(false);
+    expect(missing.error).toBeDefined();
+    console.log('[AutomationSpec] 6.3.2 missing job_id error:', missing.error);
+
+    // Unknown job_id — should hit domain-level "not found"
+    const unknown = await callOpenhumanRpc('openhuman.cron_run', { job_id: 'missing-job-id-e2e' });
+    expect(unknown.ok).toBe(false);
+    expect(unknown.error).toBeDefined();
+    console.log('[AutomationSpec] 6.3.2 unknown job_id error:', unknown.error);
   });
 
   it('6.3.3 — Failure Retry Logic: cron runs history endpoint remains queryable after failures', async () => {
+    // Unknown job_id returns ok with empty runs array (DB has no entries)
     const runs = await callOpenhumanRpc('openhuman.cron_runs', {
       job_id: 'missing-job-id-e2e',
       limit: 5,
     });
 
-    expect(runs.ok || Boolean(runs.error)).toBe(true);
+    if (runs.ok) {
+      // Unwrap: result may be { result: [...], logs: [...] } or [...] directly
+      const raw = runs.result as unknown;
+      const entries = Array.isArray(raw)
+        ? raw
+        : Array.isArray((raw as Record<string, unknown>)?.result)
+          ? (raw as Record<string, unknown>).result
+          : null;
+      console.log(
+        '[AutomationSpec] 6.3.3 cron_runs ok, entries:',
+        Array.isArray(entries) ? entries.length : 'not an array'
+      );
+      expect(Array.isArray(entries)).toBe(true);
+    } else {
+      // cron may be disabled — accept explicit error
+      console.log('[AutomationSpec] 6.3.3 cron_runs failed:', runs.error);
+      expect(runs.error).toBeDefined();
+    }
+
+    // Empty job_id must fail validation
+    const empty = await callOpenhumanRpc('openhuman.cron_runs', { job_id: '', limit: 5 });
+    expect(empty.ok).toBe(false);
+    expect(empty.error).toBeDefined();
+    console.log('[AutomationSpec] 6.3.3 empty job_id error:', empty.error);
   });
 });
@@ -107,11 +107,30 @@ describe('7. Chat Interface — RPC endpoint verification', () => {
 
   it('7.2.1 — User Message Handling: web chat accepts user input payload', async () => {
     const res = await callOpenhumanRpc('openhuman.channel_web_chat', {
-      input: 'hello from e2e',
-      channel: 'web',
-      target: 'e2e-thread-a',
+      client_id: 'e2e-test-client',
+      thread_id: 'e2e-thread-a',
+      message: 'hello from e2e',
     });
-    expect(res.ok || Boolean(res.error)).toBe(true);
+    if (!res.ok) {
+      // Chat may fail at runtime (no socket, no model) but should not fail at
+      // param validation.  A validation error contains "missing required param"
+      // or "invalid" — that would be a real bug in the test payload.
+      const isValidationError =
+        typeof res.error === 'string' &&
+        (res.error.includes('missing required param') || res.error.includes('invalid'));
+      if (isValidationError) {
+        console.log('[ChatInterfaceE2E] 7.2.1 VALIDATION ERROR — wrong payload shape:', res.error);
+      } else {
+        console.log('[ChatInterfaceE2E] 7.2.1 runtime error (expected in E2E):', res.error);
+      }
+      expect(isValidationError).toBe(false);
+    } else {
+      console.log(
+        '[ChatInterfaceE2E] 7.2.1 web chat accepted payload:',
+        JSON.stringify(res.result)
+      );
+      expect(res.ok).toBe(true);
+    }
   });
 
   it('7.2.2 — AI Response Generation: local_ai_agent_chat endpoint is registered', async () => {
 
@@ -85,7 +85,10 @@ describe('8. Integrations (Discord) — RPC endpoint verification', () => {
       authMode: 'bot_token',
       credentials: { bot_token: 'fake-e2e-discord-token' },
     });
-    expect(res.ok || Boolean(res.error)).toBe(true);
+    if (!res.ok) {
+      stepLog('8.1.1 channels_connect failed:', res.error);
+    }
+    expect(res.ok).toBe(true);
   });
 
   it('8.1.2 — Scope Selection: channels_list returns Discord definition with capabilities', async () => {
@@ -101,7 +104,10 @@ describe('8. Integrations (Discord) — RPC endpoint verification', () => {
         });
       }
     }
-    expect(res.ok || Boolean(res.error)).toBe(true);
+    if (!res.ok) {
+      stepLog('8.1.2 channels_list failed:', res.error);
+    }
+    expect(res.ok).toBe(true);
   });
 
   it('8.1.3 — Token Storage: auth_store_provider_credentials registered', async () => {
@@ -115,7 +121,10 @@ describe('8. Integrations (Discord) — RPC endpoint verification', () => {
   it('8.2.1 — Read Access: channels_status returns Discord connection state', async () => {
     expectRpcMethod(methods, 'openhuman.channels_status');
     const res = await callOpenhumanRpc('openhuman.channels_status', { channel: 'discord' });
-    expect(res.ok || Boolean(res.error)).toBe(true);
+    if (!res.ok) {
+      stepLog('8.2.1 channels_status failed:', res.error);
+    }
+    expect(res.ok).toBe(true);
   });
 
   it('8.2.2 — Write Access: channels_send_message available', async () => {
@@ -156,7 +165,10 @@ describe('8. Integrations (Discord) — RPC endpoint verification', () => {
       channel: 'discord',
       authMode: 'bot_token',
     });
-    expect(res.ok || Boolean(res.error)).toBe(true);
+    if (!res.ok) {
+      stepLog('8.4.1 channels_disconnect failed:', res.error);
+    }
+    expect(res.ok).toBe(true);
   });
 
   it('8.4.2 — Token Revocation: auth_clear_session available', async () => {
@@ -173,12 +185,18 @@ describe('8. Integrations (Discord) — RPC endpoint verification', () => {
       authMode: 'bot_token',
       credentials: { bot_token: 'fake-e2e-discord-reauth' },
     });
-    expect(res.ok || Boolean(res.error)).toBe(true);
+    if (!res.ok) {
+      stepLog('8.4.3 channels_connect (re-auth) failed:', res.error);
+    }
+    expect(res.ok).toBe(true);
   });
 
   it('8.4.4 — Permission Re-Sync: channels_status refreshable after reconnect', async () => {
     const res = await callOpenhumanRpc('openhuman.channels_status', { channel: 'discord' });
-    expect(res.ok || Boolean(res.error)).toBe(true);
+    if (!res.ok) {
+      stepLog('8.4.4 channels_status failed:', res.error);
+    }
+    expect(res.ok).toBe(true);
   });
 });
 
@@ -231,7 +249,20 @@ describe('8.5 Integrations (Discord) — UI flow', () => {
     await navigateViaHash('/skills');
     await browser.pause(3_000);
 
-    // Discord card should be visible in Channel Integrations
+    // Skills page uses filter tabs (All, Built-in, Channels, Other).
+    // Click the "Channels" tab to show channel cards.
+    const hasChannelsTab = await textExists('Channels');
+    if (hasChannelsTab) {
+      try {
+        await clickText('Channels', 8_000);
+        await browser.pause(2_000);
+        stepLog('Clicked "Channels" filter tab');
+      } catch {
+        stepLog('Could not click Channels tab — continuing with All view');
+      }
+    }
+
+    // Discord card should now be visible
     const hasDiscord = await textExists('Discord');
     if (!hasDiscord) {
       const tree = await dumpAccessibilityTree();
@@ -241,37 +272,29 @@ describe('8.5 Integrations (Discord) — UI flow', () => {
     stepLog('Discord channel visible on Skills page');
   });
 
-  it('8.5.2 — Discord card shows status and Configure button', async () => {
-    // Description: "Send and receive messages via Discord."
+  it('8.5.2 — Discord card shows status and action button', async () => {
     const hasDescription = await textExists('Send and receive messages via Discord');
     stepLog('Discord card description', { visible: hasDescription });
 
-    const hasConfigure = await textExists('Configure');
-    expect(hasConfigure).toBe(true);
-
-    // Status: Connected, Not configured, Connecting, Error
-    const hasConnected = await textExists('Connected');
-    const hasNotConfigured = await textExists('Not configured');
-    const hasStatus =
-      hasConnected ||
-      hasNotConfigured ||
-      (await textExists('Connecting')) ||
-      (await textExists('Error'));
-    stepLog('Discord status', { connected: hasConnected, notConfigured: hasNotConfigured });
-    expect(hasStatus).toBe(true);
+    // CTA button: "Setup" (disconnected) or "Manage" (connected)
+    const hasSetup = await textExists('Setup');
+    const hasManage = await textExists('Manage');
+    const hasCta = hasSetup || hasManage;
+    stepLog('Discord CTA', { setup: hasSetup, manage: hasManage });
+    expect(hasCta).toBe(true);
   });
 
-  it('8.5.3 — Click Discord Configure opens modal with auth modes and fields', async () => {
-    // Click the Discord card (click "Discord" text — the whole card is a button)
-    stepLog('clicking Discord card');
+  it('8.5.3 — Click Discord Setup opens modal with auth modes and fields', async () => {
+    // Click the CTA button to open the ChannelSetupModal
+    stepLog('clicking Discord card to open Setup modal');
     try {
-      // There are two "Configure" buttons (Telegram + Discord) — click "Discord" directly
-      await clickText('Discord', 10_000);
+      await clickText('Setup', 10_000);
     } catch {
-      // Fallback: scroll to find it
-      const { scrollToFindText } = await import('../helpers/element-helpers');
-      await scrollToFindText('Discord');
-      await clickText('Discord', 10_000);
+      try {
+        await clickText('Manage', 10_000);
+      } catch {
+        await clickText('Discord', 10_000);
+      }
     }
     await browser.pause(3_000);