create-walle 0.9.21 → 0.9.23

package/template/wall-e/tools/permission-checker.js

@@ -15,6 +15,56 @@ const ALWAYS_ASK_TOOLS = new Set([
   'applescript', 'claude_code', 'mail_send', 'mail_reply', 'slack_send_message',
 ]);
 
+// Shell builtins that only navigate / change shell state — harmless on their
+// own. Treated as allow ONLY inside per-clause evaluation, where every sibling
+// clause of a compound command is independently checked, so a safe `cd` can
+// never whitewash a dangerous neighbour (e.g. `cd /x && rm -rf /`).
+const NAVIGATION_BUILTINS = new Set(['cd', 'pushd', 'popd', 'dirs']);
+
+const _ACTION_RANK = { allow: 0, ask: 1, deny: 2 };
+
+/**
+ * Evaluate every clause of a (possibly compound) shell command and return the
+ * MOST-RESTRICTIVE decision (deny > ask > allow).
+ *
+ * `clauses` is an array of raw token arrays — one per clause — exactly as
+ * produced by analyzeShellCommand().commandTokens (split on &&, ||, ;, |, &).
+ * Judging the whole command by its first clause alone is both a usability bug
+ * (a leading `cd` forces an ask and parks the agent) and a security hole (an
+ * allow-listed first clause masks a destructive trailing clause).
+ *
+ * @param {string[][]} clauses
+ * @param {Array} allRules - merged ruleset (DEFAULT_RULES + agent + user)
+ * @returns {{ action: 'allow'|'ask'|'deny', pattern: string, reason: string }}
+ */
+function evaluateBashClauses(clauses, allRules) {
+  let worst = null;
+  for (const tokens of clauses) {
+    if (!Array.isArray(tokens) || tokens.length === 0) continue;
+    const cmd = tokens[0];
+    let action, pattern, reason;
+    if (DENYLIST.has(cmd)) {
+      action = 'deny';
+      pattern = `${cmd} *`;
+      reason = `${cmd} is a destructive command`;
+    } else if (NAVIGATION_BUILTINS.has(cmd)) {
+      action = 'allow';
+      pattern = `${cmd} *`;
+      reason = `Rule: bash/${cmd} * -> allow (navigation)`;
+    } else {
+      const prefix = bashArityPrefix(tokens);
+      pattern = prefix.join(' ') + ' *';
+      action = evaluate('bash', pattern, allRules).action;
+      reason = `Rule: bash/${pattern} -> ${action}`;
+    }
+    if (!worst || _ACTION_RANK[action] > _ACTION_RANK[worst.action]) {
+      worst = { action, pattern, reason };
+      if (action === 'deny') break; // deny is the floor — nothing is more restrictive
+    }
+  }
+  return worst || { action: 'ask', pattern: '*', reason: 'Rule: bash/* -> ask' };
+}
+
 let _ctmBaseUrl = null;
 let _ctmToken = null;
 let _userRulesCache = null;
