feat: Read My Mind phase 2, the predictor and the brain button

The feature as pitched in docs/readmymind-plan.md: pressing the header
brain button predicts the prompt you were about to type, from the case's
intent profile plus everything the session already knows.

Backend:
- readmymind-context.ts: pure budgeted context assembler (9 ranked
  sources: pending approval dialog, user goals, last assistant turn tail,
  recent prompts, tool activity, git workspace signals, away context,
  sibling sessions, rethink state; 30 KB budget, whole-section drop from
  the bottom of the ranking, trust tiers stated in the prompt)
- readmymind-collectors.ts: transcript tail reader (the live watcher
  keeps only a 500-char snippet) and git signal collection (execFile,
  2s timeout, skipped for remote-SSH cases)
- readmymind-predictor.ts: one-shot claude -p in a throwaway tmux
  session, opus by default (readMyMindModel setting), strict JSON
  contract with 1-3 suggestions (continue / verify / redirect), newline
  stripping, 90s timeout; mutable singleton so route tests can stub it
- POST /api/sessions/:id/readmymind: claude-mode only (400), one
  prediction in flight per session (409 CONFLICT), rethink body
  { steer, rejected }; ownership via findSessionOrFail

Frontend:
- readmymind-ui.js (loadorder 11.3): header brain button, marker-hidden
  until readMyMindEnabled is ON, desktop only (phone key is phase 3);
  modal with editable suggestion + rationale and Send / Insert /
  Rethink / Dismiss; suggestion text rendered via value/textContent only
  and nothing ever auto-sends
- App Settings -> Panels checkbox for readMyMindEnabled; en + zh-CN
  strings

Verified end to end against a live isolated instance: transcript
capture, a real opus prediction grounded in the stated goals, rethink
steering, the 409, and the browser modal incl. Insert leaving the text
unsubmitted on the composer. 41 new unit/route tests; full test:ci
sweep green (4680 tests).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/web/ports/config-port.ts

@@ -24,4 +24,12 @@ export interface ConfigPort {
   getLightSessionsState(): unknown[];
   startTranscriptWatcher(sessionId: string, transcriptPath: string): void;
   stopTranscriptWatcher(sessionId: string): void;
+  /**
+   * Transcript JSONL path from the session's live watcher, or null (no hook
+   * has fired yet / not a claude-mode session). Read My Mind's transcript
+   * collector tail-reads this file for prediction context.
+   */
+  getTranscriptPath(sessionId: string): string | null;
+  /** Read My Mind predictor model: the `readMyMindModel` setting, defaulting to AI_CHECK_MODEL. */
+  getReadMyMindModel(): Promise<string>;
 }

src/web/public/i18n.js

@@ -251,6 +251,20 @@
     Permission: '权限',
     Question: '问题',
     Idle: '空闲',
+    'Read My Mind': '读心术',
+    'Read My Mind: predict your next prompt': '读心术：预测您的下一条提示',
+    'Predict my next prompt': '预测我的下一条提示',
+    'Reading your mind…': '正在读取您的想法…',
+    'No suggestion this time. Rethink to try again.': '这次没有建议。点击「重想」再试一次。',
+    Rethink: '重想',
+    Insert: '插入',
+    "Put the text on the session's composer without submitting it": '将文本放入会话输入框但不提交',
+    'Predicted prompt, editable': '预测的提示，可编辑',
+    'Select a session first': '请先选择一个会话',
+    'Read My Mind works on Claude sessions only': '读心术仅适用于 Claude 会话',
+    'Prompt sent': '提示已发送',
+    'Inserted, press Enter in the terminal to send': '已插入，在终端中按 Enter 发送',
+    'Could not reach the session': '无法连接到会话',
     'Subagent Options': '子智能体选项',
     'Enable Tracking': '启用跟踪',
     'Active Tab Only': '仅活动标签页',

src/web/public/index.html

@@ -135,6 +135,7 @@
           <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M18 8A6 6 0 0 0 6 8c0 7-3 9-3 9h18s-3-2-3-9"/><path d="M13.73 21a2 2 0 0 1-3.46 0"/></svg>
           <span class="approvals-badge" id="approvalsBadge">0</span>
         </button>
