@meistrari/remy-cli 1.12.0 → 1.14.0

package/dist/remy.js

@@ -18,8 +18,8 @@ var __export = (target, all) => {
 // src/commands.ts
 import { randomUUID as randomUUID5 } from "crypto";
 import { spawn } from "child_process";
-import { mkdir as mkdir5, readFile as readFile5, readdir as readdir2, rename as rename4, unlink as unlink3, writeFile as writeFile4 } from "fs/promises";
-import { tmpdir } from "os";
+import { mkdir as mkdir5, readFile as readFile5, readdir as readdir3, rename as rename4, unlink as unlink3, writeFile as writeFile4 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
 import { dirname as dirname6, join as join6 } from "path";
 
 // ../../node_modules/.bun/@meistrari+auth-cli@1.6.1+aff0271b2b55d60c/node_modules/@meistrari/auth-cli/dist/index.mjs
@@ -31673,6 +31673,31 @@ var repositorySuggestionsInputSchema = exports_external2.strictObject({
   installationId: exports_external2.string().min(1),
   prompt: exports_external2.string().trim().min(1).max(20000)
 });
+var branchSuggestionsInputSchema = exports_external2.strictObject({
+  installationId: exports_external2.string().min(1),
+  prompt: exports_external2.string().trim().min(1).max(20000),
+  repositoryIds: exports_external2.array(exports_external2.string().min(1)).min(1).max(20)
+});
+var branchSuggestionsResponseSchema = exports_external2.strictObject({
+  repositories: exports_external2.array(exports_external2.discriminatedUnion("suggestion_kind", [
+    exports_external2.strictObject({
+      repository_id: exports_external2.string().min(1),
+      suggestion_kind: exports_external2.literal("continue_pull_request"),
+      branch_name: exports_external2.string().min(1),
+      pull_request: exports_external2.strictObject({
+        number: exports_external2.number().int().positive(),
+        title: exports_external2.string(),
+        url: exports_external2.url()
+      })
+    }),
+    exports_external2.strictObject({
+      repository_id: exports_external2.string().min(1),
+      suggestion_kind: exports_external2.literal("create_session_branch"),
+      branch_name: exports_external2.null(),
+      pull_request: exports_external2.null()
+    })
+  ]))
+});
 var repositorySuggestionsResponseSchema = exports_external2.discriminatedUnion("selection_kind", [
   exports_external2.object({
     selection_kind: exports_external2.literal("repositories"),
@@ -31757,19 +31782,95 @@ async function suggestRemoteRepositories({
     confidence: parsed.data.confidence
   };
 }
+async function suggestRemoteBranches({
+  client,
+  input
+}) {
+  const parsedInput = branchSuggestionsInputSchema.parse(input);
+  const response = await client.request("/v1/repositories/branch-suggestions", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      github_installation_id: parsedInput.installationId,
+      prompt: parsedInput.prompt,
+      repository_ids: parsedInput.repositoryIds
+    })
+  });
+  let body;
+  try {
+    body = await response.json();
+  } catch (error93) {
+    throw new CodingAgentProtocolError("Branch suggestions response was not valid JSON.", { cause: error93 });
+  }
+  const parsed = branchSuggestionsResponseSchema.safeParse(body);
+  if (!parsed.success)
+    throw new CodingAgentProtocolError("Branch suggestions response did not match the public API contract.", { cause: parsed.error });
+  return parsed.data.repositories.map((repository) => repository.suggestion_kind === "continue_pull_request" ? {
+    suggestionKind: "continuePullRequest",
+    repositoryId: repository.repository_id,
+    branchName: repository.branch_name,
+    pullRequest: repository.pull_request
+  } : {
+    suggestionKind: "createSessionBranch",
+    repositoryId: repository.repository_id,
+    branchName: null,
+    pullRequest: null
+  });
+}
+
+// ../../packages/coding-agent-client/src/users.ts
+var remoteUserPageDtoSchema = exports_external2.object({
+  data: exports_external2.array(exports_external2.object({
+    id: exports_external2.string(),
+    name: exports_external2.string(),
+    email: exports_external2.email()
+  })),
+  has_more: exports_external2.boolean(),
+  next_cursor: exports_external2.string().nullable()
+});
+async function listRemoteUsers({
+  client,
+  limit,
+  after,
+  signal
+}) {
+  const searchParams = new URLSearchParams;
+  if (limit !== undefined)
+    searchParams.set("limit", String(limit));
+  if (after)
+    searchParams.set("after", after);
+  const suffix = searchParams.size > 0 ? `?${searchParams.toString()}` : "";
+  const response = await client.request(`/users${suffix}`, { signal });
+  let body;
+  try {
+    body = await response.json();
+  } catch (error93) {
+    throw new CodingAgentProtocolError("User directory response was not valid JSON.", { cause: error93 });
+  }
+  const parsed = remoteUserPageDtoSchema.safeParse(body);
+  if (!parsed.success)
+    throw new CodingAgentProtocolError("User directory response did not match the API contract.", { cause: parsed.error });
+  return {
+    data: parsed.data.data.map((user) => ({ id: user.id, name: user.name, email: user.email })),
+    hasMore: parsed.data.has_more,
+    nextCursor: parsed.data.next_cursor
+  };
+}
 
 // ../../packages/coding-agent-client/src/files.ts
+import { Buffer } from "buffer";
 import { createHash } from "crypto";
 import { open } from "fs/promises";
 import { basename } from "path";
-var maxFileBytes = 20 * 1024 * 1024;
+var fileUploadMaxBytes = 20 * 1024 * 1024;
+var fileUploadMaxSizeLabel = `${fileUploadMaxBytes / (1024 * 1024)} MiB`;
 var defaultPollIntervalMs = 250;
 var sha256Schema = exports_external2.string().regex(/^[0-9a-f]{64}$/);
 var fileIdentitySchema = exports_external2.strictObject({
   id: exports_external2.string(),
   filename: exports_external2.string().min(1).max(255),
   media_type: exports_external2.string().min(1).max(255),
-  byte_size: exports_external2.number().int().min(0).max(maxFileBytes),
+  byte_size: exports_external2.number().int().min(0).max(fileUploadMaxBytes),
   sha256: sha256Schema
 });
 var uploadSignedUrlSchema = exports_external2.strictObject({
@@ -31820,9 +31921,37 @@ var fileResponseSchema = exports_external2.union([
 var createFileRequestSchema = exports_external2.strictObject({
   filename: exports_external2.string().min(1).max(255),
   media_type: exports_external2.string().min(1).max(255),
-  byte_size: exports_external2.number().int().min(0).max(maxFileBytes),
+  byte_size: exports_external2.number().int().min(0).max(fileUploadMaxBytes),
   sha256: sha256Schema
 });
+async function readFileHandleWithLimit({
+  fileHandle,
+  initialByteSize,
+  maxBytes
+}) {
+  const maximumBufferBytes = maxBytes + 1;
+  let buffer = Buffer.allocUnsafe(Math.min(maximumBufferBytes, Math.max(1, initialByteSize + 1)));
+  let byteLength = 0;
+  while (true) {
+    if (byteLength === buffer.byteLength) {
+      if (byteLength > maxBytes)
+        return { status: "limit_exceeded" };
+      const nextBuffer = Buffer.allocUnsafe(Math.min(maximumBufferBytes, Math.max(buffer.byteLength * 2, byteLength + 1)));
+      buffer.copy(nextBuffer, 0, 0, byteLength);
+      buffer = nextBuffer;
+    }
+    const { bytesRead } = await fileHandle.read(buffer, byteLength, buffer.byteLength - byteLength, null);
+    if (bytesRead === 0) {
+      return {
+        status: "complete",
+        bytes: Buffer.from(buffer.subarray(0, byteLength))
+      };
+    }
+    byteLength += bytesRead;
+    if (byteLength > maxBytes)
+      return { status: "limit_exceeded" };
+  }
+}
 async function reserveAndUploadFile({
   client,
   filePath,
@@ -31907,13 +32036,18 @@ async function readLocalUploadFile({ filePath, mediaType }) {
       throw new LocalFileSelectionError(`Local attachment is not a regular file: ${filePath}`);
     if (fileStat.size === 0)
       throw new LocalFileSelectionError(`Local attachment is empty: ${filePath}`);
-    if (fileStat.size > maxFileBytes)
-      throw new LocalFileSelectionError(`Local attachment exceeds ${maxFileBytes} bytes: ${filePath}`);
-    const bytes = await fileHandle.readFile();
+    if (fileStat.size > fileUploadMaxBytes)
+      throw oversizedLocalFileError(filePath);
+    const readResult = await readFileHandleWithLimit({
+      fileHandle,
+      initialByteSize: fileStat.size,
+      maxBytes: fileUploadMaxBytes
+    });
+    if (readResult.status === "limit_exceeded")
+      throw oversizedLocalFileError(filePath);
+    const { bytes } = readResult;
     if (bytes.byteLength === 0)
       throw new LocalFileSelectionError(`Local attachment is empty: ${filePath}`);
-    if (bytes.byteLength > maxFileBytes)
-      throw new LocalFileSelectionError(`Local attachment exceeds ${maxFileBytes} bytes: ${filePath}`);
     return {
       filename: basename(filePath),
       mediaType,
@@ -31925,6 +32059,9 @@ async function readLocalUploadFile({ filePath, mediaType }) {
     await fileHandle.close();
   }
 }
+function oversizedLocalFileError(filePath) {
+  return new LocalFileSelectionError(`Local attachment ${JSON.stringify(filePath)} is larger than ${fileUploadMaxSizeLabel}. Choose a file no larger than ${fileUploadMaxSizeLabel}.`);
+}
 async function parseJson(response, failureMessage) {
   try {
     return await response.json();
@@ -32675,11 +32812,17 @@ var sessionTelaPageArtifactEventSchema = exports_external2.strictObject({
   published_at: exports_external2.iso.datetime()
 });
 var sessionArtifactEventSchema = exports_external2.discriminatedUnion("kind", [
-  sessionFileArtifactEventSchema,
+  sessionFileArtifactEventSchema.extend({
+    download_url: exports_external2.string().optional(),
+    preview_url: exports_external2.url().optional()
+  }),
   sessionTelaPageArtifactEventSchema
 ]);
 var sessionArtifactSchema = exports_external2.discriminatedUnion("kind", [
-  sessionFileArtifactEventSchema.extend({ download_url: exports_external2.string() }),
+  sessionFileArtifactEventSchema.extend({
+    download_url: exports_external2.string(),
+    preview_url: exports_external2.url().optional()
+  }),
   sessionTelaPageArtifactEventSchema.extend({ preview_url: exports_external2.string() })
 ]);
 var sessionMessageSchema = exports_external2.strictObject({
@@ -32721,6 +32864,10 @@ var sessionConnectionSchema = exports_external2.discriminatedUnion("status", [
 var createCodexSessionInputSchema = exports_external2.strictObject({
   installationId: exports_external2.string().min(1),
   repositoryIds: exports_external2.array(exports_external2.string().min(1)),
+  repositoryBranchOverrides: exports_external2.array(exports_external2.strictObject({
+    repositoryId: exports_external2.string().min(1),
+    branchName: exports_external2.string().min(1)
+  })).optional(),
   prompt: exports_external2.string().refine((value) => value.trim().length > 0),
   fileIds: exports_external2.array(exports_external2.string().min(1)),
   model: codexModelIdSchema.optional(),
@@ -32762,6 +32909,7 @@ var withdrawSessionMessageResponseSchema = exports_external2.strictObject({
 });
 var sessionDetailResponseSchema = exports_external2.object({
   id: exports_external2.string(),
+  title: exports_external2.string().nullable(),
   status: sessionStatusSchema,
   session_number: exports_external2.number().int().positive(),
   agent_status: exports_external2.string().min(1),
@@ -32852,7 +33000,13 @@ async function createCodexSession({
           ...parsedInput.reasoningEffort ? { reasoning_effort: parsedInput.reasoningEffort } : {}
         }
       } : {},
-      repositories: parsedInput.repositoryIds.map((repositoryId) => ({ repository_id: repositoryId })),
+      repositories: parsedInput.repositoryIds.map((repositoryId) => {
+        const override = parsedInput.repositoryBranchOverrides?.find((candidate) => candidate.repositoryId === repositoryId);
+        return {
+          repository_id: repositoryId,
+          ...override ? { branch_name: override.branchName } : {}
+        };
+      }),
       message: {
         text: parsedInput.prompt,
         file_ids: parsedInput.fileIds
@@ -32934,6 +33088,8 @@ async function listSessions({
   client,
   limit,
   after,
+  statuses,
+  creatorUserIds,
   signal
 }) {
   const searchParams = new URLSearchParams;
@@ -32941,6 +33097,10 @@ async function listSessions({
     searchParams.set("limit", String(limit));
   if (after)
     searchParams.set("after", after);
+  for (const status of statuses ?? [])
+    searchParams.append("status", status);
+  for (const creatorUserId of creatorUserIds ?? [])
+    searchParams.append("creator_user_id", creatorUserId);
   const suffix = searchParams.size > 0 ? `?${searchParams.toString()}` : "";
   const response = await client.request(`/v1/sessions${suffix}`, { signal });
   const parsed = sessionListResponseSchema.safeParse(await parseJson2(response, "Session list response was not valid JSON."));
@@ -33027,7 +33187,8 @@ async function listSessionEvents({
   client,
   sessionId,
   limit,
-  after
+  after,
+  signal
 }) {
   const searchParams = new URLSearchParams;
   if (limit !== undefined)
@@ -33035,7 +33196,7 @@ async function listSessionEvents({
   if (after)
     searchParams.set("after", after);
   const suffix = searchParams.size > 0 ? `?${searchParams.toString()}` : "";
-  const response = await client.request(`/v1/sessions/${encodeURIComponent(sessionId)}/events${suffix}`);
+  const response = await client.request(`/v1/sessions/${encodeURIComponent(sessionId)}/events${suffix}`, { signal });
   const parsed = sessionEventsResponseSchema.safeParse(await parseJson3(response, "Session events response was not valid JSON."));
   if (!parsed.success)
     throw new CodingAgentProtocolError("Session events response did not match the public API contract.", { cause: parsed.error });
@@ -33925,15 +34086,16 @@ var sessionWorkspaceGitRevisionEventSchema = exports_external2.object({
     trigger: exports_external2.enum(["turn-ended", "boot-reconcile"])
   }).passthrough()
 }).passthrough();
-var agentTurnEndedEventSchema = exports_external2.object({
-  type: exports_external2.literal("agent.turn.ended"),
-  turnId: exports_external2.string().min(1),
-  actor: exports_external2.object({ type: exports_external2.enum(["main", "subagent"]) }).passthrough(),
-  payload: exports_external2.object({ status: exports_external2.enum(["completed", "failed", "cancelled", "interrupted"]) }).passthrough()
+var agentTurnEndedEventSchema = wrappedTurnEndedAgentEventSchema.pick({
+  type: true,
+  turnId: true,
+  actor: true,
+  payload: true
 }).passthrough();
-var agentMessageDeltaEventSchema = exports_external2.object({
-  type: exports_external2.literal("agent.message.delta"),
-  payload: exports_external2.object({ role: exports_external2.string(), delta: exports_external2.string() }).passthrough()
+var agentMessageDeltaEventSchema = wrappedMessageDeltaAgentEventSchema.pick({
+  type: true,
+  actor: true,
+  payload: true
 }).passthrough();
 var publicMessageContentSegmentSchema = exports_external2.discriminatedUnion("type", [
   exports_external2.strictObject({ type: exports_external2.literal("text"), text: exports_external2.string() }),
@@ -33970,7 +34132,9 @@ function createSessionViewState({ detail, activeMessageId }) {
     kind: "session-view",
     sessionId: detail.id,
     ...detail.sessionNumber === undefined ? {} : { sessionNumber: detail.sessionNumber },
+    title: detail.title ?? null,
     aggregateStatus: detail.status,
+    ...detail.agentStatus === undefined ? {} : { agentStatus: detail.agentStatus },
     connectionStatus: "connected",
     pullRequest: toSessionPullRequest(detail),
     ...activeMessageId !== undefined ? { activeMessageId } : {},
@@ -33985,6 +34149,13 @@ function createSessionViewState({ detail, activeMessageId }) {
     messageTurns: {},
     retainedTurnStarts: {},
     retainedTurnEnds: {},
+    childLineage: {
+      nextOrder: 0,
+      runtimeEpochs: {},
+      seenRuntimeBoundaryEventIds: {},
+      facts: [],
+      owners: []
+    },
     context: {
       snapshot: { status: "unknown" },
       through: 0
@@ -33996,7 +34167,9 @@ function updateSessionDetail({ state, detail }) {
     ...state,
     sessionId: detail.id,
     ...detail.sessionNumber === undefined ? {} : { sessionNumber: detail.sessionNumber },
+    ..."title" in detail ? { title: detail.title ?? null } : {},
     aggregateStatus: detail.status,
+    ...detail.agentStatus === undefined ? {} : { agentStatus: detail.agentStatus },
     pullRequest: toSessionPullRequest(detail),
     connectionPreviews: toConnectionPreviews(detail)
   };
@@ -34038,7 +34211,7 @@ function sessionTurnOutcome({ state, sessionMessageId }) {
 }
 function projectEphemeralEvent({ state, event }) {
   const messageDelta = agentMessageDeltaEventSchema.safeParse(event);
-  if (messageDelta.success && messageDelta.data.payload.role === "assistant") {
+  if (messageDelta.success && messageDelta.data.actor.type === "main" && messageDelta.data.payload.role === "assistant") {
     return {
       ...state,
       previews: { ...state.previews, assistantText: state.previews.assistantText + messageDelta.data.payload.delta }
@@ -34059,6 +34232,7 @@ function projectRetainedEvent({
   const workspaceGitRevision = sessionWorkspaceGitRevisionEventSchema.safeParse(event);
   const turnEnded = agentTurnEndedEventSchema.safeParse(event);
   let projected = messageCreated.success ? projectSessionMessageCreated({ state, event: messageCreated.data, occurredAt }) : turnAssociated.success ? projectSessionMessageTurnAssociated({ state, event: turnAssociated.data }) : workspaceGitInitialized.success ? projectSessionWorkspaceGitInitialized({ state, event: workspaceGitInitialized.data, occurredAt, retainedEventId }) : workspaceGitRevision.success ? projectSessionWorkspaceGitRevision({ state, event: workspaceGitRevision.data, occurredAt, retainedEventId }) : turnEnded.success ? projectAgentTurnEnded({ state, event: turnEnded.data, occurredAt, retainedEventId }) : projectDurableAgentEvent({ state, event, occurredAt, retainedEventId });
+  projected = recordAgentLineageEvent({ state: projected, event, retainedEventId });
   if (artifact) {
     const publication = artifact.kind === "file" ? { artifactId: artifact.artifact_id, kind: artifact.kind, title: artifact.filename } : { artifactId: artifact.artifact_id, kind: artifact.kind, title: artifact.title, url: artifact.url };
     const timelineArtifact = artifact.kind === "file" ? {
@@ -34067,7 +34241,9 @@ function projectRetainedEvent({
       artifactId: artifact.artifact_id,
       occurredAt,
       title: artifact.filename,
-      mediaType: artifact.media_type
+      mediaType: artifact.media_type,
+      ...artifact.download_url === undefined ? {} : { downloadUrl: artifact.download_url },
+      ...artifact.preview_url === undefined ? {} : { previewUrl: artifact.preview_url }
     } : {
       kind: "artifact",
       artifactKind: artifact.kind,
@@ -34171,19 +34347,22 @@ function projectSessionWorkspaceGitRevision({ state, event, occurredAt, retained
   });
 }
 function projectAgentTurnEnded({ state, event, occurredAt, retainedEventId }) {
-  const retainedTurnEnds = { ...state.retainedTurnEnds, [event.turnId]: { actorType: event.actor.type, outcome: event.payload.status } };
-  const messageTurns = event.actor.type === "main" ? Object.fromEntries(Object.entries(state.messageTurns).map(([messageId, turn]) => [messageId, turn.turnId === event.turnId ? { ...turn, outcome: event.payload.status } : turn])) : state.messageTurns;
-  return appendActivity({
-    state: { ...state, retainedTurnEnds, messageTurns },
-    retainedEventId,
-    occurredAt,
-    card: event.payload.status === "failed" ? { kind: "failure", weight: "signal", title: "Remy turn failed", summary: "Turn failed." } : { kind: "lifecycle", weight: "noise", title: "Remy turn ended", summary: `Turn ${event.payload.status}.` }
+  const stateWithTurnOutcome = event.actor.type === "main" ? {
+    ...state,
+    retainedTurnEnds: { ...state.retainedTurnEnds, [event.turnId]: { actorType: event.actor.type, outcome: event.payload.status } },
+    messageTurns: Object.fromEntries(Object.entries(state.messageTurns).map(([messageId, turn]) => [messageId, turn.turnId === event.turnId ? { ...turn, outcome: event.payload.status } : turn]))
+  } : state;
+  const card = event.actor.type === "main" ? event.payload.status === "failed" ? { kind: "failure", weight: "signal", title: "Remy turn failed", summary: "Turn failed." } : { kind: "lifecycle", weight: "noise", title: "Remy turn ended", summary: `Turn ${event.payload.status}.` } : createChildActivityCard({
+    identity: event.actor,
+    activityTitle: event.payload.status === "failed" ? "Turn failed" : "Turn ended",
+    card: event.payload.status === "failed" ? { kind: "failure", weight: "signal", summary: providerText(event.payload.error?.message, "Turn failed.") } : { kind: "lifecycle", weight: "noise", summary: `Turn ${event.payload.status}.` }
   });
+  return appendActivity({ state: stateWithTurnOutcome, retainedEventId, occurredAt, card });
 }
 function projectDurableAgentEvent({ state, event, occurredAt, retainedEventId }) {
   const agentEvent = parseDurableAgentEvent(event);
   if (agentEvent.type === "agent.message.ended")
-    return projectAgentMessageEnded({ state, event: agentEvent, occurredAt });
+    return projectAgentMessageEnded({ state, event: agentEvent, occurredAt, retainedEventId });
   if (agentEvent.type === "agent.context.updated")
     return state;
   if (agentEvent.type === "agent.work.observed" && agentEvent.actor.type === "main")
@@ -34195,6 +34374,9 @@ function projectDurableAgentEvent({ state, event, occurredAt, retainedEventId })
   } : state;
   return appendActivity({ state: stateWithTurnStart, retainedEventId, occurredAt, card: toAgentActivityCard(agentEvent) });
 }
+function hasOwnContextIdentity(identities, identity) {
+  return Object.prototype.hasOwnProperty.call(identities, identity);
+}
 function projectAgentWorkObserved({
   state,
   event,
@@ -34266,23 +34448,45 @@ function patchedWorkItemId(observation) {
     return observation.itemId;
   return null;
 }
-function projectAgentMessageEnded({ state, event, occurredAt }) {
+function projectAgentMessageEnded({ state, event, occurredAt, retainedEventId }) {
   const messageId = event.payload.messageId;
+  const text = event.payload.content.map(publicMessageContentSegmentText).join("");
+  if (event.actor.type === "subagent") {
+    const childId = terminalSafeSingleLine(event.actor.subagentId);
+    const card = createChildActivityCard({
+      identity: event.actor,
+      activityTitle: event.payload.role === "assistant" ? "Message completed" : `${capitalize(event.payload.role)} message`,
+      titleIncludesActivity: false,
+      card: {
+        kind: event.payload.role === "assistant" ? "command-output" : "progress",
+        weight: "signal",
+        summary: `${event.payload.role === "assistant" ? "Message completed." : `${capitalize(event.payload.role)} message retained.`} \xB7 ${childId}`,
+        detail: stripAnsi(text) || "[Empty message]"
+      }
+    });
+    return appendActivity({ state, retainedEventId, occurredAt, card });
+  }
   if (state.transcript.some((item) => item.kind === "message" && item.messageId === messageId))
     return state;
   const role2 = event.payload.role;
   const author = role2 === "assistant" ? { label: "Remy", role: "remy" } : role2 === "system" ? { label: "System", role: "system" } : { label: event.payload.commandId ? state.commandAuthorLabels[event.payload.commandId] ?? "Human" : "Human", role: "human" };
-  const text = event.payload.content.map(publicMessageContentSegmentText).join("") || (author.role === "remy" ? "[Remy sent an empty message]" : "[Empty message]");
+  const displayedText = text || (author.role === "remy" ? "[Remy sent an empty message]" : "[Empty message]");
   return {
     ...state,
     ...author.role === "remy" ? { previews: { ...state.previews, assistantText: "" } } : {},
-    transcript: [...state.transcript, { kind: "message", messageId, occurredAt, author, text, attachments: [] }]
+    transcript: [...state.transcript, { kind: "message", messageId, occurredAt, author, text: displayedText, attachments: [] }]
   };
 }
 function appendActivity({ state, retainedEventId, occurredAt, card }) {
   return { ...state, transcript: [...state.transcript, { kind: "activity", activityId: `activity:${retainedEventId}`, occurredAt, card }] };
 }
 function toAgentActivityCard(event) {
+  const identity = childActivityIdentity(event);
+  if (identity)
+    return toChildAgentActivityCard({ event, identity });
+  return toMainAgentActivityCard(event);
+}
+function toMainAgentActivityCard(event) {
   switch (event.type) {
     case "agent.session.started":
       return { kind: "lifecycle", weight: "noise", title: "Remy session started", summary: "Session is ready." };
@@ -34347,6 +34551,444 @@ function toAgentActivityCard(event) {
       throw new SessionProjectionProtocolError("Cannot project an unknown retained agent event.");
   }
 }
+function toChildAgentActivityCard({ event, identity }) {
+  switch (event.type) {
+    case "agent.turn.started":
+      return createChildActivityCard({ identity, activityTitle: "Turn started", card: { kind: "lifecycle", weight: "noise", summary: "Turn started." } });
+    case "agent.turn.ended":
+      return createChildActivityCard({
+        identity,
+        activityTitle: event.payload.status === "failed" ? "Turn failed" : "Turn ended",
+        card: event.payload.status === "failed" ? { kind: "failure", weight: "signal", summary: providerText(event.payload.error?.message, "Turn failed.") } : { kind: "lifecycle", weight: "noise", summary: `Turn ${event.payload.status}.` }
+      });
+    case "agent.work.observed":
+      return createChildActivityCard({ identity, activityTitle: "Work progress", card: { kind: "progress", weight: "noise", summary: "Subagent updated its work plan.", detail: jsonDetail(event.payload.observations) } });
+    case "agent.message.started":
+      return createChildActivityCard({ identity, activityTitle: "Message started", card: { kind: "lifecycle", weight: "noise", summary: "Subagent is composing a message." } });
+    case "agent.reasoning.started":
+      return createChildActivityCard({ identity, activityTitle: "Reasoning", card: { kind: "reasoning", weight: "noise", summary: "Subagent started a reasoning summary." } });
+    case "agent.reasoning.ended": {
+      const summary = stripAnsi(event.payload.summary ?? "").trim();
+      return createChildActivityCard({
+        identity,
+        activityTitle: "Reasoning",
+        card: summary.length > 0 ? { kind: "reasoning", weight: "signal", summary } : { kind: "reasoning", weight: "noise", summary: "Subagent completed a reasoning summary." }
+      });
+    }
+    case "agent.tool.call.started":
+      return createChildActivityCard({
+        identity,
+        activityTitle: terminalSafeSingleLine(event.payload.toolName),
+        card: {
+          kind: "tool",
+          weight: "signal",
+          summary: "Tool started.",
+          ...event.payload.input === undefined ? {} : { detail: jsonDetail(event.payload.input), detailFormat: "code" }
+        }
+      });
+    case "agent.tool.call.completed": {
+      const failed = event.payload.status === "failed" || event.payload.status === "cancelled";
+      const detail = event.payload.output === undefined ? undefined : toolOutputDetail(event.payload.output);
+      return createChildActivityCard({
+        identity,
+        activityTitle: failed ? "Tool failed" : "Tool completed",
+        card: failed ? { kind: "failure", weight: "signal", summary: providerText(event.payload.error?.message, `Tool ${event.payload.status}.`), ...detail === undefined ? {} : { detail, detailFormat: "code" } } : { kind: "command-output", weight: "signal", summary: "Tool completed.", ...detail === undefined ? {} : { detail, detailFormat: "code" } }
+      });
+    }
+    case "agent.subagent.started":
+      return createChildActivityCard({ identity, activityTitle: "Started", card: { kind: "progress", weight: "signal", summary: providerText(event.payload.name, event.payload.subagentId) } });
+    case "agent.subagent.progress":
+      return createChildActivityCard({ identity, activityTitle: "Progress", card: { kind: "progress", weight: "signal", summary: providerText(event.payload.summary, "Subagent is working.") } });
+    case "agent.subagent.ended":
+      return createChildActivityCard({
+        identity,
+        activityTitle: event.payload.status === "failed" ? "Failed" : "Ended",
+        card: event.payload.status === "failed" ? { kind: "failure", weight: "signal", summary: providerText(event.payload.error?.message, "Subagent failed.") } : { kind: "progress", weight: "signal", summary: providerText(event.payload.summary, `Subagent ${event.payload.status}.`) }
+      });
+    case "agent.usage":
+      return createChildActivityCard({ identity, activityTitle: "Usage updated", card: { kind: "progress", weight: "noise", summary: "Subagent reported usage.", detail: jsonDetail(event.payload.usage) } });
+    case "agent.context.compaction.started":
+      return createChildActivityCard({ identity, activityTitle: "Context compaction started", card: { kind: "reasoning", weight: "noise", summary: "Subagent is compacting context." } });
+    case "agent.context.compaction.completed":
+      return createChildActivityCard({
+        identity,
+        activityTitle: event.payload.status === "failed" ? "Context compaction failed" : "Context compaction completed",
+        card: event.payload.status === "failed" ? { kind: "failure", weight: "signal", summary: providerText(event.payload.error?.message, "Context compaction failed.") } : { kind: "reasoning", weight: "noise", summary: "Subagent compacted context." }
+      });
+    case "agent.user-input.requested":
+      return createChildActivityCard({ identity, activityTitle: "Needs input", card: { kind: "approval-question", weight: "signal", summary: providerText(event.payload.prompt, "Subagent needs input."), detail: jsonDetail(event.payload.questions) } });
+    case "agent.session.started":
+    case "agent.session.configured":
+    case "agent.session.skills.updated":
+    case "agent.session.state.changed":
+    case "agent.session.ended":
+    case "agent.user-input.resolved":
+    case "agent.error":
+      throw new SessionProjectionProtocolError(`Cannot attribute non-child session event type ${event.type} to a subagent.`);
+    case "agent.message.delta":
+    case "agent.reasoning.summary.delta":
+    case "agent.tool.output.delta":
+      throw new SessionProjectionProtocolError(`Cannot project ephemeral session event type ${event.type} as retained history.`);
+    default:
+      throw new SessionProjectionProtocolError("Cannot attribute an unknown retained event to a subagent.");
+  }
+}
+function createChildActivityCard({
+  identity,
+  activityTitle,
+  titleIncludesActivity = true,
+  card
+}) {
+  const subagentId = terminalSafeSingleLine(identity.subagentId);
+  const actorId = terminalSafeSingleLine(identity.actorId);
+  const displayName = terminalSafeSingleLine(identity.name ?? "") || subagentId;
+  const identityDetail = [
+    `Subagent ID: ${subagentId}`,
+    ...actorId !== subagentId ? [`Actor ID: ${actorId}`] : []
+  ].join(`
+`);
+  const detail = card.detail === undefined ? identityDetail : `${identityDetail}
+
+${card.detail}`;
+  return {
+    ...card,
+    title: `Subagent \xB7 ${displayName}${activityTitle === undefined || !titleIncludesActivity ? "" : ` \xB7 ${activityTitle}`}`,
+    detail,
+    attribution: {
+      status: "unresolved",
+      identity,
+      ...activityTitle === undefined ? {} : { activityTitle }
+    }
+  };
+}
+function childActivityIdentity(event) {
+  if (event.type === "agent.subagent.started" || event.type === "agent.subagent.progress" || event.type === "agent.subagent.ended") {
+    if (event.actor.type === "subagent") {
+      if (!subagentLifecycleIdentityMatches({ actor: event.actor, payload: event.payload }))
+        throw new SessionProjectionProtocolError(`Retained session event type ${event.type} carried contradictory subagent actor and payload identity.`);
+      return {
+        ...event.actor,
+        ...event.actor.name === undefined && event.payload.name !== undefined ? { name: event.payload.name } : {}
+      };
+    }
+    return {
+      type: "subagent",
+      actorId: event.payload.actorId,
+      subagentId: event.payload.subagentId,
+      parentActorId: event.payload.parentActorId,
+      origin: event.payload.origin,
+      ...event.payload.parentToolCallId === undefined ? {} : { parentToolCallId: event.payload.parentToolCallId },
+      ...event.payload.name === undefined ? {} : { name: event.payload.name }
+    };
+  }
+  if ("actor" in event && event.actor.type === "subagent") {
+    return event.actor;
+  }
+  return;
+}
+function subagentLifecycleIdentityMatches({ actor, payload }) {
+  return actor.actorId === payload.actorId && actor.subagentId === payload.subagentId && actor.parentActorId === payload.parentActorId && actor.parentToolCallId === payload.parentToolCallId && subagentOriginsMatch(actor.origin, payload.origin);
+}
+function subagentOriginsMatch(left, right) {
+  if (left.type === "tool_call")
+    return right.type === "tool_call" && left.toolCallId === right.toolCallId;
+  return right.type === "provider_task" && left.taskId === right.taskId;
+}
+function recordAgentLineageEvent({
+  state,
+  event,
+  retainedEventId
+}) {
+  if (!event.type.startsWith("agent."))
+    return state;
+  let parsed;
+  try {
+    parsed = parseDurableAgentEvent(event);
+  } catch (error93) {
+    if (error93 instanceof SessionProjectionProtocolError)
+      return state;
+    throw error93;
+  }
+  const runtimeBase = lineageRuntimeBase(parsed);
+  let childLineage = state.childLineage;
+  if (parsed.type === "agent.session.started" || parsed.type === "agent.session.ended") {
+    const boundaryKey = `${runtimeBase}:${lengthPrefixed(parsed.eventId)}`;
+    if (hasOwnContextIdentity(childLineage.seenRuntimeBoundaryEventIds, boundaryKey))
+      return state;
+    childLineage = {
+      ...childLineage,
+      runtimeEpochs: parsed.type === "agent.session.started" ? { ...childLineage.runtimeEpochs, [runtimeBase]: (childLineage.runtimeEpochs[runtimeBase] ?? 0) + 1 } : childLineage.runtimeEpochs,
+      seenRuntimeBoundaryEventIds: {
+        ...childLineage.seenRuntimeBoundaryEventIds,
+        [boundaryKey]: true
+      }
+    };
+    return { ...state, childLineage };
+  }
+  if (!("turnId" in parsed))
+    return state;
+  const runtimeScope = lineageRuntimeScope({
+    runtimeBase,
+    epoch: childLineage.runtimeEpochs[runtimeBase] ?? 0
+  });
+  const order = childLineage.nextOrder;
+  const identity = childActivityIdentity(parsed);
+  const fact = identity ? {
+    retainedEventId,
+    order,
+    runtimeScope,
+    turnId: parsed.turnId,
+    eventType: parsed.type,
+    identity
+  } : parsed.type === "agent.tool.call.started" && parsed.actor.type === "main" ? {
+    retainedEventId,
+    order,
+    runtimeScope,
+    turnId: parsed.turnId,
+    eventType: parsed.type,
+    toolCallId: parsed.payload.toolCallId
+  } : undefined;
+  if (!fact)
+    return state;
+  const nextState = {
+    ...state,
+    childLineage: {
+      ...childLineage,
+      nextOrder: order + 1,
+      facts: [...childLineage.facts, fact]
+    }
+  };
+  if (!isChildLineageFact(fact) || isSubagentLifecycleType(fact.eventType))
+    return reconcileChildLineage(nextState);
+  const resolution = resolveBodyFactAgainstOwners(childLineage.owners, fact);
+  if (resolution.status === "graph-change")
+    return reconcileChildLineage(nextState);
+  if (resolution.status === "unresolved")
+    return nextState;
+  return stampResolvedAttribution({ state: nextState, retainedEventId, fact, owner: resolution.owner });
+}
+function resolveBodyFactAgainstOwners(owners, fact) {
+  const candidates = owners.filter((owner) => owner.runtimeScope === fact.runtimeScope && childIdentityMatches(owner.identity, fact.identity));
+  const turnCandidates = candidates.filter((owner) => owner.childTurnIds.has(fact.turnId));
+  if (turnCandidates.length === 1)
+    return { status: "known", owner: turnCandidates[0] };
+  if (candidates.length === 1)
+    return { status: "graph-change" };
+  return { status: "unresolved" };
+}
+function stampResolvedAttribution({ state, retainedEventId, fact, owner }) {
+  const activityId = `activity:${retainedEventId}`;
+  for (let index = state.transcript.length - 1;index >= 0; index -= 1) {
+    const item = state.transcript[index];
+    if (item.kind !== "activity" || item.activityId !== activityId)
+      continue;
+    if (!item.card.attribution)
+      return state;
+    const attribution = {
+      status: "resolved",
+      identity: fact.identity,
+      ...item.card.attribution.activityTitle === undefined ? {} : { activityTitle: item.card.attribution.activityTitle },
+      ownerKey: owner.key,
+      owningMainTurnId: owner.owningMainTurnId,
+      path: ownerPath(owner)
+    };
+    if (childAttributionEqual(item.card.attribution, attribution))
+      return state;
+    const transcript = [...state.transcript];
+    transcript[index] = { ...item, card: { ...item.card, attribution } };
+    return { ...state, transcript };
+  }
+  return state;
+}
+function lineageRuntimeBase(event) {
+  return `${lengthPrefixed(event.sessionId)}:${lengthPrefixed(event.providerSessionId)}`;
+}
+function lineageRuntimeScope({ runtimeBase, epoch }) {
+  return `${runtimeBase}:${epoch}`;
+}
+function lengthPrefixed(value) {
+  return `${value.length}:${value}`;
+}
+function isChildLineageFact(fact) {
+  return "identity" in fact;
+}
+function isSubagentLifecycleType(type) {
+  return type === "agent.subagent.started" || type === "agent.subagent.progress" || type === "agent.subagent.ended";
+}
+function childIdentityMatches(left, right) {
+  return left.actorId === right.actorId && left.subagentId === right.subagentId && left.parentActorId === right.parentActorId && left.parentToolCallId === right.parentToolCallId && subagentOriginsMatch(left.origin, right.origin);
+}
+function childIdentityCanAnchor(identity) {
+  return identity.actorId !== identity.parentActorId && (identity.origin.type !== "tool_call" || identity.parentToolCallId === undefined || identity.parentToolCallId === identity.origin.toolCallId);
+}
+function reconcileChildLineage(state) {
+  const facts = state.childLineage.facts;
+  const childFacts = facts.filter(isChildLineageFact);
+  const mainToolTurns = new Map;
+  for (const fact of facts) {
+    if (isChildLineageFact(fact))
+      continue;
+    const key = `${fact.runtimeScope}:${lengthPrefixed(fact.toolCallId)}`;
+    const turns = mainToolTurns.get(key) ?? new Set;
+    turns.add(fact.turnId);
+    mainToolTurns.set(key, turns);
+  }
+  const owners = [];
+  const ownerByFactOrder = new Map;
+  const mainTurnForToolOrigin = (fact) => {
+    if (fact.identity.origin.type !== "tool_call")
+      return;
+    const turns = mainToolTurns.get(`${fact.runtimeScope}:${lengthPrefixed(fact.identity.origin.toolCallId)}`);
+    return turns?.size === 1 ? [...turns][0] : undefined;
+  };
+  const createOwner = ({
+    fact,
+    owningMainTurnId,
+    parent
+  }) => {
+    if (!childIdentityCanAnchor(fact.identity))
+      return;
+    if (parent && ownerHasActorAncestor(parent, fact.identity.actorId))
+      return;
+    const samePlacement = owners.filter((owner2) => owner2.runtimeScope === fact.runtimeScope && owner2.owningMainTurnId === owningMainTurnId && owner2.parent === parent && owner2.identity.actorId === fact.identity.actorId && owner2.identity.subagentId === fact.identity.subagentId);
+    if (samePlacement.some((owner2) => !childIdentityMatches(owner2.identity, fact.identity)))
+      return;
+    const existing = samePlacement.find((owner2) => childIdentityMatches(owner2.identity, fact.identity));
+    if (existing)
+      return existing;
+    const owner = {
+      key: `${fact.runtimeScope}:${lengthPrefixed(owningMainTurnId)}:${fact.order}`,
+      identity: fact.identity,
+      runtimeScope: fact.runtimeScope,
+      owningMainTurnId,
+      parent,
+      childTurnIds: new Set
+    };
+    owners.push(owner);
+    return owner;
+  };
+  for (const fact of childFacts) {
+    if (fact.eventType !== "agent.subagent.started" || fact.identity.parentActorId !== "main")
+      continue;
+    const toolTurn = mainTurnForToolOrigin(fact);
+    if (fact.identity.origin.type === "tool_call" && toolTurn === undefined) {
+      const turns = mainToolTurns.get(`${fact.runtimeScope}:${lengthPrefixed(fact.identity.origin.toolCallId)}`);
+      if (turns && turns.size > 1)
+        continue;
+    }
+    if (toolTurn !== undefined && toolTurn !== fact.turnId)
+      continue;
+    const owner = createOwner({ fact, owningMainTurnId: fact.turnId, parent: null });
+    if (owner)
+      ownerByFactOrder.set(fact.order, owner);
+  }
+  for (const fact of childFacts) {
+    if (isSubagentLifecycleType(fact.eventType) && fact.eventType !== "agent.subagent.started" && fact.identity.parentActorId === "main") {
+      const toolTurn = mainTurnForToolOrigin(fact);
+      if (toolTurn === undefined)
+        continue;
+      const owner = owners.find((candidate) => candidate.runtimeScope === fact.runtimeScope && candidate.parent === null && candidate.owningMainTurnId === toolTurn && childIdentityMatches(candidate.identity, fact.identity)) ?? createOwner({ fact, owningMainTurnId: toolTurn, parent: null });
+      if (owner) {
+        ownerByFactOrder.set(fact.order, owner);
+        owner.childTurnIds.add(fact.turnId);
+      }
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const fact of childFacts) {
+      if (ownerByFactOrder.has(fact.order))
+        continue;
+      const candidates = owners.filter((owner2) => owner2.runtimeScope === fact.runtimeScope && childIdentityMatches(owner2.identity, fact.identity));
+      const turnCandidates = candidates.filter((owner2) => owner2.childTurnIds.has(fact.turnId));
+      const owner = turnCandidates.length === 1 ? turnCandidates[0] : candidates.length === 1 ? candidates[0] : undefined;
+      if (!owner || fact.eventType === "agent.subagent.started")
+        continue;
+      ownerByFactOrder.set(fact.order, owner);
+      owner.childTurnIds.add(fact.turnId);
+      changed = true;
+    }
+    for (const fact of childFacts) {
+      if (ownerByFactOrder.has(fact.order) || fact.eventType !== "agent.subagent.started" || fact.identity.parentActorId === "main" || !childIdentityCanAnchor(fact.identity)) {
+        continue;
+      }
+      const parentCandidates = owners.filter((owner2) => owner2.runtimeScope === fact.runtimeScope && owner2.identity.actorId === fact.identity.parentActorId);
+      const turnParents = parentCandidates.filter((owner2) => owner2.childTurnIds.has(fact.turnId));
+      const parent = turnParents.length === 1 ? turnParents[0] : parentCandidates.length === 1 ? parentCandidates[0] : undefined;
+      if (!parent)
+        continue;
+      const owner = createOwner({ fact, owningMainTurnId: parent.owningMainTurnId, parent });
+      if (!owner)
+        continue;
+      ownerByFactOrder.set(fact.order, owner);
+      changed = true;
+    }
+  }
+  const resolvedByRetainedEventId = new Map;
+  for (const fact of childFacts) {
+    const owner = ownerByFactOrder.get(fact.order);
+    if (owner)
+      resolvedByRetainedEventId.set(fact.retainedEventId, { fact, owner });
+  }
+  let transcriptChanged = false;
+  const transcript = state.transcript.map((item) => {
+    if (item.kind !== "activity" || !item.card.attribution)
+      return item;
+    const retainedEventId = item.activityId.slice("activity:".length);
+    const resolved = resolvedByRetainedEventId.get(retainedEventId);
+    const attribution = resolved ? {
+      status: "resolved",
+      identity: resolved.fact.identity,
+      ...item.card.attribution.activityTitle === undefined ? {} : { activityTitle: item.card.attribution.activityTitle },
+      ownerKey: resolved.owner.key,
+      owningMainTurnId: resolved.owner.owningMainTurnId,
+      path: ownerPath(resolved.owner)
+    } : {
+      status: "unresolved",
+      identity: item.card.attribution.identity,
+      ...item.card.attribution.activityTitle === undefined ? {} : { activityTitle: item.card.attribution.activityTitle }
+    };
+    if (childAttributionEqual(item.card.attribution, attribution))
+      return item;
+    transcriptChanged = true;
+    return { ...item, card: { ...item.card, attribution } };
+  });
+  const nextState = { ...state, childLineage: { ...state.childLineage, owners } };
+  return transcriptChanged ? { ...nextState, transcript } : nextState;
+}
+function ownerHasActorAncestor(parent, actorId) {
+  let candidate = parent;
+  while (candidate) {
+    if (candidate.identity.actorId === actorId)
+      return true;
+    candidate = candidate.parent;
+  }
+  return false;
+}
+function ownerPath(owner) {
+  const path = [];
+  let candidate = owner;
+  while (candidate) {
+    path.unshift(candidate.identity);
+    candidate = candidate.parent;
+  }
+  return path;
+}
+function childAttributionEqual(left, right) {
+  if (left.status !== right.status || left.activityTitle !== right.activityTitle || !childIdentityMatches(left.identity, right.identity)) {
+    return false;
+  }
+  if (left.status === "unresolved" || right.status === "unresolved")
+    return true;
+  return left.ownerKey === right.ownerKey && left.owningMainTurnId === right.owningMainTurnId && left.path.length === right.path.length && left.path.every((identity, index) => childIdentityMatches(identity, right.path[index]));
+}
+function terminalSafeSingleLine(value) {
+  return stripAnsi(value).replace(/\s+/gu, " ").trim();
+}
+function capitalize(value) {
+  return value.length === 0 ? value : `${value[0].toUpperCase()}${value.slice(1)}`;
+}
 function parseDurableAgentEvent(event) {
   if (!event.type.startsWith("agent."))
     throw new SessionProjectionProtocolError(`Cannot project retained session event type ${event.type}.`);
@@ -34383,6 +35025,9 @@ var terminalControlPattern = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g;
 function stripAnsi(value) {
   return value.replace(ansiEscapePattern, "").replace(terminalControlPattern, "");
 }
+function terminalSafeText(value) {
+  return stripAnsi(value);
+}
 function formatReasoningPreview(item) {
   if (item.status === "absent")
     return "";
@@ -34583,12 +35228,12 @@ function createRemoteSessionController(dependencies) {
       detail: input.detail,
       activeMessageId: dependencies.activeMessageId ?? cache?.activeMessageId
     });
-    resolveReady();
-    publishState();
     if (input.mode === "cold-resume") {
       const hydrationGeneration = beginReasoningAttempt();
       await hydrateRetainedHistoryFromBeginning(hydrationGeneration);
     }
+    resolveReady();
+    publishState();
     await streamWithControllerReconnects();
   }
   function stop() {
@@ -34624,7 +35269,8 @@ function createRemoteSessionController(dependencies) {
   async function recordActiveMessage(sessionMessageId) {
     state = {
       ...getState(),
-      activeMessageId: sessionMessageId
+      activeMessageId: sessionMessageId,
+      agentStatus: undefined
     };
     await writeCache();
     publishState();
@@ -34645,7 +35291,8 @@ function createRemoteSessionController(dependencies) {
       const page = await dependencies.listSessionEvents({
         sessionId: dependencies.sessionId,
         limit: sessionHistoryPageSize,
-        after
+        after,
+        signal: abortController.signal
       });
       for (const item of page.data) {
         await reduceFrameAndPersist({
@@ -34899,7 +35546,10 @@ async function sleepMs(ms, signal) {
 }
 
 // src/tui/dashboard.ts
-import { bg, BoxRenderable, bold as bold2, CliRenderEvents as CliRenderEvents2, fg as fg3, ScrollBoxRenderable, stringToStyledText as stringToStyledText2, TextRenderable } from "@opentui/core";
+import { bg, BoxRenderable as BoxRenderable2, bold as bold2, CliRenderEvents as CliRenderEvents2, fg as fg3, ScrollBoxRenderable, stringToStyledText as stringToStyledText2, TextRenderable as TextRenderable2 } from "@opentui/core";
+
+// src/tui/composer.ts
+import { BoxRenderable, TextRenderable, TextareaRenderable } from "@opentui/core";
 
 // src/tui/composer-divider.ts
 import { dim as dim2, fg as fg2, StyledText as StyledText2 } from "@opentui/core";
@@ -35094,6 +35744,98 @@ function renderComposerDivider({ width, tag, leadLabel }) {
   ]);
 }
 
+// src/tui/composer-height.ts
+var composerMaxRows = 6;
+function resizeComposer(composer) {
+  composer.height = Math.min(Math.max(composer.editorView.getTotalVirtualLineCount(), 1), composerMaxRows);
+}
+
+// src/tui/composer.ts
+var defaultPlaceholder = "Message Remy\u2026  Tab paths attach \xB7 Enter/Shift+Enter send \xB7 Option+Enter newline";
+function createComposer({
+  renderer,
+  parent,
+  tag,
+  topDividerLabel,
+  placeholder = defaultPlaceholder,
+  screenPaddingX = 1,
+  onSubmit,
+  onContentChange
+}) {
+  const root = new BoxRenderable(renderer, { width: "100%", flexDirection: "column", flexShrink: 0 });
+  const dividerTop = new TextRenderable(renderer, { content: "", flexShrink: 0 });
+  const textarea = new TextareaRenderable(renderer, {
+    width: "100%",
+    height: 1,
+    flexShrink: 0,
+    wrapMode: "word",
+    placeholder,
+    keyBindings: [
+      { name: "return", action: "submit" },
+      { name: "return", shift: true, action: "submit" },
+      { name: "return", meta: true, action: "newline" },
+      { name: "j", ctrl: true, action: "newline" }
+    ],
+    onSubmit
+  });
+  const dividerBottom = new TextRenderable(renderer, { content: "", flexShrink: 0 });
+  let mounted = false;
+  root.add(dividerTop);
+  root.add(textarea);
+  root.add(dividerBottom);
+  textarea.onContentChange = () => {
+    resizeComposer(textarea);
+    onContentChange?.();
+  };
+  function render() {
+    const dividerWidth = renderer.width - screenPaddingX * 2;
+    dividerTop.content = renderComposerDivider({ width: dividerWidth, tag, leadLabel: topDividerLabel?.() });
+    dividerBottom.content = renderComposerDivider({ width: dividerWidth });
+  }
+  return {
+    textarea,
+    mount() {
+      if (mounted)
+        return;
+      mounted = true;
+      parent.add(root);
+      resizeComposer(textarea);
+      render();
+    },
+    unmount() {
+      if (!mounted)
+        return;
+      mounted = false;
+      parent.remove(root);
+    },
+    render,
+    focus() {
+      textarea.focus();
+    },
+    destroy() {
+      if (mounted)
+        parent.remove(root);
+      mounted = false;
+      root.destroyRecursively();
+    }
+  };
+}
+
+// src/tui/fuzzy-match.ts
+function fuzzyMatches(value, query) {
+  const normalizedQuery = query.replaceAll(/\s/g, "").toLowerCase();
+  if (!normalizedQuery)
+    return true;
+  let queryIndex = 0;
+  for (const character of value.toLowerCase()) {
+    if (character === normalizedQuery[queryIndex])
+      queryIndex += 1;
+    if (queryIndex === normalizedQuery.length)
+      return true;
+  }
+  return false;
+}
+
 // src/tui/renderer.ts
 import { CliRenderEvents, createClipboard, createCliRenderer, createHostClipboard, createRendererClipboardAdapter } from "@opentui/core";
 var rendererDestroyed = new WeakMap;
@@ -35176,8 +35918,17 @@ async function renderRemyView({
 
 // src/tui/dashboard.ts
 var DASHBOARD_POLL_INTERVAL_MS = 1e4;
+var lifecycleStatusOptions = [
+  { value: "open", label: "Open" },
+  { value: "completed", label: "Completed" },
+  { value: "failed", label: "Failed" },
+  { value: "cancelled", label: "Cancelled" }
+];
 async function createDashboardTui({
   initialPage,
+  initialFilters = { statuses: [], creators: [] },
+  authors: initialAuthors = [],
+  loadAuthors,
   loadPage,
   createRenderer = createDefaultRenderer
 }) {
@@ -35186,6 +35937,7 @@ async function createDashboardTui({
   let keyHandler;
   let resizeHandler;
   let refreshTimer;
+  let contentScrollHandler;
   let rendererDestroyed2 = false;
   const loadPageAbortController = new AbortController;
   try {
@@ -35197,28 +35949,61 @@ async function createDashboardTui({
       loadPageAbortController.abort();
     }, render = function() {
       const contentWidth = renderer.width - 4;
-      const rowsBelow = rowsBelowVisibleWindow({ sessionCount: page.sessions.length, selectedIndex, height: renderer.height });
+      const sessions = visibleDashboardSessions({ sessions: page.sessions, query: sessionSearchQuery });
+      const rowsBelow = rowsBelowVisibleWindow({ sessionCount: sessions.length, selectedIndex, height: renderer.height });
       const isNarrow = renderer.width < 72;
-      const selectedSession = page.sessions[selectedIndex];
-      const sessionRows = page.sessions.length === 0 ? stringToStyledText2("No remote sessions yet.") : isNarrow ? formatSessionCard({
+      const selectedSession = filterMode ? undefined : sessions[selectedIndex];
+      const sessionRows = filterMode ? formatFilterMenu({ mode: filterMode, authors, width: contentWidth }) : sessions.length === 0 ? stringToStyledText2(sessionSearchQuery ? "No sessions match the search." : hasActiveFilters(filters) ? "No sessions match the active filters." : "No remote sessions yet.") : isNarrow ? formatSessionCard({
         session: selectedSession,
         selectedIndex,
-        sessionCount: page.sessions.length,
+        sessionCount: sessions.length,
         width: contentWidth
       }) : formatSessionList({
-        sessions: page.sessions,
+        sessions,
         selectedIndex,
         width: contentWidth,
         height: renderer.height
       });
-      statusBand.content = dashboardStatusBand({ page, pageIndex });
+      statusBand.content = dashboardStatusBand({ page, pageIndex, filters, sessionSearchQuery });
       content.content = joinStyled([stringToStyledText2(""), sessionRows], `
 `);
+      desiredContentScrollY = filterMode ? filterMode.selectedIndex + 2 : 0;
+      if (!contentScrollHandler) {
+        contentScrollHandler = () => {
+          contentScrollHandler = undefined;
+          if (destroyed)
+            return;
+          listRegion.scrollTo({ x: 0, y: desiredContentScrollY });
+          renderer.requestRender();
+        };
+        renderer.once(CliRenderEvents2.FRAME, contentScrollHandler);
+      }
       const showPreview = !isNarrow && selectedSession !== undefined;
       previewBand.visible = showPreview;
       previewBand.content = showPreview ? formatSessionPreview({ session: selectedSession, width: contentWidth }) : stringToStyledText2("");
-      separator.content = renderComposerDivider({ width: contentWidth });
-      footer.content = dashboardFooter({ loadingPage, pageError, rowsBelow, logoutConfirmationOpen });
+      const activeSearchComposer = filterMode?.searching ? "filter" : sessionSearchOpen ? "session" : undefined;
+      if (activeSearchComposer !== mountedSearchComposer) {
+        if (mountedSearchComposer === "filter")
+          filterSearchComposer.unmount();
+        else if (mountedSearchComposer === "session")
+          sessionSearchComposer.unmount();
+        mountedSearchComposer = activeSearchComposer;
+        if (activeSearchComposer === "filter") {
+          filterSearchComposer.mount();
+          filterSearchComposer.focus();
+        } else if (activeSearchComposer === "session") {
+          sessionSearchComposer.mount();
+          sessionSearchComposer.focus();
+        } else {
+          listRegion.focus();
+        }
+      }
+      if (activeSearchComposer === "filter")
+        filterSearchComposer.render();
+      else if (activeSearchComposer === "session")
+        sessionSearchComposer.render();
+      separator.content = activeSearchComposer ? "" : renderComposerDivider({ width: contentWidth });
+      footer.content = filterMode ? dashboardFilterFooter({ mode: filterMode, loadingPage, loadingAuthors, pageError, authorError }) : dashboardFooter({ loadingPage, pageError, rowsBelow, logoutConfirmationOpen, sessionSearchOpen });
       renderer.requestRender();
     }, finish = function(value) {
       if (settled)
@@ -35233,9 +36018,40 @@ async function createDashboardTui({
       stopPageRefresh();
       rejectDraft(error93);
     }, moveSelectionTo = function(index) {
-      if (page.sessions.length === 0)
+      const sessions = visibleDashboardSessions({ sessions: page.sessions, query: sessionSearchQuery });
+      if (sessions.length === 0)
+        return;
+      selectedIndex = Math.max(0, Math.min(index, sessions.length - 1));
+      render();
+    }, applyFilterSearch = function() {
+      if (!filterMode?.searching)
+        return;
+      filterMode = { ...filterMode, searching: false, selectedIndex: 0 };
+      filterSearchComposer.textarea.setText("");
+      render();
+    }, cancelFilterSearch = function() {
+      if (!filterMode?.searching)
+        return;
+      filterMode = { ...filterMode, searching: false, query: "", selectedIndex: 0 };
+      filterSearchComposer.textarea.setText("");
+      render();
+    }, openSessionSearch = function() {
+      sessionSearchOpen = true;
+      sessionSearchComposer.textarea.setText(sessionSearchQuery);
+      render();
+    }, applySessionSearch = function() {
+      if (!sessionSearchOpen)
+        return;
+      sessionSearchOpen = false;
+      selectedIndex = 0;
+      render();
+    }, cancelSessionSearch = function() {
+      if (!sessionSearchOpen)
         return;
-      selectedIndex = Math.max(0, Math.min(index, page.sessions.length - 1));
+      sessionSearchOpen = false;
+      sessionSearchQuery = "";
+      selectedIndex = 0;
+      sessionSearchComposer.textarea.setText("");
       render();
     }, handleSessionKey = function(key) {
       if (logoutConfirmationOpen) {
@@ -35248,6 +36064,84 @@ async function createDashboardTui({
         }
         return;
       }
+      if (sessionSearchOpen) {
+        if (key.name === "escape") {
+          key.preventDefault();
+          cancelSessionSearch();
+        }
+        return;
+      }
+      if (filterMode) {
+        const options = visibleDashboardFilterOptions({ mode: filterMode, authors });
+        if (key.name === "escape") {
+          key.preventDefault();
+          if (filterMode.searching) {
+            cancelFilterSearch();
+            return;
+          }
+          filterMode = undefined;
+          pageError = undefined;
+          authorError = undefined;
+          render();
+          return;
+        }
+        if (filterMode.searching)
+          return;
+        if (loadingAuthors) {
+          key.preventDefault();
+          return;
+        }
+        const filterListFocused = renderer.currentFocusedRenderable === listRegion;
+        if (filterListFocused && (key.name === "G" || key.name === "g" && key.shift)) {
+          key.preventDefault();
+          awaitingVimGoToTop = false;
+          if (options.length > 0)
+            filterMode = { ...filterMode, selectedIndex: options.length - 1 };
+          render();
+          return;
+        }
+        if (filterListFocused && key.name === "g") {
+          key.preventDefault();
+          if (awaitingVimGoToTop && options.length > 0)
+            filterMode = { ...filterMode, selectedIndex: 0 };
+          awaitingVimGoToTop = !awaitingVimGoToTop;
+          render();
+          return;
+        }
+        awaitingVimGoToTop = false;
+        if (key.name === "down" || key.name === "up" || key.name === "j" || key.name === "k") {
+          key.preventDefault();
+          if (options.length > 0) {
+            const backwards = key.name === "up" || key.name === "k";
+            filterMode = { ...filterMode, selectedIndex: (filterMode.selectedIndex + (backwards ? -1 : 1) + options.length) % options.length };
+          }
+          render();
+          return;
+        }
+        if (key.name === "space" || key.name === "left" || key.name === "right" || key.name === "h" || key.name === "l") {
+          key.preventDefault();
+          const option = options[filterMode.selectedIndex];
+          if (!option)
+            return;
+          const selected = key.name === "space" ? !isDashboardFilterOptionSelected({ mode: filterMode, option }) : key.name === "right" || key.name === "l";
+          filterMode = updateDashboardFilterSelection({ mode: filterMode, option, selected, authors });
+          render();
+          return;
+        }
+        if (key.name === "s") {
+          key.preventDefault();
+          filterMode = { ...filterMode, query: "", searching: true, selectedIndex: 0 };
+          filterSearchComposer.textarea.setText("");
+          render();
+          return;
+        }
+        if (key.name === "return" || key.name === "enter") {
+          key.preventDefault();
+          const nextFilters = { statuses: [...filterMode.statuses], creators: [...filterMode.creators] };
+          applyFilters(nextFilters);
+        }
+        return;
+      }
       const listFocused = renderer.currentFocusedRenderable === listRegion;
       if (key.name === "down") {
         key.preventDefault();
@@ -35276,7 +36170,7 @@ async function createDashboardTui({
       if (listFocused && (key.name === "G" || key.name === "g" && key.shift)) {
         key.preventDefault();
         awaitingVimGoToTop = false;
-        moveSelectionTo(page.sessions.length - 1);
+        moveSelectionTo(visibleDashboardSessions({ sessions: page.sessions, query: sessionSearchQuery }).length - 1);
         return;
       }
       if (listFocused && key.name === "g") {
@@ -35301,7 +36195,7 @@ async function createDashboardTui({
       awaitingVimGoToTop = false;
       if (key.name === "return" || key.name === "enter") {
         key.preventDefault();
-        const session = page.sessions[selectedIndex];
+        const session = visibleDashboardSessions({ sessions: page.sessions, query: sessionSearchQuery })[selectedIndex];
         if (session)
           finish({ kind: "session", sessionId: session.id });
         return;
@@ -35311,6 +36205,23 @@ async function createDashboardTui({
         finish({ kind: "new" });
         return;
       }
+      if (key.name === "s") {
+        key.preventDefault();
+        openSessionSearch();
+        return;
+      }
+      if (key.name === "f") {
+        key.preventDefault();
+        authorError = undefined;
+        filterMode = createFilterMode({ kind: "status", filters });
+        render();
+        return;
+      }
+      if (key.name === "a") {
+        key.preventDefault();
+        openAuthorFilter();
+        return;
+      }
       if (key.name === "L" || key.shift && key.name === "l") {
         key.preventDefault();
         logoutConfirmationOpen = true;
@@ -35327,21 +36238,19 @@ async function createDashboardTui({
         finish(null);
       }
     };
-    const root = new BoxRenderable(renderer, { width: "100%", height: "100%", flexDirection: "column", paddingX: 2, overflow: "hidden" });
-    const statusBand = new TextRenderable(renderer, { content: "", flexShrink: 0 });
-    const content = new TextRenderable(renderer, { content: "" });
+    const root = new BoxRenderable2(renderer, { width: "100%", height: "100%", flexDirection: "column", paddingX: 2, overflow: "hidden" });
+    const statusBand = new TextRenderable2(renderer, { content: "", flexShrink: 0 });
+    const content = new TextRenderable2(renderer, { content: "" });
     const listRegion = new ScrollBoxRenderable(renderer, { flexGrow: 1, flexShrink: 1, minHeight: 0, scrollY: true });
-    const previewBand = new TextRenderable(renderer, { content: "", flexShrink: 0 });
-    const separator = new TextRenderable(renderer, { content: "", flexShrink: 0 });
-    const footer = new TextRenderable(renderer, { content: "", flexShrink: 0 });
-    root.onMouseDown = (event) => {
-      event.preventDefault();
-      listRegion.focus();
-    };
+    const previewBand = new TextRenderable2(renderer, { content: "", flexShrink: 0 });
+    const filterSearchRegion = new BoxRenderable2(renderer, { width: "100%", flexShrink: 0 });
+    const separator = new TextRenderable2(renderer, { content: "", flexShrink: 0 });
+    const footer = new TextRenderable2(renderer, { content: "", flexShrink: 0 });
     listRegion.add(content);
     root.add(statusBand);
     root.add(listRegion);
     root.add(previewBand);
+    root.add(filterSearchRegion);
     root.add(separator);
     root.add(footer);
     renderer.root.add(root);
@@ -35351,8 +36260,22 @@ async function createDashboardTui({
     let loadingPage = false;
     let pageRequestInFlight = false;
     let pageError;
+    let authorError;
+    let authors = initialAuthors;
+    let authorsLoaded = loadAuthors === undefined || initialAuthors.length > 0;
+    let loadingAuthors = false;
     let awaitingVimGoToTop = false;
     let logoutConfirmationOpen = false;
+    let filters = initialFilters;
+    let filterMode;
+    let sessionSearchOpen = false;
+    let sessionSearchQuery = "";
+    root.onMouseDown = (event) => {
+      if (filterMode?.searching || sessionSearchOpen)
+        return;
+      event.preventDefault();
+      listRegion.focus();
+    };
     let destroyed = false;
     let rendererDestroyPromise;
     let settled = false;
@@ -35362,10 +36285,41 @@ async function createDashboardTui({
     let rejectDraft = () => {
       return;
     };
+    let desiredContentScrollY = 0;
     const action = new Promise((resolve, reject) => {
       resolveAction = resolve;
       rejectDraft = reject;
     });
+    let mountedSearchComposer;
+    const filterSearchComposer = createComposer({
+      renderer,
+      parent: filterSearchRegion,
+      tag: "Filter",
+      placeholder: "Filter options\u2026",
+      screenPaddingX: 2,
+      onSubmit: () => applyFilterSearch(),
+      onContentChange: () => {
+        if (!filterMode?.searching)
+          return;
+        filterMode = { ...filterMode, query: filterSearchComposer.textarea.plainText, selectedIndex: 0 };
+        render();
+      }
+    });
+    const sessionSearchComposer = createComposer({
+      renderer,
+      parent: filterSearchRegion,
+      tag: "Search",
+      placeholder: "Search by ID, title, or number\u2026",
+      screenPaddingX: 2,
+      onSubmit: () => applySessionSearch(),
+      onContentChange: () => {
+        if (!sessionSearchOpen)
+          return;
+        sessionSearchQuery = sessionSearchComposer.textarea.plainText;
+        selectedIndex = 0;
+        render();
+      }
+    });
     async function loadAdjacentPage(direction) {
       if (pageRequestInFlight)
         return;
@@ -35382,7 +36336,8 @@ async function createDashboardTui({
           return;
         page = loadedPage;
         pageIndex = Math.max(1, pageIndex + (direction === "next" ? 1 : -1));
-        selectedIndex = direction === "next" ? 0 : Math.max(0, page.sessions.length - 1);
+        const sessions = visibleDashboardSessions({ sessions: page.sessions, query: sessionSearchQuery });
+        selectedIndex = direction === "next" ? 0 : Math.max(0, sessions.length - 1);
       } catch (error93) {
         if (!destroyed && !settled)
           pageError = error93 instanceof Error ? error93.message : String(error93);
@@ -35401,7 +36356,7 @@ async function createDashboardTui({
         const refreshedPage = await loadPage({ target: "current", signal: loadPageAbortController.signal });
         if (destroyed || settled)
           return;
-        const selectedSessionId = page.sessions[selectedIndex]?.id;
+        const selectedSessionId = visibleDashboardSessions({ sessions: page.sessions, query: sessionSearchQuery })[selectedIndex]?.id;
         page = refreshedPage;
         const refreshedSelectedIndex = selectedSessionId ? page.sessions.findIndex((session) => session.id === selectedSessionId) : -1;
         selectedIndex = refreshedSelectedIndex >= 0 ? refreshedSelectedIndex : Math.max(0, Math.min(selectedIndex, page.sessions.length - 1));
@@ -35416,10 +36371,53 @@ async function createDashboardTui({
         pageRequestInFlight = false;
       }
     }
+    async function applyFilters(nextFilters) {
+      if (loadingPage)
+        return;
+      loadingPage = true;
+      pageError = undefined;
+      authorError = undefined;
+      render();
+      try {
+        page = await loadPage({ filters: nextFilters, signal: loadPageAbortController.signal });
+        filters = nextFilters;
+        pageIndex = 1;
+        selectedIndex = 0;
+        filterMode = undefined;
+      } catch (error93) {
+        pageError = error93 instanceof Error ? error93.message : String(error93);
+      } finally {
+        loadingPage = false;
+        render();
+      }
+    }
+    async function openAuthorFilter() {
+      filterMode = createFilterMode({ kind: "creator", filters });
+      authorError = undefined;
+      render();
+      if (authorsLoaded || loadingAuthors || !loadAuthors)
+        return;
+      loadingAuthors = true;
+      render();
+      try {
+        authors = await loadAuthors();
+        authorsLoaded = true;
+        if (filterMode?.kind === "creator") {
+          const firstSelectedIndex = authors.findIndex((author) => filterMode?.creators.some((creator) => creator.id === author.id));
+          filterMode = { ...filterMode, selectedIndex: Math.max(0, firstSelectedIndex) };
+        }
+      } catch (error93) {
+        authorError = error93 instanceof Error ? error93.message : String(error93);
+      } finally {
+        loadingAuthors = false;
+        render();
+      }
+    }
     async function moveSelection(direction) {
-      if (loadingPage || page.sessions.length === 0)
+      const sessions = visibleDashboardSessions({ sessions: page.sessions, query: sessionSearchQuery });
+      if (loadingPage || sessions.length === 0)
         return;
-      const isBoundary = direction === "next" ? selectedIndex === page.sessions.length - 1 : selectedIndex === 0;
+      const isBoundary = direction === "next" ? selectedIndex === sessions.length - 1 : selectedIndex === 0;
       if (!isBoundary) {
         selectedIndex += direction === "next" ? 1 : -1;
         render();
@@ -35434,7 +36432,13 @@ async function createDashboardTui({
       }
       return false;
     };
-    keyHandler = handleSessionKey;
+    filterSearchComposer.textarea.onKeyDown = handleSessionKey;
+    sessionSearchComposer.textarea.onKeyDown = handleSessionKey;
+    keyHandler = (key) => {
+      if (mountedSearchComposer && key.name !== "escape" && !(key.ctrl && key.name === "c"))
+        return;
+      handleSessionKey(key);
+    };
     renderer.addInputHandler(inputHandler);
     renderer.keyInput.on("keypress", keyHandler);
     renderer.on(CliRenderEvents2.RENDER_ERROR, (event) => fail(event.error));
@@ -35461,6 +36465,10 @@ async function createDashboardTui({
         if (resizeHandler)
           renderer.off(CliRenderEvents2.RESIZE, resizeHandler);
         stopPageRefresh();
+        if (contentScrollHandler)
+          renderer.off(CliRenderEvents2.FRAME, contentScrollHandler);
+        filterSearchComposer.destroy();
+        sessionSearchComposer.destroy();
         rendererDestroyed2 = true;
         renderer.destroy();
       },
@@ -35478,6 +36486,8 @@ async function createDashboardTui({
     if (refreshTimer !== undefined)
       clearInterval(refreshTimer);
     loadPageAbortController.abort();
+    if (contentScrollHandler)
+      renderer.off(CliRenderEvents2.FRAME, contentScrollHandler);
     if (!rendererDestroyed2) {
       rendererDestroyed2 = true;
       renderer.destroy();
@@ -35515,6 +36525,63 @@ function rowsBelowVisibleWindow({ sessionCount, selectedIndex, height }) {
   const { firstIndex, rowCount } = visibleListWindow({ sessionCount, selectedIndex, height });
   return Math.max(0, sessionCount - (firstIndex + rowCount));
 }
+function createFilterMode({ kind, filters }) {
+  return {
+    kind,
+    selectedIndex: 0,
+    statuses: [...filters.statuses],
+    creators: [...filters.creators],
+    query: "",
+    searching: false
+  };
+}
+function formatFilterMenu({ mode, authors, width }) {
+  const options = visibleDashboardFilterOptions({ mode, authors });
+  const selectedCount = mode.kind === "status" ? mode.statuses.length : mode.creators.length;
+  const heading = `${mode.kind === "status" ? "Filter by status" : "Filter by author"} \xB7 ${selectedCount} selected \xB7 empty shows all`;
+  const rows = options.map((option, index) => {
+    const active = isDashboardFilterOptionSelected({ mode, option });
+    const label = `${active ? "[x]" : "[ ]"} ${truncate(option.label, Math.max(1, width - 4))}`;
+    const chunk = index === mode.selectedIndex ? bg(PALETTE.selectionBg)(fg3(PALETTE.bodyText)(label.padEnd(width))) : active ? bold2(fg3(PALETTE.humanAccent)(label)) : fg3(PALETTE.dimText)(label);
+    return [chunk];
+  });
+  return joinStyled([
+    [bold2(fg3(PALETTE.bodyText)(truncate(heading, width)))],
+    ...rows.length > 0 ? rows : [[fg3(PALETTE.dimText)("No matching options.")]]
+  ], `
+`);
+}
+function dashboardFilterOptions({ kind, authors }) {
+  return kind === "status" ? lifecycleStatusOptions.map((option) => ({ kind: "status", id: option.value, label: option.label })) : authors.map((author) => ({ kind: "creator", id: author.id, label: author.name }));
+}
+function visibleDashboardFilterOptions({ mode, authors }) {
+  return dashboardFilterOptions({ kind: mode.kind, authors }).filter((option) => fuzzyMatches(option.label, mode.query));
+}
+function isDashboardFilterOptionSelected({ mode, option }) {
+  return option.kind === "status" ? mode.statuses.includes(option.id) : mode.creators.some((creator) => creator.id === option.id);
+}
+function updateDashboardFilterSelection({ mode, option, selected, authors }) {
+  if (option.kind === "status") {
+    const selectedStatuses = new Set(mode.statuses);
+    if (selected)
+      selectedStatuses.add(option.id);
+    else
+      selectedStatuses.delete(option.id);
+    return {
+      ...mode,
+      statuses: lifecycleStatusOptions.map((entry) => entry.value).filter((status) => selectedStatuses.has(status))
+    };
+  }
+  const selectedCreatorIds = new Set(mode.creators.map((creator) => creator.id));
+  if (selected)
+    selectedCreatorIds.add(option.id);
+  else
+    selectedCreatorIds.delete(option.id);
+  return {
+    ...mode,
+    creators: authors.filter((author) => selectedCreatorIds.has(author.id))
+  };
+}
 function formatSessionList({ sessions, selectedIndex, width, height }) {
   const { firstIndex, rowCount } = visibleListWindow({ sessionCount: sessions.length, selectedIndex, height });
   const visibleSessions = sessions.slice(firstIndex, firstIndex + rowCount);
@@ -35601,18 +36668,34 @@ function formatUpdatedAt(value) {
     return `${Math.floor(seconds / (60 * 60))}h ago`;
   return new Date(milliseconds).toLocaleDateString(undefined, { month: "short", day: "numeric" });
 }
-function dashboardStatusBand({ page, pageIndex }) {
-  const openCount = page.sessions.filter((session) => session.status === "open").length;
+function matchesSessionSearch({ session, query }) {
+  return fuzzyMatches(session.id, query) || fuzzyMatches(session.title ?? "", query) || fuzzyMatches(String(session.sessionNumber), query);
+}
+function visibleDashboardSessions({ sessions, query }) {
+  return sessions.filter((session) => matchesSessionSearch({ session, query }));
+}
+function dashboardStatusBand({ page, pageIndex, filters, sessionSearchQuery }) {
+  const openCount = visibleDashboardSessions({ sessions: page.sessions, query: sessionSearchQuery }).filter((session) => session.status === "open").length;
   const paging = [`page ${pageIndex}`];
   if (page.canGoPrevious)
     paging.push("\u2190 prev");
   if (page.hasMore)
     paging.push("more \u2192");
-  return `remy \xB7 sessions \xB7 ${openCount} open \xB7 ${paging.join(" \xB7 ")}`;
+  const activeFilters = [
+    filters.statuses.length > 0 ? `status: ${filters.statuses.map(sessionStatusLabel).join(", ")}` : undefined,
+    filters.creators.length > 0 ? `author: ${filters.creators.map((creator) => creator.name).join(", ")}` : undefined,
+    sessionSearchQuery ? `search: ${sessionSearchQuery}` : undefined
+  ].filter((value) => value !== undefined);
+  return `remy \xB7 sessions \xB7 ${openCount} open${activeFilters.length > 0 ? ` \xB7 ${activeFilters.join(" \xB7 ")}` : ""} \xB7 ${paging.join(" \xB7 ")}`;
 }
-function dashboardFooter({ loadingPage, pageError, rowsBelow, logoutConfirmationOpen }) {
+function hasActiveFilters(filters) {
+  return filters.statuses.length > 0 || filters.creators.length > 0;
+}
+function dashboardFooter({ loadingPage, pageError, rowsBelow, logoutConfirmationOpen, sessionSearchOpen }) {
   if (logoutConfirmationOpen)
     return "Log out of Remy? y confirms \xB7 Esc cancels";
+  if (sessionSearchOpen)
+    return "type to search \xB7 \u23CE apply search \xB7 Esc clear search";
   const parts = [];
   if (loadingPage)
     parts.push("Loading sessions\u2026");
@@ -35620,9 +36703,22 @@ function dashboardFooter({ loadingPage, pageError, rowsBelow, logoutConfirmation
     parts.push(`Could not load sessions: ${pageError}`);
   if (rowsBelow > 0)
     parts.push(`\u2193 ${rowsBelow} more below`);
-  parts.push("\u2191\u2193 move \xB7 \u23CE open \xB7 n new session \xB7 \u21E7l log out \xB7 q quit");
+  parts.push("\u2191\u2193 move \xB7 \u23CE open \xB7 s search \xB7 f status \xB7 a author \xB7 n new session \xB7 \u21E7l log out \xB7 q quit");
   return parts.join(" \xB7 ");
 }
+function dashboardFilterFooter({ mode, loadingPage, loadingAuthors, pageError, authorError }) {
+  if (loadingAuthors)
+    return "Loading authors\u2026 \xB7 Esc cancel";
+  if (loadingPage)
+    return "Applying filter\u2026";
+  if (mode.searching)
+    return "type to filter \xB7 \u23CE apply search \xB7 Esc cancel search";
+  return [
+    authorError ? `Could not load authors: ${authorError}` : undefined,
+    pageError ? `Could not apply filter: ${pageError}` : undefined,
+    "\u2191\u2193/jk move \xB7 space toggle \xB7 \u2190\u2192/hl mark \xB7 s search \xB7 \u23CE apply \xB7 Esc cancel"
+  ].filter((value) => value !== undefined).join(" \xB7 ");
+}
 function truncate(value, width) {
   if (value.length <= width)
     return value;
@@ -35633,87 +36729,33 @@ async function createDefaultRenderer() {
 }
 
 // src/tui/new-session-wizard.ts
-import { bg as bg3, BoxRenderable as BoxRenderable3, bold as bold3, CliRenderEvents as CliRenderEvents3, dim as dim3, fg as fg5, ScrollBoxRenderable as ScrollBoxRenderable2, StyledText as StyledText4, stringToStyledText as stringToStyledText4, TextRenderable as TextRenderable3 } from "@opentui/core";
-
-// src/tui/composer.ts
-import { BoxRenderable as BoxRenderable2, TextRenderable as TextRenderable2, TextareaRenderable } from "@opentui/core";
+import { bg as bg3, BoxRenderable as BoxRenderable3, bold as bold3, CliRenderEvents as CliRenderEvents3, dim as dim4, fg as fg6, ScrollBoxRenderable as ScrollBoxRenderable2, StyledText as StyledText5, stringToStyledText as stringToStyledText4, TextRenderable as TextRenderable3 } from "@opentui/core";
 
-// src/tui/composer-height.ts
-var composerMaxRows = 6;
-function resizeComposer(composer) {
-  composer.height = Math.min(Math.max(composer.editorView.getTotalVirtualLineCount(), 1), composerMaxRows);
+// src/tui/attachment-presentation.ts
+import { dim as dim3, fg as fg4, StyledText as StyledText3 } from "@opentui/core";
+function attachmentUploadMessage(filenames) {
+  return filenames.length === 1 ? `Attaching ${filenames[0]}\u2026` : `Attaching ${filenames.length} files\u2026`;
+}
+function renderAttachmentFeedback(feedback) {
+  const presentation = feedback.kind === "progress" ? { glyph: "\u28FF", color: PALETTE.progress } : feedback.kind === "success" ? { glyph: "\u2713", color: PALETTE.statusCompleted } : { glyph: "\u2717", color: PALETTE.failure };
+  return new StyledText3([
+    fg4(presentation.color)(`${presentation.glyph} `),
+    fg4(feedback.kind === "failure" ? PALETTE.failure : PALETTE.bodyText)(feedback.message)
+  ]);
 }
-
-// src/tui/composer.ts
-var defaultPlaceholder = "Message Remy\u2026  Tab paths attach \xB7 Enter send \xB7 Shift+Enter/Ctrl+J newline";
-function createComposer({
-  renderer,
-  parent,
-  tag,
-  topDividerLabel,
-  placeholder = defaultPlaceholder,
-  onSubmit,
-  onContentChange
-}) {
-  const root = new BoxRenderable2(renderer, { width: "100%", flexDirection: "column", flexShrink: 0 });
-  const dividerTop = new TextRenderable2(renderer, { content: "", flexShrink: 0 });
-  const textarea = new TextareaRenderable(renderer, {
-    width: "100%",
-    height: 1,
-    flexShrink: 0,
-    wrapMode: "word",
-    placeholder,
-    keyBindings: [
-      { name: "return", action: "submit" },
-      { name: "return", shift: true, action: "newline" },
-      { name: "j", ctrl: true, action: "newline" }
-    ],
-    onSubmit
-  });
-  const dividerBottom = new TextRenderable2(renderer, { content: "", flexShrink: 0 });
-  let mounted = false;
-  root.add(dividerTop);
-  root.add(textarea);
-  root.add(dividerBottom);
-  textarea.onContentChange = () => {
-    resizeComposer(textarea);
-    onContentChange?.();
-  };
-  function render() {
-    dividerTop.content = renderComposerDivider({ width: renderer.width - 2, tag, leadLabel: topDividerLabel?.() });
-    dividerBottom.content = renderComposerDivider({ width: renderer.width - 2 });
-  }
-  return {
-    textarea,
-    mount() {
-      if (mounted)
-        return;
-      mounted = true;
-      parent.add(root);
-      resizeComposer(textarea);
-      render();
-    },
-    unmount() {
-      if (!mounted)
-        return;
-      mounted = false;
-      parent.remove(root);
-    },
-    render,
-    focus() {
-      textarea.focus();
-    },
-    destroy() {
-      if (mounted)
-        parent.remove(root);
-      mounted = false;
-      root.destroyRecursively();
-    }
-  };
+function renderAttachmentSummary(attachments) {
+  if (attachments.length === 0)
+    return new StyledText3([]);
+  const label = attachments.length === 1 ? "Attachment" : `${attachments.length} attachments`;
+  return new StyledText3([
+    dim3(fg4(PALETTE.dimText)("\u21B3 ")),
+    fg4(PALETTE.tool)(label),
+    dim3(fg4(PALETTE.dimText)(` \xB7 ${attachments.map((attachment) => attachment.filename).join(" \xB7 ")}`))
+  ]);
 }
 
 // src/tui/path-completion-menu.ts
-import { bg as bg2, fg as fg4, stringToStyledText as stringToStyledText3, StyledText as StyledText3 } from "@opentui/core";
+import { bg as bg2, fg as fg5, stringToStyledText as stringToStyledText3, StyledText as StyledText4 } from "@opentui/core";
 var maximumVisibleCompletions = 8;
 function renderPathCompletionMenu({ completions, selectedIndex }) {
   if (completions.length === 0)
@@ -35724,7 +36766,7 @@ function renderPathCompletionMenu({ completions, selectedIndex }) {
     const completionIndex = firstIndex + index;
     const selected = completionIndex === selectedIndex;
     const rowStyle = selected ? bg2(PALETTE.selectionBg) : (chunk) => chunk;
-    return new StyledText3([rowStyle(fg4(PALETTE.bodyText)(`${selected ? "\u203A " : "  "}${completion.display}`))]);
+    return new StyledText4([rowStyle(fg5(PALETTE.bodyText)(`${selected ? "\u203A " : "  "}${completion.display}`))]);
   });
   const overflow = completions.length > visibleCompletions.length ? stringToStyledText3(`${firstIndex + 1}-${firstIndex + visibleCompletions.length} of ${completions.length}`) : undefined;
   return joinStyled([
@@ -35764,13 +36806,62 @@ async function completePathToken({ text, cwd, homeDirectory = homedir() }) {
     const normalized = replacementPath.split(sep).join("/");
     const suffix = entry.isDirectory() ? "/" : "";
     const completed = `${normalized}${suffix}`;
-    return { display: completed, replacement: `${token.startsWith("@") ? "@" : ""}${completed}` };
+    return {
+      display: completed,
+      replacement: `${token.startsWith("@") ? "@" : ""}${completed}`,
+      ...entry.isFile() ? { attachmentPath: completedPath } : {}
+    };
   });
 }
 function replaceActivePathToken({ text, replacement }) {
   const token = activePathToken(text);
   return token === undefined ? text : `${text.slice(0, text.length - token.length)}${replacement}`;
 }
+function selectedAttachmentPaths({ text, selections }) {
+  return selections.filter((selection) => text.slice(selection.start, selection.end) === selection.token && hasPathTokenBoundaries({ text, selection })).map((selection) => selection.attachmentPath);
+}
+function createSelectedPathCompletion({ attachmentPath, token, end }) {
+  return { attachmentPath, token, start: end - token.length, end };
+}
+function reconcileSelectedPathCompletions({
+  previousText,
+  text,
+  selections
+}) {
+  if (text === previousText)
+    return selections;
+  let changeStart = 0;
+  while (changeStart < previousText.length && changeStart < text.length && previousText[changeStart] === text[changeStart])
+    changeStart += 1;
+  let previousChangeEnd = previousText.length;
+  let nextChangeEnd = text.length;
+  while (previousChangeEnd > changeStart && nextChangeEnd > changeStart && previousText[previousChangeEnd - 1] === text[nextChangeEnd - 1]) {
+    previousChangeEnd -= 1;
+    nextChangeEnd -= 1;
+  }
+  const offsetChange = nextChangeEnd - previousChangeEnd;
+  return selections.flatMap((selection) => {
+    if (selection.end <= changeStart)
+      return [selection];
+    if (selection.start >= previousChangeEnd) {
+      return [{
+        ...selection,
+        start: selection.start + offsetChange,
+        end: selection.end + offsetChange
+      }];
+    }
+    return [];
+  }).filter((selection) => hasPathTokenBoundaries({ text, selection }));
+}
+function hasPathTokenBoundaries({ text, selection }) {
+  let before = selection.start;
+  while (before > 0 && "([{'\"`".includes(text[before - 1]))
+    before -= 1;
+  let after = selection.end;
+  while (after < text.length && '),.;:!?]}"`'.includes(text[after]))
+    after += 1;
+  return (before === 0 || /\s/.test(text[before - 1])) && (after === text.length || /\s/.test(text[after]));
+}
 function activePathToken(text) {
   const match = text.match(/(?:^|\s)(\S*)$/);
   return match?.[1];
@@ -35783,6 +36874,7 @@ async function createNewSessionWizard({
   repositories,
   reloadRepositories,
   suggestRepositories,
+  suggestBranches,
   readClipboardImage,
   savePastedImage,
   attachPromptPaths,
@@ -35819,15 +36911,19 @@ async function createNewSessionWizard({
       else
         overrides.set(repositoryId, isSelected);
     }, renderRepositoryLoadingSkeleton = function() {
-      return new StyledText4([
-        dim3(fg5(PALETTE.dimText)(`\u283F \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588
+      return new StyledText5([
+        dim4(fg6(PALETTE.dimText)(`\u283F \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588
 \u283F \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588
 \u283F \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588`))
       ]);
     }, render = function() {
       const repositoryListVisible = step === "repositories" || step === "repositorySearch";
       const composerVisible = step === "prompt" || step === "repositorySearch" || step === "recompute";
-      const orient = (body) => joinStyled([renderStepIndicator({ step, hasInstallationChoice: installationIds.length > 1 }), body], `
+      const orient = (body) => joinStyled([renderStepIndicator({
+        step,
+        hasInstallationChoice: installationIds.length > 1,
+        hasBranchChoice: step === "loadingBranches" || branchSuggestions.some((suggestion) => suggestion.suggestionKind !== "createSessionBranch")
+      }), body], `
 `);
       if (composerVisible && !composerMounted) {
         composerMounted = true;
@@ -35845,19 +36941,22 @@ async function createNewSessionWizard({
       repositoryRows.content = "";
       repositoryDivider.content = "";
       repositoryFooter.content = "";
-      const attachmentText = attachments.length > 0 ? stringToStyledText4(`Attachments: ${attachments.map((attachment) => attachment.filename).join(", ")}`) : undefined;
+      const attachmentText = renderAttachmentSummary(attachments);
+      const attachmentStatus = attachmentFeedback ? renderAttachmentFeedback(attachmentFeedback) : undefined;
       if (step === "prompt") {
         const parts = [
-          new StyledText4([stepHeader("New remote Codex session")]),
+          new StyledText5([stepHeader("New remote Codex session")]),
           stringToStyledText4("Describe the work you want Remy to do. Press Enter to continue; Esc back.")
         ];
-        if (attachmentText)
+        if (attachmentText.chunks.length > 0)
           parts.push(attachmentText);
         const completionMenu = pathCompletionMenuOpen ? renderPathCompletionMenu({ completions: pathCompletions, selectedIndex: completionIndex }) : undefined;
         if (completionMenu)
           parts.push(completionMenu);
         if (status)
           parts.push(stringToStyledText4(status));
+        if (attachmentStatus)
+          parts.push(attachmentStatus);
         content.content = orient(joinStyled(parts, `
 
 `));
@@ -35865,7 +36964,7 @@ async function createNewSessionWizard({
         const rows = joinStyled(installationIds.map((id, index) => renderSelectableRow({ label: id, isCursor: index === installationIndex })), `
 `);
         content.content = orient(joinStyled([
-          new StyledText4([stepHeader("Select GitHub installation")]),
+          new StyledText5([stepHeader("Select GitHub installation")]),
           rows,
           stringToStyledText4("\u2191\u2193 move \xB7 \u23CE continue \xB7 esc back")
         ], `
@@ -35874,11 +36973,11 @@ async function createNewSessionWizard({
       } else if (step === "loadingRepositories") {
         const failed = repositoryLoadState === "failed";
         const parts = [
-          new StyledText4([stepHeader("Select repositories")]),
+          new StyledText5([stepHeader("Select repositories")]),
           stringToStyledText4(failed ? "Could not load your repositories." : "Loading your repos\u2026")
         ];
         if (failed) {
-          parts.push(new StyledText4([dim3(fg5(PALETTE.dimText)(`(${status})`))]));
+          parts.push(new StyledText5([dim4(fg6(PALETTE.dimText)(`(${status})`))]));
           parts.push(stringToStyledText4("r retry \xB7 esc back"));
         } else {
           parts.push(renderRepositoryLoadingSkeleton());
@@ -35889,12 +36988,41 @@ async function createNewSessionWizard({
 `));
       } else if (step === "loadingSuggestions") {
         content.content = orient(joinStyled([
-          new StyledText4([stepHeader("Select repositories")]),
-          new StyledText4([fg5(PALETTE.progress)(`${suggestionSpinnerFrames[suggestionSpinnerFrame]} Remy is matching your prompt to repositories\u2026`)]),
-          new StyledText4([dim3(fg5(PALETTE.dimText)("This can take a few seconds."))]),
+          new StyledText5([stepHeader("Select repositories")]),
+          new StyledText5([fg6(PALETTE.progress)(`${suggestionSpinnerFrames[suggestionSpinnerFrame]} Remy is matching your prompt to repositories\u2026`)]),
+          new StyledText5([dim4(fg6(PALETTE.dimText)("This can take a few seconds."))]),
           stringToStyledText4("s select repositories yourself \xB7 esc back")
         ], `
 
+`));
+      } else if (step === "loadingBranches") {
+        content.content = orient(joinStyled([
+          new StyledText5([stepHeader("Choose branches")]),
+          new StyledText5([fg6(PALETTE.progress)(`${suggestionSpinnerFrames[suggestionSpinnerFrame]} Remy is checking for related open pull requests\u2026`)]),
+          new StyledText5([dim4(fg6(PALETTE.dimText)("This can take a few seconds."))]),
+          stringToStyledText4("esc back")
+        ], `
+
+`));
+      } else if (step === "branches") {
+        const existing = branchSuggestions.filter((suggestion) => suggestion.suggestionKind !== "createSessionBranch");
+        const parts = [new StyledText5([stepHeader("Choose branches")])];
+        if (existing.length > 0) {
+          parts.push(stringToStyledText4("Remy found related open pull-request work:"));
+          for (const suggestion of existing) {
+            const repository = installationRepositories().find((candidate) => candidate.id === suggestion.repositoryId);
+            parts.push(stringToStyledText4(`${repository?.fullName ?? suggestion.repositoryId} \u2014 ${suggestion.branchName}${suggestion.pullRequest ? ` (PR #${suggestion.pullRequest.number}: ${suggestion.pullRequest.title})` : ""}`));
+          }
+          parts.push(new StyledText5(renderSelectableRow({ label: "Continue from the suggested branch", isCursor: branchChoice === "existing" })));
+          parts.push(new StyledText5(renderSelectableRow({ label: "Create a new session branch", isCursor: branchChoice === "new" })));
+          parts.push(stringToStyledText4("\u2191\u2193 choose \xB7 \u23CE continue \xB7 esc back"));
+        } else {
+          parts.push(stringToStyledText4("Remy recommends creating a new session branch."));
+          parts.push(new StyledText5([dim4(fg6(PALETTE.dimText)(status || "No related open pull request was identified from your request."))]));
+          parts.push(stringToStyledText4("\u23CE continue \xB7 esc back"));
+        }
+        content.content = orient(joinStyled(parts, `
+
 `));
       } else if (repositoryListVisible) {
         const selectionOverrides = searchSelections ?? manualSelections;
@@ -35909,15 +37037,17 @@ async function createNewSessionWizard({
 `) : step === "repositorySearch" ? "No matching repositories." : "No repositories available for this installation.";
         repositoryDivider.content = renderComposerDivider({ width: renderer.width - 2 });
         repositoryFooter.content = step === "repositorySearch" ? "type to filter \xB7 \u23CE apply \xB7 esc cancel search" : "\u2191\u2193 move \xB7 space toggle \xB7 \u2190\u2192 mark \xB7 s search \xB7 r recompute \xB7 \u23CE continue \xB7 esc back";
-        const parts = step === "repositorySearch" ? [new StyledText4([stepHeader("Search repositories")]), stringToStyledText4("Fuzzy matching repository names.")] : [
-          new StyledText4([stepHeader("Select repositories")]),
+        const parts = step === "repositorySearch" ? [new StyledText5([stepHeader("Search repositories")]), stringToStyledText4("Fuzzy matching repository names.")] : [
+          new StyledText5([stepHeader("Select repositories")]),
           stringToStyledText4(`${selected.size} selected \xB7 ${suggestedIds.size} suggested by Remy${suggestionConfidence ? ` (${suggestionConfidence} confidence)` : ""}`),
           stringToStyledText4("Suggestions are based on your prompt and recompute instruction.")
         ];
-        if (attachmentText)
+        if (attachmentText.chunks.length > 0)
           parts.push(attachmentText);
         if (status && step === "repositories")
           parts.push(stringToStyledText4(status));
+        if (attachmentStatus)
+          parts.push(attachmentStatus);
         content.content = orient(joinStyled(parts, `
 
 `));
@@ -35925,11 +37055,11 @@ async function createNewSessionWizard({
           editor.placeholder = "Filter repositories\u2026";
       } else if (step === "recompute") {
         const parts = [
-          new StyledText4([stepHeader("Recompute suggestions")]),
+          new StyledText5([stepHeader("Recompute suggestions")]),
           stringToStyledText4("Suggestions use your prompt and instruction. Existing manual toggles stay selected or unselected."),
           stringToStyledText4("Enter instruction, then press Enter to continue. Esc back.")
         ];
-        if (attachmentText)
+        if (attachmentText.chunks.length > 0)
           parts.push(attachmentText);
         content.content = orient(joinStyled(parts, `
 
@@ -35937,26 +37067,31 @@ async function createNewSessionWizard({
         editor.placeholder = "e.g. worker, migration, dashboard";
       } else {
         const selected = installationRepositories().filter((repository) => selectedRepositoryIds().has(repository.id));
-        const meta5 = new StyledText4([
-          fg5(PALETTE.bodyText)(`Installation: ${selectedInstallationId() ?? "(missing)"}
+        const branchOverrides = branchChoice === "existing" ? branchSuggestions.filter((suggestion) => suggestion.suggestionKind !== "createSessionBranch") : [];
+        const meta5 = new StyledText5([
+          fg6(PALETTE.bodyText)(`Installation: ${selectedInstallationId() ?? "(missing)"}
 `),
-          fg5(PALETTE.bodyText)(`Repositories: ${selected.map((repository) => repository.fullName).join(", ") || "(none)"}
+          fg6(PALETTE.bodyText)(`Repositories: ${selected.map((repository) => repository.fullName).join(", ") || "(none)"}
 `),
-          fg5(PALETTE.bodyText)(`Model: ${newSessionModelLabel(model)} \xB7 ${newSessionReasoningEffortLabel(reasoningEffort)} reasoning`),
-          dim3(fg5(PALETTE.dimText)("   \u25B8 m model \xB7 \u2190\u2192 reasoning"))
+          fg6(PALETTE.bodyText)(`Branches: ${branchOverrides.length > 0 ? branchOverrides.map((override) => override.branchName).join(", ") : "new session branches"}
+`),
+          fg6(PALETTE.bodyText)(`Model: ${newSessionModelLabel(model)} \xB7 ${newSessionReasoningEffortLabel(reasoningEffort)} reasoning`),
+          dim4(fg6(PALETTE.dimText)("   \u25B8 m model \xB7 \u2190\u2192 reasoning"))
         ]);
         const parts = [
-          new StyledText4([stepHeader("Confirm new session")]),
-          new StyledText4([renderRoleLabel({ label: "You", role: "human" })]),
+          new StyledText5([stepHeader("Confirm new session")]),
+          new StyledText5([renderRoleLabel({ label: "You", role: "human" })]),
           renderMessageBody({ text: prompt, role: "human" }),
           meta5
         ];
-        if (attachmentText)
+        if (attachmentText.chunks.length > 0)
           parts.push(attachmentText);
-        parts.push(new StyledText4([dim3(fg5(PALETTE.dimText)("Remy will clone the selected repositories, work on a new branch, and open a pull request; you land in the session view."))]));
-        parts.push(stringToStyledText4("\u23CE create \xB7 e edit prompt \xB7 r repositories \xB7 esc back"));
+        parts.push(new StyledText5([dim4(fg6(PALETTE.dimText)(branchOverrides.length > 0 ? "Remy will continue on the selected existing branch and update its pull request; you land in the session view." : "Remy will clone the selected repositories, work on new session branches, and open a pull request for each repository; you land in the session view."))]));
+        parts.push(stringToStyledText4(branchSuggestions.some((suggestion) => suggestion.suggestionKind !== "createSessionBranch") ? "\u23CE create \xB7 e edit prompt \xB7 r repositories \xB7 b branches \xB7 esc back" : "\u23CE create \xB7 e edit prompt \xB7 r repositories \xB7 esc back"));
         if (status)
           parts.push(stringToStyledText4(status));
+        if (attachmentStatus)
+          parts.push(attachmentStatus);
         content.content = orient(joinStyled(parts, `
 
 `));
@@ -35981,7 +37116,7 @@ async function createNewSessionWizard({
       syncSuggestionLoadingIndicator();
       renderer.requestRender();
     }, syncSuggestionLoadingIndicator = function() {
-      if (destroyed || settled || step !== "loadingSuggestions") {
+      if (destroyed || settled || step !== "loadingSuggestions" && step !== "loadingBranches") {
         if (suggestionSpinnerTimer) {
           clearInterval(suggestionSpinnerTimer);
           suggestionSpinnerTimer = undefined;
@@ -35992,22 +37127,28 @@ async function createNewSessionWizard({
       if (suggestionSpinnerTimer)
         return;
       suggestionSpinnerTimer = setInterval(() => {
-        if (destroyed || settled || step !== "loadingSuggestions") {
+        if (destroyed || settled || step !== "loadingSuggestions" && step !== "loadingBranches") {
           syncSuggestionLoadingIndicator();
           return;
         }
         suggestionSpinnerFrame = (suggestionSpinnerFrame + 1) % suggestionSpinnerFrames.length;
         render();
       }, suggestionSpinnerIntervalMs);
+    }, invalidatePendingConfirmation = function() {
+      pendingConfirmation = undefined;
+      if (attachmentFeedback?.kind === "progress")
+        attachmentFeedback = undefined;
     }, finish = function(value) {
       if (settled)
         return;
+      invalidatePendingConfirmation();
       settled = true;
       syncSuggestionLoadingIndicator();
       resolveDraft(value);
     }, fail = function(error93) {
       if (settled)
         return;
+      invalidatePendingConfirmation();
       settled = true;
       syncSuggestionLoadingIndicator();
       rejectDraft(error93);
@@ -36078,7 +37219,15 @@ async function createNewSessionWizard({
         returnToPromptFromRepositoryLoading();
         return;
       }
+      if (step === "loadingBranches" || step === "branches") {
+        branchRequestGeneration += 1;
+        step = "repositories";
+        render();
+        return;
+      }
       if (step === "recompute" || step === "confirmation") {
+        if (step === "confirmation")
+          invalidatePendingConfirmation();
         step = "repositories";
         editor.setText("");
         render();
@@ -36106,6 +37255,15 @@ async function createNewSessionWizard({
             const completedText = replaceActivePathToken({ text: editor.plainText, replacement: completion.replacement });
             editor.setText(completedText);
             editor.cursorOffset = completedText.length;
+            if (completion.attachmentPath) {
+              const selectedCompletion = createSelectedPathCompletion({
+                attachmentPath: completion.attachmentPath,
+                token: completion.replacement,
+                end: completedText.length
+              });
+              selectedPathCompletions = [...selectedPathCompletions, selectedCompletion];
+            }
+            previousPromptEditorText = completedText;
           }
           pathCompletions = [];
           pathCompletionMenuOpen = false;
@@ -36131,12 +37289,14 @@ async function createNewSessionWizard({
       if (step === "confirmation") {
         if (key.name === "m") {
           key.preventDefault();
+          invalidatePendingConfirmation();
           model = cycle({ values: newSessionModels, value: model, direction: 1 });
           render();
           return;
         }
         if (key.name === "left" || key.name === "right") {
           key.preventDefault();
+          invalidatePendingConfirmation();
           reasoningEffort = clampedStep({
             values: newSessionReasoningEfforts,
             value: reasoningEffort,
@@ -36147,6 +37307,7 @@ async function createNewSessionWizard({
         }
         if (key.name === "e") {
           key.preventDefault();
+          invalidatePendingConfirmation();
           step = "prompt";
           editor.setText(prompt);
           render();
@@ -36154,11 +37315,19 @@ async function createNewSessionWizard({
         }
         if (key.name === "r") {
           key.preventDefault();
+          invalidatePendingConfirmation();
           step = "repositories";
           editor.setText("");
           render();
           return;
         }
+        if (key.name === "b" && branchSuggestions.some((suggestion) => suggestion.suggestionKind !== "createSessionBranch")) {
+          key.preventDefault();
+          invalidatePendingConfirmation();
+          step = "branches";
+          render();
+          return;
+        }
       }
       if (step === "repositorySearch")
         return;
@@ -36179,8 +37348,16 @@ async function createNewSessionWizard({
           return;
         }
       }
+      if (step === "branches" && branchSuggestions.some((suggestion) => suggestion.suggestionKind !== "createSessionBranch") && (key.name === "up" || key.name === "down" || key.name === "left" || key.name === "right")) {
+        key.preventDefault();
+        branchChoice = branchChoice === "existing" ? "new" : "existing";
+        render();
+        return;
+      }
       if (!composerMounted && (key.name === "return" || key.name === "enter")) {
         key.preventDefault();
+        if (step === "loadingBranches")
+          return;
         submitEditor();
         return;
       }
@@ -36269,6 +37446,7 @@ async function createNewSessionWizard({
     let repositoryLoadState = Array.isArray(repositories) ? "ready" : "loading";
     let repositoryRequestGeneration = 0;
     let suggestionRequestGeneration = 0;
+    let branchRequestGeneration = 0;
     let installationIds = [...new Set(loadedRepositories.map((repository) => repository.githubInstallationId))].sort((left, right) => left.localeCompare(right));
     let step = initialDraft ? "confirmation" : "prompt";
     let prompt = initialDraft?.prompt ?? "";
@@ -36280,7 +37458,9 @@ async function createNewSessionWizard({
     let recomputeInstruction = "";
     let suggestionSpinnerFrame = 0;
     let attachments = [...initialDraft?.attachments ?? []];
+    let previousPromptEditorText = "";
     let pathCompletions = [];
+    let selectedPathCompletions = [];
     let completionIndex = 0;
     let pathCompletionMenuOpen = false;
     let repositoryHeaderHeight;
@@ -36289,8 +37469,17 @@ async function createNewSessionWizard({
     let searchSelections;
     let suggestedIds = new Set;
     let suggestionConfidence;
+    let branchSuggestions = initialDraft?.repositoryBranchOverrides?.map((override) => ({
+      suggestionKind: "continueExistingBranch",
+      repositoryId: override.repositoryId,
+      branchName: override.branchName,
+      pullRequest: null
+    })) ?? [];
+    let branchChoice = initialDraft?.repositoryBranchOverrides?.length ? "existing" : "new";
     let status = initialError ?? "";
+    let attachmentFeedback;
     let pendingPastedImageWrites = 0;
+    let pendingConfirmation;
     let destroyed = false;
     let rendererDestroyPromise;
     let settled = false;
@@ -36313,6 +37502,14 @@ async function createNewSessionWizard({
         submitEditor();
       },
       onContentChange: () => {
+        if (step === "prompt") {
+          selectedPathCompletions = reconcileSelectedPathCompletions({
+            previousText: previousPromptEditorText,
+            text: editor.plainText,
+            selections: selectedPathCompletions
+          });
+          previousPromptEditorText = editor.plainText;
+        }
         pathCompletionMenuOpen = false;
         if (step === "repositorySearch") {
           repositoryQuery = editor.plainText;
@@ -36348,6 +37545,35 @@ async function createNewSessionWizard({
         status = error93 instanceof Error ? error93.message : String(error93);
       }
     }
+    async function startBranchReview() {
+      const installationId = selectedInstallationId();
+      if (!installationId)
+        return;
+      const repositoryIds = [...selectedRepositoryIds()];
+      const requestGeneration = ++branchRequestGeneration;
+      branchSuggestions = [];
+      branchChoice = "new";
+      step = "loadingBranches";
+      status = "";
+      render();
+      try {
+        const suggestions = await suggestBranches({ installationId, prompt, repositoryIds });
+        if (destroyed || requestGeneration !== branchRequestGeneration || step !== "loadingBranches")
+          return;
+        branchSuggestions = suggestions;
+        const hasExistingBranch = branchSuggestions.some((suggestion) => suggestion.suggestionKind !== "createSessionBranch");
+        branchChoice = hasExistingBranch ? "existing" : "new";
+        step = hasExistingBranch ? "branches" : "confirmation";
+      } catch (error93) {
+        if (destroyed || requestGeneration !== branchRequestGeneration || step !== "loadingBranches")
+          return;
+        branchSuggestions = [];
+        branchChoice = "new";
+        status = error93 instanceof Error ? error93.message : String(error93);
+        step = "confirmation";
+      }
+      render();
+    }
     async function openPathCompletionMenu() {
       if (destroyed)
         return;
@@ -36379,28 +37605,33 @@ async function createNewSessionWizard({
     }
     async function pasteClipboardImage() {
       if (!readClipboardImage || !savePastedImage) {
-        status = "Clipboard image paste is unavailable.";
+        attachmentFeedback = { kind: "failure", message: "Clipboard image paste is unavailable." };
         render();
         return;
       }
       pendingPastedImageWrites += 1;
-      status = "Saving clipboard image\u2026";
+      attachmentFeedback = { kind: "progress", message: "Saving clipboard image\u2026" };
       render();
       try {
         const image = await readClipboardImage();
         const path = await savePastedImage(image);
         if (!destroyed) {
           editor.insertText(path);
-          status = "Clipboard image added; continue to attach it.";
+          const selectedCompletion = createSelectedPathCompletion({ attachmentPath: path, token: path, end: editor.cursorOffset });
+          selectedPathCompletions = [...selectedPathCompletions, selectedCompletion];
+          previousPromptEditorText = editor.plainText;
+          attachmentFeedback = { kind: "success", message: "Clipboard image ready to attach." };
         }
       } catch (error93) {
-        status = error93 instanceof Error ? error93.message : String(error93);
+        attachmentFeedback = { kind: "failure", message: error93 instanceof Error ? error93.message : String(error93) };
       } finally {
         pendingPastedImageWrites -= 1;
       }
       render();
     }
     async function confirm() {
+      if (destroyed || settled || step !== "confirmation" || pendingConfirmation)
+        return;
       const installationId = selectedInstallationId();
       if (!installationId) {
         status = "GitHub installation selection is required.";
@@ -36412,22 +37643,55 @@ async function createNewSessionWizard({
         fail(new Error("Selected repositories must belong to the chosen GitHub installation."));
         return;
       }
+      const repositoryBranchOverrides = branchChoice === "existing" ? branchSuggestions.flatMap((suggestion) => suggestion.suggestionKind === "createSessionBranch" ? [] : [{ repositoryId: suggestion.repositoryId, branchName: suggestion.branchName }]) : [];
+      const confirmation = Symbol("confirmation");
+      const confirmedAttachments = [...attachments];
+      const confirmedPrompt = prompt;
+      const confirmedModel = model;
+      const confirmedReasoningEffort = reasoningEffort;
+      const confirmedSelectedPaths = selectedAttachmentPaths({ text: confirmedPrompt, selections: selectedPathCompletions });
+      pendingConfirmation = confirmation;
+      const ownsConfirmation = () => !destroyed && !settled && step === "confirmation" && pendingConfirmation === confirmation;
       if (attachPromptPaths) {
-        status = "Attaching referenced files\u2026";
-        render();
+        attachmentFeedback = undefined;
         try {
           const promptAttachments = await attachPromptPaths({
-            text: prompt,
-            excludedPaths: attachments.flatMap((attachment) => attachment.sourcePath ? [attachment.sourcePath] : [])
+            text: confirmedPrompt,
+            excludedPaths: confirmedAttachments.flatMap((attachment) => attachment.sourcePath ? [attachment.sourcePath] : []),
+            selectedPaths: confirmedSelectedPaths,
+            onUploadStart: ({ filenames }) => {
+              if (!ownsConfirmation())
+                return;
+              attachmentFeedback = { kind: "progress", message: attachmentUploadMessage(filenames) };
+              render();
+            }
           });
-          attachments = [...attachments, ...promptAttachments];
+          if (!ownsConfirmation())
+            return;
+          confirmedAttachments.push(...promptAttachments);
+          attachments = confirmedAttachments;
+          selectedPathCompletions = [];
+          attachmentFeedback = undefined;
         } catch (error93) {
-          status = error93 instanceof Error ? error93.message : String(error93);
+          if (!ownsConfirmation())
+            return;
+          pendingConfirmation = undefined;
+          attachmentFeedback = { kind: "failure", message: error93 instanceof Error ? error93.message : String(error93) };
           render();
           return;
         }
       }
-      finish({ prompt, githubInstallationId: installationId, repositories: selected, attachments, model, reasoningEffort });
+      if (!ownsConfirmation())
+        return;
+      finish({
+        prompt: confirmedPrompt,
+        githubInstallationId: installationId,
+        repositories: selected,
+        ...repositoryBranchOverrides.length > 0 ? { repositoryBranchOverrides } : {},
+        attachments: confirmedAttachments,
+        model: confirmedModel,
+        reasoningEffort: confirmedReasoningEffort
+      });
     }
     async function submitEditor() {
       const value = editor.plainText.trim();
@@ -36461,8 +37725,12 @@ async function createNewSessionWizard({
         return;
       }
       if (step === "repositories") {
-        step = "confirmation";
         editor.setText("");
+        startBranchReview();
+        return;
+      }
+      if (step === "branches") {
+        step = "confirmation";
         render();
         return;
       }
@@ -36526,6 +37794,7 @@ async function createNewSessionWizard({
       destroy() {
         if (rendererDestroyed2)
           return;
+        invalidatePendingConfirmation();
         destroyed = true;
         if (inputHandler)
           renderer.removeInputHandler(inputHandler);
@@ -36562,12 +37831,13 @@ async function createNewSessionWizard({
   }
 }
 function stepHeader(title) {
-  return bold3(fg5(PALETTE.remyAccent)(title));
+  return bold3(fg6(PALETTE.remyAccent)(title));
 }
 var WIZARD_STEPS = [
   { key: "describe", label: "Describe" },
   { key: "installation", label: "Installation" },
   { key: "repositories", label: "Repositories" },
+  { key: "branches", label: "Branches" },
   { key: "confirm", label: "Confirm" }
 ];
 function wizardStepKey(step) {
@@ -36575,52 +37845,41 @@ function wizardStepKey(step) {
     return "describe";
   if (step === "installation")
     return "installation";
+  if (step === "loadingBranches" || step === "branches")
+    return "branches";
   if (step === "confirmation")
     return "confirm";
   return "repositories";
 }
-function renderStepIndicator({ step, hasInstallationChoice }) {
-  const steps = WIZARD_STEPS.filter((entry) => entry.key !== "installation" || hasInstallationChoice);
+function renderStepIndicator({ step, hasInstallationChoice, hasBranchChoice = false }) {
+  const steps = WIZARD_STEPS.filter((entry) => (entry.key !== "installation" || hasInstallationChoice) && (entry.key !== "branches" || hasBranchChoice));
   const currentKey = wizardStepKey(step);
   const currentIndex = steps.findIndex((entry) => entry.key === currentKey);
   const position = currentIndex >= 0 ? currentIndex + 1 : steps.length;
   const crumbs = [];
   steps.forEach((entry, index) => {
     if (index > 0)
-      crumbs.push(fg5(PALETTE.dimText)(" \u203A "));
-    crumbs.push(entry.key === currentKey ? bold3(fg5(PALETTE.bodyText)(entry.label)) : fg5(PALETTE.dimText)(entry.label));
+      crumbs.push(fg6(PALETTE.dimText)(" \u203A "));
+    crumbs.push(entry.key === currentKey ? bold3(fg6(PALETTE.bodyText)(entry.label)) : fg6(PALETTE.dimText)(entry.label));
   });
-  return new StyledText4([
-    bold3(fg5(PALETTE.remyAccent)(`Step ${position} of ${steps.length}`)),
-    fg5(PALETTE.dimText)("   "),
+  return new StyledText5([
+    bold3(fg6(PALETTE.remyAccent)(`Step ${position} of ${steps.length}`)),
+    fg6(PALETTE.dimText)("   "),
     ...crumbs
   ]);
 }
 function renderSelectableRow({ label, isCursor }) {
   const line = `${isCursor ? "> " : "  "}${label}`;
-  const styled = fg5(PALETTE.bodyText)(line);
+  const styled = fg6(PALETTE.bodyText)(line);
   return [isCursor ? bg3(PALETTE.selectionBg)(styled) : styled];
 }
 function renderRepositoryRow({ repository, isCursor, isChecked, source }) {
   const marker = isChecked ? "[x]" : "[ ]";
   const line = `${isCursor ? "> " : "  "}${marker} ${repository.fullName}`;
-  const styled = isChecked ? bold3(fg5(PALETTE.humanAccent)(line)) : fg5(PALETTE.dimText)(line);
-  const tag = source === "suggested" && isChecked ? dim3(fg5(PALETTE.tool)(" \u25C6 suggested by Remy")) : undefined;
+  const styled = isChecked ? bold3(fg6(PALETTE.humanAccent)(line)) : fg6(PALETTE.dimText)(line);
+  const tag = source === "suggested" && isChecked ? dim4(fg6(PALETTE.tool)(" \u25C6 suggested by Remy")) : undefined;
   return [isCursor ? bg3(PALETTE.selectionBg)(styled) : styled, ...tag ? [tag] : []];
 }
-function fuzzyMatches(value, query) {
-  const normalizedQuery = query.replaceAll(/\s/g, "").toLowerCase();
-  if (!normalizedQuery)
-    return true;
-  let queryIndex = 0;
-  for (const character of value.toLowerCase()) {
-    if (character === normalizedQuery[queryIndex])
-      queryIndex += 1;
-    if (queryIndex === normalizedQuery.length)
-      return true;
-  }
-  return false;
-}
 function cycle({ values, value, direction }) {
   const currentIndex = values.indexOf(value);
   const nextIndex = (currentIndex + direction + values.length) % values.length;
@@ -36636,7 +37895,7 @@ async function createDefaultRenderer2() {
 }
 
 // src/tui/session-view.ts
-import { CliRenderEvents as CliRenderEvents4, BoxRenderable as BoxRenderable4, bg as bg4, bold as bold4, dim as dim4, fg as fg6, ScrollBoxRenderable as ScrollBoxRenderable3, StyledText as StyledText5, stringToStyledText as stringToStyledText5, TextRenderable as TextRenderable4 } from "@opentui/core";
+import { CliRenderEvents as CliRenderEvents4, BoxRenderable as BoxRenderable4, bg as bg4, bold as bold4, dim as dim5, fg as fg7, ScrollBoxRenderable as ScrollBoxRenderable3, StyledText as StyledText6, stringToStyledText as stringToStyledText5, TextRenderable as TextRenderable4 } from "@opentui/core";
 var composerSlashCommands = [
   { value: "/sessions", description: "Back to the session list" },
   { value: "/complete", description: "Finish this session" },
@@ -36717,6 +37976,7 @@ async function createSessionTui({
       }
       promptHistoryIndex = direction === "up" ? Math.max(0, promptHistoryIndex - 1) : Math.min(promptHistory.length, promptHistoryIndex + 1);
       const text = promptHistoryIndex === promptHistory.length ? promptHistoryDraft : promptHistory[promptHistoryIndex];
+      selectedPathCompletions = [];
       historyReplacement = text;
       composer.setText(text);
       composer.cursorOffset = text.length;
@@ -36739,10 +37999,10 @@ async function createSessionTui({
       syncTerminalSessionControls();
       syncWorkingIndicator();
       renderRetainedTranscript();
-      const assistantPreview = latestState.previews.assistantText ? new StyledText5([dim4(fg6(PALETTE.dimText)(`Live assistant preview
-`)), fg6(PALETTE.remyAccent)(latestState.previews.assistantText)]) : new StyledText5([]);
-      const reasoningPreview = latestState.previews.reasoningText ? new StyledText5([dim4(fg6(PALETTE.dimText)(`Live reasoning preview
-`)), dim4(fg6(PALETTE.dimText)(latestState.previews.reasoningText))]) : new StyledText5([]);
+      const assistantPreview = latestState.previews.assistantText ? new StyledText6([dim5(fg7(PALETTE.dimText)(`Live assistant preview
+`)), fg7(PALETTE.remyAccent)(latestState.previews.assistantText)]) : new StyledText6([]);
+      const reasoningPreview = latestState.previews.reasoningText ? new StyledText6([dim5(fg7(PALETTE.dimText)(`Live reasoning preview
+`)), dim5(fg7(PALETTE.dimText)(latestState.previews.reasoningText))]) : new StyledText6([]);
       const working = isRemyWorking(latestState);
       const startedAt = workingTurnStartedAt(latestState);
       const elapsedMs = startedAt === undefined ? 0 : Math.max(0, now3() - Date.parse(startedAt));
@@ -36751,7 +38011,7 @@ async function createSessionTui({
         frame: workingSpinnerFrames[spinnerFrameIndex],
         elapsedMs,
         mode: stopState.kind === "stopping" ? "stopping" : "working"
-      }) : new StyledText5([]);
+      }) : new StyledText6([]);
       const liveContent = [assistantPreview, reasoningPreview, liveIndicator].filter((part) => part.chunks.length > 0);
       liveTranscript.content = liveContent.length === 0 ? "" : joinStyled([stringToStyledText5(`
 
@@ -36767,6 +38027,7 @@ async function createSessionTui({
       const commandMenu = renderSlashCommandMenu({ commands: slashCompletions, selectedIndex: slashCompletionIndex });
       const composerStatus = [
         helpVisible ? renderHelpPanel() : undefined,
+        attachmentFeedback ? renderAttachmentFeedback(attachmentFeedback) : undefined,
         composerFeedback ? stringToStyledText5(composerFeedback) : undefined,
         submissionStatus,
         commandMenu,
@@ -36839,10 +38100,17 @@ async function createSessionTui({
       }
       slashCompletions = composerSlashCommands.filter((command) => command.value.startsWith(value) && command.value !== value && (!["/complete", "/cancel"].includes(command.value) || latestState.aggregateStatus === "open"));
       slashCompletionIndex = 0;
+    }, invalidateAttachmentPreparation = function() {
+      attachmentPreparationOwner = undefined;
+    }, ownsAttachmentPreparation = function(owner) {
+      return attachmentPreparationOwner === owner && !destroyed && !settled;
+    }, viewIsActive = function() {
+      return !destroyed && !settled;
     }, finish = function(result, error93) {
       if (settled)
         return;
       settled = true;
+      invalidateAttachmentPreparation();
       if (error93)
         rejectAction(error93);
       else
@@ -36866,17 +38134,21 @@ async function createSessionTui({
     let settled = false;
     let activityExpanded = false;
     let composerDraft = initialComposer ?? { text: "", attachments: [] };
+    let previousComposerText = composerDraft.text;
     let pathCompletions = [];
+    let selectedPathCompletions = [];
     let completionIndex = 0;
     let pathCompletionMenuOpen = false;
     let slashCompletions = [];
     let slashCompletionIndex = 0;
     let composerFeedback = initialFeedback;
+    let attachmentFeedback;
     const localPromptHistory = [];
     let promptHistoryIndex;
     let promptHistoryDraft = "";
     let historyReplacement;
     let pendingPastedImageWrites = 0;
+    let attachmentPreparationOwner;
     let admittedSubmissions = [];
     let stopState = { kind: "idle" };
     let lifecycleRequestState = { kind: "idle" };
@@ -36915,6 +38187,12 @@ async function createSessionTui({
         submitComposer();
       },
       onContentChange: () => {
+        selectedPathCompletions = reconcileSelectedPathCompletions({
+          previousText: previousComposerText,
+          text: composer.plainText,
+          selections: selectedPathCompletions
+        });
+        previousComposerText = composer.plainText;
         if (historyReplacement !== composer.plainText)
           promptHistoryIndex = undefined;
         historyReplacement = undefined;
@@ -36995,12 +38273,12 @@ async function createSessionTui({
     };
     async function pasteClipboardImage() {
       if (!readClipboardImage || !savePastedImage) {
-        composerFeedback = "Clipboard image paste is unavailable.";
+        attachmentFeedback = { kind: "failure", message: "Clipboard image paste is unavailable." };
         render();
         return;
       }
       pendingPastedImageWrites += 1;
-      composerFeedback = "Saving clipboard image\u2026";
+      attachmentFeedback = { kind: "progress", message: "Saving clipboard image\u2026" };
       render();
       try {
         const image = await readClipboardImage();
@@ -37008,10 +38286,13 @@ async function createSessionTui({
         if (destroyed)
           return;
         composer.insertText(path);
-        composerFeedback = "Clipboard image added; send message to attach it.";
+        const selectedCompletion = createSelectedPathCompletion({ attachmentPath: path, token: path, end: composer.cursorOffset });
+        selectedPathCompletions = [...selectedPathCompletions, selectedCompletion];
+        previousComposerText = composer.plainText;
+        attachmentFeedback = { kind: "success", message: "Clipboard image ready to attach." };
       } catch (error93) {
         if (!destroyed)
-          composerFeedback = error93 instanceof Error ? error93.message : String(error93);
+          attachmentFeedback = { kind: "failure", message: error93 instanceof Error ? error93.message : String(error93) };
       } finally {
         pendingPastedImageWrites -= 1;
         if (!destroyed)
@@ -37071,6 +38352,15 @@ async function createSessionTui({
             const completedText = replaceActivePathToken({ text: composer.plainText, replacement: completion.replacement });
             composer.setText(completedText);
             composer.cursorOffset = completedText.length;
+            if (completion.attachmentPath) {
+              const selectedCompletion = createSelectedPathCompletion({
+                attachmentPath: completion.attachmentPath,
+                token: completion.replacement,
+                end: completedText.length
+              });
+              selectedPathCompletions = [...selectedPathCompletions, selectedCompletion];
+            }
+            previousComposerText = completedText;
           }
           pathCompletions = [];
           pathCompletionMenuOpen = false;
@@ -37101,8 +38391,10 @@ async function createSessionTui({
       render();
     }
     async function submitComposer() {
+      if (attachmentPreparationOwner)
+        return;
       if (pendingPastedImageWrites > 0) {
-        composerFeedback = "Saving pasted image\u2026";
+        attachmentFeedback = { kind: "progress", message: "Saving pasted image\u2026" };
         render();
         return;
       }
@@ -37110,33 +38402,61 @@ async function createSessionTui({
       const value = composerDraft.text;
       if (value.trim() === "")
         return;
-      if (await handleComposerCommand(value))
+      const preparationOwner = Symbol("attachment preparation");
+      attachmentPreparationOwner = preparationOwner;
+      if (await handleComposerCommand(value)) {
+        if (attachmentPreparationOwner === preparationOwner)
+          invalidateAttachmentPreparation();
+        return;
+      }
+      if (!ownsAttachmentPreparation(preparationOwner))
         return;
       if (lifecycleRequestState.kind === "pending") {
         composerFeedback = `${lifecycleOperationPresentParticiple(lifecycleRequestState.operation)} the session \u2014 messages are paused.`;
         render();
+        invalidateAttachmentPreparation();
         return;
       }
       if (latestState.aggregateStatus !== "open") {
         composerFeedback = "This session is already terminal. Run /sessions to return to the session list.";
         render();
+        invalidateAttachmentPreparation();
         return;
       }
       if (attachPromptPaths) {
-        composerFeedback = "Attaching referenced files\u2026";
-        render();
+        let handedOffToAdmission = false;
         try {
           const attachments = await attachPromptPaths({
             text: composerDraft.text,
-            excludedPaths: composerDraft.attachments.flatMap((attachment) => attachment.sourcePath ? [attachment.sourcePath] : [])
+            excludedPaths: composerDraft.attachments.flatMap((attachment) => attachment.sourcePath ? [attachment.sourcePath] : []),
+            selectedPaths: selectedAttachmentPaths({ text: composerDraft.text, selections: selectedPathCompletions }),
+            onUploadStart: ({ filenames }) => {
+              if (!ownsAttachmentPreparation(preparationOwner))
+                return;
+              attachmentFeedback = { kind: "progress", message: attachmentUploadMessage(filenames) };
+              render();
+            }
           });
+          if (!ownsAttachmentPreparation(preparationOwner))
+            return;
           composerDraft = { ...composerDraft, attachments: [...composerDraft.attachments, ...attachments] };
+          selectedPathCompletions = [];
+          attachmentFeedback = undefined;
+          handedOffToAdmission = true;
         } catch (error93) {
-          composerFeedback = error93 instanceof Error ? error93.message : String(error93);
+          if (!ownsAttachmentPreparation(preparationOwner))
+            return;
+          attachmentFeedback = { kind: "failure", message: error93 instanceof Error ? error93.message : String(error93) };
           render();
           return;
+        } finally {
+          if (!handedOffToAdmission && attachmentPreparationOwner === preparationOwner)
+            invalidateAttachmentPreparation();
         }
       }
+      if (!ownsAttachmentPreparation(preparationOwner))
+        return;
+      invalidateAttachmentPreparation();
       const submission = {
         id: crypto.randomUUID(),
         idempotencyKey: crypto.randomUUID(),
@@ -37173,13 +38493,13 @@ async function createSessionTui({
       if (command === "/complete") {
         composer.setText("");
         composerDraft = { ...composerDraft, text: "" };
-        await handleLifecycleRequest("complete");
+        handleLifecycleRequest("complete");
         return true;
       }
       if (command === "/cancel") {
         composer.setText("");
         composerDraft = { ...composerDraft, text: "" };
-        await handleLifecycleRequest("cancel");
+        handleLifecycleRequest("cancel");
         return true;
       }
       if (command === "/logout") {
@@ -37207,16 +38527,22 @@ async function createSessionTui({
           attachments: submission.attachments,
           idempotencyKey: submission.idempotencyKey
         });
+        if (!viewIsActive())
+          return;
         localPromptHistory.push(submission.text);
         const messageId = latestState.activeMessageId;
         admittedSubmissions = messageId ? admittedSubmissions.map((candidate) => candidate.id === submission.id ? { id: candidate.id, idempotencyKey: candidate.idempotencyKey, text: candidate.text, attachments: candidate.attachments, status: "submitted", messageId } : candidate) : admittedSubmissions.filter((candidate) => candidate.id !== submission.id);
         composerFeedback = undefined;
       } catch (error93) {
+        if (!viewIsActive())
+          return;
         admittedSubmissions = admittedSubmissions.map((candidate) => candidate.id === submission.id ? { id: candidate.id, idempotencyKey: candidate.idempotencyKey, text: candidate.text, attachments: candidate.attachments, status: "failed", error: error93 instanceof Error ? error93.message : String(error93) } : candidate);
       }
       render();
     }
     async function retryOldestFailedSubmission() {
+      if (!viewIsActive())
+        return;
       const failed = admittedSubmissions.find((submission) => submission.status === "failed");
       if (!failed)
         return;
@@ -37332,6 +38658,7 @@ async function createSessionTui({
         if (destroyed)
           return;
         destroyed = true;
+        invalidateAttachmentPreparation();
         if (workingSpinnerTimer) {
           clearInterval(workingSpinnerTimer);
           workingSpinnerTimer = undefined;
@@ -37373,9 +38700,9 @@ function renderSlashCommandMenu({ commands, selectedIndex }) {
   const rows = commands.map((command, index) => {
     const selected = index === selectedIndex;
     const rowStyle = selected ? bg4(PALETTE.selectionBg) : (chunk) => chunk;
-    return new StyledText5([
-      rowStyle(fg6(PALETTE.remyAccent)(`${selected ? "\u203A " : "  "}${command.value.padEnd(12)}`)),
-      rowStyle(fg6(PALETTE.dimText)(command.description))
+    return new StyledText6([
+      rowStyle(fg7(PALETTE.remyAccent)(`${selected ? "\u203A " : "  "}${command.value.padEnd(12)}`)),
+      rowStyle(fg7(PALETTE.dimText)(command.description))
     ]);
   });
   return joinStyled([joinStyled(rows, `
@@ -37396,15 +38723,15 @@ var helpEntries = [
 ];
 function renderHelpPanel() {
   const width = helpEntries.reduce((max, entry) => Math.max(max, entry.token.length), 0) + 2;
-  const rows = [new StyledText5([dim4(fg6(PALETTE.dimText)("What you can do here"))])];
+  const rows = [new StyledText6([dim5(fg7(PALETTE.dimText)("What you can do here"))])];
   let lastGroup;
   for (const entry of helpEntries) {
     if (lastGroup !== undefined && entry.group !== lastGroup)
-      rows.push(new StyledText5([fg6(PALETTE.dimText)(" ")]));
+      rows.push(new StyledText6([fg7(PALETTE.dimText)(" ")]));
     lastGroup = entry.group;
-    rows.push(new StyledText5([
-      fg6(PALETTE.remyAccent)(`  ${entry.token.padEnd(width)}`),
-      dim4(fg6(PALETTE.dimText)(entry.description))
+    rows.push(new StyledText6([
+      fg7(PALETTE.remyAccent)(`  ${entry.token.padEnd(width)}`),
+      dim5(fg7(PALETTE.dimText)(entry.description))
     ]));
   }
   return joinStyled(rows, `
@@ -37418,23 +38745,22 @@ function renderStatusBand({ state, working, elapsedMs, stopState, lifecycleReque
   const pendingOperation = lifecycleRequestState?.kind === "pending" ? lifecycleRequestState.operation : undefined;
   const presentation = pendingOperation ? { label: lifecycleOperationPresentParticiple(pendingOperation), color: PALETTE.approvalQuestion } : stopping ? { label: "Stopping", color: PALETTE.approvalQuestion } : sessionViewStatePresentation({ aggregateStatus: state.aggregateStatus, isWorking: working });
   const elapsed = (working || stopping) && elapsedMs !== undefined && elapsedMs > 0 ? ` ${formatElapsed(elapsedMs)}` : "";
-  const connection = state.connectionStatus === "connected" ? dim4(fg6(PALETTE.dimText)("connected")) : fg6(PALETTE.approvalQuestion)("reconnecting\u2026");
-  const sessionLabel = state.sessionNumber !== undefined ? `Session #${state.sessionNumber}` : `Session ${state.sessionId}`;
-  const context = renderContextStatus(state.context.snapshot);
+  const connection = state.connectionStatus === "connected" ? new StyledText6([fg7(PALETTE.statusCompleted)("\u25CF "), dim5(fg7(PALETTE.dimText)("connected"))]) : new StyledText6([fg7(PALETTE.approvalQuestion)("\u25CF reconnecting\u2026")]);
+  const sessionLabel = state.sessionNumber !== undefined ? `#${state.sessionNumber}` : state.sessionId;
   const pullRequest = state.pullRequest;
-  return new StyledText5([
-    fg6(presentation.color)("\u25CF "),
-    ...repositoryLabel ? [dim4(fg6(PALETTE.dimText)(`${repositoryLabel} \xB7 `))] : [],
-    dim4(fg6(PALETTE.dimText)(`${sessionLabel} \xB7 `)),
-    bold4(fg6(presentation.color)(`${presentation.label}${elapsed}`)),
-    dim4(fg6(PALETTE.dimText)(" \xB7 ")),
-    connection,
-    ...context ? [dim4(fg6(PALETTE.dimText)(` \xB7 ${context}`))] : [],
-    ...pullRequest ? [
-      dim4(fg6(PALETTE.dimText)(" \xB7 ")),
-      bold4(fg6(statusColor(pullRequest.status))(`PR #${pullRequest.number} \xB7 ${pullRequest.draft ? "Draft" : sessionStatusLabel(pullRequest.status)}`))
-    ] : []
-  ]);
+  const contextStatus = renderContextStatus(state.context.snapshot);
+  const headerContext = [
+    ...repositoryLabel ? [[dim5(fg7(PALETTE.dimText)(repositoryLabel))]] : [],
+    ...pullRequest ? [[bold4(fg7(statusColor(pullRequest.status))(`PR#${pullRequest.number}`))]] : [],
+    [bold4(fg7(presentation.color)(`${presentation.label}${elapsed}`))],
+    connection.chunks,
+    ...contextStatus ? [[dim5(fg7(PALETTE.dimText)(contextStatus))]] : []
+  ];
+  return joinStyled([
+    [bold4(fg7(PALETTE.bodyText)(`${sessionLabel} ${state.title ?? "Untitled session"}`))],
+    joinStyled(headerContext, " \xB7 ")
+  ], `
+`);
 }
 function renderContextStatus(snapshot) {
   if (snapshot.status === "unknown")
@@ -37445,33 +38771,39 @@ function renderContextStatus(snapshot) {
 function renderTerminalSessionBand({ aggregateStatus }) {
   const status = sessionStatusLabel(aggregateStatus).toLowerCase();
   return joinStyled([
-    new StyledText5([
-      bg4(PALETTE.selectionBg)(bold4(fg6(PALETTE.systemAccent)(` Session ${status} `))),
-      bg4(PALETTE.selectionBg)(fg6(PALETTE.bodyText)("\u2014 this conversation is closed. "))
+    new StyledText6([
+      bg4(PALETTE.selectionBg)(bold4(fg7(PALETTE.systemAccent)(` Session ${status} `))),
+      bg4(PALETTE.selectionBg)(fg7(PALETTE.bodyText)("\u2014 this conversation is closed. "))
     ]),
-    new StyledText5([
-      bg4(PALETTE.selectionBg)(fg6(PALETTE.remyAccent)(" esc: ")),
-      bg4(PALETTE.selectionBg)(dim4(fg6(PALETTE.dimText)("return to dashboard  \xB7 "))),
-      bg4(PALETTE.selectionBg)(fg6(PALETTE.remyAccent)("n: ")),
-      bg4(PALETTE.selectionBg)(dim4(fg6(PALETTE.dimText)("new session ")))
+    new StyledText6([
+      bg4(PALETTE.selectionBg)(fg7(PALETTE.remyAccent)(" esc: ")),
+      bg4(PALETTE.selectionBg)(dim5(fg7(PALETTE.dimText)("return to dashboard  \xB7 "))),
+      bg4(PALETTE.selectionBg)(fg7(PALETTE.remyAccent)("n: ")),
+      bg4(PALETTE.selectionBg)(dim5(fg7(PALETTE.dimText)("new session ")))
     ])
   ], `
 `);
 }
 function renderActionBar({ state, working, stopState, lifecycleRequestState }) {
   if (lifecycleRequestState.kind === "pending")
-    return new StyledText5([dim4(fg6(PALETTE.dimText)(`${lifecycleOperationPresentParticiple(lifecycleRequestState.operation).toLowerCase()} the session\u2026`))]);
+    return new StyledText6([dim5(fg7(PALETTE.dimText)(`${lifecycleOperationPresentParticiple(lifecycleRequestState.operation).toLowerCase()} the session\u2026`))]);
   if (state.aggregateStatus !== "open")
-    return new StyledText5([]);
+    return new StyledText6([]);
   const stopToken = working && stopState.kind === "failed" ? ["esc retry stop"] : [];
   const idleGroup = lifecycleRequestState.kind === "failed" ? `/${lifecycleRequestState.operation} retries \xB7 /new \xB7 /sessions` : "/new \xB7 /sessions \xB7 /complete \xB7 /cancel";
   const tokens = working ? ["/ commands", ...stopToken, "ctrl+o activity"] : ["/ commands", idleGroup, "ctrl+o activity"];
-  return new StyledText5([dim4(fg6(PALETTE.dimText)(tokens.join("  \xB7  ")))]);
+  return new StyledText6([dim5(fg7(PALETTE.dimText)(tokens.join("  \xB7  ")))]);
 }
 function isRemyWorking(state) {
-  if (state.aggregateStatus !== "open" || state.connectionStatus !== "connected")
+  if (state.aggregateStatus !== "open" || state.connectionStatus !== "connected") {
     return false;
-  return hasRunningTurn(state) || state.activeMessageId !== undefined && state.messageTurns[state.activeMessageId]?.outcome === undefined;
+  }
+  if (state.activeMessageId !== undefined && state.messageTurns[state.activeMessageId]?.outcome === undefined)
+    return true;
+  return isWorkingAgentStatus(state.agentStatus) && hasRunningTurn(state);
+}
+function isWorkingAgentStatus(agentStatus) {
+  return agentStatus === undefined || agentStatus === "pending" || agentStatus === "queued" || agentStatus === "running";
 }
 function workingTurnStartedAt(state) {
   const activeTurn = state.activeMessageId === undefined ? undefined : state.messageTurns[state.activeMessageId];
@@ -37512,58 +38844,64 @@ function renderTimeline({ state, activityExpanded }) {
 }
 function renderTimelineItem(item, activityExpanded) {
   if (item.kind === "message") {
-    const header = new StyledText5([
+    const header = new StyledText6([
       renderTimestampChunk(item.occurredAt),
       renderRoleLabel({ label: item.author.label, role: item.author.role }),
-      ...item.author.source ? [dim4(fg6(PALETTE.dimText)(` (${item.author.source})`))] : []
+      ...item.author.source ? [dim5(fg7(PALETTE.dimText)(` (${item.author.source})`))] : []
     ]);
-    return joinStyled([header, renderMessageBody({ text: item.text, role: item.author.role })], `
+    const attachments = renderAttachmentSummary(item.attachments);
+    return joinStyled([
+      header,
+      renderMessageBody({ text: item.text, role: item.author.role }),
+      ...attachments.chunks.length > 0 ? [attachments] : []
+    ], `
 `);
   }
   if (item.kind === "plan")
     return renderPlan({ item, expanded: activityExpanded });
   if (item.artifactKind === "tela_page") {
-    return new StyledText5([
+    return new StyledText6([
       renderTimestampChunk(item.occurredAt),
-      bold4(fg6(PALETTE.tool)("Tela Page: ")),
-      fg6(PALETTE.bodyText)(item.title),
-      dim4(fg6(PALETTE.dimText)(` \xB7 ${item.url}`))
+      bold4(fg7(PALETTE.tool)("Tela Page: ")),
+      fg7(PALETTE.bodyText)(item.title),
+      dim5(fg7(PALETTE.dimText)(` \xB7 ${item.url}`))
     ]);
   }
-  return new StyledText5([
+  return new StyledText6([
     renderTimestampChunk(item.occurredAt),
-    bold4(fg6(PALETTE.tool)("Artifact: ")),
-    fg6(PALETTE.bodyText)(item.title)
+    bold4(fg7(PALETTE.tool)("Artifact: ")),
+    fg7(PALETTE.bodyText)(item.title),
+    ...item.previewUrl ? [dim5(fg7(PALETTE.dimText)(` (${item.previewUrl})`))] : []
   ]);
 }
 var collapsedPlanItemLimit = 5;
 function renderPlan({ item, expanded }) {
   if (item.items.length === 0)
-    return new StyledText5([]);
+    return new StyledText6([]);
   const completed = item.items.filter((workItem) => workItem.status === "completed").length;
   const visibleItems = expanded ? item.items : collapsedPlanItems(item.items);
   const rows = visibleItems.map((workItem) => {
     if (workItem.status === "in_progress") {
-      return new StyledText5([
-        fg6(PALETTE.remyAccent)("  \u25B8 "),
-        bold4(fg6(PALETTE.bodyText)(workItem.title))
+      return new StyledText6([
+        fg7(PALETTE.remyAccent)("  \u25B8 "),
+        bold4(fg7(PALETTE.bodyText)(workItem.title))
       ]);
     }
     const glyph = workItem.status === "completed" ? "\u2713" : "\u25CB";
-    return new StyledText5([
-      fg6(PALETTE.dimText)(`  ${glyph} `),
-      dim4(fg6(PALETTE.dimText)(workItem.title))
+    return new StyledText6([
+      fg7(PALETTE.dimText)(`  ${glyph} `),
+      dim5(fg7(PALETTE.dimText)(workItem.title))
     ]);
   });
   const hidden = item.items.length - visibleItems.length;
   return joinStyled([
-    new StyledText5([
+    new StyledText6([
       renderTimestampChunk(item.occurredAt),
-      bold4(fg6(PALETTE.remyAccent)("Plan")),
-      dim4(fg6(PALETTE.dimText)(` \xB7 ${completed}/${item.items.length} done`))
+      bold4(fg7(PALETTE.remyAccent)("Plan")),
+      dim5(fg7(PALETTE.dimText)(` \xB7 ${completed}/${item.items.length} done`))
     ]),
     ...rows,
-    ...hidden > 0 ? [new StyledText5([dim4(fg6(PALETTE.dimText)(`  \u2026 ${hidden} more task${hidden === 1 ? "" : "s"} \xB7 Ctrl+O details`))])] : []
+    ...hidden > 0 ? [new StyledText6([dim5(fg7(PALETTE.dimText)(`  \u2026 ${hidden} more task${hidden === 1 ? "" : "s"} \xB7 Ctrl+O details`))])] : []
   ], `
 `);
 }
@@ -37593,20 +38931,24 @@ function activityGlyph({ kind, inFlight }) {
     return { glyph: "\xB7", color: PALETTE.dimText };
   return { glyph: "\u2713", color: PALETTE.dimText };
 }
-function dedupeActivitySteps(items) {
-  const runs = [];
-  for (const item of items) {
-    const last = runs[runs.length - 1];
-    if (last && last.item.card.kind === item.card.kind && last.item.card.title === item.card.title && last.item.card.summary === item.card.summary)
-      last.count += 1;
-    else
-      runs.push({ item, count: 1 });
+function activityCardsHaveEqualDisclosure(left, right) {
+  return left.kind === right.kind && left.title === right.title && left.summary === right.summary && left.detail === right.detail && left.detailFormat === right.detailFormat && canonicalValuesEqual(left.attribution, right.attribution);
+}
+function canonicalValuesEqual(left, right) {
+  if (Object.is(left, right))
+    return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => canonicalValuesEqual(value, right[index]));
   }
-  return runs;
+  if (typeof left !== "object" || left === null || typeof right !== "object" || right === null)
+    return false;
+  const leftEntries = Object.entries(left);
+  const rightEntries = Object.entries(right);
+  return leftEntries.length === rightEntries.length && leftEntries.every(([key, value], index) => rightEntries[index]?.[0] === key && canonicalValuesEqual(value, rightEntries[index]?.[1]));
 }
 function renderActivityGroup({ items, activityExpanded }) {
   if (items.length === 0)
-    return new StyledText5([]);
+    return new StyledText6([]);
   const summary = renderActivitySummary({ items, includeTimestamp: activityExpanded });
   const lastInFlightIndex = items.length - 1;
   if (!activityExpanded) {
@@ -37615,58 +38957,129 @@ function renderActivityGroup({ items, activityExpanded }) {
       item,
       inFlight: item.card.kind === "tool" && tailStart + index === lastInFlightIndex
     }));
-    const elision = tailStart > 0 ? new StyledText5([dim4(fg6(PALETTE.dimText)(`  \u2026 ${tailStart} earlier step${tailStart === 1 ? "" : "s"}`))]) : undefined;
+    const elision = tailStart > 0 ? new StyledText6([dim5(fg7(PALETTE.dimText)(`  \u2026 ${tailStart} earlier step${tailStart === 1 ? "" : "s"}`))]) : undefined;
     return joinStyled([
-      new StyledText5([renderTimestampChunk(items[0].occurredAt), dim4(fg6(PALETTE.dimText)("Worked"))]),
+      new StyledText6([renderTimestampChunk(items[0].occurredAt), dim5(fg7(PALETTE.dimText)("Worked"))]),
       ...elision ? [elision] : [],
       ...tail,
       summary
     ], `
 `);
   }
-  const steps = dedupeActivitySteps(items).map(({ item, count }) => {
-    const inFlight = item.card.kind === "tool" && items.indexOf(item) === lastInFlightIndex;
-    const { glyph, color } = activityGlyph({ kind: item.card.kind, inFlight });
-    const showSummary = item.card.summary.length > 0 && item.card.summary !== item.card.title && !boilerplateActivitySummaries.has(item.card.summary);
-    const detail = item.card.detail === undefined ? undefined : item.card.detailFormat === "code" ? renderCodeSnippet({ text: item.card.detail, indent: "      " }) : new StyledText5([dim4(fg6(PALETTE.dimText)(`      ${item.card.detail}`))]);
-    const step = new StyledText5([
-      fg6(color)(`  ${glyph} `),
-      fg6(PALETTE.bodyText)(item.card.title),
-      ...count > 1 ? [dim4(fg6(PALETTE.dimText)(`  \xD7${count}`))] : [],
-      ...showSummary ? [dim4(fg6(PALETTE.dimText)(`
-      ${item.card.summary}`))] : []
-    ]);
-    return detail ? joinStyled([step, detail], `
+  return joinStyled([summary, ...renderExpandedActivityHierarchy({ items, lastInFlightIndex })], `
+`);
+}
+function renderExpandedActivityHierarchy({ items, lastInFlightIndex }) {
+  const rendered = [];
+  let activeOwnerKey;
+  let index = 0;
+  while (index < items.length) {
+    const item = items[index];
+    const attribution = item.card.attribution;
+    if (attribution?.status === "resolved") {
+      if (activeOwnerKey !== attribution.ownerKey) {
+        rendered.push(new StyledText6([
+          dim5(fg7(PALETTE.dimText)("  ")),
+          fg7(PALETTE.bodyText)(`Subagent \xB7 ${lineagePathLabel(attribution.path)}`)
+        ]));
+      }
+      activeOwnerKey = attribution.ownerKey;
+    } else {
+      activeOwnerKey = undefined;
+    }
+    let count = 1;
+    while (items[index + count] && activityCardsHaveEqualDisclosure(item.card, items[index + count].card)) {
+      count += 1;
+    }
+    rendered.push(renderExpandedActivityStep({
+      item,
+      count,
+      inFlight: item.card.kind === "tool" && index === lastInFlightIndex,
+      nested: attribution?.status === "resolved"
+    }));
+    index += count;
+  }
+  return rendered;
+}
+function renderExpandedActivityStep({ item, count, inFlight, nested }) {
+  const { glyph, color } = activityGlyph({ kind: item.card.kind, inFlight });
+  const showSummary = item.card.summary.length > 0 && item.card.summary !== item.card.title && !boilerplateActivitySummaries.has(item.card.summary);
+  const disclosure = renderActivityDisclosure(item.card);
+  const title = expandedActivityTitle(item.card);
+  const indent = nested ? "    " : "  ";
+  const step = new StyledText6([
+    fg7(color)(`${indent}${glyph} `),
+    fg7(PALETTE.bodyText)(title),
+    ...count > 1 ? [dim5(fg7(PALETTE.dimText)(`  \xD7${count}`))] : [],
+    ...showSummary ? [dim5(fg7(PALETTE.dimText)(`
+${indent}    ${item.card.summary}`))] : []
+  ]);
+  return disclosure ? joinStyled([step, disclosure], `
 `) : step;
-  });
-  return joinStyled([summary, ...steps], `
+}
+function expandedActivityTitle(card) {
+  if (!card.attribution)
+    return card.title;
+  if (card.attribution.status === "resolved")
+    return card.attribution.activityTitle ?? "Activity";
+  const name = childIdentityLabel(card.attribution.identity);
+  return `Unattributed subagent \xB7 ${name}${card.attribution.activityTitle ? ` \xB7 ${card.attribution.activityTitle}` : ""}`;
+}
+function lineagePathLabel(path) {
+  return path.map(childIdentityLabel).join(" \u203A ");
+}
+function childIdentityLabel(identity) {
+  const safeName = terminalSafeText(identity.name ?? "").replace(/\s+/gu, " ").trim();
+  if (safeName.length > 0)
+    return safeName;
+  return terminalSafeText(identity.subagentId).replace(/\s+/gu, " ").trim();
+}
+function renderActivityDisclosure(card) {
+  const details = [];
+  if (card.detail !== undefined) {
+    const safeDetail = terminalSafeText(card.detail);
+    details.push(card.detailFormat === "code" ? renderCodeSnippet({ text: safeDetail, indent: "      " }) : new StyledText6([dim5(fg7(PALETTE.dimText)(`      ${safeDetail}`))]));
+  }
+  return details.length === 0 ? undefined : joinStyled(details, `
+
 `);
 }
 function renderActivitySummary({ items, includeTimestamp }) {
-  return new StyledText5([
+  return new StyledText6([
     ...includeTimestamp ? [renderTimestampChunk(items[0].occurredAt)] : [],
-    dim4(fg6(PALETTE.dimText)(`Worked \xB7 ${items.length} step${items.length === 1 ? "" : "s"} \xB7 Ctrl+O details`))
+    dim5(fg7(PALETTE.dimText)(`Worked \xB7 ${items.length} step${items.length === 1 ? "" : "s"} \xB7 Ctrl+O details`))
   ]);
 }
 function renderCollapsedActivityStep({ item, inFlight }) {
   const { glyph, color } = activityGlyph({ kind: item.card.kind, inFlight });
-  return new StyledText5([
-    fg6(color)(`  ${glyph} `),
-    dim4(fg6(PALETTE.dimText)(item.card.title))
+  return new StyledText6([
+    fg7(color)(`  ${glyph} `),
+    dim5(fg7(PALETTE.dimText)(collapsedActivityTitle(item.card)))
   ]);
 }
+function collapsedActivityTitle(card) {
+  const attribution = card.attribution;
+  if (!attribution)
+    return card.title;
+  if (attribution.status === "unresolved") {
+    const name = childIdentityLabel(attribution.identity);
+    return `Unattributed subagent \xB7 ${name}${attribution.activityTitle ? ` \xB7 ${attribution.activityTitle}` : ""}`;
+  }
+  const activityTitle = attribution.activityTitle ? ` \xB7 ${attribution.activityTitle}` : "";
+  return `${lineagePathLabel(attribution.path)}${activityTitle}`;
+}
 function renderSubmittedTimeline({ state, admittedSubmissions }) {
   const submitted = admittedSubmissions.filter((submission) => submission.status === "submitted" && !state.transcript.some((item) => item.kind === "message" && item.messageId === submission.messageId));
   const messages = submitted.map((submission) => {
-    const attachments = submission.attachments.length > 0 ? dim4(fg6(PALETTE.dimText)(`Attachments: ${submission.attachments.map((attachment) => attachment.filename).join(", ")}`)) : undefined;
-    const header = new StyledText5([
+    const attachments = renderAttachmentSummary(submission.attachments);
+    const header = new StyledText6([
       renderRoleLabel({ label: "You", role: "human" }),
-      dim4(fg6(PALETTE.dimText)(" (CLI)"))
+      dim5(fg7(PALETTE.dimText)(" (CLI)"))
     ]);
     return joinStyled([
       header,
       renderMessageBody({ text: submission.text, role: "human" }),
-      ...attachments ? [new StyledText5([attachments])] : []
+      ...attachments.chunks.length > 0 ? [attachments] : []
     ], `
 `);
   });
@@ -37676,20 +39089,20 @@ function renderSubmittedTimeline({ state, admittedSubmissions }) {
 }
 function renderWorkingIndicator({ frame, elapsedMs, mode }) {
   if (mode === "stopping") {
-    return new StyledText5([
-      fg6(PALETTE.approvalQuestion)("\u23F9"),
-      dim4(fg6(PALETTE.dimText)(` Stopping\u2026  ${formatElapsed(elapsedMs)}`))
+    return new StyledText6([
+      fg7(PALETTE.approvalQuestion)("\u23F9"),
+      dim5(fg7(PALETTE.dimText)(` Stopping\u2026  ${formatElapsed(elapsedMs)}`))
     ]);
   }
   if (mode === "complete" || mode === "cancel") {
-    return new StyledText5([
-      fg6(PALETTE.approvalQuestion)(frame),
-      dim4(fg6(PALETTE.dimText)(` ${lifecycleOperationPresentParticiple(mode)} the session\u2026`))
+    return new StyledText6([
+      fg7(PALETTE.approvalQuestion)(frame),
+      dim5(fg7(PALETTE.dimText)(` ${lifecycleOperationPresentParticiple(mode)} the session\u2026`))
     ]);
   }
-  return new StyledText5([
-    fg6(PALETTE.remyAccent)(frame),
-    dim4(fg6(PALETTE.dimText)(` Working  ${formatElapsed(elapsedMs)}`))
+  return new StyledText6([
+    fg7(PALETTE.remyAccent)(frame),
+    dim5(fg7(PALETTE.dimText)(` Working  ${formatElapsed(elapsedMs)}`))
   ]);
 }
 function lifecycleOperationPresentParticiple(operation) {
@@ -37711,22 +39124,22 @@ function truncate2(value, width) {
 }
 function renderComposerStatus({ admittedSubmissions }) {
   if (admittedSubmissions.length === 0)
-    return new StyledText5([]);
+    return new StyledText6([]);
   const parts = admittedSubmissions.flatMap((submission) => {
     if (submission.status === "submitted")
       return [];
-    const attachments = submission.attachments.length > 0 ? `
-Attachments: ${submission.attachments.map((attachment) => attachment.filename).join(", ")}` : "";
-    return [submission.status === "failed" ? new StyledText5([
-      bold4(fg6(PALETTE.failure)("Failed: ")),
-      fg6(PALETTE.bodyText)(`${submission.error ?? ""}
-${submission.text}${attachments}
-`),
-      dim4(fg6(PALETTE.dimText)("Ctrl+R retries oldest failed submission."))
-    ]) : new StyledText5([
-      fg6(PALETTE.progress)("Admitting: "),
-      fg6(PALETTE.bodyText)(`${submission.text}${attachments}`)
-    ])];
+    const attachments = renderAttachmentSummary(submission.attachments);
+    return [submission.status === "failed" ? joinStyled([
+      new StyledText6([bold4(fg7(PALETTE.failure)("Failed: ")), fg7(PALETTE.bodyText)(submission.error ?? "")]),
+      renderMessageBody({ text: submission.text, role: "human" }),
+      ...attachments.chunks.length > 0 ? [attachments] : [],
+      new StyledText6([dim5(fg7(PALETTE.dimText)("Ctrl+R retries oldest failed submission."))])
+    ], `
+`) : joinStyled([
+      new StyledText6([fg7(PALETTE.progress)("Admitting: "), fg7(PALETTE.bodyText)(submission.text)]),
+      ...attachments.chunks.length > 0 ? [attachments] : []
+    ], `
+`)];
   });
   return joinStyled(parts, `
 
@@ -37737,10 +39150,15 @@ async function createDefaultRenderer3() {
 }
 
 // src/tui/attachments.ts
+import { Buffer as Buffer2 } from "buffer";
 import { randomUUID as randomUUID4 } from "crypto";
-import { writeFile as writeFile3, stat } from "fs/promises";
-import { homedir as homedir2 } from "os";
+import { mkdtemp, open as open4, readdir as readdir2, rm, stat, writeFile as writeFile3 } from "fs/promises";
+import { homedir as homedir2, tmpdir } from "os";
 import { basename as basename3, isAbsolute as isAbsolute2, join as join5, resolve as resolve2 } from "path";
+var directoryArchiveMediaType = "application/gzip";
+var directoryArchiveSuffix = ".tar.gz";
+var maxPortableFilenameBytes = 255;
+var attachmentSizeLimitLabel = `${fileUploadMaxBytes / (1024 * 1024)} MiB`;
 async function readClipboardImage() {
   if (process.platform !== "darwin")
     throw new Error("Clipboard image paste is supported on macOS only.");
@@ -37766,11 +39184,13 @@ async function attachPromptPaths({
   text,
   cwd,
   excludedPaths = [],
-  reserveAndUploadFile: reserveAndUploadFile2
+  selectedPaths = [],
+  reserveAndUploadFile: reserveAndUploadFile2,
+  onUploadStart
 }) {
   const excluded = new Set(excludedPaths);
-  const attachments = [];
-  for (const candidate of promptFilePaths({ text, cwd })) {
+  const pathsToUpload = [];
+  for (const candidate of promptFilePaths({ text, cwd, selectedPaths })) {
     const { filePath } = candidate;
     if (excluded.has(filePath))
       continue;
@@ -37782,27 +39202,168 @@ async function attachPromptPaths({
         continue;
       throw error93;
     }
-    if (!file3.isFile() && candidate.explicit)
-      throw new Error(`Prompt attachment path is not a regular file: ${filePath}`);
-    if (!file3.isFile())
+    if (!file3.isFile() && !file3.isDirectory() && candidate.explicit)
+      throw new Error(`Prompt attachment path is not a regular file or directory: ${filePath}`);
+    if (!file3.isFile() && !file3.isDirectory())
       continue;
+    pathsToUpload.push(filePath);
+  }
+  if (pathsToUpload.length === 0)
+    return [];
+  onUploadStart?.({ filenames: pathsToUpload.map((filePath) => basename3(filePath)) });
+  const attachments = [];
+  for (const filePath of pathsToUpload) {
+    const uploaded = await uploadLocalAttachment({ filePath, reserveAndUploadFile: reserveAndUploadFile2 });
     attachments.push({
       id: randomUUID4(),
-      fileId: await reserveAndUploadFile2({ filePath }),
-      filename: basename3(filePath),
-      sourcePath: filePath
+      ...uploaded
     });
   }
   return attachments;
 }
-function promptFilePaths({ text, cwd }) {
+async function uploadLocalAttachment({
+  filePath,
+  reserveAndUploadFile: reserveAndUploadFile2
+}) {
+  const sourcePath = resolve2(filePath);
+  const source = await stat(sourcePath);
+  if (source.isFile()) {
+    if (source.size > fileUploadMaxBytes)
+      throw oversizedFileAttachmentError(sourcePath);
+    return {
+      fileId: await reserveAndUploadFile2({ filePath: sourcePath }),
+      filename: basename3(sourcePath),
+      sourcePath
+    };
+  }
+  if (!source.isDirectory())
+    throw new Error(`Attachment path is not a regular file or directory: ${sourcePath}`);
+  const archive = await createDirectoryArchive(sourcePath);
+  try {
+    return {
+      fileId: await reserveAndUploadFile2({ filePath: archive.path, mediaType: directoryArchiveMediaType }),
+      filename: archive.filename,
+      sourcePath
+    };
+  } finally {
+    await rm(archive.temporaryDirectory, { recursive: true, force: true });
+  }
+}
+async function createDirectoryArchive(directoryPath) {
+  const rootName = basename3(directoryPath) || "directory";
+  const files = Object.create(null);
+  await collectDirectoryFiles({
+    directoryPath,
+    archivePath: rootName,
+    attachmentDirectoryPath: directoryPath,
+    collectedByteSize: 0,
+    files
+  });
+  if (Object.keys(files).length === 0)
+    throw new Error(`Directory attachment contains no regular files: ${directoryPath}`);
+  const temporaryDirectory = await mkdtemp(join5(tmpdir(), "remy-directory-attachment-"));
+  const filename = directoryArchiveFilename(rootName);
+  const archivePath = join5(temporaryDirectory, filename);
+  try {
+    await Bun.Archive.write(archivePath, files, { compress: "gzip" });
+    if ((await stat(archivePath)).size > fileUploadMaxBytes)
+      throw oversizedDirectoryArchiveError(directoryPath);
+  } catch (error93) {
+    await rm(temporaryDirectory, { recursive: true, force: true });
+    throw error93;
+  }
+  return { path: archivePath, filename, temporaryDirectory };
+}
+async function collectDirectoryFiles({
+  directoryPath,
+  archivePath,
+  attachmentDirectoryPath,
+  collectedByteSize,
+  files
+}) {
+  const entries = await readdir2(directoryPath, { withFileTypes: true });
+  entries.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+  let byteSize = collectedByteSize;
+  for (const entry of entries) {
+    const entryPath = join5(directoryPath, entry.name);
+    const entryArchivePath = `${archivePath}/${entry.name}`;
+    if (entry.isDirectory()) {
+      byteSize = await collectDirectoryFiles({
+        directoryPath: entryPath,
+        archivePath: entryArchivePath,
+        attachmentDirectoryPath,
+        collectedByteSize: byteSize,
+        files
+      });
+      continue;
+    }
+    if (entry.isFile()) {
+      const fileHandle = await open4(entryPath, "r");
+      try {
+        const entryStat = await fileHandle.stat();
+        if (!entryStat.isFile())
+          throw new Error(`Directory attachment contains a non-regular entry: ${entryPath}`);
+        const remainingBytes = fileUploadMaxBytes - byteSize;
+        if (entryStat.size > remainingBytes)
+          throw oversizedDirectoryAttachmentError(attachmentDirectoryPath);
+        const readResult = await readFileHandleWithLimit({
+          fileHandle,
+          initialByteSize: entryStat.size,
+          maxBytes: remainingBytes
+        });
+        if (readResult.status === "limit_exceeded")
+          throw oversizedDirectoryAttachmentError(attachmentDirectoryPath);
+        files[entryArchivePath] = readResult.bytes;
+        byteSize += readResult.bytes.byteLength;
+      } finally {
+        await fileHandle.close();
+      }
+      continue;
+    }
+    if (entry.isSymbolicLink())
+      throw new Error(`Directory attachment contains a symbolic link: ${entryPath}`);
+    throw new Error(`Directory attachment contains a non-regular entry: ${entryPath}`);
+  }
+  return byteSize;
+}
+function oversizedFileAttachmentError(filePath) {
+  return new Error(`Attachment file ${JSON.stringify(filePath)} is larger than ${attachmentSizeLimitLabel}. Choose a file no larger than ${attachmentSizeLimitLabel}.`);
+}
+function oversizedDirectoryAttachmentError(directoryPath) {
+  return new Error(`Attachment directory ${JSON.stringify(directoryPath)} contains more than ${attachmentSizeLimitLabel} of files. Choose fewer or smaller files.`);
+}
+function oversizedDirectoryArchiveError(directoryPath) {
+  return new Error(`Attachment directory ${JSON.stringify(directoryPath)} produces an archive larger than ${attachmentSizeLimitLabel}. Choose fewer or smaller files.`);
+}
+function directoryArchiveFilename(directoryName) {
+  const stem = truncateUtf8(directoryName, maxPortableFilenameBytes - Buffer2.byteLength(directoryArchiveSuffix)) || "directory";
+  return `${stem}${directoryArchiveSuffix}`;
+}
+function truncateUtf8(value, maxBytes) {
+  let result = "";
+  let resultBytes = 0;
+  for (const character of value) {
+    const characterBytes = Buffer2.byteLength(character);
+    if (resultBytes + characterBytes > maxBytes)
+      break;
+    result += character;
+    resultBytes += characterBytes;
+  }
+  return result;
+}
+function promptFilePaths({ text, cwd, selectedPaths }) {
   const paths = new Map;
+  for (const selectedPath of selectedPaths)
+    paths.set(isAbsolute2(selectedPath) ? selectedPath : resolve2(cwd, selectedPath), true);
   for (const rawToken of text.split(/\s+/)) {
     const token = rawToken.replace(/^[([{'"`]+/, "").replace(/[),.;:!?\]}"`]+$/, "");
     const pathText = token.startsWith("@") ? token.slice(1) : token;
     if (!pathText)
       continue;
     const explicit = token.startsWith("@") || pathText.startsWith("./") || pathText.startsWith("../") || isAbsolute2(pathText) || pathText.startsWith("~/");
+    const pathShaped = explicit || pathText.includes("/") || pathText.includes("\\") || pathText.includes(".");
+    if (!pathShaped)
+      continue;
     const expandedPath = pathText.startsWith("~/") ? join5(homedir2(), pathText.slice(2)) : pathText;
     const filePath = isAbsolute2(expandedPath) ? expandedPath : resolve2(cwd, expandedPath);
     paths.set(filePath, paths.get(filePath) || explicit);
@@ -37825,7 +39386,7 @@ function isPng(bytes) {
 }
 
 // src/tui/remy-splash.ts
-import { bold as bold5, BoxRenderable as BoxRenderable5, fg as fg7, NativeImage, StyledText as StyledText6, TextRenderable as TextRenderable5, bg as bg5 } from "@opentui/core";
+import { bold as bold5, BoxRenderable as BoxRenderable5, fg as fg8, NativeImage, StyledText as StyledText7, TextRenderable as TextRenderable5, bg as bg5 } from "@opentui/core";
 // src/tui/remy-mark.ts
 var remyPixelFieldSource = new URL("../assets/remy-pixel-field.png", import.meta.url);
 function shouldShowRemySplash({ width, height }) {
@@ -37844,7 +39405,7 @@ var compactMarkRows = 9;
 var compactMinWidth = 48;
 var compactMinHeight = 20;
 var markBrightnessGain = 4.2;
-var remyCliVersion = "1.12.0";
+var remyCliVersion = "1.14.0";
 async function showRemySplash({
   createRenderer = createRemyRenderer,
   durationMs = splashDurationMs,
@@ -37902,7 +39463,7 @@ async function showRemySplash({
     });
     const approvalCopy = new TextRenderable5(renderer, { content: "" });
     const metadata = new TextRenderable5(renderer, {
-      content: new StyledText6([fg7(PALETTE.dimText)(`v${remyCliVersion} \xB7 Tela\xAE`)])
+      content: new StyledText7([fg8(PALETTE.dimText)(`v${remyCliVersion} \xB7 Tela\xAE`)])
     });
     const field = await loadPixelFieldUntilAbort({ signal });
     if (!field || signal?.aborted)
@@ -38000,32 +39561,32 @@ function createSplashController({
   };
 }
 function renderBootstrapActions({ state, frame }) {
-  return new StyledText6([
+  return new StyledText7([
     actionText({ label: state.authenticatedEmail ? `Authenticated as ${state.authenticatedEmail}` : "Checking authentication...", status: state.authentication, frame }),
-    fg7(PALETTE.dimText)(`
+    fg8(PALETTE.dimText)(`
 `),
     actionText({ label: "Load sessions", status: state.loadingSessions, frame })
   ]);
 }
 function actionText({ label, status, frame }) {
   if (status === "complete")
-    return fg7(PALETTE.statusCompleted)(`\u2713 ${label === "Load sessions" ? "Sessions loaded!" : label}`);
+    return fg8(PALETTE.statusCompleted)(`\u2713 ${label === "Load sessions" ? "Sessions loaded!" : label}`);
   if (status === "needed")
-    return fg7(PALETTE.approvalQuestion)("\u26A0 Authentication needed");
+    return fg8(PALETTE.approvalQuestion)("\u26A0 Authentication needed");
   if (status === "active")
-    return fg7(PALETTE.progress)(`${splashSpinnerFrames[frame % splashSpinnerFrames.length]} ${label === "Load sessions" ? "Loading sessions..." : label}`);
-  return fg7(PALETTE.dimText)(`\u25CB ${label}`);
+    return fg8(PALETTE.progress)(`${splashSpinnerFrames[frame % splashSpinnerFrames.length]} ${label === "Load sessions" ? "Loading sessions..." : label}`);
+  return fg8(PALETTE.dimText)(`\u25CB ${label}`);
 }
 function renderAuthenticationBand({ state, frame }) {
   if (!state.waitingForAuthentication)
-    return new StyledText6([]);
+    return new StyledText7([]);
   const spinner = splashSpinnerFrames[frame % splashSpinnerFrames.length];
-  const url3 = state.verificationUrl ? [fg7(PALETTE.dimText)(`
-Verification URL: `), bold5(fg7(PALETTE.humanAccent)(state.verificationUrl))] : [];
-  return new StyledText6([
-    fg7(PALETTE.bodyText)("Continue authentication in your browser."),
+  const url3 = state.verificationUrl ? [fg8(PALETTE.dimText)(`
+Verification URL: `), bold5(fg8(PALETTE.humanAccent)(state.verificationUrl))] : [];
+  return new StyledText7([
+    fg8(PALETTE.bodyText)("Continue authentication in your browser."),
     ...url3,
-    fg7(PALETTE.dimText)(`
+    fg8(PALETTE.dimText)(`
 ${spinner} Waiting for approval \xB7 q / esc cancel`)
   ]);
 }
@@ -38100,7 +39661,7 @@ function renderMark(field, frame, rows = markRows) {
     const flush = () => {
       if (runLength === 0)
         return;
-      chunks.push(fg7(grey(runTop))(bg5(grey(runBottom))(upperHalfBlock.repeat(runLength))));
+      chunks.push(fg8(grey(runTop))(bg5(grey(runBottom))(upperHalfBlock.repeat(runLength))));
       runLength = 0;
     };
     for (let column = 0;column < columns; column++) {
@@ -38117,10 +39678,10 @@ function renderMark(field, frame, rows = markRows) {
     }
     flush();
     if (row < rows - 1)
-      chunks.push(fg7("#000000")(`
+      chunks.push(fg8("#000000")(`
 `));
   }
-  return new StyledText6(chunks);
+  return new StyledText7(chunks);
 }
 function shimmerBrightness(field, column, sampleRow, columns, sampleRows, center) {
   const x0 = Math.floor(column / columns * field.width);
@@ -38140,8 +39701,8 @@ function grey(value) {
   return `#${hex5}${hex5}${hex5}`;
 }
 function renderSplashTitle() {
-  return new StyledText6([
-    bold5(fg7(PALETTE.bodyText)("Remy CLI"))
+  return new StyledText7([
+    bold5(fg8(PALETTE.bodyText)("Remy CLI"))
   ]);
 }
 
@@ -38476,6 +40037,9 @@ function createRepositoryLister({ client }) {
 function createRepositorySuggester({ client }) {
   return async (input) => await suggestRemoteRepositories({ client, input });
 }
+function createBranchSuggester({ client }) {
+  return async (input) => await suggestRemoteBranches({ client, input });
+}
 function parseOptionalStringFlag(value, name) {
   if (value === undefined)
     return;
@@ -38619,48 +40183,98 @@ async function dashboard({
   const openDashboardTui = dependencies.openDashboardTui ?? createDashboardTui;
   const pages = [initialSessions];
   let pageIndex = 0;
-  let loadingPage;
+  let filters = { statuses: [], creators: [] };
+  let authors;
+  let activeDashboardGeneration = 0;
   function holdTransitionScreen() {
     showRemyTransitionScreen({ write: (chunk) => dependencies.output.writeStdout(chunk) });
   }
-  async function loadDashboardPage({ target, signal }) {
-    if (loadingPage)
-      return await loadingPage;
-    loadingPage = (async () => {
-      if (target === "current") {
-        const after = pageIndex > 0 ? pages[pageIndex - 1]?.nextCursor ?? undefined : undefined;
-        const refreshed = toDashboardPage(await operations.listSessions({
+  function createDashboardPageLoader({ generation }) {
+    const loadingPages = new Map;
+    let pageLoadTail = Promise.resolve();
+    return async (input) => {
+      const requestKey = "filters" in input ? `filters:${JSON.stringify(input.filters)}` : input.target;
+      const matchingPageLoad = loadingPages.get(requestKey);
+      if (matchingPageLoad)
+        return await matchingPageLoad;
+      const pendingPageLoad = pageLoadTail;
+      const pageLoad = pendingPageLoad.then(async () => {
+        if (generation !== activeDashboardGeneration)
+          return { ...pages[pageIndex], canGoPrevious: pageIndex > 0 };
+        if ("filters" in input) {
+          const nextFilters = input.filters;
+          const first = toDashboardPage(await operations.listSessions({
+            client: operations.client,
+            limit: 20,
+            ...nextFilters.statuses.length > 0 ? { statuses: nextFilters.statuses } : {},
+            ...nextFilters.creators.length > 0 ? { creatorUserIds: nextFilters.creators.map((creator) => creator.id) } : {},
+            signal: input.signal
+          }));
+          if (generation !== activeDashboardGeneration)
+            return first;
+          filters = nextFilters;
+          pages.splice(0, pages.length, first);
+          pageIndex = 0;
+          return first;
+        }
+        const { target, signal } = input;
+        if (target === "current") {
+          const after = pageIndex > 0 ? pages[pageIndex - 1]?.nextCursor ?? undefined : undefined;
+          const refreshed = toDashboardPage(await operations.listSessions({
+            client: operations.client,
+            limit: 20,
+            after,
+            ...filters.statuses.length > 0 ? { statuses: filters.statuses } : {},
+            ...filters.creators.length > 0 ? { creatorUserIds: filters.creators.map((creator) => creator.id) } : {},
+            signal
+          }));
+          if (generation !== activeDashboardGeneration)
+            return refreshed;
+          pages.splice(pageIndex, pages.length - pageIndex, refreshed);
+          return { ...refreshed, canGoPrevious: pageIndex > 0 };
+        }
+        if (target === "previous") {
+          pageIndex = Math.max(0, pageIndex - 1);
+          return { ...pages[pageIndex], canGoPrevious: pageIndex > 0 };
+        }
+        const current = pages[pageIndex];
+        if (!current.hasMore || !current.nextCursor)
+          return { ...current, canGoPrevious: pageIndex > 0 };
+        const next = toDashboardPage(await operations.listSessions({
           client: operations.client,
           limit: 20,
-          after,
+          after: current.nextCursor,
+          ...filters.statuses.length > 0 ? { statuses: filters.statuses } : {},
+          ...filters.creators.length > 0 ? { creatorUserIds: filters.creators.map((creator) => creator.id) } : {},
           signal
         }));
-        pages.splice(pageIndex, pages.length - pageIndex, refreshed);
-        return { ...refreshed, canGoPrevious: pageIndex > 0 };
-      }
-      if (target === "previous") {
-        pageIndex = Math.max(0, pageIndex - 1);
-        return { ...pages[pageIndex], canGoPrevious: pageIndex > 0 };
+        if (generation !== activeDashboardGeneration)
+          return next;
+        pages.splice(pageIndex + 1);
+        pages.push(next);
+        pageIndex += 1;
+        return { ...next, canGoPrevious: pageIndex > 0 };
+      });
+      loadingPages.set(requestKey, pageLoad);
+      pageLoadTail = pageLoad.then(() => {
+        return;
+      }, () => {
+        return;
+      });
+      try {
+        return await pageLoad;
+      } finally {
+        if (loadingPages.get(requestKey) === pageLoad)
+          loadingPages.delete(requestKey);
       }
-      const current = pages[pageIndex];
-      if (!current.hasMore || !current.nextCursor)
-        return { ...current, canGoPrevious: pageIndex > 0 };
-      const next = toDashboardPage(await operations.listSessions({
-        client: operations.client,
-        limit: 20,
-        after: current.nextCursor,
-        signal
-      }));
-      pages.splice(pageIndex + 1);
-      pages.push(next);
-      pageIndex += 1;
-      return { ...next, canGoPrevious: pageIndex > 0 };
-    })();
-    try {
-      return await loadingPage;
-    } finally {
-      loadingPage = undefined;
-    }
+    };
+  }
+  async function loadDashboardAuthors() {
+    if (authors)
+      return authors;
+    const loadedAuthors = await collectAllUsers({ listUsers: operations.listUsers, signal: dependencies.abortSignal });
+    authors = loadedAuthors;
+    return loadedAuthors;
   }
   let firstOpen = true;
   holdTransitionScreen();
@@ -38669,17 +40283,30 @@ async function dashboard({
       pages.splice(0, pages.length, toDashboardPage(await operations.listSessions({
         client: operations.client,
         limit: 20,
+        ...filters.statuses.length > 0 ? { statuses: filters.statuses } : {},
+        ...filters.creators.length > 0 ? { creatorUserIds: filters.creators.map((creator) => creator.id) } : {},
         signal: dependencies.abortSignal
       })));
       pageIndex = 0;
     }
     firstOpen = false;
+    const dashboardGeneration = ++activeDashboardGeneration;
+    const loadDashboardPage = createDashboardPageLoader({ generation: dashboardGeneration });
     const action = await renderRemyView({
       open: async () => await openDashboardTui({
         initialPage: pages[0],
+        initialFilters: filters,
+        loadAuthors: loadDashboardAuthors,
         loadPage: loadDashboardPage
       }),
-      waitForAction: async (dashboardTui) => await awaitWithAbort({ value: dashboardTui.waitForAction(), abortSignal: dependencies.abortSignal })
+      waitForAction: async (dashboardTui) => {
+        try {
+          return await awaitWithAbort({ value: dashboardTui.waitForAction(), abortSignal: dependencies.abortSignal });
+        } finally {
+          if (activeDashboardGeneration === dashboardGeneration)
+            activeDashboardGeneration += 1;
+        }
+      }
     });
     if (!action)
       return 0;
@@ -38722,12 +40349,12 @@ async function prepareDashboardBootstrap({
     return;
   });
   onLoadingSessions?.();
-  const initialSessions = toDashboardPage(await resolvedOperations.listSessions({
+  const initialSessionPage = await resolvedOperations.listSessions({
     client: resolvedOperations.client,
     limit: 20,
     signal: dependencies.abortSignal
-  }));
-  return { operations: resolvedOperations, repositories, initialSessions };
+  });
+  return { operations: resolvedOperations, repositories, initialSessions: toDashboardPage(initialSessionPage) };
 }
 async function prepareDashboardWithStartupSplash({
   dependencies,
@@ -38918,11 +40545,15 @@ async function createNewSession({
     throw new Error("All selected repositories must belong to the same GitHub installation.");
   const fileIds = [];
   for (const attachment of command.attachments) {
-    fileIds.push(await operations.reserveAndUploadFile({
-      client: operations.client,
+    const uploaded = await uploadLocalAttachment({
       filePath: attachment,
-      idempotencyKey: randomUUID5()
-    }));
+      reserveAndUploadFile: async (input) => await operations.reserveAndUploadFile({
+        ...input,
+        client: operations.client,
+        idempotencyKey: randomUUID5()
+      })
+    });
+    fileIds.push(uploaded.fileId);
   }
   const created = await operations.createCodexSession({
     client: operations.client,
@@ -38996,6 +40627,7 @@ async function createFromTuiDraft({
     input: {
       installationId: draft.githubInstallationId,
       repositoryIds: draft.repositories.map((repository) => repository.id),
+      repositoryBranchOverrides: draft.repositoryBranchOverrides ?? [],
       prompt: draft.prompt,
       fileIds: draft.attachments.map((attachment) => attachment.fileId),
       model: draft.model,
@@ -39018,10 +40650,11 @@ async function openTuiNewSessionWizard({
       repositories,
       reloadRepositories,
       suggestRepositories: operations.suggestRepositories,
+      suggestBranches: operations.suggestBranches,
       initialDraft,
       initialError,
       readClipboardImage,
-      savePastedImage: async (input) => await writePastedImage({ ...input, temporaryDirectory: tmpdir() }),
+      savePastedImage: async (input) => await writePastedImage({ ...input, temporaryDirectory: tmpdir2() }),
       attachPromptPaths: async (input) => await uploadPromptPaths({ operations, ...input })
     }),
     waitForAction: async (wizard) => await awaitWithAbort({ value: wizard.waitForDraft(), abortSignal: dependencies.abortSignal })
@@ -39030,15 +40663,20 @@ async function openTuiNewSessionWizard({
 async function uploadPromptPaths({
   operations,
   text,
-  excludedPaths
+  excludedPaths,
+  selectedPaths,
+  onUploadStart
 }) {
   return await attachPromptPaths({
     text,
     excludedPaths,
+    selectedPaths,
+    onUploadStart,
     cwd: process.cwd(),
-    reserveAndUploadFile: async ({ filePath }) => await operations.reserveAndUploadFile({
+    reserveAndUploadFile: async ({ filePath, mediaType }) => await operations.reserveAndUploadFile({
       client: operations.client,
       filePath,
+      ...mediaType ? { mediaType } : {},
       idempotencyKey: randomUUID5()
     })
   });
@@ -39096,7 +40734,7 @@ async function runAttachedSession({
     ...activeMessageId ? { activeMessageId } : {},
     environment: dependencies.environment,
     getSession: async ({ sessionId: id }) => await operations.getSession({ client: operations.client, sessionId: id }),
-    listSessionEvents: async ({ sessionId: id, limit, after }) => await operations.listSessionEvents({ client: operations.client, sessionId: id, limit, after }),
+    listSessionEvents: async ({ sessionId: id, limit, after, signal }) => await operations.listSessionEvents({ client: operations.client, sessionId: id, limit, after, signal }),
     openEventStream: ({ sessionId: id, lastRetainedEventId, signal, onSynchronized }) => operations.streamSessionEvents({ client: operations.client, sessionId: id, lastRetainedEventId, signal, onSynchronized })
   });
   const interactive = !noTui && !json3 && isInteractiveTerminal(dependencies);
@@ -39135,8 +40773,14 @@ async function runAttachedSession({
       });
     }
     const startPromise = controller.start(start);
-    await Promise.race([controller.waitUntilReady(), startPromise]);
+    await Promise.race([
+      controller.waitUntilReady(),
+      startPromise,
+      ...aborted3 ? [aborted3] : []
+    ]);
     if (interactive) {
+      if (dependencies.abortSignal?.aborted)
+        throw dependencies.abortSignal.reason ?? new Error("interrupted");
       const openSessionTui = dependencies.openSessionTui ?? createSessionTui;
       let composerSnapshot;
       const holdTransitionScreen = () => showRemyTransitionScreen({ write: (chunk) => dependencies.output.writeStdout(chunk) });
@@ -39173,7 +40817,7 @@ async function runAttachedSession({
               controller.updateDetail(detail);
             },
             readClipboardImage,
-            savePastedImage: async (input) => await writePastedImage({ ...input, temporaryDirectory: tmpdir() }),
+            savePastedImage: async (input) => await writePastedImage({ ...input, temporaryDirectory: tmpdir2() }),
             attachPromptPaths: async (input) => await uploadPromptPaths({ operations, ...input })
           }),
           waitForAction: async (tui) => await Promise.race([tui.waitForAction(), aborted3])
@@ -39282,7 +40926,9 @@ async function createSessionOperations(dependencies, { onAuthenticated } = {}) {
     return {
       client: dependencies.sessionClient,
       listRepositories: dependencies.listRepositories ?? (async () => await Promise.reject(new Error("Missing remote repository operation."))),
+      listUsers: dependencies.listUsers ?? (async (input) => await listRemoteUsers({ client: dependencies.sessionClient, ...input })),
       suggestRepositories: dependencies.suggestRepositories ?? (async () => await Promise.reject(new Error("Missing remote repository suggestions operation."))),
+      suggestBranches: dependencies.suggestBranches ?? (async () => await Promise.reject(new Error("Missing remote branch suggestions operation."))),
       reserveAndUploadFile: dependencies.reserveAndUploadFile ?? reserveAndUploadFile,
       createCodexSession: dependencies.createCodexSession ?? createCodexSession,
       appendSessionMessage: dependencies.appendSessionMessage ?? appendSessionMessage,
@@ -39300,7 +40946,9 @@ async function createSessionOperations(dependencies, { onAuthenticated } = {}) {
   return {
     client,
     listRepositories: dependencies.listRepositories ?? createRepositoryLister({ client }),
+    listUsers: dependencies.listUsers ?? (async (input) => await listRemoteUsers({ client, ...input })),
     suggestRepositories: dependencies.suggestRepositories ?? createRepositorySuggester({ client }),
+    suggestBranches: dependencies.suggestBranches ?? createBranchSuggester({ client }),
     reserveAndUploadFile: dependencies.reserveAndUploadFile ?? reserveAndUploadFile,
     createCodexSession: dependencies.createCodexSession ?? createCodexSession,
     appendSessionMessage: dependencies.appendSessionMessage ?? appendSessionMessage,
@@ -39342,6 +40990,20 @@ async function collectAllRepositories({
     after = page.nextCursor;
   }
 }
+async function collectAllUsers({
+  listUsers,
+  signal
+}) {
+  const users = [];
+  let after;
+  while (true) {
+    const page = await listUsers({ limit: 100, after, signal });
+    users.push(...page.data);
+    if (!page.hasMore || !page.nextCursor)
+      return users;
+    after = page.nextCursor;
+  }
+}
 function resolveSessionCachePathForCommand({ dependencies, sessionId }) {
   const stateBase = dependencies.environment.XDG_STATE_HOME ?? (dependencies.environment.HOME ? join6(dependencies.environment.HOME, ".local/state") : undefined);
   if (!stateBase)
@@ -39468,7 +41130,7 @@ Options:
   --installation <id>                     Select a GitHub installation
   --model <name>                          Select an agent model
   --reasoning-effort <low|medium|high|xhigh> Select agent reasoning effort
-  --attach <path>                         Upload a file; repeat for more attachments
+  --attach <path>                         Upload a file or directory (20 MiB max); repeat as needed
   --no-tui                                Do not open the interactive terminal view
   --json                                  Write session updates as JSON
   --help, -h                              Show this help
@@ -39617,7 +41279,7 @@ async function removeCommittedTokenRecoveryArtifacts({
   const directory = dirname6(tokenPath);
   let entries;
   try {
-    entries = await readdir2(directory);
+    entries = await readdir3(directory);
   } catch (error93) {
     if (isMissingFileError3(error93))
       return;