relay-companion 0.1.149 → 0.1.151

package/overlay/main.cjs

@@ -3422,6 +3422,82 @@ function safeNoteStem(value) {
   return String(value || "note").replace(/[^0-9A-Za-z._-]+/g, "-").replace(/^-|-$/g, "");
 }
 
+// --- The task session feed ---------------------------------------------------
+// The session face reads the SAME native transcript the host app renders —
+// the forged Claude session JSONL or the Codex rollout — through the audited
+// reader in src/ai-session-transcript.js (redacted, thinking excluded,
+// newest-first). The preview polls this; there is no watcher anywhere in the
+// companion by design (fs.watch is unreliable across atomic renames).
+async function previewTaskSession(relayId) {
+  const id = String(relayId || "");
+  const row = rowById(id);
+  if (!row || row.relayNotificationKind !== "task") return { ok: false, error: "Not a task." };
+  const claudePath = row.claudeNativeSession && row.claudeNativeSession.sessionPath;
+  const codexPath = row.codexSessionPath || row.sessionPath;
+  const provider = claudePath ? "claude" : codexPath ? "codex" : "";
+  if (!provider) return { ok: false, error: "The session has not started on this computer yet." };
+  try {
+    const { inspectAiSession } = await import("../src/ai-session-transcript.js");
+    const target = provider === "claude"
+      ? { id, provider, state: "", nativeRef: { transcriptPath: claudePath } }
+      : { id, provider, state: "", nativeRef: { sessionPath: codexPath } };
+    const page = await inspectAiSession(target, { limit: 200 });
+    return {
+      ok: true,
+      provider,
+      liveState: await previewTaskLiveState(row, provider),
+      records: Array.isArray(page.records) ? page.records : [],
+      // Receipts ride the poll: the content payload is pushed once, and the
+      // Done flip should not wait for a window reopen.
+      taskStartedAt: row.taskStartedAt || null,
+      taskCompletedAt: row.taskCompletedAt || null,
+    };
+  } catch (error) {
+    return { ok: false, error: (error && error.message) || String(error) };
+  }
+}
+
+// "Is the agent working right now?" — read from the same session registry the
+// pill's directory uses: a live inbox socket means the session process exists.
+async function previewTaskLiveState(row, provider) {
+  try {
+    if (provider !== "claude") return "unknown";
+    const sessionId = row.claudeNativeSession && row.claudeNativeSession.sessionId;
+    if (!sessionId) return "unknown";
+    const { liveClaudeRegistrations, claudeState } = await import("../src/session-directory.js");
+    const match = liveClaudeRegistrations().get(String(sessionId));
+    return match ? claudeState(match) : "offline";
+  } catch {
+    return "unknown";
+  }
+}
+
+// Steer: put the reader's words INTO the live agent turn (Claude's inbox
+// socket), never to the sender — replies to the sender belong to the chat
+// face. Codex steering needs the app-server turn id; not wired yet.
+async function previewTaskSteer(input) {
+  const id = String((input && input.relayId) || "");
+  const body = String((input && input.body) || "").trim();
+  if (!body) return { ok: false, error: "Write something first." };
+  if (body.length > 20000) return { ok: false, error: "That is too long to send." };
+  const row = rowById(id);
+  if (!row || row.relayNotificationKind !== "task") return { ok: false, error: "Not a task." };
+  const sessionId = row.claudeNativeSession && row.claudeNativeSession.sessionId;
+  if (!sessionId) return { ok: false, error: "Steering needs the Claude session — open it in Claude instead." };
+  try {
+    const { liveClaudeRegistrations } = await import("../src/session-directory.js");
+    const { sendClaudeSocket } = await import("../src/session-controller.js");
+    const match = liveClaudeRegistrations().get(String(sessionId));
+    if (!match || !match.socketLive || !match.messagingSocketPath) {
+      return { ok: false, error: "The session isn't live right now — open it in Claude to continue." };
+    }
+    await sendClaudeSocket(match.messagingSocketPath, body);
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: (error && error.message) || String(error) };
+  }
+}
+
 function installActiveSpaceWatcher() {
   if (process.platform !== "darwin") return;
   subscribeActiveSpaceChanges(
@@ -3837,6 +3913,16 @@ ipcMain.handle("relay:preview:startTask", async (event, input) => {
   if (!isPreviewEvent(event)) return { ok: false, error: "Not the preview window." };
   return startTaskFromPreview(input);
 });
+// The session face's feed and its Steer verb. Preview-only, like everything
+// on this channel; the feed reads only this staged relay's own session.
+ipcMain.handle("relay:preview:session", (event, relayId) => {
+  if (!isPreviewEvent(event)) return { ok: false, error: "Not the preview window." };
+  return previewTaskSession(relayId);
+});
+ipcMain.handle("relay:preview:steer", (event, input) => {
+  if (!isPreviewEvent(event)) return { ok: false, error: "Not the preview window." };
+  return previewTaskSteer(input);
+});
 ipcMain.on("relay:openTask", (_e, taskId) => openTaskDetail(taskId));
 ipcMain.on("relay:openUrl", (_e, url) => openUrlTarget(url));
 ipcMain.on("relay:ack", (_e, id) => ackPacket(id));

package/overlay/preview-preload-source.cjs

@@ -150,5 +150,12 @@ contextBridge.exposeInMainWorld("relayPreview", {
       model: String(model || ""),
       effort: String(effort || ""),
     }),
+  // The session face: the live transcript feed and the Steer verb.
+  loadSession: (relayId) => ipcRenderer.invoke("relay:preview:session", String(relayId || "")),
+  steer: (relayId, body) =>
+    ipcRenderer.invoke("relay:preview:steer", {
+      relayId: String(relayId || ""),
+      body: String(body || ""),
+    }),
   renderMarkdown,
 });