@@ -104,7 +154,7 @@ function listTrustedDirectories() {
  *
  * Returns: { decision: 'allow'|'deny'|'ask', source, reason, ruleId? }
  */
-async function checkPermission({ tool, command, commandTokens, args, projectPath, sessionId, mode }) {
+async function checkPermission({ tool, command, commandTokens, commandClauses, args, projectPath, sessionId, mode }) {
   // Layer 1: Hardcoded denylist (safety floor — never overridable)
   if (tool === 'run_shell') {
     // Extract first command token for denylist check
@@ -120,8 +170,15 @@ async function checkPermission({ tool, command, commandTokens, args, projectPath
     return { decision: 'allow', source: 'trust', reason: `Directory ${projectPath} is trusted` };
   }
 
-  // Layer 2: CTM remote rules (if connected)
-  if (_ctmBaseUrl) {
+  // Layer 2: CTM unified auto-approver (when connected).
+  // Shell commands are decided by the SAME auto-approver Claude/Codex use —
+  // editable blocklist -> per-clause heuristic risk -> goal-aligned verifier —
+  // so policy is a single source of truth. Only `run_shell` is routed: file
+  // edits keep the local path-aware rules below (which protect .env/.ssh/.aws —
+  // protections the shell approver does not have), and read/mcp/skill keep their
+  // local defaults. If CTM is unreachable we fall through to the local rules,
+  // so coding never hard-breaks offline.
+  if (_ctmBaseUrl && tool === 'run_shell') {
     try {
       const body = { tool, command: command || '', args: args || [], project_path: projectPath || '', session_id: sessionId || '', agent: 'walle' };
       const url = `${_ctmBaseUrl}/api/permissions/walle-check${_ctmToken ? '?token=' + encodeURIComponent(_ctmToken) : ''}`;
@@ -149,7 +206,17 @@ async function checkPermission({ tool, command, commandTokens, args, projectPath
   const allRules = merge(DEFAULT_RULES, agentRules, _userRulesCache);
 
   if (tool === 'run_shell') {
-    // Build permission pattern using BashArity
+    // Per-clause evaluation when the full clause list is available. A compound
+    // command like `cd ~/x && wc -l f && cat f` must be judged by ALL clauses
+    // (most-restrictive wins), not just the first — otherwise a leading `cd`
+    // forces an ask (parking the agent) and an allow-listed first clause masks
+    // a destructive trailing clause (the `&&`-bypass class).
+    if (Array.isArray(commandClauses) && commandClauses.length > 0) {
+      const r = evaluateBashClauses(commandClauses, allRules);
+      return { decision: r.action, source: 'rules', reason: r.reason };
+    }
+    // Legacy fallback: only the first clause's tokens (or the raw string) are
+    // available. Stay conservative — derive the pattern from BashArity.
     let pattern;
     if (commandTokens && commandTokens.length > 0) {
       const prefix = bashArityPrefix(commandTokens);
@@ -220,6 +287,7 @@ async function recordDecision({ tool, command, args, decision, sessionId, projec
 
 module.exports = {
   checkPermission, recordDecision, configure,
-  DENYLIST, ALWAYS_ASK_TOOLS,
+  evaluateBashClauses,
+  DENYLIST, ALWAYS_ASK_TOOLS, NAVIGATION_BUILTINS,
   isDirectoryTrusted, trustDirectory, untrustDirectory, listTrustedDirectories,
 };

package/template/wall-e/tools/question-manager.js

@@ -11,6 +11,16 @@
 const crypto = require('node:crypto');
 
 const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+const SAFE_HTML_PREVIEW_TAGS = new Set([
+  'a', 'article', 'b', 'blockquote', 'br', 'code', 'div', 'em', 'footer',
+  'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hr', 'i', 'img', 'li',
+  'ol', 'p', 'pre', 'section', 'span', 'strong', 'table', 'tbody', 'td',
+  'th', 'thead', 'tr', 'ul',
+]);
+const SAFE_HTML_PREVIEW_ATTRS = new Set([
+  'alt', 'aria-label', 'aria-describedby', 'aria-labelledby', 'class', 'colspan',
+  'height', 'href', 'role', 'rowspan', 'src', 'title', 'width',
+]);
 
 // Shared pending map — all QuestionManager instances share the same questions
 // so the API registry and session instances can find the same pending questions.
@@ -51,13 +61,14 @@ class QuestionManager {
   ask(sessionId, question, askOpts = {}) {
     const id = `q_${crypto.randomUUID().slice(0, 8)}`;
     const timeoutMs = askOpts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const normalizedQuestion = normalizeQuestion(question || {});
 
     return new Promise((resolve) => {
       const timer = timeoutMs > 0
         ? setTimeout(() => this._expire(id), timeoutMs)
         : null;
 
-      const entry = { sessionId, question, resolve, timer };
+      const entry = { sessionId, question: normalizedQuestion, resolve, timer };
       this._pending.set(id, entry);
 
       // Publish on bus so UI / SSE subscribers can show the question
@@ -65,10 +76,11 @@ class QuestionManager {
         this._events.emit('question.asked', {
           id,
           sessionId,
-          question: question.question,
-          header: question.header || '',
-          options: question.options || [],
-          multiple: !!question.multiple,
+          question: normalizedQuestion.question,
+          header: normalizedQuestion.header || '',
+          options: normalizedQuestion.options || [],
+          multiple: !!normalizedQuestion.multiple,
+          preview: normalizedQuestion.preview || null,
           timestamp: Date.now(),
         });
       }
@@ -186,12 +198,22 @@ class QuestionManager {
  */
 const ASK_USER_TOOL = {
   name: 'ask_user',
-  description: 'Ask the user a clarifying question and wait for their answer. Use when you need more information before proceeding (e.g., which approach to take, what file to target, or confirmation of a destructive action). The user sees the question in real-time.',
+  description: 'Ask the user a clarifying question and wait for their answer. Supports safe markdown previews and sanitized HTML-fragment previews for visual choices. Use when you need more information before proceeding.',
   input_schema: {
     type: 'object',
     properties: {
       question: { type: 'string', description: 'The question to ask' },
       header: { type: 'string', description: 'Short label (max 30 chars)' },
+      preview: {
+        type: 'object',
+        description: 'Optional question-level preview. Use type=markdown for prose, type=html for a sanitized fragment, or type=image/pdf_page with a local path.',
+        properties: {
+          type: { type: 'string', enum: ['markdown', 'html', 'image', 'pdf_page'] },
+          content: { type: 'string', description: 'Markdown or safe HTML fragment.' },
+          path: { type: 'string', description: 'Optional local artifact path for image/pdf_page previews.' },
+          title: { type: 'string', description: 'Optional preview title.' },
+        },
+      },
       options: {
         type: 'array',
         items: {
@@ -199,6 +221,16 @@ const ASK_USER_TOOL = {
           properties: {
             label: { type: 'string', description: 'Display text (1-5 words)' },
             description: { type: 'string', description: 'Explanation of this choice' },
+            preview: {
+              type: 'object',
+              description: 'Optional preview for this option. Same shape as question preview.',
+              properties: {
+                type: { type: 'string', enum: ['markdown', 'html', 'image', 'pdf_page'] },
+                content: { type: 'string' },
+                path: { type: 'string' },
+                title: { type: 'string' },
+              },
+            },
           },
           required: ['label'],
         },
@@ -210,4 +242,82 @@ const ASK_USER_TOOL = {
   },
 };
 
-module.exports = { QuestionManager, ASK_USER_TOOL, DEFAULT_TIMEOUT_MS };
+function normalizeQuestion(question) {
+  return {
+    question: String(question.question || '').slice(0, 4000),
+    header: String(question.header || '').slice(0, 30),
+    multiple: !!question.multiple,
+    preview: sanitizePreview(question.preview),
+    options: Array.isArray(question.options)
+      ? question.options.slice(0, 10).map((option) => ({
+        label: String(option?.label || '').slice(0, 80),
+        description: String(option?.description || '').slice(0, 1000),
+        preview: sanitizePreview(option?.preview),
+      })).filter((option) => option.label)
+      : [],
+  };
+}
+
+function sanitizePreview(preview) {
+  if (!preview) return null;
+  if (typeof preview === 'string') {
+    return { type: 'markdown', content: preview.slice(0, 12000) };
+  }
+  if (typeof preview !== 'object') return null;
+  const type = String(preview.type || preview.kind || 'markdown').toLowerCase();
+  const title = String(preview.title || '').slice(0, 160);
+  if (type === 'markdown') {
+    return {
+      type: 'markdown',
+      title,
+      content: String(preview.content || '').slice(0, 12000),
+    };
+  }
+  if (type === 'html') {
+    const content = String(preview.content || '').slice(0, 12000);
+    const error = unsafeHtmlFragmentReason(content);
+    if (error) return { type: 'rejected', title, error };
+    return { type: 'html', title, content };
+  }
+  if (type === 'image' || type === 'pdf_page') {
+    return {
+      type,
+      title,
+      path: String(preview.path || '').slice(0, 2000),
+      mimeType: String(preview.mimeType || preview.mime_type || '').slice(0, 120),
+      content: String(preview.content || '').slice(0, 2000),
+    };
+  }
+  return { type: 'rejected', title, error: `Unsupported preview type: ${type}` };
+}
+
+function unsafeHtmlFragmentReason(html) {
+  if (/<\s*(?:script|style|iframe|object|embed|link|meta|html|head|body)\b/i.test(html)) {
+    return 'HTML preview contains a blocked tag.';
+  }
+  if (/\son[a-z]+\s*=/i.test(html)) return 'HTML preview contains an event handler attribute.';
+  if (/\bjavascript\s*:/i.test(html)) return 'HTML preview contains a javascript: URL.';
+  const tagRe = /<\s*\/?\s*([a-z][a-z0-9-]*)([^>]*)>/gi;
+  for (const match of html.matchAll(tagRe)) {
+    const tag = match[1].toLowerCase();
+    const attrs = match[2] || '';
+    if (!SAFE_HTML_PREVIEW_TAGS.has(tag)) return `HTML preview contains unsupported tag: ${tag}.`;
+    if (/<|>/.test(attrs)) return 'HTML preview contains malformed tag attributes.';
+    const attrRe = /\s([:@a-zA-Z_][:@a-zA-Z0-9_.-]*)\s*(?:=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?/g;
+    for (const attrMatch of attrs.matchAll(attrRe)) {
+      const attr = attrMatch[1].toLowerCase();
+      if (attr.startsWith('data-') || attr.startsWith('aria-')) continue;
+      if (!SAFE_HTML_PREVIEW_ATTRS.has(attr)) return `HTML preview contains unsupported attribute: ${attr}.`;
+    }
+  }
+  return '';
+}
+
+module.exports = {
+  QuestionManager,
+  ASK_USER_TOOL,
+  DEFAULT_TIMEOUT_MS,
+  normalizeQuestion,
+  sanitizePreview,
+  unsafeHtmlFragmentReason,
+};

package/template/wall-e/training/harvester.js

@@ -196,33 +196,18 @@ async function harvestCodexSessions(since) {
 // --- CTM Session Harvesting ---
 
 async function harvestCtmSessions(since, dataDirOverride = null) {
-  const dataDir = dataDirOverride || process.env.WALL_E_DATA_DIR || path.join(process.env.HOME, '.walle', 'data');
-  const ctmDbPath = path.join(dataDir, 'task-manager.db');
-  if (!fs.existsSync(ctmDbPath)) return [];
-
-  let Database;
-  try { Database = require('better-sqlite3'); } catch { return []; }
-  let ctmDb;
   try {
-    ctmDb = new Database(ctmDbPath, { readonly: true, fileMustExist: true });
-  } catch {
-    return [];
-  }
-
-  try {
-    let sql = `
-      SELECT u.session_id, u.message_text AS prompt, u.executed_at, u.project_path,
-             a.message_text AS response, a.tool_uses
-      FROM prompt_executions u
-      JOIN prompt_executions a ON a.session_id = u.session_id AND a.message_index = u.message_index + 1
-      WHERE u.role = 'user' AND a.role = 'assistant'
-        AND length(u.message_text) >= 20 AND length(a.message_text) >= 20
-    `;
-    if (since) { sql += ` AND u.executed_at > ?`; }
-    sql += ' ORDER BY u.executed_at DESC LIMIT 500';
-
-    const rows = since ? ctmDb.prepare(sql).all(since) : ctmDb.prepare(sql).all();
-    ctmDb.close();
+    const {
+      listPromptExecutions,
+      pairPromptExecutions,
+    } = require('../memory/ctm-prompt-executions-client');
+    const executions = await listPromptExecutions({
+      since,
+      limit: 5000,
+      order: 'desc',
+      timeoutMs: 1500,
+    });
+    const rows = pairPromptExecutions(executions, { limit: 500 });
 
     return rows.map(row => ({
       id: contentHash('ctm', row.prompt),
@@ -239,8 +224,7 @@ async function harvestCtmSessions(since, dataDirOverride = null) {
       quality_label: 0.7,
     }));
   } catch (err) {
-    try { ctmDb.close(); } catch {}
-    console.error('[harvester] Error reading CTM sessions:', err.message);
+    console.error('[harvester] Error reading CTM sessions through API:', err.message);
     return [];
   }
 }

package/template/wall-e/training/replay.js

@@ -1,29 +1,18 @@
 'use strict';
 
-const fs = require('fs');
-const path = require('path');
 const { classifyTaskType } = require('./harvester');
 const { getShadowConfig } = require('./shadow');
 const { createClient } = require('../llm/client');
+const {
+  groupPromptExecutionsBySession,
+  listPromptExecutions,
+  pairPromptExecutions,
+} = require('../memory/ctm-prompt-executions-client');
 
 const INTER_CALL_DELAY_MS = 1000;
 const CALL_TIMEOUT_MS = 600000; // 10 min safety ceiling — no real timeout for training; local models can take minutes on complex prompts
 const MAX_HISTORY_CHARS = 32000; // Cap conversation history sent to shadow model
 
-// --- Shared helpers ---
-
-function openCtmDb() {
-  const dataDir = process.env.WALL_E_DATA_DIR || path.join(process.env.HOME, '.walle', 'data');
-  const ctmDbPath = path.join(dataDir, 'task-manager.db');
-  if (!fs.existsSync(ctmDbPath)) return null;
-  const Database = require('better-sqlite3');
-  try {
-    return new Database(ctmDbPath, { readonly: true, fileMustExist: true });
-  } catch {
-    return null;
-  }
-}
-
 function makeShadowClient(models) {
   const shadowModel = models[0];
   const client = createClient(shadowModel.provider || 'ollama', {
@@ -70,36 +59,21 @@ async function runReplay(brain, options = {}) {
   const state = brain.getHarvestState('ctm-replay');
   const lastReplayAt = state?.last_processed_at || '2000-01-01';
 
-  const ctmDb = openCtmDb();
-  if (!ctmDb) return { replayed: 0 };
-
   let rows;
   try {
-    // Only pick single-turn sessions (sessions with exactly 1 user/assistant pair)
-    // Multi-turn sessions are handled by runMultiTurnReplay
-    rows = ctmDb.prepare(`
-      SELECT u.session_id, u.message_text AS prompt, u.executed_at,
-             a.message_text AS response
-      FROM prompt_executions u
-      JOIN prompt_executions a ON a.session_id = u.session_id
-        AND a.message_index = u.message_index + 1
-      WHERE u.role = 'user' AND a.role = 'assistant'
-        AND length(u.message_text) >= 20 AND length(a.message_text) >= 20
-        AND u.executed_at > ?
-        AND u.session_id IN (
-          SELECT session_id FROM prompt_executions
-          WHERE role = 'user'
-          GROUP BY session_id HAVING COUNT(*) = 1
-        )
-      ORDER BY u.executed_at ASC
-      LIMIT ?
-    `).all(lastReplayAt, limit);
+    const executions = await listPromptExecutions({
+      since: lastReplayAt,
+      limit: 5000,
+      order: 'asc',
+      timeoutMs: 1500,
+    });
+    // Only pick single-turn sessions. Multi-turn sessions are handled by
+    // runMultiTurnReplay.
+    rows = pairPromptExecutions(executions, { limit, singleTurnOnly: true });
   } catch (err) {
-    try { ctmDb.close(); } catch {}
-    console.error('[replay] Error querying CTM DB:', err.message);
+    console.error('[replay] Error querying CTM API:', err.message);
     return { replayed: 0 };
   }
-  ctmDb.close();
 
   if (!rows.length) return { replayed: 0 };
 
@@ -186,50 +160,21 @@ async function runMultiTurnReplay(brain, options = {}) {
   const state = brain.getHarvestState('ctm-replay-mt');
   const lastReplayAt = state?.last_processed_at || '2000-01-01';
 
-  const ctmDb = openCtmDb();
-  if (!ctmDb) return { replayed: 0, sessions: 0 };
-
   let sessions;
   try {
-    // Find multi-turn sessions (2+ user messages) newer than watermark
-    sessions = ctmDb.prepare(`
-      SELECT session_id, MIN(executed_at) AS started_at, COUNT(*) AS msg_count
-      FROM prompt_executions
-      WHERE executed_at > ?
-      GROUP BY session_id
-      HAVING SUM(CASE WHEN role = 'user' THEN 1 ELSE 0 END) >= 2
-      ORDER BY MIN(executed_at) ASC
-      LIMIT ?
-    `).all(lastReplayAt, sessionLimit);
+    const executions = await listPromptExecutions({
+      since: lastReplayAt,
+      limit: 10000,
+      order: 'asc',
+      timeoutMs: 1500,
+    });
+    sessions = groupPromptExecutionsBySession(executions, { multiTurnOnly: true, limit: sessionLimit });
   } catch (err) {
-    try { ctmDb.close(); } catch {}
-    console.error('[replay-mt] Error finding sessions:', err.message);
+    console.error('[replay-mt] Error finding sessions through CTM API:', err.message);
     return { replayed: 0, sessions: 0 };
   }
 
-  if (!sessions.length) {
-    ctmDb.close();
-    return { replayed: 0, sessions: 0 };
-  }
-
-  // Pre-load all messages for selected sessions
-  const sessionMessages = new Map();
-  try {
-    for (const s of sessions) {
-      const msgs = ctmDb.prepare(`
-        SELECT message_text, role, message_index, tool_uses, executed_at
-        FROM prompt_executions
-        WHERE session_id = ?
-        ORDER BY message_index ASC
-      `).all(s.session_id);
-      sessionMessages.set(s.session_id, msgs);
-    }
-  } catch (err) {
-    try { ctmDb.close(); } catch {}
-    console.error('[replay-mt] Error loading messages:', err.message);
-    return { replayed: 0, sessions: 0 };
-  }
-  ctmDb.close();
+  if (!sessions.length) return { replayed: 0, sessions: 0 };
 
   const existing = loadExistingPromptPrefixes(brain);
   const { client, shadowModel } = makeShadowClient(models);
@@ -239,7 +184,7 @@ async function runMultiTurnReplay(brain, options = {}) {
   let lastTimestamp = lastReplayAt;
 
   for (const session of sessions) {
-    const msgs = sessionMessages.get(session.session_id);
+    const msgs = session.messages;
     if (!msgs || msgs.length < 4) continue; // need at least 2 user + 2 assistant
 
     // Build progressive history and replay each assistant turn

package/template/website/index.html

@@ -4,7 +4,7 @@
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <title>Wall-E &mdash; AI Coding Dashboard + Personal Agent</title>
-<meta name="description" content="Run Claude Code, Codex, Gemini, and Aider sessions side by side. Manage prompts, queue tasks, review code and docs, use remote phone access, and let an AI agent build a second brain from your work life. Runs locally.">
+<meta name="description" content="Run Claude Code, Codex, Gemini, and Aider sessions side by side. Manage prompts, queue tasks, review code and docs, use remote phone and tablet access, and let an AI agent build a second brain from your work life. Runs locally.">
 <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🤖</text></svg>">
 <style>
   :root {
@@ -241,7 +241,7 @@
   <h1>Your AI Coding <span class="accent">Command Center</span> +<br>Personal <span class="accent">Agent</span></h1>
   <p class="sub">
     Run Claude Code, Codex, Gemini, Aider, OpenCode, and Cursor Agent sessions side by side. Manage prompts,
-    queue tasks, review code and docs, open a phone-friendly remote UI with live prompts and model controls, and let an AI agent build a second brain from your work life.
+    queue tasks, review code and docs, open a touch-friendly remote UI for phone and tablet with live prompts and model controls, and let an AI agent build a second brain from your work life.
   </p>
   <div class="install-box" onclick="navigator.clipboard.writeText('npx create-walle install ./walle');this.querySelector('.copy-hint').textContent='Copied!'">
     <code>npx create-walle install ./walle</code>
@@ -250,7 +250,7 @@
   <div class="badge-row">
     <span class="badge">MIT License</span>
     <span class="badge">Local-first</span>
-    <span class="badge">Remote Phone Access</span>
+    <span class="badge">Phone &amp; Tablet Access</span>
     <span class="badge">Code &amp; Doc Review</span>
     <span class="badge">SQLite</span>
     <span class="badge">No Cloud Required</span>
@@ -281,7 +281,7 @@
   <h2>One dashboard for every AI coding agent</h2>
   <p class="desc">
     Run Claude Code, Codex, Gemini CLI, and Aider sessions side by side.
-    Manage prompts, queue tasks, review code and docs, and respond from your phone.
+    Manage prompts, queue tasks, review code and docs, and respond from your phone or tablet.
   </p>
   <div class="features">
     <div class="feature-card">
@@ -306,8 +306,8 @@
     </div>
     <div class="feature-card">
       <span class="icon">&#128241;</span>
-      <h3>Remote Phone Access</h3>
-      <p>Pair your phone with a QR code and use a mobile CTM UI through Microsoft Dev Tunnels, Tailscale, Cloudflare Tunnel, or Walle Remote, including live prompts and model controls.</p>
+      <h3>Remote Phone &amp; Tablet Access</h3>
+      <p>Pair your phone or tablet with a QR code and use a responsive CTM UI through Microsoft Dev Tunnels, Tailscale, Cloudflare Tunnel, or Walle Remote, including live prompts and model controls.</p>
     </div>
     <div class="feature-card">
       <span class="icon">&#916;</span>
@@ -354,7 +354,7 @@
     <div class="feature-card">
       <span class="icon">&#128241;</span>
       <h3>Multi-Device</h3>
-      <p>Share your brain across machines via Dropbox, iCloud, or any file sync. Pair your phone when you need to monitor or respond away from the Mac.</p>
+      <p>Share your brain across machines via Dropbox, iCloud, or any file sync. Pair your phone or tablet when you need to monitor or respond away from the Mac.</p>
     </div>
   </div>
 </section>
@@ -378,8 +378,8 @@
       <p>Click through to connect Slack (OAuth), email, and calendar. All optional &mdash; Wall-E works without them.</p>
     </div>
     <div class="step">
-      <h3>Pair your phone</h3>
-      <p>Choose Microsoft Dev Tunnels, Tailscale, Cloudflare Tunnel, or Walle Remote from Setup and scan the QR code.</p>
+      <h3>Pair your device</h3>
+      <p>Choose Microsoft Dev Tunnels, Tailscale, Cloudflare Tunnel, or Walle Remote from Setup and scan the QR code on a phone or tablet.</p>
     </div>
     <div class="step">
       <h3>Start working</h3>
@@ -405,7 +405,7 @@
         <li>Multi-agent terminal multiplexer</li>
         <li>Prompt store &amp; task queue</li>
         <li>Approval engine &amp; model registry</li>
-        <li>Remote phone pairing &amp; mobile UI</li>
+        <li>Remote phone/tablet pairing &amp; responsive UI</li>
         <li>Code and document review workspace</li>
       </ul>
     </div>