+        <button class="btn-icon-header btn-readmymind btn-readmymind--hidden" id="readMyMindBtn" onclick="app.openReadMyMind()" title="Read My Mind: predict your next prompt" aria-label="Predict my next prompt"><span class="readmymind-icon" aria-hidden="true">🧠</span></button>
         <button class="btn-icon-header btn-attachments-history btn-attachments-history--hidden" id="attachmentsHistoryBtn" onclick="app.toggleAttachmentHistory()" title="Attachments" aria-label="Open attachment history" aria-expanded="false">
           <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m21.44 11.05-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48"/></svg>
           <span class="attachment-history-badge" id="attachmentHistoryBadge" style="display:none;">0</span>
@@ -1549,6 +1550,13 @@
                   <span class="slider"></span>
                 </label>
               </div>
+              <div class="settings-item" title="Read My Mind: capture your submitted prompts into a per-case intent profile and predict your next prompt on demand (header 🧠 button on Claude sessions). Predictions cost tokens and are never auto-sent">
+                <span class="settings-item-label">Read My Mind</span>
+                <label class="switch switch-sm">
+                  <input type="checkbox" id="appSettingsReadMyMind">
+                  <span class="slider"></span>
+                </label>
+              </div>
               <div class="settings-item" title="Show ultracode / Workflow runs as a master-detail tab (tasks on the left, agents with tokens + tool calls on the right)">
                 <span class="settings-item-label">Ultracode Agents</span>
                 <label class="switch switch-sm">
@@ -2740,6 +2748,37 @@
   </div>
 
   <!-- Approvals Inbox drawer (populated by approvals-ui.js; opened from the header bell) -->
+  <!-- Read My Mind: predicted-next-prompt modal (readmymind-ui.js). Suggestion
+       text is set via value/textContent only: predictor output derives from
+       observable (injectable) content, and the explicit click here is the
+       security boundary (nothing is ever auto-sent). -->
+  <div class="modal" id="readMyMindModal">
+    <div class="modal-backdrop" onclick="app.closeReadMyMind()"></div>
+    <div class="modal-content readmymind-modal">
+      <div class="modal-header">
+        <h3><span aria-hidden="true">🧠</span> Read My Mind</h3>
+        <button class="modal-close" onclick="app.closeReadMyMind()" aria-label="Close">&times;</button>
+      </div>
+      <div class="modal-body">
+        <div class="readmymind-loading">Reading your mind…</div>
+        <div class="readmymind-result" style="display:none">
+          <div class="readmymind-suggestion-row">
+            <span class="readmymind-kind" id="readMyMindKind" data-i18n-skip>continue</span>
+            <input type="text" id="readMyMindPrompt" class="readmymind-prompt-input" data-i18n-skip aria-label="Predicted prompt, editable" onkeydown="if(event.key==='Enter')app.sendReadMyMind(true)">
+          </div>
+          <div class="readmymind-why" id="readMyMindWhy" data-i18n-skip></div>
+        </div>
+        <div class="readmymind-error" style="display:none">No suggestion this time. Rethink to try again.</div>
+      </div>
+      <div class="modal-footer">
+        <button class="btn btn-secondary" onclick="app.closeReadMyMind()">Dismiss</button>
+        <button class="btn btn-secondary" id="readMyMindRethink" onclick="app.rethinkReadMyMind()">Rethink</button>
+        <button class="btn btn-secondary" onclick="app.sendReadMyMind(false)" title="Put the text on the session's composer without submitting it">Insert</button>
+        <button class="btn btn-primary" onclick="app.sendReadMyMind(true)">Send</button>
+      </div>
+    </div>
+  </div>
+
   <div class="approvals-drawer" id="approvalsDrawer" role="complementary" aria-label="Approvals inbox">
     <div class="approvals-header">
       <div>
@@ -2768,6 +2807,7 @@
   <script defer src="cron-ui.js"></script>
   <script defer src="settings-ui.js"></script>
   <script defer src="panels-ui.js"></script>
+  <script defer src="readmymind-ui.js"></script>
   <script defer src="ultracode-panel.js"></script>
   <script defer src="approvals-ui.js"></script>
   <script defer src="admin-ui.js"></script>

src/web/public/mobile.css

@@ -530,6 +530,12 @@ html.mobile-init .file-browser-panel {
     display: none !important;
   }
 