package/overlay/preview-preload.cjs

@@ -6513,6 +6513,12 @@ contextBridge.exposeInMainWorld("relayPreview", {
     model: String(model || ""),
     effort: String(effort || "")
   }),
+  // The session face: the live transcript feed and the Steer verb.
+  loadSession: (relayId) => ipcRenderer.invoke("relay:preview:session", String(relayId || "")),
+  steer: (relayId, body) => ipcRenderer.invoke("relay:preview:steer", {
+    relayId: String(relayId || ""),
+    body: String(body || "")
+  }),
   renderMarkdown
 });
 /*! Bundled license information:

package/overlay/preview-renderer.js

@@ -40,6 +40,9 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
   const runtimeWordsEl = document.getElementById("runtimeWords");
   const runtimePopEl = document.getElementById("runtimePop");
   const rtCodexItemEl = document.getElementById("rtCodexItem");
+  const sessionScrollEl = document.getElementById("sessionScroll");
+  const sessionListEl = document.getElementById("sessionList");
+  const sessionStateEl = document.getElementById("sessionState");
 
   const COMPOSER_MIN_HEIGHT = 42;
   const COMPOSER_MAX_HEIGHT = 124;
@@ -63,6 +66,14 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
   /** The task face's ignition state: composer starts the task, not a reply. */
   let taskMode = false;
   let starting = false;
+  /** A started task shows its live session in the message-face slot. */
+  let sessionMode = false;
+  let sessionTimer = 0;
+  let sessionFingerprint = "";
+  let sessionLive = { provider: "", liveState: "", error: "" };
+  /** Disclosure rows the reader has opened; keyed by a stable per-record key. */
+  const actOpen = new Set();
+  const SESSION_POLL_MS = 1200;
   /** The runtime the Start button will use. Claude Code · Opus 5 · high. */
   const runtime = { host: "claude", model: "claude-opus-5", effort: "high" };
   const MODEL_LABELS = { "claude-opus-5": "Opus 5", "claude-sonnet-5": "Sonnet 5" };
@@ -193,6 +204,19 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
     }
     taskRuntimeNoteEl.classList.add("gone");
     replyNoteEl.classList.remove("gone");
+    if (sessionMode && face !== "chat") {
+      // On the session face the composer talks to the AGENT: words land in the
+      // live turn without interrupting it. Replies to the sender live one
+      // slide away, on the conversation face.
+      const done = Boolean(text(content.taskCompletedAt));
+      replyInputEl.placeholder = done ? "Write a reply…" : "Steer the current turn…";
+      replyInputEl.disabled = sending;
+      const ready = !sending && Boolean(replyInputEl.value.trim());
+      replyButtonEl.disabled = !ready;
+      replyButtonEl.setAttribute("aria-disabled", ready ? "false" : "true");
+      replyButtonEl.textContent = sending ? "Sending…" : done ? "Send" : "Steer";
+      return;
+    }
     const hasTarget = Boolean(replyTargetId());
     replyInputEl.placeholder = composerPlaceholder();
     replyInputEl.disabled = sending || !hasTarget;
@@ -265,13 +289,13 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
     replyInputEl.value = "";
     autosizeComposer();
     renderTaskMeta();
+    // The window turns into the live session: the note appears as the one
+    // bubble, the agent's work streams in beneath it. The conversation (with
+    // the sender's "Started" copy) stays one slide away on the chip.
+    setSessionMode(true);
     refreshComposer();
     setNote("Started — your agent has it from here.");