+  /* Read My Mind 🧠 button: desktop header only in phase 2; the phone surface
+     is a planned keyboard-accessory key (docs/readmymind-plan.md phase 3). */
+  .btn-icon-header.btn-readmymind {
+    display: none !important;
+  }
+
   /* The big labeled Admin Panel button is desktop-only (admin-gated, revealed by
      admin-ui.js). On phones admins still reach user management via App Settings →
      Users, so the cramped header stays minimal. */

src/web/public/readmymind-ui.js

@@ -0,0 +1,135 @@
+/**
+ * @fileoverview Read My Mind UI: predict the prompt you were about to type.
+ *
+ * A 🧠 header button (marker-hidden until the synced opt-in `readMyMindEnabled`
+ * setting is ON) opens a modal that asks the server for the user's most likely
+ * next prompt (`POST /api/sessions/:id/readmymind`, one-shot predictor over the
+ * case's intent profile + live session signals). The top suggestion lands in an
+ * editable single-line field with its rationale below; buttons are Send (with
+ * Enter), Insert (drop on the CLI composer WITHOUT Enter, for editing), Rethink
+ * (re-run with the shown suggestion recorded as rejected), Dismiss.
+ *
+ * Suggestions are NEVER auto-sent: the explicit click here is the security
+ * boundary for observed/injectable predictor inputs, so suggestion text is
+ * always rendered via value/textContent, never innerHTML. Send/Insert go
+ * server-side through `POST /api/sessions/:id/input` (UI chrome, not terminal
+ * typing, so the local-echo-overlay `sendEnterKey` trap does not apply);
+ * Send appends the `\r` that actually submits, Insert omits it.
+ *
+ * Backend: src/web/routes/readmymind-routes.ts, design: docs/readmymind-plan.md.
+ *
+ * @mixin Extends CodemanApp.prototype via Object.assign
+ * @dependency app.js (CodemanApp class, this.sessions, this.activeSessionId, showToast)
+ * @dependency settings-ui.js (loadAppSettingsFromStorage)
+ * @dependency api-client.js at runtime (this._apiJson; loads later but is only called after init)
+ * @loadorder 11.3, after panels-ui.js, before ultracode-panel.js
+ */
+
+Object.assign(CodemanApp.prototype, {
+  /** Synced setting, default OFF, opt-in via App Settings → Panels. */
+  readMyMindEnabled() {
+    return this.loadAppSettingsFromStorage().readMyMindEnabled === true;
+  },
+
+  /** Open the modal for the active session and start a prediction. */
+  openReadMyMind() {
+    const sessionId = this.activeSessionId;
+    const session = sessionId ? this.sessions.get(sessionId) : null;
+    if (!session) {
+      this.showToast('Select a session first', 'warning');
+      return;
+    }
+    if (session.mode && session.mode !== 'claude') {
+      this.showToast('Read My Mind works on Claude sessions only', 'warning');
+      return;
+    }
+    // Rethink memory resets on each open (a fresh open is a fresh question).
+    this._rmm = { sessionId, shown: null, rejected: [], busy: false };
+    document.getElementById('readMyMindModal')?.classList.add('active');
+    this._readMyMindPredict();
+  },
+
+  closeReadMyMind() {
+    document.getElementById('readMyMindModal')?.classList.remove('active');
+    this._rmm = null;
+  },
+
+  /** Run (or re-run) the prediction and render the top suggestion. */
+  async _readMyMindPredict() {
+    const state = this._rmm;
+    if (!state || state.busy) return;
+    state.busy = true;
+    this._rmmSetPhase('loading');
+
+    const body = state.rejected.length > 0 ? { rejected: state.rejected.slice(-10) } : {};
+    const data = await this._apiJson(`/api/sessions/${state.sessionId}/readmymind`, { method: 'POST', body });
+
+    // The modal may have been dismissed (or reopened for another session) while
+    // the predictor ran; drop a stale response instead of painting over it.
+    if (this._rmm !== state) return;
+    state.busy = false;
+
+    const suggestion = data && data.suggestions && data.suggestions[0];
+    if (!suggestion) {
+      this._rmmSetPhase('error');
+      return;
+    }
+    state.shown = suggestion;
+    this._rmmSetPhase('ready');
+
+    const input = document.getElementById('readMyMindPrompt');
+    const why = document.getElementById('readMyMindWhy');
+    const kind = document.getElementById('readMyMindKind');
+    // Predictor output is derived from observable (injectable) content:
+    // value/textContent only, never innerHTML.
+    if (input) input.value = suggestion.prompt;
+    if (why) why.textContent = suggestion.why || '';
+    if (kind) {
+      kind.textContent = suggestion.kind || 'continue';
+      kind.className = `readmymind-kind readmymind-kind-${suggestion.kind || 'continue'}`;
+    }
+    input?.focus();
+  },
+
+  /**
+   * Send the (possibly edited) suggestion. `withEnter` submits (`\r`, the
+   * documented single-line input rule); without it the text sits unsubmitted
+   * on the CLI composer for further editing (Insert).
+   */
+  async sendReadMyMind(withEnter) {
+    const state = this._rmm;
+    const input = document.getElementById('readMyMindPrompt');
+    const text = input ? input.value.replace(/[\r\n]+/g, ' ').trim() : '';
+    if (!state || !text) return;
+
+    const res = await this._apiJson(`/api/sessions/${state.sessionId}/input`, {
+      method: 'POST',
+      body: { input: withEnter ? `${text}\r` : text },
+    });
+    if (res === null) {
+      this.showToast('Could not reach the session', 'error');
+      return;
+    }
+    this.closeReadMyMind();
+    this.showToast(withEnter ? 'Prompt sent' : 'Inserted, press Enter in the terminal to send', 'success');
+  },
+
+  /** Re-run with the shown suggestion recorded as a rejection. */
+  rethinkReadMyMind() {
+    const state = this._rmm;
+    if (!state || state.busy) return;
+    if (state.shown && state.shown.prompt) state.rejected.push(state.shown.prompt);
+    this._readMyMindPredict();
+  },
+
+  /** Toggle the modal between its loading / ready / error phases. */
+  _rmmSetPhase(phase) {
+    const modal = document.getElementById('readMyMindModal');
+    if (!modal) return;
+    modal.querySelector('.readmymind-loading').style.display = phase === 'loading' ? '' : 'none';
+    modal.querySelector('.readmymind-result').style.display = phase === 'ready' ? '' : 'none';
+    modal.querySelector('.readmymind-error').style.display = phase === 'error' ? '' : 'none';
+    const rethinkBtn = document.getElementById('readMyMindRethink');
+    if (rethinkBtn) rethinkBtn.disabled = phase === 'loading';
+  },
+});

src/web/public/settings-ui.js

@@ -344,6 +344,8 @@ Object.assign(CodemanApp.prototype, {
     document.getElementById('appSettingsShowUltracodeAgents').checked = settings.showUltracodeAgents ?? defaults.showUltracodeAgents ?? false;
     // Approvals Inbox: synced, default OFF (opt-in; only an explicit true enables).
     document.getElementById('appSettingsApprovalsInbox').checked = settings.approvalsInboxEnabled === true;
+    // Read My Mind: synced, default OFF (opt-in; capture + prediction cost real tokens).
+    document.getElementById('appSettingsReadMyMind').checked = settings.readMyMindEnabled === true;
     document.getElementById('appSettingsUltracodeFloatingWindows').checked =
       settings.ultracodeFloatingWindows ?? defaults.ultracodeFloatingWindows ?? false;
     document.getElementById('appSettingsShowMultiMonitorButton').checked = settings.showMultiMonitorButton ?? defaults.showMultiMonitorButton ?? false;
@@ -1544,6 +1546,7 @@ Object.assign(CodemanApp.prototype, {
       showSubagents: document.getElementById('appSettingsShowSubagents').checked,
       showUltracodeAgents: document.getElementById('appSettingsShowUltracodeAgents').checked,
       approvalsInboxEnabled: document.getElementById('appSettingsApprovalsInbox').checked,
+      readMyMindEnabled: document.getElementById('appSettingsReadMyMind').checked,
       ultracodeFloatingWindows: document.getElementById('appSettingsUltracodeFloatingWindows').checked,
       showMultiMonitorButton: document.getElementById('appSettingsShowMultiMonitorButton').checked,
       showPlanUsageLimits: document.getElementById('appSettingsShowPlanUsageLimits').checked,
@@ -2106,6 +2109,15 @@ Object.assign(CodemanApp.prototype, {
       ultracodeBtn.classList.toggle('btn-ultracode-agents--hidden', !showUltracodeAgents);
     }
 
+    // Read My Mind 🧠 — hidden unless the synced opt-in `readMyMindEnabled` is
+    // ON (only an explicit true enables, mirroring the Approvals bell). Marker
+    // class (base is display:inline-flex !important); phones hide it in
+    // mobile.css regardless (the phase-3 surface there is an accessory key).
+    const readMyMindBtn = document.querySelector('.btn-readmymind');
+    if (readMyMindBtn) {
+      readMyMindBtn.classList.toggle('btn-readmymind--hidden', settings.readMyMindEnabled !== true);
+    }
+
     // Plan-usage chip — shown by default on desktop, OFF on handhelds (App
     // Settings → Display → "Plan Usage Limits"). The template always ships it
     // hidden because display is per-device and the server cannot know a

src/web/public/styles.css

@@ -10668,6 +10668,80 @@ kbd {
   display: none !important;
 }
 
+/* Read My Mind 🧠 header button: opt-in (`readMyMindEnabled`, synced, default
+   OFF), revealed by applyHeaderVisibilitySettings(). Marker-class pattern:
+   the base display rule is !important, so hiding must also be a class. */
+.btn-readmymind {
+  display: inline-flex !important;
+}
+.btn-readmymind.btn-readmymind--hidden {
+  display: none !important;
+}
+.btn-readmymind .readmymind-icon {
+  font-size: 13px;
+  line-height: 1;
+}
+
+/* Read My Mind modal: top suggestion in an editable single-line field with the
+   kind badge beside it and the rationale below. */
+.modal-content.readmymind-modal {
+  max-width: 560px;
+}
+.readmymind-loading {
+  padding: 14px 4px;
+  color: var(--text-dim);
+  animation: readmymind-pulse 1.4s ease-in-out infinite;
+}
+@keyframes readmymind-pulse {
+  0%, 100% { opacity: 0.45; }
+  50% { opacity: 1; }
+}
+.readmymind-suggestion-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.readmymind-kind {
+  flex: 0 0 auto;
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  padding: 3px 7px;
+  border-radius: 9px;
+  border: 1px solid var(--control-border);
+  color: var(--text-dim);
+}
+.readmymind-kind-verify {
+  color: var(--warning, #e5c07b);
+}
+.readmymind-kind-redirect {
+  color: var(--accent);
+}
+.readmymind-prompt-input {
+  flex: 1 1 auto;
+  min-width: 0;
+  font-family: var(--mono-font, monospace);
+  font-size: 13px;
+  padding: 8px 10px;
+  background: var(--bg-dark);
+  color: var(--text);
+  border: 1px solid var(--control-border);
+  border-radius: 8px;
+}
+.readmymind-prompt-input:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+.readmymind-why {
+  margin-top: 8px;
+  font-size: 12px;
+  color: var(--text-dim);
+}
+.readmymind-error {
+  padding: 12px 4px;
+  color: var(--text-dim);
+}
+
 .approvals-badge {
   position: absolute;
   top: 2px;

src/web/routes/readmymind-routes.ts

@@ -1,11 +1,12 @@
 /**
- * @fileoverview Read My Mind intent routes.
+ * @fileoverview Read My Mind routes: intent profiles + the predictor.
  *
  * Per-case intent profiles feeding the Read My Mind predictor
  * (docs/readmymind-plan.md):
  * - `GET    /api/sessions/:id/intent`: the profile for the session's case
  * - `PUT    /api/sessions/:id/intent`: replace the goals text
  * - `DELETE /api/sessions/:id/intent`: forget the case's profile
+ * - `POST   /api/sessions/:id/readmymind`: predict the user's next prompt
  *
  * The profile is keyed by owner + workingDir, so multi-user scoping is
  * structural; session ownership is still enforced via `findSessionOrFail`
@@ -16,6 +17,15 @@
  * the session resolves owner + workingDir server-side, so a caller can never
  * address another case's profile by guessing keys.
  *
+ * Predict gathers every signal Codeman already has (intent profile, pending
+ * approval dialog, transcript tail, git state, run-summary events, sibling
+ * sessions), assembles a budgeted prompt via the pure
+ * `buildPredictionContext()`, and runs the one-shot predictor. Claude-mode
+ * only (400: capture and transcripts exist for nothing else), one prediction
+ * in flight per session (409 CONFLICT), and suggestions are only ever
+ * RETURNED, never sent: the human click in the modal is the boundary, which
+ * is also the prompt-injection mitigation for observed content.
+ *
  * Registrations use the bare `app.<method>('path', ...)` + `req.params as`
  * shape (session-routes style): these endpoints are documented in the agent
  * skill, and the endpoints.md drift test's scanner does not see registrations
@@ -23,12 +33,21 @@
  */
 
 import { FastifyInstance } from 'fastify';
-import { IntentGoalsSchema } from '../schemas.js';
+import { ApiErrorCode, createErrorResponse } from '../../types.js';
+import { IntentGoalsSchema, ReadMyMindPredictSchema } from '../schemas.js';
 import { parseBody, findSessionOrFail } from '../route-helpers.js';
 import { intentStore } from '../../intent-store.js';
-import type { SessionPort } from '../ports/index.js';
+import { approvalInbox } from '../approval-inbox.js';
+import { hooksAvailableForMode } from '../session-wait-registry.js';
+import { buildPredictionContext, type PredictionContextInputs } from '../../readmymind-context.js';
+import { collectWorkspaceSignals, readTranscriptSignals } from '../../readmymind-collectors.js';
+import { readMyMindPredictor } from '../../readmymind-predictor.js';
+import type { ConfigPort, InfraPort, SessionPort } from '../ports/index.js';
 
-export function registerReadMyMindRoutes(app: FastifyInstance, ctx: SessionPort): void {
+/** One prediction in flight per session; a second POST while running is a 409. */
+const predictionsInFlight = new Set<string>();
+
+export function registerReadMyMindRoutes(app: FastifyInstance, ctx: SessionPort & ConfigPort & InfraPort): void {
   app.get('/api/sessions/:id/intent', async (req) => {
     const { id } = req.params as { id: string };
     const session = findSessionOrFail(ctx, id, req);
@@ -47,4 +66,73 @@ export function registerReadMyMindRoutes(app: FastifyInstance, ctx: SessionPort)
     const session = findSessionOrFail(ctx, id, req);
     return { success: true, data: { deleted: intentStore.deleteProfile(session.owner, session.workingDir) } };
   });
+
+  app.post('/api/sessions/:id/readmymind', async (req, reply) => {
+    const { id } = req.params as { id: string };
+    const body = parseBody(ReadMyMindPredictSchema, req.body ?? {});
+    const session = findSessionOrFail(ctx, id, req);
+
+    if (!hooksAvailableForMode(session.mode)) {
+      reply.code(400);
+      return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Read My Mind predicts claude-mode sessions only');
+    }
+    if (predictionsInFlight.has(id)) {
+      reply.code(409);
+      return createErrorResponse(ApiErrorCode.CONFLICT, 'A prediction is already running for this session');
+    }
+
+    predictionsInFlight.add(id);
+    try {
+      const profile = intentStore.getProfile(session.owner, session.workingDir);
+      const pending = approvalInbox.getForSession(id);
+      const transcriptPath = ctx.getTranscriptPath(id);
+      const transcript = transcriptPath ? await readTranscriptSignals(transcriptPath) : null;
+      // Remote-SSH cases skip git: workingDir is not local. Docker cases are
+      // fine (the workspace is bind-mounted at the same host path).
+      const workspace = session.remote ? null : await collectWorkspaceSignals(session.workingDir);
+
+      const lastPromptTs = profile.recentPrompts[profile.recentPrompts.length - 1]?.ts;
+      const tracker = ctx.runSummaryTrackers.get(id);
+      const awayEvents = (tracker?.getRecentEvents(15) ?? [])
+        .filter((ev) => lastPromptTs === undefined || ev.timestamp >= lastPromptTs)
+        .map((ev) => ({ timestamp: ev.timestamp, title: ev.title, details: ev.details }));
+
+      const siblings = [...ctx.sessions.values()]
+        .filter((s) => s.id !== id && s.workingDir === session.workingDir && s.status !== 'stopped')
+        .map((s) => ({ name: s.name, mode: s.mode, working: s.isWorking }));
+
+      const inputs: PredictionContextInputs = {
+        pendingDialog: pending
+          ? {
+              kind: pending.kind,
+              toolName: pending.toolName,
+              message: pending.message,
+              context: pending.context,
+              options: pending.options,
+            }
+          : undefined,
+        goals: profile.goals,
+        lastAssistantText: transcript?.lastAssistantText ?? undefined,
+        recentPrompts: profile.recentPrompts.map((p) => ({ ts: p.ts, text: p.text })),
+        recentTools: transcript?.recentTools,
+        workspace: workspace ?? undefined,
+        awaySinceMs: lastPromptTs !== undefined ? Date.now() - lastPromptTs : undefined,
+        awayEvents,
+        siblings,
+        steer: body.steer,
+        rejected: body.rejected,
+      };
+
+      const { prompt } = buildPredictionContext(inputs);
+      const model = await ctx.getReadMyMindModel();
+      const result = await readMyMindPredictor.predict({ sessionId: id, prompt, model });
+      return { success: true, data: { suggestions: result.suggestions, durationMs: result.durationMs } };
+    } catch (err) {
+      reply.code(502);
+      const message = err instanceof Error ? err.message : 'Prediction failed';
+      return createErrorResponse(ApiErrorCode.OPERATION_FAILED, message);
+    } finally {
+      predictionsInFlight.delete(id);
+    }
+  });
 }

src/web/schemas.ts

@@ -710,6 +710,19 @@ export const IntentGoalsSchema = z
   })
   .strict();
 
+/**
+ * Body of POST /api/sessions/:id/readmymind (Read My Mind predict). Both
+ * fields are the Rethink flow: `rejected` carries suggestions the user
+ * dismissed (strong negative signal, fed back verbatim), `steer` an optional
+ * free-text correction ("no, I meant the mobile bug").
+ */
+export const ReadMyMindPredictSchema = z
+  .object({
+    steer: z.string().max(2000).optional(),
+    rejected: z.array(z.string().max(1000)).max(10).optional(),
+  })
+  .strict();
+
 // ========== Configuration ==========
 
 /**
@@ -826,6 +839,12 @@ export const SettingsUpdateSchema = z
      * stored profiles stay until DELETE /api/sessions/:id/intent.
      */
     readMyMindEnabled: z.boolean().optional(),
+    /**
+     * Read My Mind predictor model override. Empty/absent = the AI-checker
+     * default (opus: prediction quality is the product and it runs only on an
+     * explicit press). Shell-safety is validated again at spawn time.
+     */
+    readMyMindModel: z.string().max(100).optional(),
     tunnelEnabled: z.boolean().optional(),
     // Action field (NOT persisted): explicit per-request acknowledgment that the
     // operator accepts exposing an UNAUTHENTICATED public tunnel (no CODEMAN_PASSWORD).

src/web/server.ts

@@ -87,6 +87,7 @@ import {
 } from './session-listener-wiring.js';
 import { sessionWaits, hooksAvailableForMode } from './session-wait-registry.js';
 import { intentStore } from '../intent-store.js';
+import { AI_CHECK_MODEL } from '../config/ai-defaults.js';
 import { approvalInbox } from './approval-inbox.js';
 import {
   wireRespawnListeners,
@@ -639,6 +640,8 @@ export class WebServer extends EventEmitter {
       getLightSessionsState: this.getLightSessionsState.bind(this),
       startTranscriptWatcher: this.startTranscriptWatcher.bind(this),
       stopTranscriptWatcher: this.stopTranscriptWatcher.bind(this),
+      getTranscriptPath: (sessionId: string) => this.transcriptWatchers.get(sessionId)?.getPath() ?? null,
+      getReadMyMindModel: this.getReadMyMindModel.bind(this),
       // InfraPort
       mux: this.mux,
       runSummaryTrackers: this.runSummaryTrackers,
@@ -1696,6 +1699,18 @@ export class WebServer extends EventEmitter {
     return settings.agentSkillEnabled === true;
   }
 
+  /**
+   * Read My Mind predictor model (docs/readmymind-plan.md): `readMyMindModel`
+   * setting, defaulting to the AI-checker opus model. Prediction quality is
+   * the product and runs only on an explicit press, so the cost profile is
+   * nothing like the idle checker's.
+   */
+  private async getReadMyMindModel(): Promise<string> {
+    const settings = await this.readSettings();
+    const model = typeof settings.readMyMindModel === 'string' ? settings.readMyMindModel.trim() : '';
+    return model || AI_CHECK_MODEL;
+  }
+
   // Helper to get model configuration from settings
   private async getModelConfig(): Promise<{
     defaultModel?: string;