-    loadChat({ keepScroll: false })
-      .then(() => {
-        if (chat) showFace("chat");
-      })
-      .catch(() => {});
+    loadChat({ keepScroll: false }).catch(() => {});
   }
 
   function setNote(message, isError) {
@@ -754,6 +778,12 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
       await submitStart();
       return;
     }
+    // A running session's composer steers the agent; once the task is done it
+    // settles into an ordinary reply to the sender.
+    if (sessionMode && face !== "chat" && !text(content.taskCompletedAt)) {
+      await submitSteer();
+      return;
+    }
     if (sending) return;
     const body = replyInputEl.value.trim();
     const targetId = replyTargetId();
@@ -770,6 +800,347 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
     if (!replyInputEl.disabled) replyInputEl.focus();
   }
 
+  // --- The session face -------------------------------------------------------
+  // A started task's transcript, rendered as a calm document: the human's
+  // words in the one bubble, the agent's prose flat, and every action folded
+  // to a dimmed sentence. Evidence appears only when asked for.
+
+  const TOOL_ICONS = {
+    command:
+      '<svg width="13" height="13" viewBox="0 0 16 16" fill="none"><path d="M2.5 4.5 6 8l-3.5 3.5M8.5 11.5h5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>',
+    file:
+      '<svg width="13" height="13" viewBox="0 0 16 16" fill="none"><path d="M9.5 1.5h-5a1 1 0 0 0-1 1v11a1 1 0 0 0 1 1h7a1 1 0 0 0 1-1V4.5l-3-3Z" stroke="currentColor" stroke-width="1.3" stroke-linejoin="round"/><path d="M9.5 1.5v3h3" stroke="currentColor" stroke-width="1.3" stroke-linejoin="round"/></svg>',
+    search:
+      '<svg width="13" height="13" viewBox="0 0 16 16" fill="none"><circle cx="7" cy="7" r="4.5" stroke="currentColor" stroke-width="1.4"/><path d="m10.5 10.5 3 3" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"/></svg>',
+    web:
+      '<svg width="13" height="13" viewBox="0 0 16 16" fill="none"><circle cx="8" cy="8" r="6" stroke="currentColor" stroke-width="1.3"/><path d="M2.2 8h11.6M8 2c1.8 1.7 2.6 3.7 2.6 6S9.8 12.3 8 14C6.2 12.3 5.4 10.3 5.4 8S6.2 3.7 8 2Z" stroke="currentColor" stroke-width="1.1"/></svg>',
+    agent:
+      '<svg width="13" height="13" viewBox="0 0 16 16" fill="none"><circle cx="4.5" cy="4" r="2" stroke="currentColor" stroke-width="1.3"/><circle cx="11.5" cy="12" r="2" stroke="currentColor" stroke-width="1.3"/><path d="M4.5 6v2.5a2 2 0 0 0 2 2h3" stroke="currentColor" stroke-width="1.3" stroke-linecap="round"/></svg>',
+  };
+  const ACT_CHEVRON =
+    '<svg class="act-chev" viewBox="0 0 10 10" fill="none" aria-hidden="true"><path d="M3 1.5 7 5 3 8.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>';
+
+  function parseToolInput(input) {
+    if (input && typeof input === "object") return input;
+    try {
+      return JSON.parse(String(input || "{}")) || {};
+    } catch {
+      return {};
+    }
+  }
+
+  function basename(value) {
+    const parts = String(value || "").split(/[\\/]/);
+    return parts[parts.length - 1] || String(value || "");
+  }
+
+  function firstWords(value, max) {
+    const clean = String(value || "").replace(/\s+/g, " ").trim();
+    return clean.length > max ? `${clean.slice(0, max - 1).trimEnd()}…` : clean;
+  }
+
+  /**
+   * The verb map: every tool gets an active and a completed sentence in plain
+   * words, with the object in mono. Nothing here shows code — the sentence is
+   * the surface, the evidence waits behind the click.
+   */
+  function describeTool(tool, input, running) {
+    const name = String(tool || "tool");
+    const args = parseToolInput(input);
+    const mono = (value) => (value ? { obj: firstWords(value, 64) } : {});
+    if (name === "Bash") {
+      return { icon: "command", text: running ? "Running a command" : "Ran a command", ...mono(args.command), evidence: "command" };
+    }
+    if (["Edit", "Write", "MultiEdit", "NotebookEdit"].includes(name)) {
+      const file = basename(args.file_path || args.path || args.notebook_path);
+      return { icon: "file", text: `${running ? "Editing" : "Edited"}${file ? " " : ""}`, obj: file, evidence: "file" };
+    }
+    if (name === "Read") {
+      return { icon: "search", text: running ? "Reading" : "Read", obj: basename(args.file_path || args.path), evidence: "quiet" };
+    }
+    if (["Glob", "Grep"].includes(name)) {
+      return { icon: "search", text: running ? "Searching the code" : "Searched the code", ...mono(args.pattern || args.query), evidence: "quiet" };
+    }
+    if (["WebSearch", "WebFetch"].includes(name)) {
+      return { icon: "web", text: running ? "Searching the web" : "Searched the web", ...mono(args.query || args.url), evidence: "quiet" };
+    }
+    if (["Task", "Agent"].includes(name)) {
+      return { icon: "agent", text: running ? "Running an agent" : "Ran an agent", ...mono(args.description || args.prompt), evidence: "quiet" };
+    }
+    const mcp = name.match(/^mcp__([^_]+(?:[-_][^_]+)*?)__(.+)$/);
+    if (mcp) {
+      const server = mcp[1].replace(/[-_]+/g, " ").trim();
+      const toolWords = mcp[2].replace(/[-_]+/g, " ").trim();
+      return { icon: "web", text: `${running ? "Using" : "Used"} ${server}`, obj: toolWords, evidence: "quiet" };
+    }
+    return { icon: "command", text: `${running ? "Using" : "Used"} ${name}`, evidence: "quiet" };
+  }
+
+  /** Oldest-first entries the session face renders, built from reader records. */
+  function sessionEntries(records) {
+    const oldestFirst = records.slice().reverse();
+    const entries = [];
+    let seedDropped = false;
+    for (let i = 0; i < oldestFirst.length; i += 1) {
+      const record = oldestFirst[i] || {};
+      if (record.type === "message" && record.role === "assistant" && !seedDropped && entries.length === 0) {
+        // The forged seed: the brief the reader has already seen on the task
+        // face. Rendering it again would open every session with a wall.
+        seedDropped = true;
+        continue;
+      }
+      if (record.type === "message" && record.text) {
+        entries.push({ kind: record.role === "user" ? "user" : "prose", text: record.text, at: record.at, key: `m${i}` });
+        continue;
+      }
+      if (record.type === "progress" && record.text) {
+        entries.push({ kind: "progress", text: record.text, at: record.at, key: `p${i}` });
+        continue;
+      }
+      if (record.type === "tool_call") {
+        // Pair with the next result so the sentence knows its tense and the
+        // click has its evidence.
+        let result = null;
+        for (let j = i + 1; j < oldestFirst.length; j += 1) {
+          const candidate = oldestFirst[j] || {};
+          if (candidate.type === "tool_call") break;
+          if (candidate.type === "tool_result") {
+            result = candidate;
+            break;
+          }
+        }
+        entries.push({ kind: "act", tool: record.tool, input: record.input, result, at: record.at, key: `t${i}` });
+      }
+    }
+    return entries;
+  }
+
+  function buildActRow(entry, { live }) {
+    const running = !entry.result && live;
+    const spec = describeTool(entry.tool, entry.input, running);
+    const act = document.createElement("div");
+    act.className = "act";
+    if (actOpen.has(entry.key)) act.classList.add("open");
+    const head = document.createElement("button");
+    head.className = "act-head";
+    head.type = "button";
+    head.setAttribute("aria-expanded", actOpen.has(entry.key) ? "true" : "false");
+    const icon = document.createElement("span");
+    icon.className = "act-ic";
+    icon.innerHTML = TOOL_ICONS[spec.icon] || TOOL_ICONS.command;
+    const sum = document.createElement("span");
+    sum.className = `act-sum${running ? " shimmer" : ""}`;
+    sum.append(document.createTextNode(spec.text + (spec.obj ? " " : "")));
+    if (spec.obj) {
+      const obj = document.createElement("span");
+      obj.className = "obj";
+      obj.textContent = spec.obj;
+      sum.appendChild(obj);
+    }
+    if (running) sum.append(document.createTextNode("…"));
+    head.append(icon, sum);
+    head.insertAdjacentHTML("beforeend", ACT_CHEVRON);
+    act.appendChild(head);
+
+    const body = document.createElement("div");
+    body.className = "act-body";
+    const ev = document.createElement("div");
+    ev.className = "ev";
+    const args = parseToolInput(entry.input);
+    if (spec.evidence === "command" && args.command) {
+      const cmd = document.createElement("div");
+      cmd.className = "ev-cmd";
+      cmd.textContent = String(args.command);
+      ev.appendChild(cmd);
+    } else {
+      const cmd = document.createElement("pre");
+      cmd.className = "ev-out";
+      cmd.textContent = firstWords(JSON.stringify(args, null, 1), 2000) || "(no input)";
+      ev.appendChild(cmd);
+    }
+    if (entry.result && entry.result.output) {
+      const out = document.createElement("pre");
+      out.className = "ev-out";
+      out.textContent = String(entry.result.output);
+      ev.appendChild(out);
+    }
+    if (entry.result) {
+      const foot = document.createElement("div");
+      foot.className = `ev-foot${entry.result.isError ? " error" : ""}`;
+      foot.textContent = entry.result.isError ? "Failed" : "Completed";
+      ev.appendChild(foot);
+    }
+    body.appendChild(ev);
+    act.appendChild(body);
+
+    head.addEventListener("click", () => {
+      if (actOpen.has(entry.key)) actOpen.delete(entry.key);
+      else actOpen.add(entry.key);
+      act.classList.toggle("open");
+      head.setAttribute("aria-expanded", act.classList.contains("open") ? "true" : "false");
+    });
+    return act;
+  }
+
+  function workedForLabel() {
+    const startAt = parseDate(content.taskStartedAt);
+    if (!startAt) return "";
+    const endAt = parseDate(content.taskCompletedAt) || new Date();
+    const minutes = Math.max(1, Math.round((endAt - startAt) / 60000));
+    const clock = minutes >= 60 ? `${Math.floor(minutes / 60)} h ${minutes % 60} min` : `${minutes} min`;
+    return content.taskCompletedAt ? `Done · worked for ${clock}` : `Working for ${clock}`;
+  }
+
+  function renderSession(records) {
+    const done = Boolean(text(content.taskCompletedAt));
+    const live = !done && sessionLive.liveState === "active";
+    const entries = sessionEntries(records);
+    const nearBottom = sessionScrollEl.scrollHeight - sessionScrollEl.scrollTop - sessionScrollEl.clientHeight < 90;
+
+    const fragment = document.createDocumentFragment();
+    const marker = document.createElement("div");
+    marker.className = "turn-marker";
+    marker.textContent = done
+      ? "Turn complete"
+      : live
+        ? "Current turn · in progress"
+        : sessionLive.liveState === "needs_input"
+          ? "Current turn · needs you in Claude"
+          : "Session";
+    fragment.appendChild(marker);
+
+    let group = null;
+    for (const entry of entries) {
+      if (entry.kind === "act" || entry.kind === "progress") {
+        if (!group) {
+          group = document.createElement("div");
+          group.className = "group-gap";
+          fragment.appendChild(group);
+        }
+      } else {
+        group = null;
+      }
+      if (entry.kind === "user") {
+        const bubble = document.createElement("div");
+        bubble.className = "user-msg";
+        bubble.textContent = entry.text;
+        fragment.appendChild(bubble);
+      } else if (entry.kind === "prose") {
+        const prose = document.createElement("div");
+        prose.className = "agent-prose";
+        try {
+          const html = bridge.renderMarkdown(entry.text);
+          const article = document.createElement("div");
+          article.className = "markdown";
+          article.innerHTML = html;
+          prose.appendChild(article);
+        } catch {
+          prose.textContent = entry.text;
+        }
+        fragment.appendChild(prose);
+      } else if (entry.kind === "progress") {
+        const line = document.createElement("div");
+        line.className = "act";
+        const sum = document.createElement("span");
+        sum.className = "act-sum";
+        sum.style.fontSize = "11px";
+        sum.textContent = `› ${entry.text}`;
+        line.appendChild(sum);
+        group.appendChild(line);
+      } else if (entry.kind === "act") {
+        group.appendChild(buildActRow(entry, { live }));
+      }
+    }
+    const worked = workedForLabel();
+    if (worked) {
+      const foot = document.createElement("div");
+      foot.className = "worked-for";
+      foot.textContent = worked;
+      fragment.appendChild(foot);
+    }
+    sessionListEl.replaceChildren(fragment);
+    sessionStateEl.classList.add("gone");
+    if (nearBottom) {
+      requestAnimationFrame(() => {
+        sessionScrollEl.scrollTop = sessionScrollEl.scrollHeight;
+      });
+    }
+  }
+
+  async function pollSession() {
+    if (!sessionMode) return;
+    let result;
+    try {
+      result = await bridge.loadSession(text(content.relayId));
+    } catch (error) {
+      result = { ok: false, error: (error && error.message) || String(error) };
+    }
+    if (!sessionMode) return;
+    if (!result || !result.ok) {
+      sessionLive = { provider: "", liveState: "", error: text(result && result.error) };
+      if (!sessionListEl.childElementCount) {
+        sessionStateEl.textContent = sessionLive.error || "The session is not readable yet.";
+        sessionStateEl.classList.remove("gone");
+      }
+      return;
+    }
+    sessionLive = { provider: result.provider, liveState: text(result.liveState), error: "" };
+    // Receipts ride the poll — the Done flip lands here, not on a reopen.
+    if (text(result.taskStartedAt)) content.taskStartedAt = text(result.taskStartedAt);
+    if (text(result.taskCompletedAt) && !text(content.taskCompletedAt)) {
+      content.taskCompletedAt = text(result.taskCompletedAt);
+      renderTaskMeta();
+    }
+    const fingerprint = `${result.provider}|${sessionLive.liveState}|${text(content.taskCompletedAt)}|${JSON.stringify(result.records)}`;
+    if (fingerprint === sessionFingerprint && sessionListEl.childElementCount) return;
+    sessionFingerprint = fingerprint;
+    renderSession(result.records || []);
+    refreshComposer();
+  }
+
+  function setSessionMode(next) {
+    sessionMode = Boolean(next);
+    detailScrollEl.classList.toggle("gone", sessionMode);
+    sessionScrollEl.classList.toggle("gone", !sessionMode);
+    if (sessionTimer) {
+      clearInterval(sessionTimer);
+      sessionTimer = 0;
+    }
+    if (sessionMode) {
+      sessionFingerprint = "";
+      actOpen.clear();
+      sessionStateEl.textContent = "Reading the session…";
+      sessionStateEl.classList.remove("gone");
+      pollSession().catch(() => {});
+      sessionTimer = setInterval(() => pollSession().catch(() => {}), SESSION_POLL_MS);
+    }
+  }
+
+  async function submitSteer() {
+    if (sending) return;
+    const body = replyInputEl.value.trim();
+    const id = text(content.relayId);
+    if (!body || !id) return;
+    sending = true;
+    refreshComposer();
+    let result;
+    try {
+      result = await bridge.steer(id, body);
+    } catch (error) {
+      result = { ok: false, error: (error && error.message) || String(error) };
+    }
+    sending = false;
+    if (result && result.ok) {
+      replyInputEl.value = "";
+      autosizeComposer();
+      setNote("Steered — it lands in the current turn without interrupting it.");
+      pollSession().catch(() => {});
+    } else {
+      setNote(text(result && result.error) || "The steer did not send.", true);
+    }
+    refreshComposer();
+  }
+
   // --- The message face -------------------------------------------------------
 
   async function renderContent(next) {
@@ -826,6 +1197,7 @@ try { if (localStorage.getItem("relayTheme") === "dark") document.documentElemen
       renderRuntimeWords();
     }
     renderTaskMeta();
+    setSessionMode(text(row.openFace) === "task" && Boolean(text(row.taskStartedAt)));
     showFace(opensInChat ? "chat" : "message", { force: true });
     setNote("");
     refreshComposer();

package/overlay/preview.html

@@ -262,6 +262,76 @@
     .rt-item .rt-sub { margin-left:auto; color:var(--muted-2); font-size:11px; }
     .rt-sep { height:1px; margin:2px 8px; background:var(--line); }
 
+    /* ---- The session face -------------------------------------------------
+       A started task's transcript is a CALM DOCUMENT: the human speaks in the
+       one bubble, the agent writes in flat prose, and everything the agent DID
+       collapses to a dimmed one-line sentence you can expand. Four text
+       strengths off one ink; no spinners — live state is a cadenced shimmer on
+       the words themselves. */
+    .session-scroll {
+      flex:1 1 auto; min-height:0; overflow:auto; overscroll-behavior:contain;
+      padding:20px 26px 26px; scrollbar-gutter:stable;
+    }
+    .session-scroll::-webkit-scrollbar { width:11px; height:11px; }
+    .session-scroll::-webkit-scrollbar-thumb {
+      border:3px solid var(--paper); border-radius:999px;
+      background:rgba(31,26,23,.17); background-clip:padding-box;
+    }
+    .session-inner { width:min(100%, 720px); margin:0 auto; display:flex; flex-direction:column; gap:15px; }
+    .session-inner .group-gap { display:flex; flex-direction:column; gap:5px; }
+    .turn-marker { display:flex; align-items:center; gap:10px; color:var(--muted-2); font-size:11px; white-space:nowrap; }
+    .turn-marker::after { content:""; flex:1 1 auto; height:1px; background:var(--line); }
+    .user-msg {
+      align-self:flex-end; width:fit-content; max-width:min(82%, 430px);
+      background:var(--canvas); color:var(--ink-soft);
+      border-radius:14px 14px 4px 14px; padding:10px 13px;
+      font-size:13px; line-height:1.55; user-select:text; overflow-wrap:anywhere;
+    }
+    .agent-prose { font-size:13.5px; line-height:1.62; color:var(--ink-soft); user-select:text; max-width:62ch; overflow-wrap:anywhere; }
+    .agent-prose .markdown { font-size:13.5px; line-height:1.62; }
+    .act { display:flex; flex-direction:column; align-items:flex-start; }
+    .act-head {
+      appearance:none; border:0; background:transparent; cursor:pointer; text-align:left;
+      display:inline-flex; align-items:center; gap:7px; max-width:100%;
+      padding:3px 6px; margin:-3px -6px; border-radius:6px; font:inherit;
+      transition:background-color .13s ease;
+    }
+    .act-head:hover { background:var(--hover); }
+    .act-ic { flex:0 0 auto; width:14px; height:14px; color:var(--muted-2); display:grid; place-items:center; }
+    .act-sum {
+      font-size:13px; line-height:1.5; color:var(--muted); min-width:0;
+      overflow:hidden; text-overflow:ellipsis; white-space:nowrap;
+      transition:color .13s ease;
+    }
+    .act-sum .obj { font-family:var(--mono); font-size:11.5px; }
+    .act-head:hover .act-sum { color:var(--ink); }
+    .act-chev { flex:0 0 auto; width:10px; height:10px; color:var(--muted-2); opacity:0; transition:opacity .13s ease, transform .2s ease; }
+    .act-head:hover .act-chev, .act.open .act-chev, .act-head:focus-visible .act-chev { opacity:1; }
+    .act.open .act-chev { transform:rotate(90deg); }
+    .act-body { display:none; margin:7px 0 3px 21px; max-width:min(100%, 560px); align-self:stretch; }
+    .act.open .act-body { display:block; }
+    .ev { border:1px solid var(--line); border-radius:9px; background:var(--canvas); overflow:hidden; }
+    .ev-cmd { padding:8px 11px; font-family:var(--mono); font-size:11px; line-height:1.6; color:var(--ink-soft); user-select:text; overflow-wrap:anywhere; }
+    .ev-cmd::before { content:"$ "; color:var(--muted-2); }
+    .ev-out {
+      border-top:1px solid var(--line); padding:8px 11px; margin:0;
+      font-family:var(--mono); font-size:10.5px; line-height:1.6; color:var(--muted);
+      white-space:pre-wrap; overflow-wrap:anywhere; user-select:text;
+      max-height:260px; overflow:auto;
+    }
+    .ev-foot { border-top:1px solid var(--line); padding:5px 11px; font-size:10.5px; font-weight:600; color:var(--ok); }
+    .ev-foot.error { color:var(--danger); }
+    /* Live state is a cadenced sweep across the words themselves — one pass a
+       second, three seconds of rest. Presence without anxiety. */
+    .shimmer {
+      background:linear-gradient(100deg, var(--muted) 40%, var(--ink) 50%, var(--muted) 60%);
+      background-size:240% 100%; background-position:120% 0;
+      -webkit-background-clip:text; background-clip:text; color:transparent;
+      animation:relayShimmer 4s linear infinite;
+    }
+    @keyframes relayShimmer { 0% { background-position:120% 0; } 25% { background-position:-60% 0; } 100% { background-position:-60% 0; } }
+    .worked-for { font-size:11px; color:var(--muted-2); }
+
     /* ---- Chat header ---------------------------------------------------- */
     .chat-head { display:flex; align-items:center; gap:10px; min-width:0; }
     .chat-back {
@@ -536,6 +606,12 @@
               <p class="render-error gone" id="renderError" role="alert"></p>
             </div>
           </main>
+          <!-- A started task swaps the reading surface for its live session:
+               same face slot, so the chat face stays one slide away. -->
+          <main class="session-scroll gone" id="sessionScroll" tabindex="0" aria-label="Task session">
+            <div class="session-inner" id="sessionList"></div>
+            <p class="chat-state gone" id="sessionState"></p>
+          </main>
         </section>
 
         <section class="face" id="faceChat" aria-label="Conversation" aria-hidden="true">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-companion",
-  "version": "0.1.149",
+  "version": "0.1.151",
   "description": "Companion CLI for Relay (sendrelays.com): pairs this machine with your Relay account so coding agents like Claude Code and Codex can send and receive Relay messages.",
   "homepage": "https://sendrelays.com",
   "repository": {

package/src/claude-session-writer.js

@@ -21,7 +21,7 @@ import { relayRowTitle, renderRelayRowSeed } from "./relay-briefing.js";
 import { claudeDesktopSessionsDir, claudeProjectsDir } from "./host-paths.js";
 import { relayClaudePermissionMode } from "./claude-session-runtime.js";
 
-const DEFAULT_CLAUDE_METADATA_MODEL = "claude-opus-4-8";
+const DEFAULT_CLAUDE_METADATA_MODEL = "claude-opus-5";
 const CLAUDE_DESKTOP_LIVE_TITLE_LIMITATION = {
   attempted: true,
   supported: "best-effort",

package/src/mcp.js

@@ -82,7 +82,12 @@ export const TOOLS = [
             },
           },
         },
-        kind: { type: "string", enum: ["message", "handoff"], description: "Use message for notes/questions; handoff for larger context takeovers." },
+        kind: {
+          type: "string",
+          enum: ["message", "handoff", "task"],
+          description:
+            "Use message for notes/questions; handoff for larger context takeovers; task to ask the recipient to run a JOB on their machine. A task arrives with a Start button: when the recipient presses it, their own coding agent runs the job and their completion reply marks it Done for the sender. For a task, the title names the job ('Chase down the Windows tasklist poll-storm'), the body is the brief — context, concrete steps if known, and a 'Done means:' line stating what finished looks like. One recipient only; groups refuse tasks.",
+        },
         title: {
           type: "string",
           description:

package/src/runtime.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { relayClaudePermissionMode } from "./claude-session-runtime.js";
+import { cliBinaryPath, installedCliVersions } from "./desktop-wake.js";
 import readline from "node:readline";
 import { randomUUID } from "node:crypto";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
@@ -528,8 +529,25 @@ function clearQueuedInput(sessionRef) {
   return next;
 }
 
+/**
+ * Claude Desktop downloads the REAL Claude Code CLI (to ~/Library/Application
+ * Support/Claude/claude-code/<ver>/…) and spawns it for every session, so a
+ * desktop-only machine has a full runtime without `claude` ever being on PATH.
+ * `which claude` alone therefore under-reports; count the newest downloaded
+ * binary as installed.
+ */
+function desktopClaudeCliExists() {
+  try {
+    const versions = installedCliVersions();
+    for (let i = versions.length - 1; i >= 0; i -= 1) {
+      if (fs.existsSync(cliBinaryPath(versions[i]))) return true;
+    }
+  } catch {}
+  return false;
+}
+
 function hostStatus(kind, command, exists, version) {
-  const installed = exists(command);
+  const installed = exists(command) || (kind === "claude_code" && desktopClaudeCliExists());
   const adapter = kind === "codex" && process.env.RELAY_CODEX_ADAPTER !== "cli"
     ? "app_server"
     : kind === "claude_code" && process.env.RELAY_CLAUDE_ADAPTER !== "cli"

package/src/session-controller.js

@@ -67,7 +67,9 @@ function liveClaudeRegistration(sessionId) {
   return rows.sort((a, b) => b.updatedAt - a.updatedAt)[0] || null;
 }
 
-function sendClaudeSocket(socketPath, prompt, timeoutMs = 30_000) {
+// Exported for the task preview's Steer verb: one line of user text into a
+// live session's inbox socket.
+export function sendClaudeSocket(socketPath, prompt, timeoutMs = 30_000) {
   return new Promise((resolve, reject) => {
     const socket = net.createConnection(socketPath);
     const timer = setTimeout(() => {

package/src/session-directory.js

@@ -114,7 +114,9 @@ export function discoverCodexSessions({ homeDir = codexHome(), nowMs = Date.now(
   return rows.sort((a, b) => Date.parse(b.lastActiveAt) - Date.parse(a.lastActiveAt)).slice(0, MAX_SESSIONS_PER_PROVIDER);
 }
 
-function liveClaudeRegistrations(configDir) {
+// Exported for the task preview's session face: it needs "is this forged
+// session live, and through which socket" without the full directory sweep.
+export function liveClaudeRegistrations(configDir = process.env.CLAUDE_CONFIG_DIR || claudeHome()) {
   const dir = process.env.RELAY_CLAUDE_SESSION_REGISTRY_DIR || path.join(configDir, "sessions");
   const bySession = new Map();
   let names = [];
@@ -136,7 +138,7 @@ function liveClaudeRegistrations(configDir) {
   return bySession;
 }
 
-function claudeState(registration) {
+export function claudeState(registration) {
   if (!registration?.socketLive) return "offline";
   const status = String(registration.status || "").toLowerCase();
   if (["running", "busy", "working", "active"].includes(status)) return "active";