diff --git a/scripts/task-launch-e2e-config.mjs b/scripts/task-launch-e2e-config.mjs
new file mode 100644
index 0000000..ab83b69
--- /dev/null
+++ b/scripts/task-launch-e2e-config.mjs
@@ -0,0 +1,123 @@
+const DEFAULT_API_BASE_URL_BY_PROTOCOL = {
+  anthropic: "https://api.anthropic.com",
+  openai: "https://api.openai.com/v1",
+  azure: "",
+  google: "https://generativelanguage.googleapis.com",
+  ollama: "https://ollama.com",
+  senseaudio: "https://api.senseaudio.cn",
+};
+
+const DEFAULT_API_MODEL_BY_PROTOCOL = {
+  anthropic: "claude-sonnet-4-5",
+  openai: "gpt-4o",
+  azure: "gpt-4o",
+  google: "gemini-2.0-flash",
+  ollama: "gemma3:4b",
+  senseaudio: "senseaudio-s2",
+};
+
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function parseMaxTokens(value) {
+  const parsed = Number(nonEmpty(value));
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : 8192;
+}
+
+function parseJsonObject(value) {
+  const raw = nonEmpty(value);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? parsed
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function readByokApiKey(env) {
+  const direct = nonEmpty(env.DEVLOG_E2E_API_KEY);
+  if (direct) return direct;
+
+  const envVarName =
+    nonEmpty(env.DEVLOG_E2E_API_KEY_ENV_VAR) ??
+    nonEmpty(env.DEVLOG_E2E_AGENT_API_KEY_ENV_VAR) ??
+    "ANTHROPIC_API_KEY";
+  return nonEmpty(env[envVarName]);
+}
+
+export function buildTaskLaunchRuntimePayload(env = process.env) {
+  const mode = nonEmpty(env.DEVLOG_E2E_AUTH_MODE) ?? "local-cli";
+  const model = nonEmpty(env.DEVLOG_E2E_AGENT_MODEL);
+
+  if (mode === "agent-api-key") {
+    return {
+      session_auth_mode: "agent-api-key",
+      agent_api_key_env_var:
+        nonEmpty(env.DEVLOG_E2E_AGENT_API_KEY_ENV_VAR) ?? "ANTHROPIC_API_KEY",
+      agent_model: model ?? "claude-sonnet-4-6",
+    };
+  }
+
+  if (mode === "anthropic-api-key") {
+    const protocol = nonEmpty(env.DEVLOG_E2E_API_PROTOCOL) ?? "anthropic";
+    const apiKey = readByokApiKey(env);
+    return {
+      session_auth_mode: "anthropic-api-key",
+      agent_api_protocol: protocol,
+      agent_model:
+        model ??
+        DEFAULT_API_MODEL_BY_PROTOCOL[protocol] ??
+        "claude-sonnet-4-5",
+      agent_base_url:
+        nonEmpty(env.DEVLOG_E2E_AGENT_BASE_URL) ??
+        DEFAULT_API_BASE_URL_BY_PROTOCOL[protocol] ??
+        "",
+      agent_api_version: nonEmpty(env.DEVLOG_E2E_AGENT_API_VERSION) ?? "",
+      agent_max_tokens: parseMaxTokens(env.DEVLOG_E2E_AGENT_MAX_TOKENS),
+      ...(apiKey ? { anthropic_api_key: apiKey } : {}),
+    };
+  }
+
+  const localCliEnv = parseJsonObject(env.DEVLOG_E2E_LOCAL_CLI_ENV_JSON);
+  return {
+    session_auth_mode: "local-cli",
+    local_cli_agent_id:
+      nonEmpty(env.DEVLOG_E2E_LOCAL_CLI_AGENT_ID) ??
+      nonEmpty(env.DEVLOG_E2E_LOCAL_CLI_AGENT) ??
+      "claude",
+    agent_model: model ?? "default",
+    agent_reasoning: nonEmpty(env.DEVLOG_E2E_AGENT_REASONING) ?? "medium",
+    ...(localCliEnv ? { local_cli_agent_env: localCliEnv } : {}),
+  };
+}
+
+export function describeTaskLaunchRuntimePayload(payload) {
+  if (payload.session_auth_mode === "anthropic-api-key") {
+    return [
+      "mode=anthropic-api-key",
+      `protocol=${payload.agent_api_protocol}`,
+      `model=${payload.agent_model}`,
+      `baseUrl=${payload.agent_base_url}`,
+      `key=${payload.anthropic_api_key ? "provided" : "missing"}`,
+    ].join(" ");
+  }
+
+  if (payload.session_auth_mode === "agent-api-key") {
+    return [
+      "mode=agent-api-key",
+      `keyEnv=${payload.agent_api_key_env_var ? "configured" : "missing"}`,
+      `model=${payload.agent_model}`,
+    ].join(" ");
+  }
+
+  return [
+    "mode=local-cli",
+    `agent=${payload.local_cli_agent_id}`,
+    `model=${payload.agent_model}`,
+    `reasoning=${payload.agent_reasoning}`,
+  ].join(" ");
+}
diff --git a/scripts/task-launch-e2e.mjs b/scripts/task-launch-e2e.mjs
index 7784870..839f0dd 100644
--- a/scripts/task-launch-e2e.mjs
+++ b/scripts/task-launch-e2e.mjs
@@ -1,5 +1,10 @@
 #!/usr/bin/env node
 
+import {
+  buildTaskLaunchRuntimePayload,
+  describeTaskLaunchRuntimePayload,
+} from "./task-launch-e2e-config.mjs";
+
 const baseUrl = (process.env.DEVLOG_E2E_BASE_URL ?? "http://localhost:3000")
   .replace(/\/$/, "");
 const projectId = process.env.DEVLOG_E2E_PROJECT_ID ?? "devlog";
@@ -8,10 +13,7 @@ const codingAgentId =
   process.env.DEVLOG_E2E_CODING_AGENT_ID ?? "general-coding-agent";
 const agentTeamId =
   process.env.DEVLOG_E2E_AGENT_TEAM_ID ?? "implementation-review-team";
-const sessionAuthMode =
-  process.env.DEVLOG_E2E_AUTH_MODE ?? "backend-oauth";
-const agentApiKeyEnvVar =
-  process.env.DEVLOG_E2E_AGENT_API_KEY_ENV_VAR ?? "ANTHROPIC_API_KEY";
+const runtimePayload = buildTaskLaunchRuntimePayload(process.env);
 
 const startedAt = Date.now();
 const marker = `DEVLOG_E2E_${Date.now()}`;
@@ -92,6 +94,7 @@ async function watchSse(sessionId, evidence, signal) {
 
 async function main() {
   console.log(`DevLog task launch E2E against ${baseUrl} project=${projectId}`);
+  console.log(`runtime ${describeTaskLaunchRuntimePayload(runtimePayload)}`);
 
   const task = await request("/api/tasks", {
     method: "POST",
@@ -114,8 +117,7 @@ async function main() {
     body: JSON.stringify({
       coding_agent_id: codingAgentId,
       agent_team_id: agentTeamId,
-      session_auth_mode: sessionAuthMode,
-      agent_api_key_env_var: agentApiKeyEnvVar,
+      ...runtimePayload,
     }),
   });
   const session = launched.session;
@@ -147,6 +149,7 @@ async function main() {
         "Human follow-up E2E instruction.",
         `Reply with exactly ${followupAck}.`,
       ].join(" "),
+      ...runtimePayload,
     }),
   });
   if (!("queue_length" in patched) || !("is_processing" in patched)) {
@@ -164,7 +167,7 @@ async function main() {
       .join("\n");
     if (/Failed to authenticate|API Error/i.test(assistantText)) {
       throw new Error(
-        "Claude session authentication failed. Use backend OAuth on a logged-in Claude Code runtime or set DEVLOG_E2E_AUTH_MODE=agent-api-key with a backend env var such as ANTHROPIC_API_KEY.",
+        "Session authentication failed. Use DEVLOG_E2E_AUTH_MODE=local-cli with a usable local coding agent, DEVLOG_E2E_AUTH_MODE=anthropic-api-key with DEVLOG_E2E_API_KEY, or explicitly use DEVLOG_E2E_AUTH_MODE=agent-api-key with a backend env var such as ANTHROPIC_API_KEY.",
       );
     }
     if (assistantText.includes(followupAck)) return rows;
diff --git a/src/app/api/sessions/[id]/stream/route.ts b/src/app/api/sessions/[id]/stream/route.ts
index a5962e7..acb80af 100644
--- a/src/app/api/sessions/[id]/stream/route.ts
+++ b/src/app/api/sessions/[id]/stream/route.ts
@@ -1,72 +1,137 @@
 import { NextRequest } from "next/server";
 import { getDb } from "@/core/db";
+import { filterBufferedReplayDuplicates } from "@/core/session-stream-dedupe";
+import { buildSessionStreamReplayEvents } from "@/core/session-stream-replay";
 import { streamManager } from "@/core/stream-manager";
-import type { ChatMessage } from "@/core/types-dashboard";
+import { resolveProjectId } from "@/lib/api-utils";
+import type { ChatStreamEvent } from "@/core/stream-manager";
 
 export async function GET(
   _req: NextRequest,
   { params }: { params: Promise<{ id: string }> }
 ) {
   const { id } = await params;
+  const projectId = resolveProjectId(_req);
+  const db = getDb();
+  const ownedSession = db
+    .prepare("SELECT 1 FROM sessions WHERE id = ? AND project_id = ? LIMIT 1")
+    .get(id, projectId);
+
+  if (!ownedSession) {
+    return new Response("Forbidden", { status: 403 });
+  }
 
   const encoder = new TextEncoder();
+  let cleanupStream = () => {};
   const stream = new ReadableStream({
     start(controller) {
-      // Replay persisted messages so the frontend catches up
-      try {
-        const db = getDb();
-        const messages = db
-          .prepare(
-            "SELECT * FROM session_messages WHERE session_id = ? ORDER BY id ASC"
-          )
-          .all(id) as ChatMessage[];
-
-        for (const msg of messages) {
-          controller.enqueue(
-            encoder.encode(
-              `data: ${JSON.stringify({ type: "message", role: msg.role, content: msg.content })}\n\n`
-            )
-          );
-        }
-      } catch {
-        // DB might not be ready
-      }
+      const liveEventBuffer: ChatStreamEvent[] = [];
+      let bufferingLiveEvents = true;
+      let heartbeat: ReturnType<typeof setInterval> | undefined;
+      let unsubscribe = () => {};
+      let cleanedUp = false;
+      let abortHandler: (() => void) | undefined;
 
-      // Signal replay complete
-      controller.enqueue(
-        encoder.encode(`data: ${JSON.stringify({ type: "sync" })}\n\n`)
-      );
-
-      // Subscribe to live events
-      const unsubscribe = streamManager.subscribe(id, (event) => {
-        try {
-          controller.enqueue(
-            encoder.encode(`data: ${JSON.stringify(event)}\n\n`)
-          );
-        } catch {
-          unsubscribe();
+      const cleanup = () => {
+        if (cleanedUp) {
+          return;
         }
-      });
+        cleanedUp = true;
+        if (heartbeat) {
+          clearInterval(heartbeat);
+        }
+        if (abortHandler) {
+          _req.signal.removeEventListener("abort", abortHandler);
+        }
+        unsubscribe();
+      };
+      cleanupStream = cleanup;
 
-      // Heartbeat every 15s
-      const heartbeat = setInterval(() => {
+      const safeEnqueue = (chunk: string) => {
         try {
-          controller.enqueue(encoder.encode(`: heartbeat\n\n`));
+          controller.enqueue(encoder.encode(chunk));
+          return true;
         } catch {
-          clearInterval(heartbeat);
-          unsubscribe();
+          cleanup();
+          return false;
         }
-      }, 15000);
+      };
 
-      _req.signal.addEventListener("abort", () => {
-        clearInterval(heartbeat);
-        unsubscribe();
+      const enqueueEvent = (event: ChatStreamEvent) => {
+        return safeEnqueue(`data: ${JSON.stringify(event)}\n\n`);
+      };
+
+      abortHandler = () => {
+        cleanup();
         try {
           controller.close();
         } catch {
           // already closed
         }
+      };
+      _req.signal.addEventListener("abort", abortHandler);
+
+      if (_req.signal.aborted) {
+        cleanup();
+        return;
+      }
+
+      // Subscribe before replay so live events are not lost during catch-up.
+      unsubscribe = streamManager.subscribe(id, (event) => {
+        if (bufferingLiveEvents) {
+          liveEventBuffer.push(event);
+          return;
+        }
+
+        enqueueEvent(event);
       });
+
+      if (_req.signal.aborted) {
+        cleanup();
+        return;
+      }
+
+      // Replay persisted messages so the frontend catches up
+      let replayEvents: ChatStreamEvent[] = [];
+      try {
+        replayEvents = buildSessionStreamReplayEvents(db, id);
+
+        for (const event of replayEvents) {
+          if (!enqueueEvent(event)) {
+            return;
+          }
+        }
+      } catch (error) {
+        // DB might not be ready
+        console.warn("Failed to replay session stream events", {
+          sessionId: id,
+          error,
+        });
+      }
+
+      // Signal replay complete
+      if (!safeEnqueue(`data: ${JSON.stringify({ type: "sync" })}\n\n`)) {
+        return;
+      }
+
+      const eventsToDrain = filterBufferedReplayDuplicates(
+        replayEvents,
+        liveEventBuffer,
+      );
+      for (const event of eventsToDrain) {
+        if (!enqueueEvent(event)) {
+          return;
+        }
+      }
+      bufferingLiveEvents = false;
+
+      // Heartbeat every 15s
+      heartbeat = setInterval(() => {
+        safeEnqueue(": heartbeat\n\n");
+      }, 15000);
+    },
+    cancel() {
+      cleanupStream();
     },
   });
 
diff --git a/src/app/api/sessions/route.ts b/src/app/api/sessions/route.ts
index 94370d8..53a1437 100644
--- a/src/app/api/sessions/route.ts
+++ b/src/app/api/sessions/route.ts
@@ -14,8 +14,13 @@ import {
 import {
   buildSessionRuntimeAuthInstructions,
   getSessionRuntimeAuthInputFromPayload,
+  getPersistedSessionBaseUrl,
   resolveSessionRuntimeAuthConfig,
 } from "@/core/session-runtime-auth";
+import {
+  markSessionFailedAndReleaseLinkedTask,
+  validateTaskSessionLaunch,
+} from "@/core/task-lifecycle";
 import type { Session } from "@/core/types-dashboard";
 
 export async function GET(req: NextRequest) {
@@ -37,35 +42,60 @@ export async function POST(req: NextRequest) {
     body = {};
   }
 
+  const bodyRecord =
+    body && typeof body === "object" && !Array.isArray(body)
+      ? (body as Record<string, unknown>)
+      : {};
   const {
     task_id,
     worktree_name,
     worktree_path,
     branch_name,
     prompt,
-  } = body as Record<string, unknown>;
-  if (!prompt) {
+  } = bodyRecord;
+  if (typeof prompt !== "string" || !prompt.trim()) {
     return NextResponse.json({ error: "prompt is required" }, { status: 400 });
   }
-  if (!worktree_path) {
+  if (typeof worktree_path !== "string" || !worktree_path.trim()) {
     return NextResponse.json({ error: "worktree_path is required" }, { status: 400 });
   }
+  const promptText = prompt.trim();
+  const worktreePath = worktree_path.trim();
+  const taskId =
+    typeof task_id === "string" && task_id.trim().length > 0
+      ? task_id.trim()
+      : null;
+  if (task_id != null && !taskId) {
+    return NextResponse.json(
+      { error: "task_id must be a non-empty string" },
+      { status: 400 },
+    );
+  }
 
   const id = randomBytes(8).toString("hex");
   const agentConfig = resolveAgentExecutionConfig(
-    getAgentExecutionInputFromPayload(body),
+    getAgentExecutionInputFromPayload(bodyRecord),
   );
-  const runtimeAuthInput = getSessionRuntimeAuthInputFromPayload(body);
+  const runtimeAuthInput = getSessionRuntimeAuthInputFromPayload(bodyRecord);
   const runtimeAuthConfig = resolveSessionRuntimeAuthConfig(runtimeAuthInput);
   const preflight = validateSessionRuntimeProcessLaunch(
     runtimeAuthConfig,
-    String(worktree_path),
+    worktreePath,
   );
   if (!preflight.ok) {
     return NextResponse.json({ error: preflight.error }, { status: 400 });
   }
+  if (taskId) {
+    const taskLaunch = validateTaskSessionLaunch(db, taskId, projectId);
+    if (!taskLaunch.ok) {
+      return NextResponse.json(
+        { error: taskLaunch.error },
+        { status: taskLaunch.status },
+      );
+    }
+  }
   const sessionPrompt = [
-    String(prompt).trim(),
+    promptText,
     "",
     "## Agent Execution",
     buildAgentExecutionInstructions(agentConfig),
@@ -81,16 +111,16 @@ export async function POST(req: NextRequest) {
         agent_reasoning, agent_api_protocol, agent_api_version,
         agent_base_url, agent_max_tokens, prompt
       )
-       VALUES (?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       VALUES (?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        RETURNING *`
     )
     .get(
       id,
       projectId,
-      task_id ?? null,
-      worktree_name ?? null,
-      worktree_path,
-      branch_name ?? null,
+      taskId,
+      typeof worktree_name === "string" ? worktree_name : null,
+      worktreePath,
+      typeof branch_name === "string" ? branch_name : null,
       agentConfig.codingAgent.id,
       agentConfig.agentTeam.id,
       runtimeAuthConfig.mode,
@@ -100,17 +130,16 @@ export async function POST(req: NextRequest) {
       runtimeAuthConfig.reasoning,
       runtimeAuthConfig.apiProtocol,
       runtimeAuthConfig.apiVersion,
-      runtimeAuthConfig.baseUrl,
+      getPersistedSessionBaseUrl(runtimeAuthConfig),
       runtimeAuthConfig.maxTokens,
       sessionPrompt
     ) as Session;
 
   // Link session to task if provided
-  if (task_id) {
-    db.prepare("UPDATE tasks SET session_id = ?, status = 'in_progress' WHERE id = ?").run(
-      id,
-      task_id
-    );
+  if (taskId) {
+    db.prepare(
+      "UPDATE tasks SET session_id = ?, status = 'in_progress', fail_reason = NULL, completed_at = NULL, updated_at = datetime('now') WHERE id = ? AND project_id = ?",
+    ).run(id, taskId, projectId);
   }
 
   // Send the initial prompt as the first turn
@@ -118,9 +147,11 @@ export async function POST(req: NextRequest) {
     // Don't await — let it process in the background
     processManager.sendMessage(id, sessionPrompt, runtimeAuthInput);
   } catch (err) {
-    db.prepare(
-      "UPDATE sessions SET status = 'failed', ended_at = datetime('now') WHERE id = ?"
-    ).run(id);
+    markSessionFailedAndReleaseLinkedTask(
+      db,
+      id,
+      `Failed to start: ${(err as Error).message}`,
+    );
     return NextResponse.json(
       { error: `Failed to start: ${(err as Error).message}` },
       { status: 500 }
diff --git a/src/app/api/tasks/[id]/execute/route.ts b/src/app/api/tasks/[id]/execute/route.ts
index 7b06c87..0fa39ea 100644
--- a/src/app/api/tasks/[id]/execute/route.ts
+++ b/src/app/api/tasks/[id]/execute/route.ts
@@ -10,13 +10,19 @@ import {
 } from "@/core/process-manager";
 import { fileWatcher } from "@/core/file-watcher";
 import { hasTaskPrompt } from "@/core/task-readiness";
-import { slugify, buildPromptTemplate } from "@/core/task-lifecycle";
+import {
+  markSessionFailedAndReleaseLinkedTask,
+  slugify,
+  buildPromptTemplate,
+} from "@/core/task-lifecycle";
+import { isTaskExecutableStatus } from "@/core/task-status-flow";
 import {
   getAgentExecutionInputFromPayload,
   resolveAgentExecutionConfig,
 } from "@/core/agent-presets";
 import {
   getSessionRuntimeAuthInputFromPayload,
+  getPersistedSessionBaseUrl,
   resolveSessionRuntimeAuthConfig,
 } from "@/core/session-runtime-auth";
 import type { Task, Session } from "@/core/types-dashboard";
@@ -54,7 +60,7 @@ export async function POST(
       { status: 400 }
     );
   }
-  if (task.status !== "todo" && task.status !== "blocked") {
+  if (!isTaskExecutableStatus(task.status)) {
     return NextResponse.json(
       { error: `Cannot execute task with status '${task.status}'` },
       { status: 400 }
@@ -122,7 +128,7 @@ export async function POST(
         agent_reasoning, agent_api_protocol, agent_api_version,
         agent_base_url, agent_max_tokens, prompt
       )
-       VALUES (?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       VALUES (?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        RETURNING *`
     )
     .get(
@@ -141,14 +147,14 @@ export async function POST(
       runtimeAuthConfig.reasoning,
       runtimeAuthConfig.apiProtocol,
       runtimeAuthConfig.apiVersion,
-      runtimeAuthConfig.baseUrl,
+      getPersistedSessionBaseUrl(runtimeAuthConfig),
       runtimeAuthConfig.maxTokens,
       prompt
     ) as Session;
 
   // 4. Update task
   db.prepare(
-    "UPDATE tasks SET status = 'in_progress', worktree_name = ?, session_id = ?, updated_at = datetime('now') WHERE id = ?"
+    "UPDATE tasks SET status = 'in_progress', worktree_name = ?, session_id = ?, fail_reason = NULL, completed_at = NULL, updated_at = datetime('now') WHERE id = ?"
   ).run(worktreeName, sessionId, taskId);
 
   // 5. Start file watcher
@@ -162,9 +168,11 @@ export async function POST(
   try {
     processManager.sendMessage(sessionId, prompt, runtimeAuthInput);
   } catch (err) {
-    db.prepare(
-      "UPDATE sessions SET status = 'failed', ended_at = datetime('now') WHERE id = ?"
-    ).run(sessionId);
+    markSessionFailedAndReleaseLinkedTask(
+      db,
+      sessionId,
+      `Failed to start agent: ${(err as Error).message}`,
+    );
     return NextResponse.json(
       { error: `Failed to start agent: ${(err as Error).message}` },
       { status: 500 }
diff --git a/src/app/api/tasks/[id]/retry/route.ts b/src/app/api/tasks/[id]/retry/route.ts
index d8ab488..6e2d28d 100644
--- a/src/app/api/tasks/[id]/retry/route.ts
+++ b/src/app/api/tasks/[id]/retry/route.ts
@@ -4,9 +4,22 @@ import { getDb } from "@/core/db";
 import { resolveProjectId } from "@/lib/api-utils";
 import { getProject } from "@/core/project-adapter";
 import { listWorktrees } from "@/core/worktree-manager";
-import { processManager } from "@/core/process-manager";
+import {
+  processManager,
+  validateSessionRuntimeProcessLaunch,
+} from "@/core/process-manager";
 import { compileSession } from "@/core/vcc";
-import { buildPromptTemplate } from "@/core/task-lifecycle";
+import { markSessionFailedAndReleaseLinkedTask } from "@/core/task-lifecycle";
+import { buildTaskRetryPrompt } from "@/core/task-retry";
+import {
+  getAgentExecutionInputFromPayload,
+  resolveAgentExecutionConfig,
+} from "@/core/agent-presets";
+import {
+  getSessionRuntimeAuthInputFromPayload,
+  getPersistedSessionBaseUrl,
+  resolveSessionRuntimeAuthConfig,
+} from "@/core/session-runtime-auth";
 import type { Task, Session } from "@/core/types-dashboard";
 
 export async function POST(
@@ -16,7 +29,17 @@ export async function POST(
   const { id: taskId } = await params;
   const db = getDb();
   const projectId = resolveProjectId(req);
-  const { feedback } = (await req.json()) as { feedback: string };
+  let payload: unknown;
+  try {
+    payload = await req.json();
+  } catch {
+    payload = {};
+  }
+  const record =
+    payload && typeof payload === "object" && !Array.isArray(payload)
+      ? (payload as Record<string, unknown>)
+      : {};
+  const feedback = typeof record.feedback === "string" ? record.feedback : "";
 
   if (!feedback?.trim()) {
     return NextResponse.json({ error: "Feedback is required" }, { status: 400 });
@@ -48,6 +71,18 @@ export async function POST(
   }
 
   const project = getProject(projectId);
+  const agentConfig = resolveAgentExecutionConfig(
+    getAgentExecutionInputFromPayload(payload),
+  );
+  const runtimeAuthInput = getSessionRuntimeAuthInputFromPayload(payload);
+  const runtimeAuthConfig = resolveSessionRuntimeAuthConfig(runtimeAuthInput);
+  const preflight = validateSessionRuntimeProcessLaunch(
+    runtimeAuthConfig,
+    wt.path,
+  );
+  if (!preflight.ok) {
+    return NextResponse.json({ error: preflight.error }, { status: 400 });
+  }
 
   // 3. Get previous session brief for context
   let previousBrief = "";
@@ -70,32 +105,29 @@ export async function POST(
   }
 
   // 4. Build retry prompt
-  const basePrompt = buildPromptTemplate(
+  const retryPrompt = buildTaskRetryPrompt({
     task,
     project,
-    wt.path,
-    wt.branch
-  );
-  const retryPrompt = [
-    basePrompt,
-    "",
-    "## Previous Attempt Feedback",
-    feedback,
-    previousBrief
-      ? `\n## Previous Session Summary\n\`\`\`\n${previousBrief}\n\`\`\``
-      : "",
-    "",
-    "Address the feedback above and complete the task.",
-  ]
-    .filter(Boolean)
-    .join("\n");
+    worktreePath: wt.path,
+    branchName: wt.branch,
+    feedback: feedback.trim(),
+    previousBrief,
+    agentConfig,
+    runtimeAuthConfig,
+  });
 
   // 5. Create new session
   const sessionId = randomBytes(8).toString("hex");
   const session = db
     .prepare(
-      `INSERT INTO sessions (id, project_id, task_id, worktree_name, worktree_path, branch_name, status, prompt)
-       VALUES (?, ?, ?, ?, ?, ?, 'running', ?)
+      `INSERT INTO sessions (
+        id, project_id, task_id, worktree_name, worktree_path, branch_name,
+        status, coding_agent_id, agent_team_id, session_auth_mode,
+        agent_api_key_env_var, local_cli_agent_id, agent_model,
+        agent_reasoning, agent_api_protocol, agent_api_version,
+        agent_base_url, agent_max_tokens, prompt
+      )
+       VALUES (?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        RETURNING *`
     )
     .get(
@@ -105,21 +137,34 @@ export async function POST(
       task.worktree_name,
       wt.path,
       wt.branch,
+      agentConfig.codingAgent.id,
+      agentConfig.agentTeam.id,
+      runtimeAuthConfig.mode,
+      runtimeAuthConfig.agentApiKeyEnvVar,
+      runtimeAuthConfig.localCliAgentId,
+      runtimeAuthConfig.model,
+      runtimeAuthConfig.reasoning,
+      runtimeAuthConfig.apiProtocol,
+      runtimeAuthConfig.apiVersion,
+      getPersistedSessionBaseUrl(runtimeAuthConfig),
+      runtimeAuthConfig.maxTokens,
       retryPrompt
     ) as Session;
 
   // 6. Update task
   db.prepare(
-    "UPDATE tasks SET status = 'in_progress', session_id = ?, updated_at = datetime('now') WHERE id = ?"
+    "UPDATE tasks SET status = 'in_progress', session_id = ?, fail_reason = NULL, completed_at = NULL, updated_at = datetime('now') WHERE id = ?"
   ).run(sessionId, taskId);
 
   // 7. Spawn agent
   try {
-    processManager.sendMessage(sessionId, retryPrompt);
+    processManager.sendMessage(sessionId, retryPrompt, runtimeAuthInput);
   } catch (err) {
-    db.prepare(
-      "UPDATE sessions SET status = 'failed', ended_at = datetime('now') WHERE id = ?"
-    ).run(sessionId);
+    markSessionFailedAndReleaseLinkedTask(
+      db,
+      sessionId,
+      `Failed to start: ${(err as Error).message}`,
+    );
     return NextResponse.json(
       { error: `Failed to start: ${(err as Error).message}` },
       { status: 500 }
diff --git a/src/app/sessions/[id]/page.tsx b/src/app/sessions/[id]/page.tsx
index 9eaf3fc..70e9688 100644
--- a/src/app/sessions/[id]/page.tsx
+++ b/src/app/sessions/[id]/page.tsx
@@ -167,7 +167,11 @@ export default function SessionDetailPage() {
 
       {/* Tab content */}
       <div className={cn("flex-1 min-h-0", tab !== "chat" && "hidden")}>
-        <SessionChat sessionId={params.id} isActive={isActive} />
+        <SessionChat
+          sessionId={params.id}
+          isActive={isActive}
+          sessionRuntime={session}
+        />
       </div>
       <div className={cn("flex-1 min-h-0", tab !== "observe" && "hidden")}>
         <SessionVcc sessionId={params.id} isActive={isActive} />
diff --git a/src/components/dashboard/task-quick-view.tsx b/src/components/dashboard/task-quick-view.tsx
index 1a77617..a05df26 100644
--- a/src/components/dashboard/task-quick-view.tsx
+++ b/src/components/dashboard/task-quick-view.tsx
@@ -10,6 +10,7 @@ import { CreateTaskDialog } from "@/components/kanban/create-task-dialog";
 import { TaskDetailDialog } from "@/components/kanban/task-detail-dialog";
 import { useTasks } from "@/hooks/use-tasks";
 import type { Task, TaskStatus } from "@/core/types-dashboard";
+import type { SessionRuntimeAuthInput } from "@/core/session-runtime-auth";
 import { cn } from "@/core/dashboard-utils";
 
 const QUICK_COLUMNS: TaskStatus[] = ["todo", "in_progress"];
@@ -125,9 +126,15 @@ export function TaskQuickView() {
     task: Task,
     worktreePath: string,
     worktreeName?: string,
-    branchName?: string
+    branchName?: string,
+    agentConfig?: {
+      coding_agent_id: string;
+      agent_team_id: string;
+    } & SessionRuntimeAuthInput,
+    promptOverride?: string,
   ): Promise<{ id: string } | null> => {
-    if (!task.prompt) return null;
+    const prompt = promptOverride?.trim() || task.prompt;
+    if (!prompt) return null;
     const res = await fetch("/api/sessions", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -136,7 +143,8 @@ export function TaskQuickView() {
         worktree_name: worktreeName,
         worktree_path: worktreePath,
         branch_name: branchName,
-        prompt: task.prompt,
+        prompt,
+        ...agentConfig,
       }),
     });
     if (res.ok) {
diff --git a/src/components/kanban/board.tsx b/src/components/kanban/board.tsx
index 02f74ac..fdf5d36 100644
--- a/src/components/kanban/board.tsx
+++ b/src/components/kanban/board.tsx
@@ -5,7 +5,7 @@ import Link from "next/link";
 import { useRouter } from "next/navigation";
 import { DragDropContext, type DropResult } from "@hello-pangea/dnd";
 import { FileText } from "lucide-react";
-import { KanbanColumn } from "./column";
+import { KanbanColumn, KanbanGroupedColumn } from "./column";
 import { CreateTaskDialog } from "./create-task-dialog";
 import { TaskDetailDialog } from "./task-detail-dialog";
 import { useTasks } from "@/hooks/use-tasks";
@@ -13,24 +13,31 @@ import { useTaskSessions } from "@/hooks/use-task-sessions";
 import { useAgentSettings } from "@/hooks/use-agent-settings";
 import type { Task, TaskStatus } from "@/core/types-dashboard";
 import type { SessionRuntimeAuthInput } from "@/core/session-runtime-auth";
+import { getTaskBoardColumns } from "@/core/task-status-flow";
 import { Button } from "@/components/ui/button";
 import { Skeleton } from "@/components/ui/skeleton";
 
-const COLUMNS: TaskStatus[] = ["todo", "in_progress", "review", "blocked", "done"];
+const COLUMNS = getTaskBoardColumns();
 
 export function KanbanBoard() {
   const { loading, tasksByStatus, createTask, updateTask, deleteTask, reorder, executeTask } = useTasks();
   const taskSessions = useTaskSessions();
-  const { runtimePayload, byokReady } = useAgentSettings();
+  const { runtimePayload, byokReady, loaded, settingsReady } = useAgentSettings();
   const router = useRouter();
   const [selectedTask, setSelectedTask] = useState<Task | null>(null);
   const [detailOpen, setDetailOpen] = useState(false);
 
   const handleExecuteTask = async (taskId: string) => {
+    if (!loaded) {
+      return;
+    }
     if (!byokReady) {
       router.push("/settings");
       return;
     }
+    if (!settingsReady) {
+      return;
+    }
     const result = await executeTask(taskId, runtimePayload);
     if (result?.session) {
       router.push(`/sessions/${result.session.id}`);
@@ -121,8 +128,8 @@ export function KanbanBoard() {
   if (loading) {
     return (
       <div className="flex gap-4 overflow-x-auto pb-2">
-        {COLUMNS.map((col) => (
-          <Skeleton key={col} className="h-[400px] min-w-[240px] flex-1 rounded-lg" />
+        {COLUMNS.map((column) => (
+          <Skeleton key={column.id} className="h-[400px] min-w-[240px] flex-1 rounded-lg" />
         ))}
       </div>
     );
@@ -141,18 +148,34 @@ export function KanbanBoard() {
       </div>
       <DragDropContext onDragEnd={handleDragEnd}>
         <div className="flex gap-4 overflow-x-auto pb-2">
-          {COLUMNS.map((status) => (
-            <KanbanColumn
-              key={status}
-              status={status}
-              tasks={tasksByStatus(status)}
-              taskSessions={taskSessions}
-              onDeleteTask={deleteTask}
-              onClickTask={handleClickTask}
-              onExecuteTask={handleExecuteTask}
-              onPauseTask={handlePauseTask}
-            />
-          ))}
+          {COLUMNS.map((column) =>
+            column.type === "group" ? (
+              <KanbanGroupedColumn
+                key={column.id}
+                label={column.label}
+                sections={column.statuses.map((status) => ({
+                  status,
+                  tasks: tasksByStatus(status),
+                }))}
+                taskSessions={taskSessions}
+                onDeleteTask={deleteTask}
+                onClickTask={handleClickTask}
+                onExecuteTask={handleExecuteTask}
+                onPauseTask={handlePauseTask}
+              />
+            ) : (
+              <KanbanColumn
+                key={column.id}
+                status={column.status}
+                tasks={tasksByStatus(column.status)}
+                taskSessions={taskSessions}
+                onDeleteTask={deleteTask}
+                onClickTask={handleClickTask}
+                onExecuteTask={handleExecuteTask}
+                onPauseTask={handlePauseTask}
+              />
+            ),
+          )}
         </div>
       </DragDropContext>
 
diff --git a/src/components/kanban/column.tsx b/src/components/kanban/column.tsx
index 641233c..f6a1384 100644
--- a/src/components/kanban/column.tsx
+++ b/src/components/kanban/column.tsx
@@ -26,7 +26,55 @@ interface KanbanColumnProps {
   onPauseTask?: (sessionId: string) => void;
 }
 
-export function KanbanColumn({ status, tasks, taskSessions, onDeleteTask, onClickTask, onExecuteTask, onPauseTask }: KanbanColumnProps) {
+interface KanbanGroupedColumnProps
+  extends Omit<KanbanColumnProps, "status" | "tasks"> {
+  label: string;
+  sections: { status: TaskStatus; tasks: Task[] }[];
+}
+
+function KanbanTaskSection({
+  status,
+  tasks,
+  taskSessions,
+  onDeleteTask,
+  onClickTask,
+  onExecuteTask,
+  onPauseTask,
+  compact = false,
+}: KanbanColumnProps & { compact?: boolean }) {
+  return (
+    <Droppable droppableId={status}>
+      {(provided, snapshot) => (
+        <div
+          ref={provided.innerRef}
+          {...provided.droppableProps}
+          className={cn(
+            "space-y-2 transition-colors",
+            compact ? "min-h-[96px]" : "flex-1 min-h-[200px] p-2",
+            snapshot.isDraggingOver && "bg-accent/50",
+          )}
+        >
+          {tasks.map((task, index) => (
+            <TaskCard
+              key={task.id}
+              task={task}
+              index={index}
+              session={taskSessions?.get(task.id)}
+              onDelete={onDeleteTask}
+              onClick={onClickTask}
+              onExecute={onExecuteTask}
+              onPause={onPauseTask}
+            />
+          ))}
+          {provided.placeholder}
+        </div>
+      )}
+    </Droppable>
+  );
+}
+
+export function KanbanColumn(props: KanbanColumnProps) {
+  const { status, tasks } = props;
   const config = COLUMN_CONFIG[status];
 
   return (
@@ -38,32 +86,59 @@ export function KanbanColumn({ status, tasks, taskSessions, onDeleteTask, onClic
           {tasks.length}
         </Badge>
       </div>
-      <Droppable droppableId={status}>
-        {(provided, snapshot) => (
-          <div
-            ref={provided.innerRef}
-            {...provided.droppableProps}
-            className={cn(
-              "flex-1 space-y-2 p-2 min-h-[200px] transition-colors",
-              snapshot.isDraggingOver && "bg-accent/50"
-            )}
-          >
-            {tasks.map((task, index) => (
-              <TaskCard
-                key={task.id}
-                task={task}
-                index={index}
-                session={taskSessions?.get(task.id)}
-                onDelete={onDeleteTask}
-                onClick={onClickTask}
-                onExecute={onExecuteTask}
-                onPause={onPauseTask}
+      <KanbanTaskSection {...props} />
+    </div>
+  );
+}
+
+export function KanbanGroupedColumn({
+  label,
+  sections,
+  taskSessions,
+  onDeleteTask,
+  onClickTask,
+  onExecuteTask,
+  onPauseTask,
+}: KanbanGroupedColumnProps) {
+  const totalTasks = sections.reduce((sum, section) => sum + section.tasks.length, 0);
+
+  return (
+    <div className="flex flex-col rounded-lg bg-muted/50 min-w-[280px] w-full">
+      <div className="flex items-center gap-2 p-3 border-b border-border">
+        <span className="h-2 w-2 rounded-full bg-amber-500" />
+        <span className="h-2 w-2 rounded-full bg-rose-500" />
+        <h3 className="text-sm font-medium">{label}</h3>
+        <Badge variant="secondary" className="ml-auto text-xs">
+          {totalTasks}
+        </Badge>
+      </div>
+      <div className="flex-1 space-y-3 p-2">
+        {sections.map(({ status, tasks }) => {
+          const config = COLUMN_CONFIG[status];
+
+          return (
+            <section key={status} className="space-y-2">
+              <div className="flex items-center gap-2 px-1 text-xs text-muted-foreground">
+                <span className={cn("h-1.5 w-1.5 rounded-full", config.color)} />
+                <span>{config.label}</span>
+                <Badge variant="outline" className="ml-auto h-5 px-1.5 text-[10px]">
+                  {tasks.length}
+                </Badge>
+              </div>
+              <KanbanTaskSection
+                status={status}
+                tasks={tasks}
+                taskSessions={taskSessions}
+                onDeleteTask={onDeleteTask}
+                onClickTask={onClickTask}
+                onExecuteTask={onExecuteTask}
+                onPauseTask={onPauseTask}
+                compact
               />
-            ))}
-            {provided.placeholder}
-          </div>
-        )}
-      </Droppable>
+            </section>
+          );
+        })}
+      </div>
     </div>
   );
 }
diff --git a/src/components/kanban/task-card-actions.ts b/src/components/kanban/task-card-actions.ts
index 6f5cccd..a9ae186 100644
--- a/src/components/kanban/task-card-actions.ts
+++ b/src/components/kanban/task-card-actions.ts
@@ -1,9 +1,10 @@
 import { isActiveSessionStatus } from "@/core/task-readiness";
+import { isTaskExecutableStatus } from "@/core/task-status-flow";
 import type { Session, Task } from "@/core/types-dashboard";
 
 export function canExecuteTaskFromCard(task: Task, session?: Session): boolean {
   return (
-    (task.status === "todo" || task.status === "blocked") &&
+    isTaskExecutableStatus(task.status) &&
     !isActiveSessionStatus(session?.status)
   );
 }
diff --git a/src/components/kanban/task-detail-dialog.tsx b/src/components/kanban/task-detail-dialog.tsx
index 44357b0..896ec33 100644
--- a/src/components/kanban/task-detail-dialog.tsx
+++ b/src/components/kanban/task-detail-dialog.tsx
@@ -28,6 +28,7 @@ import {
   Loader2,
   GitBranch,
   Terminal,
+  AlertCircle,
 } from "lucide-react";
 import {
   DEFAULT_AGENT_TEAM_ID,
@@ -35,6 +36,7 @@ import {
 } from "@/core/agent-presets";
 import { AgentSelector } from "@/components/sessions/agent-selector";
 import { useAgentSettings } from "@/hooks/use-agent-settings";
+import { isTaskExecutableStatus } from "@/core/task-status-flow";
 import type { SessionRuntimeAuthInput } from "@/core/session-runtime-auth";
 import type { Task, TaskPriority, TaskStatus, Worktree } from "@/core/types-dashboard";
 import { cn } from "@/core/dashboard-utils";
@@ -94,7 +96,8 @@ export function TaskDetailDialog({
   const [selectedWorktree, setSelectedWorktree] = useState("");
   const [codingAgentId, setCodingAgentId] = useState(DEFAULT_CODING_AGENT_ID);
   const [agentTeamId, setAgentTeamId] = useState(DEFAULT_AGENT_TEAM_ID);
-  const { settings, runtimePayload, byokReady } = useAgentSettings();
+  const { settings, runtimePayload, byokReady, loaded, settingsReady } =
+    useAgentSettings();
 
   // Reset form when task changes
   useEffect(() => {
@@ -139,6 +142,8 @@ export function TaskDetailDialog({
   };
 
   const handleLaunch = async () => {
+    if (!settingsReady) return;
+
     const taskPrompt = prompt.trim() || task.prompt;
     if (!taskPrompt) return;
 
@@ -174,6 +179,7 @@ export function TaskDetailDialog({
     if (!dateStr) return null;
     return new Date(dateStr).toLocaleString();
   };
+  const canLaunchSession = isTaskExecutableStatus(task.status);
 
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
@@ -263,11 +269,11 @@ export function TaskDetailDialog({
           {/* Prompt */}
           {editing ? (
             <div className="space-y-1.5">
-              <Label className="text-xs text-muted-foreground">Claude Code Prompt</Label>
+              <Label className="text-xs text-muted-foreground">Agent Prompt</Label>
               <Textarea
                 value={prompt}
                 onChange={(e) => setPrompt(e.target.value)}
-                placeholder="Prompt for Claude Code..."
+                placeholder="Prompt for the selected coding agent..."
                 rows={4}
                 className="resize-none font-mono text-xs"
               />
@@ -317,6 +323,13 @@ export function TaskDetailDialog({
             </Button>
           )}
 
+          {task.status === "fail" && task.fail_reason && (
+            <div className="flex items-start gap-2 rounded-md border border-destructive/30 bg-destructive/5 p-2 text-xs text-destructive">
+              <AlertCircle className="mt-0.5 h-3.5 w-3.5 shrink-0" />
+              <span className="whitespace-pre-wrap">{task.fail_reason}</span>
+            </div>
+          )}
+
           {/* Metadata */}
           <div className="border-t pt-3 space-y-2">
             {task.worktree_name && (
@@ -353,7 +366,7 @@ export function TaskDetailDialog({
           </div>
 
           {/* Launch session */}
-          {!task.session_id && task.status !== "done" && (
+          {canLaunchSession && (
             <div className="border-t pt-3 space-y-3">
               <Label className="text-xs text-muted-foreground">Launch Session from Task</Label>
               {worktrees.length > 1 && (
@@ -380,7 +393,9 @@ export function TaskDetailDialog({
               />
               <Button
                 onClick={handleLaunch}
-                disabled={launching || !(prompt.trim() || task.prompt) || !byokReady}
+                disabled={
+                  launching || !(prompt.trim() || task.prompt) || !settingsReady
+                }
                 size="sm"
                 className="w-full"
               >
@@ -389,6 +404,8 @@ export function TaskDetailDialog({
                     <Loader2 className="h-3.5 w-3.5 mr-1 animate-spin" />
                     Launching...
                   </>
+                ) : !loaded ? (
+                  <>Loading Settings...</>
                 ) : !byokReady ? (
                   <>Add API key in Settings</>
                 ) : (
diff --git a/src/components/kanban/task-review-panel.tsx b/src/components/kanban/task-review-panel.tsx
index b01c09e..c128832 100644
--- a/src/components/kanban/task-review-panel.tsx
+++ b/src/components/kanban/task-review-panel.tsx
@@ -14,6 +14,8 @@ import {
   CheckCircle2,
   FileCode2,
 } from "lucide-react";
+import { buildTaskRetryRequestBody } from "@/core/task-retry-request";
+import { useAgentSettings } from "@/hooks/use-agent-settings";
 import type { Task } from "@/core/types-dashboard";
 
 interface TaskReviewPanelProps {
@@ -30,6 +32,13 @@ export function TaskReviewPanel({ task, onUpdate }: TaskReviewPanelProps) {
   const [retrying, setRetrying] = useState(false);
   const [feedback, setFeedback] = useState("");
   const [showFeedback, setShowFeedback] = useState(false);
+  const { runtimePayload, byokReady, loaded, settingsReady } =
+    useAgentSettings();
+  const retryButtonLabel = !loaded
+    ? "Loading Settings..."
+    : byokReady
+      ? "Retry with Feedback"
+      : "Add API key in Settings";
 
   useEffect(() => {
     if (task.worktree_name) {
@@ -58,13 +67,15 @@ export function TaskReviewPanel({ task, onUpdate }: TaskReviewPanelProps) {
   };
 
   const handleRetry = async () => {
-    if (!feedback.trim()) return;
+    if (!feedback.trim() || !settingsReady) return;
     setRetrying(true);
     try {
       const res = await fetch(`/api/tasks/${task.id}/retry`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ feedback: feedback.trim() }),
+        body: JSON.stringify(
+          buildTaskRetryRequestBody(feedback, runtimePayload),
+        ),
       });
       if (res.ok) {
         const { session } = await res.json();
@@ -154,16 +165,18 @@ export function TaskReviewPanel({ task, onUpdate }: TaskReviewPanelProps) {
           />
           <Button
             onClick={handleRetry}
-            disabled={retrying || !feedback.trim()}
+            disabled={retrying || !feedback.trim() || !settingsReady}
             size="sm"
             className="w-full"
           >
             {retrying ? (
               <Loader2 className="h-3.5 w-3.5 mr-1 animate-spin" />
-            ) : (
+            ) : settingsReady ? (
               <RefreshCw className="h-3.5 w-3.5 mr-1" />
+            ) : (
+              <FileCode2 className="h-3.5 w-3.5 mr-1" />
             )}
-            Retry with Feedback
+            {retryButtonLabel}
           </Button>
         </div>
       )}
diff --git a/src/components/sessions/launch-dialog.tsx b/src/components/sessions/launch-dialog.tsx
index 006fc9f..83cc84b 100644
--- a/src/components/sessions/launch-dialog.tsx
+++ b/src/components/sessions/launch-dialog.tsx
@@ -57,7 +57,8 @@ export function LaunchDialog({ onSubmit }: LaunchDialogProps) {
   const [agentTeamId, setAgentTeamId] = useState(DEFAULT_AGENT_TEAM_ID);
   const [prompt, setPrompt] = useState("");
   const [launching, setLaunching] = useState(false);
-  const { settings, runtimePayload, byokReady } = useAgentSettings();
+  const { settings, runtimePayload, byokReady, loaded, settingsReady } =
+    useAgentSettings();
 
   useEffect(() => {
     if (open) {
@@ -77,6 +78,7 @@ export function LaunchDialog({ onSubmit }: LaunchDialogProps) {
   }, [open, selectedWorktree]);
 
   const handleSubmit = async () => {
+    if (!settingsReady) return;
     if (!prompt.trim() || launching) return;
 
     const wt = worktrees.find((w) => w.name === selectedWorktree);
@@ -127,11 +129,11 @@ export function LaunchDialog({ onSubmit }: LaunchDialogProps) {
       </DialogTrigger>
       <DialogContent className="sm:max-w-[520px]">
         <DialogHeader>
-          <DialogTitle>New Claude Code Session</DialogTitle>
+          <DialogTitle>New Coding Agent Session</DialogTitle>
         </DialogHeader>
         <div className="space-y-4">
           <div className="space-y-2">
-            <Label>What should Claude do?</Label>
+            <Label>What should the agent do?</Label>
             <Textarea
               value={prompt}
               onChange={(e) => setPrompt(e.target.value)}
@@ -142,7 +144,7 @@ export function LaunchDialog({ onSubmit }: LaunchDialogProps) {
               className="resize-none"
             />
             <p className="text-[10px] text-muted-foreground">
-              Describe the task clearly. Claude will work in an isolated session.
+              Describe the task clearly. The selected agent will work in an isolated session.
             </p>
           </div>
 
@@ -175,7 +177,7 @@ export function LaunchDialog({ onSubmit }: LaunchDialogProps) {
 
           <Button
             onClick={handleSubmit}
-            disabled={!prompt.trim() || launching || !byokReady}
+            disabled={!prompt.trim() || launching || !settingsReady}
             className="w-full"
           >
             {launching ? (
@@ -183,6 +185,8 @@ export function LaunchDialog({ onSubmit }: LaunchDialogProps) {
                 <Loader2 className="h-4 w-4 mr-1.5 animate-spin" />
                 Launching...
               </>
+            ) : !loaded ? (
+              <>Loading Settings...</>
             ) : !byokReady ? (
               <>Add API key in Settings</>
             ) : (
diff --git a/src/components/sessions/session-chat.test.ts b/src/components/sessions/session-chat.test.ts
index 0c42700..c5f55a2 100644
--- a/src/components/sessions/session-chat.test.ts
+++ b/src/components/sessions/session-chat.test.ts
@@ -1,11 +1,17 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import {
+  formatActivityEntryForDisplay,
+  formatActivityTimestampForDisplay,
   formatToolOutputForDisplay,
   getSessionInstructionInputCopy,
   isInteractiveSessionStatus,
   isTerminalSessionStatus,
 } from "./session-chat";
+import {
+  createReplayChatMessage,
+  mergeReplayMessagesWithQueuedPlaceholders,
+} from "@/hooks/use-session-chat";
 
 test("formatToolOutputForDisplay keeps complete output up to 20 lines", () => {
   const output = Array.from({ length: 20 }, (_, index) => `line ${index + 1}`).join(
@@ -43,6 +49,129 @@ test("formatToolOutputForDisplay folds output longer than 20 lines", () => {
   );
 });
 
+test("formatActivityEntryForDisplay returns status messages", () => {
+  assert.equal(
+    formatActivityEntryForDisplay({
+      id: 1,
+      kind: "status",
+      message: "Agent process running as PID 1234",
+    }),
+    "Agent process running as PID 1234",
+  );
+});
+
+test("formatActivityEntryForDisplay trims, truncates, and labels stderr logs", () => {
+  const longChunk = `  ${"stderr chunk ".repeat(24)}  `;
+
+  const formatted = formatActivityEntryForDisplay({
+    id: 2,
+    kind: "log",
+    stream: "stderr",
+    message: longChunk,
+  });
+
+  assert.match(formatted, /^\[stderr\] stderr chunk/);
+  assert.equal(formatted.endsWith("..."), true);
+  assert.ok(formatted.length <= "[stderr] ".length + 160 + "...".length);
+});
+
+test("formatActivityEntryForDisplay returns system warning and success messages", () => {
+  assert.equal(
+    formatActivityEntryForDisplay({
+      id: 3,
+      kind: "system",
+      level: "warning",
+      message: "Agent process exited unexpectedly",
+    }),
+    "Agent process exited unexpectedly",
+  );
+
+  assert.equal(
+    formatActivityEntryForDisplay({
+      id: 4,
+      kind: "system",
+      level: "success",
+      message: "Agent process completed",
+    }),
+    "Agent process completed",
+  );
+});
+
+test("formatActivityTimestampForDisplay omits invalid timestamps", () => {
+  assert.equal(formatActivityTimestampForDisplay(undefined), null);
+  assert.equal(formatActivityTimestampForDisplay("not a timestamp"), null);
+});
+
+test("createReplayChatMessage preserves stable persisted message ids", () => {
+  assert.deepEqual(
+    createReplayChatMessage({
+      type: "message",
+      id: 42,
+      role: "assistant",
+      content: "persisted response",
+    }),
+    {
+      id: 42,
+      role: "assistant",
+      content: "persisted response",
+    },
+  );
+});
+
+test("mergeReplayMessagesWithQueuedPlaceholders drops queued messages already replayed as user messages", () => {
+  const replayed = [
+    { id: 1, role: "user" as const, content: "persisted follow-up" },
+    { id: 2, role: "assistant" as const, content: "working" },
+  ];
+  const current = [
+    {
+      id: 3,
+      role: "user" as const,
+      content: "persisted follow-up",
+      isQueued: true,
+    },
+    {
+      id: 4,
+      role: "user" as const,
+      content: "still queued",
+      isQueued: true,
+    },
+    { id: 5, role: "assistant" as const, content: "stale live text" },
+  ];
+
+  assert.deepEqual(
+    mergeReplayMessagesWithQueuedPlaceholders(replayed, current).map(
+      (message) => message.content,
+    ),
+    ["persisted follow-up", "working", "still queued"],
+  );
+});
+
+test("mergeReplayMessagesWithQueuedPlaceholders consumes one queued duplicate per replayed user message", () => {
+  const replayed = [{ id: 1, role: "user" as const, content: "continue" }];
+  const current = [
+    {
+      id: 2,
+      role: "user" as const,
+      content: "continue",
+      isQueued: true,
+    },
+    {
+      id: 3,
+      role: "user" as const,
+      content: "continue",
+      isQueued: true,
+    },
+  ];
+
+  assert.deepEqual(
+    mergeReplayMessagesWithQueuedPlaceholders(replayed, current).map(
+      (message) => message.content,
+    ),
+    ["continue", "continue"],
+  );
+});
+
 test("isInteractiveSessionStatus treats pending, running, idle, and paused as active task runs", () => {
   assert.equal(isInteractiveSessionStatus("pending"), true);
   assert.equal(isInteractiveSessionStatus("running"), true);
@@ -85,3 +214,18 @@ test("getSessionInstructionInputCopy uses instruction-oriented copy for active s
     },
   );
 });
+
+test("getSessionInstructionInputCopy blocks session follow-up when selected runtime is not ready", () => {
+  assert.deepEqual(
+    getSessionInstructionInputCopy({
+      processing: false,
+      sessionEnded: false,
+      runtimeReady: false,
+    }),
+    {
+      placeholder: "",
+      helperText: "",
+      disabledText: "Add API key in Settings",
+    },
+  );
+});
diff --git a/src/components/sessions/session-chat.tsx b/src/components/sessions/session-chat.tsx
index 2d66638..1cb7350 100644
--- a/src/components/sessions/session-chat.tsx
+++ b/src/components/sessions/session-chat.tsx
@@ -5,7 +5,9 @@ import {
   useSessionChat,
   type ChatMsg,
   type PermissionRequest,
+  type SessionActivityEntry,
 } from "@/hooks/use-session-chat";
+import type { SessionContinuationRuntimeSnapshot } from "@/core/agent-settings";
 import type { SessionStatus } from "@/core/types-dashboard";
 import { Button } from "@/components/ui/button";
 import { Textarea } from "@/components/ui/textarea";
@@ -86,6 +88,34 @@ export function formatToolOutputForDisplay(output: string): string {
   );
 }
 
+export function formatActivityEntryForDisplay(entry: SessionActivityEntry): string {
+  if (entry.kind !== "log") {
+    return entry.message;
+  }
+
+  const stream = entry.stream ?? "stdout";
+  const trimmed = entry.message.trim();
+  const compact =
+    trimmed.length > 160 ? `${trimmed.slice(0, 160).trimEnd()}...` : trimmed;
+
+  return `[${stream}] ${compact}`;
+}
+
+export function formatActivityTimestampForDisplay(
+  timestamp: string | undefined,
+): string | null {
+  if (!timestamp) {
+    return null;
+  }
+
+  const date = new Date(timestamp);
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+
+  return date.toLocaleTimeString();
+}
+
 export function isInteractiveSessionStatus(
   status: SessionStatus | string | null | undefined,
 ): boolean {
@@ -101,9 +131,11 @@ export function isTerminalSessionStatus(
 export function getSessionInstructionInputCopy({
   processing,
   sessionEnded,
+  runtimeReady = true,
 }: {
   processing: boolean;
   sessionEnded: boolean;
+  runtimeReady?: boolean;
 }): { placeholder: string; helperText: string; disabledText: string } {
   if (sessionEnded) {
     return {
@@ -113,6 +145,14 @@ export function getSessionInstructionInputCopy({
     };
   }
 
+  if (!runtimeReady) {
+    return {
+      placeholder: "",
+      helperText: "",
+      disabledText: "Add API key in Settings",
+    };
+  }
+
   if (processing) {
     return {
       placeholder: "Queue a follow-up instruction for this task session...",
@@ -343,13 +383,69 @@ function StreamingBubble({
   );
 }
 
+function ActivityTimeline({ entries }: { entries: SessionActivityEntry[] }) {
+  if (entries.length === 0) {
+    return null;
+  }
+
+  return (
+    <div className="px-4 py-2">
+      <div className="border-l border-border/60 pl-3 space-y-1.5">
+        {entries.map((entry) => {
+          const timestamp = formatActivityTimestampForDisplay(entry.timestamp);
+
+          return (
+            <div key={entry.id} className="flex min-w-0 items-start gap-2 text-xs">
+              <span
+                className={cn(
+                  "mt-0.5 flex h-4 w-4 shrink-0 items-center justify-center rounded-full border bg-background",
+                  entry.level === "success" && "border-green-500/40 text-green-500",
+                  entry.level === "warning" && "border-amber-500/40 text-amber-500",
+                  entry.level === "error" && "border-destructive/40 text-destructive",
+                  (!entry.level || entry.level === "info") &&
+                    "border-border text-muted-foreground",
+                )}
+              >
+                {entry.level === "success" ? (
+                  <Check className="h-2.5 w-2.5" />
+                ) : entry.level === "warning" || entry.level === "error" ? (
+                  <AlertCircle className="h-2.5 w-2.5" />
+                ) : entry.kind === "log" ? (
+                  <TerminalIcon className="h-2.5 w-2.5" />
+                ) : (
+                  <Loader2 className="h-2.5 w-2.5" />
+                )}
+              </span>
+              <div className="min-w-0 flex-1">
+                <p className="whitespace-pre-wrap break-words leading-relaxed text-muted-foreground">
+                  {formatActivityEntryForDisplay(entry)}
+                </p>
+                {timestamp && (
+                  <p className="mt-0.5 text-[10px] text-muted-foreground/50">
+                    {timestamp}
+                  </p>
+                )}
+              </div>
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}
+
 // Main session chat component
 interface SessionChatProps {
   sessionId: string;
   isActive: boolean;
+  sessionRuntime?: SessionContinuationRuntimeSnapshot;
 }
 
-export function SessionChat({ sessionId, isActive }: SessionChatProps) {
+export function SessionChat({
+  sessionId,
+  isActive,
+  sessionRuntime,
+}: SessionChatProps) {
   const {
     messages,
     streamingText,
@@ -363,7 +459,9 @@ export function SessionChat({ sessionId, isActive }: SessionChatProps) {
     pendingPermission,
     respondToPermission,
     queuedCount,
-  } = useSessionChat(sessionId);
+    byokReady,
+    activityEntries,
+  } = useSessionChat(sessionId, sessionRuntime);
 
   const [input, setInput] = useState("");
   const [sending, setSending] = useState(false);
@@ -371,12 +469,13 @@ export function SessionChat({ sessionId, isActive }: SessionChatProps) {
   const scrollRef = useRef<HTMLDivElement>(null);
   const [autoScroll, setAutoScroll] = useState(true);
 
-  // Input is always available unless the session has ended
+  // Input is available when the active session can use the selected runtime.
   const sessionEnded = isTerminalSessionStatus(sessionStatus);
-  const canSend = isActive && !sessionEnded;
+  const canSend = isActive && !sessionEnded && byokReady;
   const inputCopy = getSessionInstructionInputCopy({
     processing,
     sessionEnded,
+    runtimeReady: byokReady,
   });
 
   // Auto-scroll
@@ -384,7 +483,14 @@ export function SessionChat({ sessionId, isActive }: SessionChatProps) {
     if (autoScroll && bottomRef.current) {
       bottomRef.current.scrollIntoView({ behavior: "smooth" });
     }
-  }, [messages, streamingText, streamingTools, pendingPermission, autoScroll]);
+  }, [
+    messages,
+    streamingText,
+    streamingTools,
+    activityEntries,
+    pendingPermission,
+    autoScroll,
+  ]);
 
   const handleScroll = () => {
     const el = scrollRef.current;
@@ -463,7 +569,7 @@ export function SessionChat({ sessionId, isActive }: SessionChatProps) {
         onScroll={handleScroll}
         className="flex-1 min-h-0 overflow-y-auto py-4"
       >
-        {messages.length === 0 && !processing && (
+        {messages.length === 0 && activityEntries.length === 0 && !processing && (
           <div className="flex items-center justify-center h-full">
             <div className="text-center">
               <Loader2 className="h-5 w-5 animate-spin text-muted-foreground mx-auto mb-2" />
@@ -478,6 +584,8 @@ export function SessionChat({ sessionId, isActive }: SessionChatProps) {
           <MessageBubble key={msg.id} msg={msg} />
         ))}
 
+        <ActivityTimeline entries={activityEntries} />
+
         {/* Streaming response */}
         {processing && (
           <StreamingBubble
diff --git a/src/core/__tests__/agent-connection-test.test.ts b/src/core/__tests__/agent-connection-test.test.ts
index 9176ff7..32c8d66 100644
--- a/src/core/__tests__/agent-connection-test.test.ts
+++ b/src/core/__tests__/agent-connection-test.test.ts
@@ -3,6 +3,7 @@ import { PassThrough } from "stream";
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import {
+  DEFAULT_AGENT_TIMEOUT_MS,
   testSessionRuntimeConnection,
   validateAgentConnectionBaseUrl,
   type SpawnedConnectionProcess,
@@ -324,6 +325,10 @@ test("local CLI connection test reports missing binaries before spawn", async ()
   assert.equal(result.kind, "agent_not_installed");
 });
 
+test("local CLI connection test allows slow auth refresh by default", () => {
+  assert.equal(DEFAULT_AGENT_TIMEOUT_MS, 180_000);
+});
+
 test("local CLI connection test treats assistant text as a successful smoke run", async () => {
   let stdin = "";
   const result = await testSessionRuntimeConnection(
@@ -350,6 +355,42 @@ test("local CLI connection test treats assistant text as a successful smoke run"
   assert.equal(stdin, "Reply with only: ok");
 });
 
+test("local CLI connection test extracts Codex agent messages and ignores reconnect errors", async () => {
+  const result = await testSessionRuntimeConnection(
+    resolveSessionRuntimeAuthConfig({
+      session_auth_mode: "local-cli",
+      local_cli_agent_id: "codex",
+      agent_model: "default",
+    }),
+    {
+      cwd: "/repo",
+      env: { NODE_ENV: "test", PATH: "/bin" },
+      resolveBin: () => "/mock/bin/codex",
+      spawnImpl: fakeSpawn(
+        [
+          JSON.stringify({
+            type: "error",
+            message: "Reconnecting... 2/5 (request timed out)",
+          }),
+          JSON.stringify({
+            type: "item.completed",
+            item: { type: "agent_message", text: "ok" },
+          }),
+          JSON.stringify({ type: "turn.completed" }),
+          "",
+        ].join("\n"),
+        0,
+      ),
+      timeoutMs: 100,
+    },
+  );
+
+  assert.equal(result.ok, true);
+  assert.equal(result.kind, "success");
+  assert.equal(result.agentName, "Codex CLI");
+  assert.equal(result.sample, "ok");
+});
+
 test("local CLI connection test rejects assistant text from non-zero exits", async () => {
   const result = await testSessionRuntimeConnection(
     resolveSessionRuntimeAuthConfig({
diff --git a/src/core/__tests__/agent-settings.test.ts b/src/core/__tests__/agent-settings.test.ts
index d312b7d..14455d5 100644
--- a/src/core/__tests__/agent-settings.test.ts
+++ b/src/core/__tests__/agent-settings.test.ts
@@ -7,6 +7,7 @@ import {
   DEFAULT_BASE_URL_BY_PROTOCOL,
   KNOWN_API_PROVIDERS,
   SUGGESTED_MODELS_BY_PROTOCOL,
+  buildSessionContinuationRuntimePayload,
   buildSessionRuntimePayload,
   buildStoredAgentSettings,
   getBrowserApiKeyScope,
@@ -320,6 +321,84 @@ test("browser API keys are scoped by protocol and base URL", () => {
   assert.equal(getScopedBrowserApiKey(openai, scopedKeys), "sk-openai-provider");
 });
 
+test("session continuation payload preserves provider runtime and pulls its scoped browser key", () => {
+  const scopedKeys = setScopedBrowserApiKey(
+    {
+      apiProtocol: "openai",
+      apiBaseUrl: "https://api.openai.com/v1",
+    },
+    {},
+    "sk-openai-session",
+  );
+  const currentSettings = normalizeAgentSettings({
+    executionMode: "local-cli",
+    localCliAgentId: "codex",
+    localCliModel: "gpt-5-codex",
+  });
+
+  assert.deepEqual(
+    buildSessionContinuationRuntimePayload(
+      {
+        session_auth_mode: "anthropic-api-key",
+        agent_api_protocol: "openai",
+        agent_model: "gpt-4o-mini",
+        agent_base_url: "https://api.openai.com/v1",
+        agent_api_version: "",
+        agent_max_tokens: 16384,
+      },
+      currentSettings,
+      scopedKeys,
+    ),
+    {
+      session_auth_mode: "anthropic-api-key",
+      agent_api_protocol: "openai",
+      agent_model: "gpt-4o-mini",
+      agent_base_url: "https://api.openai.com/v1",
+      agent_api_version: "",
+      agent_max_tokens: 16384,
+      anthropic_api_key: "sk-openai-session",
+    },
+  );
+});
+
+test("session continuation payload preserves local CLI runtime and uses that CLI environment", () => {
+  const currentSettings = normalizeAgentSettings({
+    executionMode: "local-cli",
+    localCliAgentId: "codex",
+    localCliModel: "gpt-5-codex",
+    localCliAgentEnv: {
+      claude: {
+        CLAUDE_CONFIG_DIR: "/tmp/claude-session",
+      },
+      codex: {
+        CODEX_BIN: "/opt/dev/codex",
+      },
+    },
+  });
+
+  assert.deepEqual(
+    buildSessionContinuationRuntimePayload(
+      {
+        session_auth_mode: "local-cli",
+        local_cli_agent_id: "claude",
+        agent_model: "claude-opus-4-7",
+        agent_reasoning: "xhigh",
+      },
+      currentSettings,
+      {},
+    ),
+    {
+      session_auth_mode: "local-cli",
+      local_cli_agent_id: "claude",
+      agent_model: "claude-opus-4-7",
+      agent_reasoning: "xhigh",
+      local_cli_agent_env: {
+        CLAUDE_CONFIG_DIR: "/tmp/claude-session",
+      },
+    },
+  );
+});
+
 test("legacy model field migrates into split local CLI and API settings", () => {
   const settings = normalizeAgentSettings({
     executionMode: "local-cli",
diff --git a/src/core/__tests__/api-session-runtime.test.ts b/src/core/__tests__/api-session-runtime.test.ts
index ec7a8b7..0c6936b 100644
--- a/src/core/__tests__/api-session-runtime.test.ts
+++ b/src/core/__tests__/api-session-runtime.test.ts
@@ -91,6 +91,59 @@ test("runProviderSessionTurn executes API mode without a Local CLI process", asy
   );
 });
 
+test("runProviderSessionTurn preserves the session provider and model when current Settings drift", async () => {
+  const db = makeTestDb();
+  let requestUrl = "";
+  let requestBody: unknown = null;
+
+  db.prepare(
+    `INSERT INTO sessions (
+      id, project_id, worktree_path, status, session_auth_mode,
+      local_cli_agent_id, agent_model, agent_reasoning, agent_api_protocol,
+      agent_api_version, agent_base_url, agent_max_tokens
+    ) VALUES (
+      'session-persisted-runtime', 'test', '/repo', 'idle', 'anthropic-api-key',
+      'claude', 'gpt-4o-mini', 'default', 'openai', '', 'https://api.openai.com/v1', 16384
+    )`,
+  ).run();
+
+  const result = await runProviderSessionTurn({
+    db,
+    sessionId: "session-persisted-runtime",
+    message: "Continue with the original session runtime",
+    runtimeAuthInput: {
+      session_auth_mode: "anthropic-api-key",
+      agent_api_protocol: "google",
+      agent_model: "gemini-2.0-flash",
+      agent_base_url: "https://generativelanguage.googleapis.com",
+      agent_max_tokens: 4096,
+      anthropic_api_key: "sk-openai-test",
+    },
+    emit: () => {},
+    fetchImpl: async (url, init) => {
+      requestUrl = String(url);
+      requestBody = JSON.parse(String(init?.body));
+      return jsonResponse(200, {
+        choices: [{ message: { content: "Original provider answer" } }],
+      });
+    },
+  });
+
+  assert.equal(result.ok, true);
+  assert.match(requestUrl, /^https:\/\/api\.openai\.com\/v1\/chat\/completions/);
+  assert.deepEqual(requestBody, {
+    model: "gpt-4o-mini",
+    max_tokens: 16384,
+    messages: [
+      {
+        role: "user",
+        content: "Continue with the original session runtime",
+      },
+    ],
+    stream: false,
+  });
+});
+
 test("runProviderSessionTurn fails before recording a user message when the browser API key is missing", async () => {
   const db = makeTestDb();
   const events: ChatStreamEvent[] = [];
@@ -141,13 +194,21 @@ test("runProviderSessionTurn keeps the user message when the provider returns an
   const db = makeTestDb();
   const events: ChatStreamEvent[] = [];
 
+  db.prepare(
+    `INSERT INTO tasks (
+      id, project_id, title, status, session_id, prompt
+    ) VALUES (
+      'task-provider-error', 'test', 'Provider task', 'in_progress',
+      'session-provider-error', 'Run provider task'
+    )`,
+  ).run();
   db.prepare(
     `INSERT INTO sessions (
-      id, project_id, worktree_path, status, session_auth_mode,
+      id, project_id, task_id, worktree_path, status, session_auth_mode,
       local_cli_agent_id, agent_model, agent_reasoning, agent_api_protocol,
       agent_api_version, agent_base_url, agent_max_tokens
     ) VALUES (
-      'session-provider-error', 'test', '/repo', 'idle', 'anthropic-api-key',
+      'session-provider-error', 'test', 'task-provider-error', '/repo', 'idle', 'anthropic-api-key',
       'claude', 'gpt-4o-mini', 'default', 'openai', '', 'https://api.openai.com/v1', 16384
     )`,
   ).run();
@@ -191,6 +252,16 @@ test("runProviderSessionTurn keeps the user message when the provider returns an
     ).status,
     "failed",
   );
+  assert.deepEqual(
+    db
+      .prepare("SELECT status, session_id, fail_reason FROM tasks WHERE id = ?")
+      .get("task-provider-error"),
+    {
+      status: "fail",
+      session_id: "session-provider-error",
+      fail_reason: "provider unavailable",
+    },
+  );
 });
 
 test("runProviderSessionTurn removes the pending user message after the session is killed", async () => {
diff --git a/src/core/__tests__/process-manager-health.test.ts b/src/core/__tests__/process-manager-health.test.ts
index 03ea3d6..2ac8129 100644
--- a/src/core/__tests__/process-manager-health.test.ts
+++ b/src/core/__tests__/process-manager-health.test.ts
@@ -491,6 +491,82 @@ test("generic JSON parser maps Copilot text and tool events", () => {
   ]);
 });
 
+test("generic JSON parser emits Codex lifecycle system logs on session stream", () => {
+  const sessionId = "test-codex-lifecycle-parser";
+  const events: ChatStreamEvent[] = [];
+  const unsubscribe = streamManager.subscribe(sessionId, (event) => {
+    events.push(event);
+  });
+  const sp: Record<string, unknown> = {
+    eventParser: "codex",
+    genericStreamState: {
+      buffer: "",
+      codexToolUses: new Set<string>(),
+      openCodeToolUses: new Set<string>(),
+      copilotToolNames: new Map<string, string>(),
+      cursorTextSoFar: "",
+    },
+    textBuffer: "",
+  };
+
+  try {
+    genericJsonLineProcess.handleGenericJsonLine(
+      sessionId,
+      sp,
+      JSON.stringify({
+        type: "thread.started",
+        thread: { id: "thread-nested" },
+      }),
+    );
+    genericJsonLineProcess.handleGenericJsonLine(
+      sessionId,
+      sp,
+      JSON.stringify({
+        type: "turn.started",
+      }),
+    );
+    genericJsonLineProcess.handleGenericJsonLine(
+      sessionId,
+      sp,
+      JSON.stringify({
+        type: "turn.completed",
+      }),
+    );
+  } finally {
+    unsubscribe();
+  }
+
+  const systemLogs = events.filter((event) => event.type === "system_log");
+  assert.deepEqual(
+    systemLogs.map((event) => ({
+      type: event.type,
+      level: event.level,
+      message: event.message,
+      session_id: event.session_id,
+    })),
+    [
+      {
+        type: "system_log",
+        level: "info",
+        message: "Codex thread started: thread-nested",
+        session_id: sessionId,
+      },
+      {
+        type: "system_log",
+        level: "info",
+        message: "Codex turn started",
+        session_id: sessionId,
+      },
+      {
+        type: "system_log",
+        level: "success",
+        message: "Codex turn completed",
+        session_id: sessionId,
+      },
+    ],
+  );
+});
+
 test("buildLocalCliProcessLaunch fails clearly when selected CLI is unavailable", () => {
   const launch = buildLocalCliProcessLaunch(
     resolveSessionRuntimeAuthConfig({
diff --git a/src/core/__tests__/quality-gates.test.ts b/src/core/__tests__/quality-gates.test.ts
index f32ade3..5317406 100644
--- a/src/core/__tests__/quality-gates.test.ts
+++ b/src/core/__tests__/quality-gates.test.ts
@@ -35,3 +35,124 @@ test("Husky pre-commit hook runs the shared pre-commit gate", () => {
   assert.match(hook, /bun run quality:precommit/);
   assert.equal(mode & 0o111, 0o111);
 });
+
+test("session insert route SQL has one value expression per column", () => {
+  const routes = [
+    "src/app/api/sessions/route.ts",
+    "src/app/api/tasks/[id]/execute/route.ts",
+    "src/app/api/tasks/[id]/retry/route.ts",
+  ];
+
+  for (const route of routes) {
+    const source = readRepoFile(route);
+    const match = source.match(
+      /INSERT INTO sessions \(([\s\S]*?)\)\s+VALUES \(([\s\S]*?)\)\s+RETURNING \*/m,
+    );
+    assert.ok(match, `${route} should contain a sessions insert`);
+
+    const columns = match[1]
+      .split(",")
+      .map((column) => column.trim())
+      .filter(Boolean);
+    const valueExpressions = match[2]
+      .split(",")
+      .map((value) => value.trim())
+      .filter(Boolean);
+
+    assert.equal(
+      valueExpressions.length,
+      columns.length,
+      `${route} session insert must keep columns and VALUES in sync`,
+    );
+  }
+});
+
+test("generic task and session launch copy is not hard-coded to Claude Code", () => {
+  const genericLaunchSurfaces = [
+    "src/components/sessions/launch-dialog.tsx",
+    "src/components/kanban/task-detail-dialog.tsx",
+  ];
+
+  for (const route of genericLaunchSurfaces) {
+    const source = readRepoFile(route);
+    assert.doesNotMatch(
+      source,
+      /Claude Code|What should Claude|Claude will/,
+      `${route} should describe the selected coding agent generically`,
+    );
+  }
+});
+
+test("task and session runtime dispatch waits for browser settings to load", () => {
+  const runtimeDispatchSurfaces = [
+    "src/components/kanban/board.tsx",
+    "src/components/kanban/task-detail-dialog.tsx",
+    "src/components/kanban/task-review-panel.tsx",
+    "src/components/sessions/launch-dialog.tsx",
+    "src/hooks/use-session-chat.ts",
+  ];
+
+  for (const route of runtimeDispatchSurfaces) {
+    const source = readRepoFile(route);
+    assert.match(
+      source,
+      /useAgentSettings\(\)[\s\S]*loaded|loaded[\s\S]*useAgentSettings\(\)/,
+      `${route} must read the agent settings loaded flag before dispatching runtime payload`,
+    );
+    assert.match(
+      source,
+      /settingsReady|runtimeReady/,
+      `${route} must gate runtime dispatch on loaded settings plus runtime readiness`,
+    );
+  }
+});
+
+test("dashboard task quick view forwards runtime payload from the detail dialog", () => {
+  const source = readRepoFile("src/components/dashboard/task-quick-view.tsx");
+
+  assert.match(
+    source,
+    /agentConfig\?: \{[\s\S]*SessionRuntimeAuthInput/,
+    "dashboard quick task launcher must accept the runtime payload supplied by TaskDetailDialog",
+  );
+  assert.match(
+    source,
+    /promptOverride\?: string/,
+    "dashboard quick task launcher must accept the edited prompt supplied by TaskDetailDialog",
+  );
+  assert.match(
+    source,
+    /\.\.\.agentConfig/,
+    "dashboard quick task launcher must forward runtime payload fields to /api/sessions",
+  );
+});
+
+test("session stream route scopes subscriptions to the current project", () => {
+  const source = readRepoFile("src/app/api/sessions/[id]/stream/route.ts");
+
+  assert.match(
+    source,
+    /resolveProjectId/,
+    "session stream route must resolve the current project before opening SSE",
+  );
+  assert.match(
+    source,
+    /sessions\s+WHERE\s+id\s*=\s*\?\s+AND\s+project_id\s*=\s*\?/,
+    "session stream route must verify the session belongs to the current project",
+  );
+});
+
+test("sessions POST narrows arbitrary JSON before destructuring", () => {
+  const source = readRepoFile("src/app/api/sessions/route.ts");
+
+  assert.match(
+    source,
+    /bodyRecord/,
+    "sessions POST should keep a narrowed record for request body fields",
+  );
+  assert.doesNotMatch(
+    source,
+    /}\s*=\s*body\s+as\s+Record<string,\s*unknown>/,
+    "sessions POST should not destructure arbitrary JSON via a blind type cast",
+  );
+});
diff --git a/src/core/__tests__/session-runtime-auth.test.ts b/src/core/__tests__/session-runtime-auth.test.ts
index 4a8deaf..10d6e74 100644
--- a/src/core/__tests__/session-runtime-auth.test.ts
+++ b/src/core/__tests__/session-runtime-auth.test.ts
@@ -5,6 +5,7 @@ import {
   DEFAULT_AGENT_MODEL,
   DEFAULT_SESSION_AUTH_MODE,
   buildClaudeProcessEnv,
+  getPersistedSessionBaseUrl,
   getSessionRuntimeAuthInputFromPayload,
   resolveSessionRuntimeAuthConfig,
 } from "../session-runtime-auth";
@@ -69,6 +70,29 @@ test("local CLI mode resolves selected agent, model, and reasoning", () => {
   assert.equal(config.reasoning, "high");
 });
 
+test("whitespace-only local CLI agent id is treated as absent", () => {
+  const config = resolveSessionRuntimeAuthConfig({
+    session_auth_mode: "local-cli",
+    local_cli_agent_id: "   ",
+    agent_model: "gpt-5-codex",
+    agent_reasoning: "high",
+  });
+
+  assert.equal(config.localCliAgentId, "claude");
+  assert.equal(config.model, "gpt-5-codex");
+  assert.equal(config.reasoning, "high");
+});
+
+test("local CLI mode persists a non-null default base URL for session metadata", () => {
+  const config = resolveSessionRuntimeAuthConfig({
+    session_auth_mode: "local-cli",
+    local_cli_agent_id: "claude",
+  });
+
+  assert.equal(config.baseUrl, null);
+  assert.equal(getPersistedSessionBaseUrl(config), "https://api.anthropic.com");
+});
+
 test("local CLI mode resolves selected allowlisted environment overrides", () => {
   const config = resolveSessionRuntimeAuthConfig({
     session_auth_mode: "local-cli",
diff --git a/src/core/__tests__/session-stream-dedupe.test.ts b/src/core/__tests__/session-stream-dedupe.test.ts
new file mode 100644
index 0000000..5d98179
--- /dev/null
+++ b/src/core/__tests__/session-stream-dedupe.test.ts
@@ -0,0 +1,78 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { filterBufferedReplayDuplicates } from "../session-stream-dedupe";
+import type { ChatStreamEvent } from "../stream-manager";
+
+test("filterBufferedReplayDuplicates removes live buffered events already covered by replay", () => {
+  const replayEvents: ChatStreamEvent[] = [
+    { type: "status", status: "running" },
+    { type: "message", id: 42, role: "user", content: "persisted prompt" },
+    {
+      type: "log",
+      id: 7,
+      stream: "stderr",
+      chunk: "persisted warning",
+      timestamp: "2026-06-04T01:00:00.000Z",
+    },
+  ];
+  const bufferedEvents: ChatStreamEvent[] = [
+    { type: "status", status: "running" },
+    { type: "message", id: 42, role: "user", content: "persisted prompt" },
+    {
+      type: "log",
+      id: 7,
+      stream: "stderr",
+      chunk: "persisted warning",
+      timestamp: "2026-06-04T01:00:00.000Z",
+    },
+    { type: "message", id: 43, role: "user", content: "new prompt" },
+    {
+      type: "system_log",
+      level: "info",
+      message: "Codex turn started",
+      timestamp: "2026-06-04T01:00:01.000Z",
+    },
+  ];
+
+  assert.deepEqual(
+    filterBufferedReplayDuplicates(replayEvents, bufferedEvents),
+    [
+      { type: "status", status: "running" },
+      { type: "message", id: 43, role: "user", content: "new prompt" },
+      {
+        type: "system_log",
+        level: "info",
+        message: "Codex turn started",
+        timestamp: "2026-06-04T01:00:01.000Z",
+      },
+    ],
+  );
+});
+
+test("filterBufferedReplayDuplicates keeps same-content messages when ids differ", () => {
+  const replayEvents: ChatStreamEvent[] = [
+    { type: "message", id: 42, role: "user", content: "continue" },
+  ];
+  const bufferedEvents: ChatStreamEvent[] = [
+    { type: "message", id: 43, role: "user", content: "continue" },
+  ];
+
+  assert.deepEqual(
+    filterBufferedReplayDuplicates(replayEvents, bufferedEvents),
+    [{ type: "message", id: 43, role: "user", content: "continue" }],
+  );
+});
+
+test("filterBufferedReplayDuplicates preserves live status metadata updates", () => {
+  const replayEvents: ChatStreamEvent[] = [
+    { type: "status", status: "running", pid: 1001 },
+  ];
+  const bufferedEvents: ChatStreamEvent[] = [
+    { type: "status", status: "running", pid: 2002 },
+  ];
+
+  assert.deepEqual(
+    filterBufferedReplayDuplicates(replayEvents, bufferedEvents),
+    [{ type: "status", status: "running", pid: 2002 }],
+  );
+});
diff --git a/src/core/__tests__/session-stream-replay.test.ts b/src/core/__tests__/session-stream-replay.test.ts
new file mode 100644
index 0000000..acdd582
--- /dev/null
+++ b/src/core/__tests__/session-stream-replay.test.ts
@@ -0,0 +1,174 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { makeTestDb } from "./test-helpers";
+import { buildSessionStreamReplayEvents } from "../session-stream-replay";
+
+test("buildSessionStreamReplayEvents replays running state, messages, and logs", () => {
+  const db = makeTestDb();
+
+  db.prepare(
+    `INSERT INTO sessions (
+      id, project_id, task_id, worktree_path, status, pid,
+      started_at, session_auth_mode, local_cli_agent_id, agent_model, agent_reasoning
+    ) VALUES (
+      'session-running', 'videoclaw', NULL, '/repo', 'running', 6560,
+      '2026-06-03 00:40:00', 'local-cli', 'codex', 'gpt-5.5', 'high'
+    )`,
+  ).run();
+  db.prepare(
+    "INSERT INTO session_messages (session_id, role, content, timestamp) VALUES (?, 'user', ?, ?)",
+  ).run("session-running", "Initial prompt", "2026-06-03 00:41:14");
+  db.prepare(
+    "INSERT INTO session_logs (session_id, chunk, stream, timestamp) VALUES (?, ?, 'stderr', ?)",
+  ).run("session-running", "warning: sandbox note", "2026-06-03 00:41:15");
+  db.prepare(
+    "INSERT INTO session_logs (session_id, chunk, stream, timestamp) VALUES (?, ?, 'stderr', ?)",
+  ).run("session-running", "apply_patch verification failed", "2026-06-03 00:46:58");
+
+  const events = buildSessionStreamReplayEvents(db, "session-running", {
+    logLimit: 10,
+  });
+
+  assert.deepEqual(
+    events.map((event) => event.type),
+    ["status", "message", "log", "log"],
+  );
+  assert.deepEqual(events[0], {
+    type: "status",
+    status: "running",
+    pid: 6560,
+    started_at: "2026-06-03 00:40:00",
+    ended_at: null,
+  });
+  assert.deepEqual(events[1], {
+    type: "message",
+    id: 1,
+    role: "user",
+    content: "Initial prompt",
+  });
+  assert.deepEqual(events[2], {
+    type: "log",
+    id: 1,
+    stream: "stderr",
+    chunk: "warning: sandbox note",
+    timestamp: "2026-06-03 00:41:15",
+  });
+  assert.deepEqual(events[3], {
+    type: "log",
+    id: 2,
+    stream: "stderr",
+    chunk: "apply_patch verification failed",
+    timestamp: "2026-06-03 00:46:58",
+  });
+});
+
+test("buildSessionStreamReplayEvents limits logs to the newest selected subset in chronological order", () => {
+  const db = makeTestDb();
+
+  db.prepare(
+    `INSERT INTO sessions (
+      id, project_id, task_id, worktree_path, status, pid,
+      started_at, session_auth_mode, local_cli_agent_id, agent_model, agent_reasoning
+    ) VALUES (
+      'session-log-limit', 'videoclaw', NULL, '/repo', 'running', 6560,
+      '2026-06-03 00:40:00', 'local-cli', 'codex', 'gpt-5.5', 'high'
+    )`,
+  ).run();
+  db.prepare(
+    "INSERT INTO session_logs (session_id, chunk, stream, timestamp) VALUES (?, ?, 'stderr', ?)",
+  ).run("session-log-limit", "oldest log", "2026-06-03 00:41:00");
+  db.prepare(
+    "INSERT INTO session_logs (session_id, chunk, stream, timestamp) VALUES (?, ?, 'stderr', ?)",
+  ).run("session-log-limit", "middle log", "2026-06-03 00:42:00");
+  db.prepare(
+    "INSERT INTO session_logs (session_id, chunk, stream, timestamp) VALUES (?, ?, 'stderr', ?)",
+  ).run("session-log-limit", "newest log", "2026-06-03 00:43:00");
+
+  const events = buildSessionStreamReplayEvents(db, "session-log-limit", {
+    logLimit: 2,
+  });
+
+  assert.deepEqual(
+    events.map((event) => event.type),
+    ["status", "log", "log"],
+  );
+  assert.deepEqual(events.slice(1), [
+    {
+      type: "log",
+      id: 2,
+      stream: "stderr",
+      chunk: "middle log",
+      timestamp: "2026-06-03 00:42:00",
+    },
+    {
+      type: "log",
+      id: 3,
+      stream: "stderr",
+      chunk: "newest log",
+      timestamp: "2026-06-03 00:43:00",
+    },
+  ]);
+});
+
+test("buildSessionStreamReplayEvents interleaves messages and logs by timestamp", () => {
+  const db = makeTestDb();
+
+  db.prepare(
+    `INSERT INTO sessions (
+      id, project_id, task_id, worktree_path, status, pid,
+      started_at, session_auth_mode, local_cli_agent_id, agent_model, agent_reasoning
+    ) VALUES (
+      'session-interleaved', 'videoclaw', NULL, '/repo', 'running', 6560,
+      '2026-06-03 00:40:00', 'local-cli', 'codex', 'gpt-5.5', 'high'
+    )`,
+  ).run();
+  db.prepare(
+    "INSERT INTO session_logs (session_id, chunk, stream, timestamp) VALUES (?, ?, 'stdout', ?)",
+  ).run("session-interleaved", "first log", "2026-06-03 00:41:00");
+  db.prepare(
+    "INSERT INTO session_messages (session_id, role, content, timestamp) VALUES (?, 'user', ?, ?)",
+  ).run("session-interleaved", "User prompt", "2026-06-03 00:42:00");
+  db.prepare(
+    "INSERT INTO session_logs (session_id, chunk, stream, timestamp) VALUES (?, ?, 'stderr', ?)",
+  ).run("session-interleaved", "second log", "2026-06-03 00:43:00");
+  db.prepare(
+    "INSERT INTO session_messages (session_id, role, content, timestamp) VALUES (?, 'assistant', ?, ?)",
+  ).run("session-interleaved", "Assistant reply", "2026-06-03 00:44:00");
+
+  const events = buildSessionStreamReplayEvents(db, "session-interleaved", {
+    logLimit: 10,
+  });
+
+  assert.deepEqual(
+    events.slice(1).map((event) => event.type),
+    ["log", "message", "log", "message"],
+  );
+  assert.deepEqual(events.slice(1), [
+    {
+      type: "log",
+      id: 1,
+      stream: "stdout",
+      chunk: "first log",
+      timestamp: "2026-06-03 00:41:00",
+    },
+    {
+      type: "message",
+      id: 1,
+      role: "user",
+      content: "User prompt",
+    },
+    {
+      type: "log",
+      id: 2,
+      stream: "stderr",
+      chunk: "second log",
+      timestamp: "2026-06-03 00:43:00",
+    },
+    {
+      type: "message",
+      id: 2,
+      role: "assistant",
+      content: "Assistant reply",
+    },
+  ]);
+});
diff --git a/src/core/__tests__/task-card-actions.test.ts b/src/core/__tests__/task-card-actions.test.ts
index 5fdc376..2f70dab 100644
--- a/src/core/__tests__/task-card-actions.test.ts
+++ b/src/core/__tests__/task-card-actions.test.ts
@@ -68,6 +68,13 @@ test("historical sessions do not hide the execute button", () => {
   );
 });
 
+test("failed tasks can execute again when the linked session is terminal", () => {
+  assert.equal(
+    canExecuteTaskFromCard(task({ status: "fail", prompt: "Run it" }), session({ status: "failed" })),
+    true
+  );
+});
+
 test("active sessions hide execute and show pause for in-progress cards", () => {
   assert.equal(
     canExecuteTaskFromCard(task({ status: "todo", prompt: "Run it" }), session({ status: "running" })),
diff --git a/src/core/__tests__/task-launch-e2e-config.test.ts b/src/core/__tests__/task-launch-e2e-config.test.ts
new file mode 100644
index 0000000..dc8ce51
--- /dev/null
+++ b/src/core/__tests__/task-launch-e2e-config.test.ts
@@ -0,0 +1,85 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+const {
+  buildTaskLaunchRuntimePayload,
+  describeTaskLaunchRuntimePayload,
+} = await import("../../../scripts/task-launch-e2e-config.mjs");
+
+function env(overrides: Record<string, string>): NodeJS.ProcessEnv {
+  return { NODE_ENV: "test", ...overrides };
+}
+
+test("task launch E2E defaults to the current Local CLI runtime payload", () => {
+  const payload = buildTaskLaunchRuntimePayload(env({}));
+
+  assert.deepEqual(payload, {
+    session_auth_mode: "local-cli",
+    local_cli_agent_id: "claude",
+    agent_model: "default",
+    agent_reasoning: "medium",
+  });
+});
+
+test("task launch E2E builds a transient BYOK provider payload from env", () => {
+  const payload = buildTaskLaunchRuntimePayload(env({
+    DEVLOG_E2E_AUTH_MODE: "anthropic-api-key",
+    DEVLOG_E2E_API_PROTOCOL: "openai",
+    DEVLOG_E2E_AGENT_MODEL: "gpt-4o-mini",
+    DEVLOG_E2E_AGENT_BASE_URL: "https://api.openai.com/v1",
+    DEVLOG_E2E_AGENT_MAX_TOKENS: "12000",
+    DEVLOG_E2E_API_KEY: "sk-test",
+  }));
+
+  assert.deepEqual(payload, {
+    session_auth_mode: "anthropic-api-key",
+    agent_api_protocol: "openai",
+    agent_model: "gpt-4o-mini",
+    agent_base_url: "https://api.openai.com/v1",
+    agent_api_version: "",
+    agent_max_tokens: 12000,
+    anthropic_api_key: "sk-test",
+  });
+});
+
+test("task launch E2E can resolve a BYOK key from a named environment variable", () => {
+  const payload = buildTaskLaunchRuntimePayload(env({
+    DEVLOG_E2E_AUTH_MODE: "anthropic-api-key",
+    DEVLOG_E2E_API_KEY_ENV_VAR: "DEVLOG_TEST_KEY",
+    DEVLOG_TEST_KEY: "sk-from-env",
+  }));
+
+  assert.equal(
+    (payload as Record<string, unknown>).anthropic_api_key,
+    "sk-from-env",
+  );
+});
+
+test("task launch E2E keeps legacy backend env-var mode available explicitly", () => {
+  const payload = buildTaskLaunchRuntimePayload(env({
+    DEVLOG_E2E_AUTH_MODE: "agent-api-key",
+    DEVLOG_E2E_AGENT_API_KEY_ENV_VAR: "ANTHROPIC_API_KEY",
+    DEVLOG_E2E_AGENT_MODEL: "claude-sonnet-4-6",
+  }));
+
+  assert.deepEqual(payload, {
+    session_auth_mode: "agent-api-key",
+    agent_api_key_env_var: "ANTHROPIC_API_KEY",
+    agent_model: "claude-sonnet-4-6",
+  });
+});
+
+test("task launch E2E runtime description does not log secret env var names", () => {
+  const payload = buildTaskLaunchRuntimePayload(env({
+    DEVLOG_E2E_AUTH_MODE: "agent-api-key",
+    DEVLOG_E2E_AGENT_API_KEY_ENV_VAR: "ANTHROPIC_API_KEY",
+    DEVLOG_E2E_AGENT_MODEL: "claude-sonnet-4-6",
+  }));
+
+  const description = describeTaskLaunchRuntimePayload(payload);
+
+  assert.match(description, /mode=agent-api-key/);
+  assert.match(description, /keyEnv=configured/);
+  assert.doesNotMatch(description, /ANTHROPIC_API_KEY/);
+  assert.doesNotMatch(description, /agent_api_key_env_var/);
+});
diff --git a/src/core/__tests__/task-lifecycle.test.ts b/src/core/__tests__/task-lifecycle.test.ts
new file mode 100644
index 0000000..a2b1315
--- /dev/null
+++ b/src/core/__tests__/task-lifecycle.test.ts
@@ -0,0 +1,123 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { makeTestDb } from "./test-helpers";
+import {
+  markSessionFailedAndReleaseLinkedTask,
+  validateTaskSessionLaunch,
+} from "../task-lifecycle";
+import {
+  getTaskBoardColumns,
+  isTaskExecutableStatus,
+} from "../task-status-flow";
+
+test("linked launch failure moves the current in-progress task to fail", () => {
+  const db = makeTestDb();
+  db.prepare(
+    `INSERT INTO tasks (
+      id, project_id, title, status, worktree_name, session_id, fail_reason, prompt
+    ) VALUES (
+      'task-failed-launch', 'devlog', 'Retryable task', 'in_progress',
+      'task-retryable-task', 'session-failed-launch', NULL, 'Run it'
+    )`,
+  ).run();
+  db.prepare(
+    `INSERT INTO sessions (
+      id, project_id, task_id, worktree_name, worktree_path, status
+    ) VALUES (
+      'session-failed-launch', 'devlog', 'task-failed-launch',
+      'task-retryable-task', '/repo/.worktrees/task-retryable-task', 'running'
+    )`,
+  ).run();
+
+  markSessionFailedAndReleaseLinkedTask(
+    db,
+    "session-failed-launch",
+    "Failed to start agent: codex not on PATH",
+  );
+
+  const task = db
+    .prepare("SELECT status, session_id, fail_reason FROM tasks WHERE id = ?")
+    .get("task-failed-launch") as {
+    status: string;
+    session_id: string | null;
+    fail_reason: string | null;
+  };
+  const session = db
+    .prepare("SELECT status, pid, ended_at FROM sessions WHERE id = ?")
+    .get("session-failed-launch") as {
+    status: string;
+    pid: number | null;
+    ended_at: string | null;
+  };
+
+  assert.deepEqual(task, {
+    status: "fail",
+    session_id: "session-failed-launch",
+    fail_reason: "Failed to start agent: codex not on PATH",
+  });
+  assert.equal(session.status, "failed");
+  assert.equal(session.pid, null);
+  assert.equal(typeof session.ended_at, "string");
+});
+
+test("failed tasks are visible in Tasks and can be launched again", () => {
+  assert.equal(isTaskExecutableStatus("fail"), true);
+  assert.equal(
+    getTaskBoardColumns().some(
+      (column) =>
+        (column.type === "status" && column.status === "fail") ||
+        (column.type === "group" && column.statuses.includes("fail")),
+    ),
+    true,
+  );
+});
+
+test("the Tasks UI groups queued and failed work without merging status semantics", () => {
+  const columns = getTaskBoardColumns();
+
+  assert.deepEqual(
+    columns.map((column) => column.id),
+    ["todo", "queue_failed", "in_progress", "review", "blocked", "done"],
+  );
+
+  const queueFailedColumn = columns.find(
+    (column) => column.id === "queue_failed",
+  );
+  assert.deepEqual(queueFailedColumn, {
+    id: "queue_failed",
+    type: "group",
+    label: "Queue / Failed",
+    statuses: ["in_queue", "fail"],
+  });
+  assert.equal(isTaskExecutableStatus("in_queue"), false);
+  assert.equal(isTaskExecutableStatus("fail"), true);
+});
+
+test("session launch validation only allows executable tasks in the current project", () => {
+  const db = makeTestDb();
+  db.prepare(
+    `INSERT INTO tasks (id, project_id, title, status)
+     VALUES
+       ('task-retryable', 'devlog', 'Retryable', 'fail'),
+       ('task-in-review', 'devlog', 'In Review', 'review'),
+       ('task-other-project', 'other', 'Other Project', 'fail')`,
+  ).run();
+
+  assert.deepEqual(validateTaskSessionLaunch(db, "task-retryable", "devlog"), {
+    ok: true,
+    task: { id: "task-retryable", status: "fail" },
+  });
+  assert.deepEqual(validateTaskSessionLaunch(db, "task-in-review", "devlog"), {
+    ok: false,
+    status: 400,
+    error: "Cannot launch session for task with status 'review'",
+  });
+  assert.deepEqual(
+    validateTaskSessionLaunch(db, "task-other-project", "devlog"),
+    {
+      ok: false,
+      status: 404,
+      error: "Task not found",
+    },
+  );
+});
diff --git a/src/core/__tests__/task-retry-request.test.ts b/src/core/__tests__/task-retry-request.test.ts
new file mode 100644
index 0000000..8990f9f
--- /dev/null
+++ b/src/core/__tests__/task-retry-request.test.ts
@@ -0,0 +1,23 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { buildTaskRetryRequestBody } from "../task-retry-request";
+
+test("buildTaskRetryRequestBody carries feedback and current runtime payload", () => {
+  assert.deepEqual(
+    buildTaskRetryRequestBody("  Fix the review notes.  ", {
+      session_auth_mode: "anthropic-api-key",
+      agent_api_protocol: "openai",
+      agent_model: "gpt-4o-mini",
+      agent_base_url: "https://api.openai.com/v1",
+      anthropic_api_key: "sk-test",
+    }),
+    {
+      feedback: "Fix the review notes.",
+      session_auth_mode: "anthropic-api-key",
+      agent_api_protocol: "openai",
+      agent_model: "gpt-4o-mini",
+      agent_base_url: "https://api.openai.com/v1",
+      anthropic_api_key: "sk-test",
+    },
+  );
+});
diff --git a/src/core/__tests__/task-retry.test.ts b/src/core/__tests__/task-retry.test.ts
new file mode 100644
index 0000000..81f38cc
--- /dev/null
+++ b/src/core/__tests__/task-retry.test.ts
@@ -0,0 +1,62 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { buildTaskRetryPrompt } from "../task-retry";
+import { resolveAgentExecutionConfig } from "../agent-presets";
+import { resolveSessionRuntimeAuthConfig } from "../session-runtime-auth";
+import type { Task } from "../types-dashboard";
+
+function task(overrides: Partial<Task> = {}): Task {
+  return {
+    id: "task-1",
+    project_id: "devlog",
+    title: "Retry task",
+    description: "Fix the workflow",
+    status: "review",
+    priority: "medium",
+    worktree_name: "task-retry-task",
+    session_id: "session-old",
+    sort_order: 0,
+    prompt: "Implement the requested change.",
+    created_at: "2026-06-01T00:00:00.000Z",
+    updated_at: "2026-06-01T00:00:00.000Z",
+    completed_at: null,
+    ...overrides,
+  };
+}
+
+test("buildTaskRetryPrompt preserves Settings-derived execution and model context", () => {
+  const prompt = buildTaskRetryPrompt({
+    task: task(),
+    project: {
+      id: "devlog",
+      name: "DevLog",
+      path: "/repo",
+      defaultBranch: "main",
+    },
+    worktreePath: "/repo-task",
+    branchName: "task/retry-task",
+    feedback: "Use the selected API model for the retry.",
+    previousBrief: "Previous attempt touched the wrong route.",
+    agentConfig: resolveAgentExecutionConfig({
+      coding_agent_id: "backend-coding-agent",
+      agent_team_id: "solo-coding-agent",
+    }),
+    runtimeAuthConfig: resolveSessionRuntimeAuthConfig({
+      session_auth_mode: "anthropic-api-key",
+      agent_api_protocol: "openai",
+      agent_model: "gpt-4o-mini",
+      agent_base_url: "https://api.openai.com/v1",
+      anthropic_api_key: "sk-test",
+      agent_max_tokens: 12000,
+    }),
+  });
+
+  assert.match(prompt, /## Agent Execution/);
+  assert.match(prompt, /Coding agent: Backend Coding Agent/);
+  assert.match(prompt, /Agent team: Solo Coding Agent/);
+  assert.match(prompt, /Runtime execution: API \(BYOK, OpenAI API\); model gpt-4o-mini/);
+  assert.match(prompt, /max output 12000 tokens/);
+  assert.match(prompt, /## Previous Attempt Feedback/);
+  assert.match(prompt, /Use the selected API model for the retry/);
+  assert.match(prompt, /## Previous Session Summary/);
+});
diff --git a/src/core/agent-connection-test.ts b/src/core/agent-connection-test.ts
index 1ca32d7..9af9f36 100644
--- a/src/core/agent-connection-test.ts
+++ b/src/core/agent-connection-test.ts
@@ -72,7 +72,7 @@ export interface AgentConnectionTestOptions {
 
 const SMOKE_PROMPT = "Reply with only: ok";
 const DEFAULT_PROVIDER_TIMEOUT_MS = 12_000;
-const DEFAULT_AGENT_TIMEOUT_MS = 45_000;
+export const DEFAULT_AGENT_TIMEOUT_MS = 180_000;
 const TEST_ALLOWED_TOOLS = ["Read", "Glob", "Grep"];
 
 function elapsed(start: number): number {
@@ -132,6 +132,13 @@ function extractTextFromJsonEvent(value: unknown): string {
     return value.map(extractTextFromJsonEvent).join("");
   }
   const record = value as Record<string, unknown>;
+  if (record.type === "error") return "";
+  if (record.type === "item.completed") {
+    const item = record.item as Record<string, unknown> | undefined;
+    if (item?.type === "agent_message" && typeof item.text === "string") {
+      return item.text;
+    }
+  }
   const direct = record.text ?? record.deltaContent ?? record.content;
   if (typeof direct === "string") return direct;
   if (record.type === "assistant.message_delta") {
diff --git a/src/core/agent-settings.ts b/src/core/agent-settings.ts
index 679a77e..1aa2e81 100644
--- a/src/core/agent-settings.ts
+++ b/src/core/agent-settings.ts
@@ -65,6 +65,17 @@ export interface AgentSettings {
   anthropicApiKey: string;
 }
 
+export interface SessionContinuationRuntimeSnapshot {
+  session_auth_mode?: string | null;
+  local_cli_agent_id?: string | null;
+  agent_model?: string | null;
+  agent_reasoning?: string | null;
+  agent_api_protocol?: string | null;
+  agent_api_version?: string | null;
+  agent_base_url?: string | null;
+  agent_max_tokens?: number | null;
+}
+
 export type StoredAgentSettings = Pick<
   AgentSettings,
   | "executionMode"
@@ -874,3 +885,49 @@ export function buildSessionRuntimePayload(
       normalized.localCliAgentEnv[normalized.localCliAgentId] ?? {},
   };
 }
+
+export function buildSessionContinuationRuntimePayload(
+  session: SessionContinuationRuntimeSnapshot,
+  settings: AgentSettings,
+  scopedKeys: BrowserApiKeyScopes = {},
+): SessionRuntimeAuthInput {
+  const normalized = normalizeAgentSettings(settings);
+
+  if (session.session_auth_mode === "anthropic-api-key") {
+    const apiProtocol = sanitizeApiProtocol(session.agent_api_protocol);
+    const apiBaseUrl = sanitizeApiBaseUrl(session.agent_base_url, apiProtocol);
+    return {
+      session_auth_mode: "anthropic-api-key",
+      agent_api_protocol: apiProtocol,
+      agent_model: sanitizeApiModel(session.agent_model, apiProtocol),
+      agent_base_url: apiBaseUrl,
+      agent_api_version: sanitizeApiVersion(session.agent_api_version),
+      agent_max_tokens: sanitizeApiMaxTokens(session.agent_max_tokens),
+      anthropic_api_key:
+        getScopedBrowserApiKey(
+          { apiProtocol, apiBaseUrl },
+          scopedKeys,
+        ).trim() || null,
+    };
+  }
+
+  const localCliAgentId = sanitizeLocalCliAgentId(session.local_cli_agent_id);
+  const localCliAgent = getLocalCliAgentDefinition(localCliAgentId);
+  const reasoningIds = new Set(
+    (localCliAgent.reasoningOptions ?? [
+      { id: DEFAULT_LOCAL_CLI_REASONING, label: "Default" },
+    ]).map((option) => option.id),
+  );
+
+  return {
+    session_auth_mode: "local-cli",
+    local_cli_agent_id: localCliAgentId,
+    agent_model: sanitizeLocalCliModel(session.agent_model, localCliAgentId),
+    agent_reasoning: sanitizeKnownOption(
+      session.agent_reasoning,
+      reasoningIds,
+      DEFAULT_AGENT_SETTINGS.localCliReasoning,
+    ),
+    local_cli_agent_env: normalized.localCliAgentEnv[localCliAgentId] ?? {},
+  };
+}
diff --git a/src/core/api-session-runtime.ts b/src/core/api-session-runtime.ts
index 78fa97d..c2b8bc1 100644
--- a/src/core/api-session-runtime.ts
+++ b/src/core/api-session-runtime.ts
@@ -6,9 +6,10 @@ import {
   type ProviderChatMessage,
 } from "./api-provider-runtime";
 import {
-  resolveSessionRuntimeAuthConfig,
+  resolveStoredSessionRuntimeAuthConfig,
   type SessionRuntimeAuthInput,
 } from "./session-runtime-auth";
+import { markSessionFailedAndReleaseLinkedTask } from "./task-lifecycle";
 import type { ChatStreamEvent } from "./stream-manager";
 
 export interface ProviderSessionTurnOptions {
@@ -51,25 +52,10 @@ export async function runProviderSessionTurn({
     return { ok: false, error: "Session not found" };
   }
 
-  const runtimeAuthConfig = resolveSessionRuntimeAuthConfig({
-    session_auth_mode:
-      runtimeAuthInput.session_auth_mode ?? session.session_auth_mode,
-    agent_api_key_env_var:
-      runtimeAuthInput.agent_api_key_env_var ?? session.agent_api_key_env_var,
-    local_cli_agent_id:
-      runtimeAuthInput.local_cli_agent_id ?? session.local_cli_agent_id,
-    agent_model: runtimeAuthInput.agent_model ?? session.agent_model,
-    agent_reasoning:
-      runtimeAuthInput.agent_reasoning ?? session.agent_reasoning,
-    agent_api_protocol:
-      runtimeAuthInput.agent_api_protocol ?? session.agent_api_protocol,
-    agent_api_version:
-      runtimeAuthInput.agent_api_version ?? session.agent_api_version,
-    agent_base_url: runtimeAuthInput.agent_base_url ?? session.agent_base_url,
-    agent_max_tokens:
-      runtimeAuthInput.agent_max_tokens ?? session.agent_max_tokens,
-    anthropic_api_key: runtimeAuthInput.anthropic_api_key,
-  });
+  const runtimeAuthConfig = resolveStoredSessionRuntimeAuthConfig(
+    session,
+    runtimeAuthInput,
+  );
 
   if (
     runtimeAuthConfig.mode !== "anthropic-api-key" ||
@@ -83,9 +69,7 @@ export async function runProviderSessionTurn({
 
   const validated = validateProviderRuntimeConfig(runtimeAuthConfig);
   if (!validated.ok) {
-    db.prepare(
-      "UPDATE sessions SET status = 'failed', ended_at = datetime('now') WHERE id = ?",
-    ).run(sessionId);
+    markSessionFailedAndReleaseLinkedTask(db, sessionId, validated.error);
     emit(sessionId, { type: "error", message: validated.error });
     emit(sessionId, { type: "status", status: "failed" });
     return { ok: false, error: validated.error };
@@ -115,23 +99,27 @@ export async function runProviderSessionTurn({
     };
   }
 
-  emit(sessionId, { type: "message", role: "user", content: message });
+  emit(sessionId, {
+    type: "message",
+    id: Number(insertedUser.lastInsertRowid),
+    role: "user",
+    content: message,
+  });
 
   if (!result.ok) {
-    db.prepare(
-      "UPDATE sessions SET status = 'failed', ended_at = datetime('now') WHERE id = ?",
-    ).run(sessionId);
+    markSessionFailedAndReleaseLinkedTask(db, sessionId, result.error);
     emit(sessionId, { type: "error", message: result.error });
     emit(sessionId, { type: "status", status: "failed" });
     return { ok: false, error: result.error };
   }
 
-  db.prepare(
+  const insertedAssistant = db.prepare(
     "INSERT INTO session_messages (session_id, role, content) VALUES (?, 'assistant', ?)",
   ).run(sessionId, result.content);
   emit(sessionId, { type: "text_delta", text: result.content });
   emit(sessionId, {
     type: "message",
+    id: Number(insertedAssistant.lastInsertRowid),
     role: "assistant",
     content: result.content,
   });
diff --git a/src/core/process-manager.ts b/src/core/process-manager.ts
index 2bbb907..69bc443 100644
--- a/src/core/process-manager.ts
+++ b/src/core/process-manager.ts
@@ -9,11 +9,15 @@ import {
   type SystemLogLevel,
   type ToolCall,
 } from "./stream-manager";
-import { onSessionExit } from "./task-lifecycle";
+import {
+  markSessionFailedAndReleaseLinkedTask,
+  onSessionExit,
+} from "./task-lifecycle";
 import {
   buildClaudeProcessEnv,
   DEFAULT_AGENT_MODEL,
   resolveSessionRuntimeAuthConfig,
+  resolveStoredSessionRuntimeAuthConfig,
   type SessionRuntimeAuthConfig,
   type SessionRuntimeAuthInput,
 } from "./session-runtime-auth";
@@ -526,7 +530,7 @@ class ProcessManager {
     watchdog.unref?.();
   }
 
-  private emitGlobalSystemLog(
+  private emitSystemLog(
     level: SystemLogLevel,
     sessionId: string,
     message: string,
@@ -536,6 +540,10 @@ class ProcessManager {
       "global",
       createSystemLogEvent({ level, prefix, sessionId, message })
     );
+    streamManager.emit(
+      sessionId,
+      createSystemLogEvent({ level, prefix, sessionId, message })
+    );
   }
 
   private checkHealth(): void {
@@ -559,7 +567,7 @@ class ProcessManager {
       if (cannotRestartWithoutBrowserKey) {
         const message =
           "BYOK session became unresponsive and cannot be restarted because DevLog does not store browser-provided API keys. Re-enter the key in Settings and start a new turn.";
-        this.emitGlobalSystemLog("warning", sessionId, message, "[WATCHDOG]");
+        this.emitSystemLog("warning", sessionId, message, "[WATCHDOG]");
 
         try {
           sp.proc.kill("SIGKILL");
@@ -570,9 +578,7 @@ class ProcessManager {
 
         try {
           const db = getDb();
-          db.prepare(
-            "UPDATE sessions SET status = 'failed', pid = NULL, ended_at = datetime('now') WHERE id = ?",
-          ).run(sessionId);
+          markSessionFailedAndReleaseLinkedTask(db, sessionId, message);
         } catch {
           // ignore
         }
@@ -582,7 +588,7 @@ class ProcessManager {
         continue;
       }
 
-      this.emitGlobalSystemLog(
+      this.emitSystemLog(
         "warning",
         sessionId,
         `Session ${sessionId.slice(0, 8)} unresponsive for 3m. Restarting...`,
@@ -690,26 +696,7 @@ class ProcessManager {
   ): SessionRuntimeAuthConfig | null {
     const session = this.getStoredSessionRuntimeRow(sessionId);
     if (!session) return null;
-    return resolveSessionRuntimeAuthConfig({
-      session_auth_mode:
-        runtimeAuthInput.session_auth_mode ?? session.session_auth_mode,
-      agent_api_key_env_var:
-        runtimeAuthInput.agent_api_key_env_var ?? session.agent_api_key_env_var,
-      local_cli_agent_id:
-        runtimeAuthInput.local_cli_agent_id ?? session.local_cli_agent_id,
-      agent_model: runtimeAuthInput.agent_model ?? session.agent_model,
-      agent_reasoning:
-        runtimeAuthInput.agent_reasoning ?? session.agent_reasoning,
-      agent_api_protocol:
-        runtimeAuthInput.agent_api_protocol ?? session.agent_api_protocol,
-      agent_api_version:
-        runtimeAuthInput.agent_api_version ?? session.agent_api_version,
-      agent_base_url: runtimeAuthInput.agent_base_url ?? session.agent_base_url,
-      agent_max_tokens:
-        runtimeAuthInput.agent_max_tokens ?? session.agent_max_tokens,
-      anthropic_api_key: runtimeAuthInput.anthropic_api_key,
-      local_cli_agent_env: runtimeAuthInput.local_cli_agent_env,
-    });
+    return resolveStoredSessionRuntimeAuthConfig(session, runtimeAuthInput);
   }
 
   /**
@@ -750,25 +737,10 @@ class ProcessManager {
 
     // Clean env: remove CLAUDECODE so child doesn't think it's nested
     const { CLAUDECODE: _, ...cleanEnv } = process.env;
-    const runtimeAuthConfig = resolveSessionRuntimeAuthConfig({
-      session_auth_mode:
-        runtimeAuthInput.session_auth_mode ?? session.session_auth_mode,
-      agent_api_key_env_var:
-        runtimeAuthInput.agent_api_key_env_var ?? session.agent_api_key_env_var,
-      local_cli_agent_id:
-        runtimeAuthInput.local_cli_agent_id ?? session.local_cli_agent_id,
-      agent_model: runtimeAuthInput.agent_model ?? session.agent_model,
-      agent_reasoning:
-        runtimeAuthInput.agent_reasoning ?? session.agent_reasoning,
-      agent_api_protocol:
-        runtimeAuthInput.agent_api_protocol ?? session.agent_api_protocol,
-      agent_api_version:
-        runtimeAuthInput.agent_api_version ?? session.agent_api_version,
-      agent_base_url: runtimeAuthInput.agent_base_url ?? session.agent_base_url,
-      agent_max_tokens:
-        runtimeAuthInput.agent_max_tokens ?? session.agent_max_tokens,
-      anthropic_api_key: runtimeAuthInput.anthropic_api_key,
-    });
+    const runtimeAuthConfig = resolveStoredSessionRuntimeAuthConfig(
+      session,
+      runtimeAuthInput,
+    );
     const launch = buildLocalCliProcessLaunch(
       runtimeAuthConfig,
       session.claude_session_id,
@@ -776,15 +748,13 @@ class ProcessManager {
       session.worktree_path,
     );
     if (!launch.ok) {
-      db.prepare(
-        "UPDATE sessions SET status = 'failed', ended_at = datetime('now') WHERE id = ?",
-      ).run(sessionId);
+      markSessionFailedAndReleaseLinkedTask(db, sessionId, launch.error);
       streamManager.emit(sessionId, {
         type: "error",
         message: launch.error,
       });
       streamManager.emit(sessionId, { type: "status", status: "failed" });
-      this.emitGlobalSystemLog("warning", sessionId, launch.error);
+      this.emitSystemLog("warning", sessionId, launch.error);
       return null;
     }
     const processEnv = buildClaudeProcessEnv(
@@ -792,15 +762,13 @@ class ProcessManager {
       runtimeAuthConfig,
     );
     if (!processEnv.ok) {
-      db.prepare(
-        "UPDATE sessions SET status = 'failed', ended_at = datetime('now') WHERE id = ?",
-      ).run(sessionId);
+      markSessionFailedAndReleaseLinkedTask(db, sessionId, processEnv.error);
       streamManager.emit(sessionId, {
         type: "error",
         message: processEnv.error,
       });
       streamManager.emit(sessionId, { type: "status", status: "failed" });
-      this.emitGlobalSystemLog("warning", sessionId, processEnv.error);
+      this.emitSystemLog("warning", sessionId, processEnv.error);
       return null;
     }
     const env = processEnv.env;
@@ -834,7 +802,7 @@ class ProcessManager {
     };
 
     this.sessions.set(sessionId, sp);
-    this.emitGlobalSystemLog(
+    this.emitSystemLog(
       "info",
       sessionId,
       `Session ${sessionId.slice(0, 8)} process started with ${launch.agentName}`
@@ -844,15 +812,13 @@ class ProcessManager {
       this.sessions.delete(sessionId);
       const message = `Failed to start ${launch.agentName} process: ${err.message}`;
       try {
-        db.prepare(
-          "UPDATE sessions SET status = 'failed', pid = NULL, ended_at = datetime('now') WHERE id = ?",
-        ).run(sessionId);
+        markSessionFailedAndReleaseLinkedTask(db, sessionId, message);
       } catch {
         // ignore
       }
       streamManager.emit(sessionId, { type: "error", message });
       streamManager.emit(sessionId, { type: "status", status: "failed" });
-      this.emitGlobalSystemLog("warning", sessionId, message);
+      this.emitSystemLog("warning", sessionId, message);
     });
 
     proc.stdin?.on("error", (err: NodeJS.ErrnoException) => {
@@ -895,14 +861,24 @@ class ProcessManager {
         const text = chunk.toString().trim();
         if (text) {
           // Log stderr but don't surface as errors unless critical
+          let logId: number | undefined;
+          const timestamp = new Date().toISOString();
           try {
             const db = getDb();
-            db.prepare(
+            const result = db.prepare(
               "INSERT INTO session_logs (session_id, chunk, stream) VALUES (?, ?, 'stderr')"
             ).run(sessionId, text);
+            logId = Number(result.lastInsertRowid);
           } catch {
             // ignore
           }
+          streamManager.emit(sessionId, {
+            type: "log",
+            id: logId,
+            stream: "stderr",
+            chunk: text,
+            timestamp,
+          });
         }
       });
     }
@@ -911,7 +887,7 @@ class ProcessManager {
     proc.on("close", (code) => {
       this.flushGenericOutput(sessionId, sp);
       this.sessions.delete(sessionId);
-      this.emitGlobalSystemLog(
+      this.emitSystemLog(
         code === 0 ? "success" : "warning",
         sessionId,
         `Session ${sessionId.slice(0, 8)} process exited with code ${code ?? "unknown"}`
@@ -1059,23 +1035,19 @@ class ProcessManager {
       });
       ok = result.ok;
       if (!result.ok) {
-        this.emitGlobalSystemLog("warning", sessionId, result.error);
+        this.emitSystemLog("warning", sessionId, result.error);
       }
     } catch (error) {
       const message =
         error instanceof Error ? error.message : "Provider session failed.";
       try {
-        getDb()
-          .prepare(
-            "UPDATE sessions SET status = 'failed', ended_at = datetime('now') WHERE id = ?",
-          )
-          .run(sessionId);
+        markSessionFailedAndReleaseLinkedTask(getDb(), sessionId, message);
       } catch {
         // ignore
       }
       streamManager.emit(sessionId, { type: "error", message });
       streamManager.emit(sessionId, { type: "status", status: "failed" });
-      this.emitGlobalSystemLog("warning", sessionId, message);
+      this.emitSystemLog("warning", sessionId, message);
     } finally {
       this.providerProcessing.delete(sessionId);
       if (ok) {
@@ -1093,13 +1065,15 @@ class ProcessManager {
     const db = getDb();
 
     // Record user message in DB
-    db.prepare(
+    const insertResult = db.prepare(
       "INSERT INTO session_messages (session_id, role, content) VALUES (?, 'user', ?)"
     ).run(sp.sessionId, message);
+    const messageId = Number(insertResult.lastInsertRowid);
 
     // Emit to stream subscribers
     streamManager.emit(sp.sessionId, {
       type: "message",
+      id: messageId,
       role: "user",
       content: message,
     });
@@ -1317,6 +1291,28 @@ class ProcessManager {
     const type = event.type;
     const item = event.item as Record<string, unknown> | undefined;
 
+    if (type === "thread.started") {
+      const codexThreadId = this.getCodexThreadId(event);
+      this.emitSystemLog(
+        "info",
+        sessionId,
+        codexThreadId
+          ? `Codex thread started: ${codexThreadId}`
+          : "Codex thread started",
+      );
+      return true;
+    }
+
+    if (type === "turn.started") {
+      this.emitSystemLog("info", sessionId, "Codex turn started");
+      return true;
+    }
+
+    if (type === "turn.completed") {
+      this.emitSystemLog("success", sessionId, "Codex turn completed");
+      return true;
+    }
+
     if (
       type === "item.started" &&
       item?.type === "command_execution" &&
@@ -1371,11 +1367,22 @@ class ProcessManager {
       return true;
     }
 
-    return (
-      type === "thread.started" ||
-      type === "turn.started" ||
-      type === "turn.completed"
-    );
+    return false;
+  }
+
+  private getCodexThreadId(event: Record<string, unknown>): string | null {
+    const directId =
+      typeof event.thread_id === "string"
+        ? event.thread_id
+        : typeof event.threadId === "string"
+          ? event.threadId
+          : typeof event.session_id === "string"
+            ? event.session_id
+            : null;
+    if (directId) return directId;
+
+    const thread = isRecord(event.thread) ? event.thread : null;
+    return typeof thread?.id === "string" ? thread.id : null;
   }
 
   private handleGeminiEvent(
@@ -1702,9 +1709,11 @@ class ProcessManager {
       const db = getDb();
       try {
         if (isError) {
-          db.prepare(
-            "UPDATE sessions SET status = 'failed', pid = NULL, ended_at = datetime('now') WHERE id = ? AND status = 'running'"
-          ).run(sessionId);
+          markSessionFailedAndReleaseLinkedTask(
+            db,
+            sessionId,
+            "Agent reported an error for this turn.",
+          );
         } else {
           db.prepare(
             "UPDATE sessions SET status = 'idle' WHERE id = ? AND status = 'running'"
@@ -1757,7 +1766,7 @@ class ProcessManager {
   /** Kill the active process for a session */
   kill(sessionId: string): boolean {
     const sp = this.sessions.get(sessionId);
-    this.emitGlobalSystemLog(
+    this.emitSystemLog(
       "warning",
       sessionId,
       `Session ${sessionId.slice(0, 8)} kill requested`
@@ -1786,7 +1795,7 @@ class ProcessManager {
       "UPDATE sessions SET status = 'killed', ended_at = datetime('now') WHERE id = ?"
     ).run(sessionId);
     streamManager.emit(sessionId, { type: "status", status: "killed" });
-    this.emitGlobalSystemLog(
+    this.emitSystemLog(
       "warning",
       sessionId,
       `Session ${sessionId.slice(0, 8)} killed`
@@ -1798,7 +1807,7 @@ class ProcessManager {
   /** Pause the active process for a session without ending the session */
   pause(sessionId: string): boolean {
     const sp = this.sessions.get(sessionId);
-    this.emitGlobalSystemLog(
+    this.emitSystemLog(
       "info",
       sessionId,
       `Session ${sessionId.slice(0, 8)} pause requested`
@@ -1815,7 +1824,7 @@ class ProcessManager {
       "UPDATE sessions SET status = 'paused' WHERE id = ? AND status NOT IN ('completed', 'killed')"
     ).run(sessionId);
     streamManager.emit(sessionId, { type: "status", status: "paused" });
-    this.emitGlobalSystemLog(
+    this.emitSystemLog(
       "info",
       sessionId,
       `Session ${sessionId.slice(0, 8)} paused`
@@ -1826,7 +1835,7 @@ class ProcessManager {
 
   /** End a session (mark completed, no more turns) */
   endSession(sessionId: string): void {
-    this.emitGlobalSystemLog(
+    this.emitSystemLog(
       "info",
       sessionId,
       `Session ${sessionId.slice(0, 8)} completion requested`
@@ -1837,7 +1846,7 @@ class ProcessManager {
       "UPDATE sessions SET status = 'completed', ended_at = datetime('now') WHERE id = ?"
     ).run(sessionId);
     streamManager.emit(sessionId, { type: "status", status: "completed" });
-    this.emitGlobalSystemLog(
+    this.emitSystemLog(
       "success",
       sessionId,
       `Session ${sessionId.slice(0, 8)} completed`
diff --git a/src/core/session-runtime-auth.ts b/src/core/session-runtime-auth.ts
index dea2e74..e4f4ea5 100644
--- a/src/core/session-runtime-auth.ts
+++ b/src/core/session-runtime-auth.ts
@@ -296,6 +296,7 @@ export function resolveSessionRuntimeAuthConfig(
   const localCliAgentValid =
     mode !== "local-cli" ||
     !input.local_cli_agent_id ||
+    !input.local_cli_agent_id.trim() ||
     input.local_cli_agent_id.trim() === localCliAgentId;
   const localCliAgent = findLocalCliAgent(localCliAgentId);
   const localCliAgentEnv =
@@ -350,6 +351,23 @@ export function resolveSessionRuntimeAuthConfig(
   };
 }
 
+export function resolveStoredSessionRuntimeAuthConfig(
+  stored: SessionRuntimeAuthInput = {},
+  transientInput: SessionRuntimeAuthInput = {},
+): SessionRuntimeAuthConfig {
+  const {
+    anthropic_api_key: _storedApiKey,
+    local_cli_agent_env: _storedLocalCliEnv,
+    ...persistedInput
+  } = stored;
+
+  return resolveSessionRuntimeAuthConfig({
+    ...persistedInput,
+    anthropic_api_key: transientInput.anthropic_api_key,
+    local_cli_agent_env: transientInput.local_cli_agent_env,
+  });
+}
+
 export function buildSessionRuntimeAuthInstructions(
   config: SessionRuntimeAuthConfig,
 ): string {
@@ -375,6 +393,12 @@ export function buildSessionRuntimeAuthInstructions(
   return `Runtime execution: Local code-agent CLI (${config.localCliAgentName}); ${modelText}${reasoningText}.`;
 }
 
+export function getPersistedSessionBaseUrl(
+  config: SessionRuntimeAuthConfig,
+): string {
+  return config.baseUrl ?? DEFAULT_BASE_URL_BY_PROTOCOL[config.apiProtocol];
+}
+
 export function buildClaudeProcessEnv(
   baseEnv: NodeJS.ProcessEnv,
   config: SessionRuntimeAuthConfig,
diff --git a/src/core/session-stream-dedupe.ts b/src/core/session-stream-dedupe.ts
new file mode 100644
index 0000000..c45063a
--- /dev/null
+++ b/src/core/session-stream-dedupe.ts
@@ -0,0 +1,30 @@
+import type { ChatStreamEvent } from "./stream-manager";
+
+export function filterBufferedReplayDuplicates(
+  replayEvents: ChatStreamEvent[],
+  bufferedEvents: ChatStreamEvent[],
+): ChatStreamEvent[] {
+  const replayKeys = new Set<string>();
+  for (const event of replayEvents) {
+    const key = getReplayDedupeKey(event);
+    if (key) replayKeys.add(key);
+  }
+
+  return bufferedEvents.filter((event) => {
+    const key = getReplayDedupeKey(event);
+    return !key || !replayKeys.has(key);
+  });
+}
+
+function getReplayDedupeKey(event: ChatStreamEvent): string | null {
+  switch (event.type) {
+    case "message":
+      return typeof event.id === "number" ? `message:${event.id}` : null;
+    case "log":
+      return typeof event.id === "number" ? `log:${event.id}` : null;
+    case "status":
+      return null;
+    default:
+      return null;
+  }
+}
diff --git a/src/core/session-stream-replay.ts b/src/core/session-stream-replay.ts
new file mode 100644
index 0000000..0206bd5
--- /dev/null
+++ b/src/core/session-stream-replay.ts
@@ -0,0 +1,131 @@
+import type Database from "better-sqlite3";
+import type { ChatStreamEvent } from "./stream-manager";
+
+export interface SessionStreamReplayOptions {
+  logLimit?: number;
+}
+
+type SessionRow = {
+  id: string;
+  status: string;
+  pid: number | null;
+  started_at: string | null;
+  ended_at: string | null;
+};
+
+type MessageRow = {
+  id: number;
+  role: "user" | "assistant";
+  content: string;
+  timestamp: string;
+};
+
+type LogRow = {
+  id: number;
+  stream: "stdout" | "stderr";
+  chunk: string;
+  timestamp: string;
+};
+
+type ReplayItem = {
+  id: number;
+  timestamp: string;
+  sourceOrder: number;
+  event: ChatStreamEvent;
+};
+
+const DEFAULT_LOG_LIMIT = 100;
+
+export function buildSessionStreamReplayEvents(
+  db: Database.Database,
+  sessionId: string,
+  options: SessionStreamReplayOptions = {},
+): ChatStreamEvent[] {
+  const session = db
+    .prepare("SELECT id, status, pid, started_at, ended_at FROM sessions WHERE id = ?")
+    .get(sessionId) as SessionRow | undefined;
+
+  if (!session) {
+    return [];
+  }
+
+  const messages = db
+    .prepare(
+      "SELECT id, role, content, timestamp FROM session_messages WHERE session_id = ? ORDER BY timestamp ASC, id ASC",
+    )
+    .all(sessionId) as MessageRow[];
+  const logLimit = normalizeLogLimit(options.logLimit);
+  const logs =
+    logLimit > 0
+      ? (db
+          .prepare(
+            `SELECT id, stream, chunk, timestamp
+             FROM (
+               SELECT id, stream, chunk, timestamp
+               FROM session_logs
+               WHERE session_id = ?
+               ORDER BY timestamp DESC, id DESC
+               LIMIT ?
+             )
+             ORDER BY timestamp ASC, id ASC`,
+          )
+          .all(sessionId, logLimit) as LogRow[])
+      : [];
+
+  const replayItems: ReplayItem[] = [
+    ...messages.map((message) => ({
+      id: message.id,
+      timestamp: message.timestamp,
+      sourceOrder: 0,
+      event: {
+        type: "message" as const,
+        id: message.id,
+        role: message.role,
+        content: message.content,
+      },
+    })),
+    ...logs.map((log) => ({
+      id: log.id,
+      timestamp: log.timestamp,
+      sourceOrder: 1,
+      event: {
+        type: "log" as const,
+        id: log.id,
+        stream: log.stream,
+        chunk: log.chunk,
+        timestamp: log.timestamp,
+      },
+    })),
+  ].sort((left, right) => {
+    const timestampOrder = left.timestamp.localeCompare(right.timestamp);
+    if (timestampOrder !== 0) {
+      return timestampOrder;
+    }
+    const idOrder = left.id - right.id;
+    if (idOrder !== 0) {
+      return idOrder;
+    }
+    return left.sourceOrder - right.sourceOrder;
+  });
+
+  return [
+    {
+      type: "status",
+      status: session.status,
+      pid: session.pid,
+      started_at: session.started_at,
+      ended_at: session.ended_at,
+    },
+    ...replayItems.map((item) => item.event),
+  ];
+}
+
+function normalizeLogLimit(logLimit: number | undefined): number {
+  if (logLimit === undefined) {
+    return DEFAULT_LOG_LIMIT;
+  }
+  if (!Number.isFinite(logLimit)) {
+    return DEFAULT_LOG_LIMIT;
+  }
+  return Math.max(0, Math.floor(logLimit));
+}
diff --git a/src/core/stream-manager.ts b/src/core/stream-manager.ts
index e0d6306..617254b 100644
--- a/src/core/stream-manager.ts
+++ b/src/core/stream-manager.ts
@@ -11,9 +11,23 @@ export type ChatStreamEvent =
   | { type: "tool_result"; name: string; output: string; is_error?: boolean }
   | { type: "turn_end"; cost_usd?: number; duration_ms?: number; session_id?: string }
   | { type: "error"; message: string }
-  | { type: "status"; status: string; content?: string }
+  | {
+      type: "status";
+      status: string;
+      content?: string;
+      pid?: number | null;
+      started_at?: string | null;
+      ended_at?: string | null;
+    }
+  | {
+      type: "log";
+      id?: number;
+      stream: "stdout" | "stderr";
+      chunk: string;
+      timestamp: string;
+    }
   | { type: "system_log"; level: SystemLogLevel; prefix?: string; message: string; session_id?: string; timestamp: string }
-  | { type: "message"; role: "user" | "assistant"; content: string; tool_calls?: ToolCall[] }
+  | { type: "message"; id?: number; role: "user" | "assistant"; content: string; tool_calls?: ToolCall[] }
   // Interactive session events
   | { type: "permission_request"; tool_name: string; tool_input: Record<string, unknown>; request_id: string }
   | { type: "permission_resolved"; request_id: string; approved: boolean }
diff --git a/src/core/task-lifecycle.ts b/src/core/task-lifecycle.ts
index ab64bef..8b0bf11 100644
--- a/src/core/task-lifecycle.ts
+++ b/src/core/task-lifecycle.ts
@@ -1,3 +1,4 @@
+import type Database from "better-sqlite3";
 import type { Task } from "./types-dashboard";
 import type { ProjectConfig } from "./types-project";
 import { getDb } from "./db";
@@ -10,6 +11,7 @@ import {
   buildSessionRuntimeAuthInstructions,
   type SessionRuntimeAuthConfig,
 } from "./session-runtime-auth";
+import { isTaskExecutableStatus } from "./task-status-flow";
 
 export function slugify(text: string): string {
   return text
@@ -58,6 +60,69 @@ export function buildPromptTemplate(
   return parts.join("\n");
 }
 
+export function markSessionFailedAndReleaseLinkedTask(
+  db: Database.Database,
+  sessionId: string,
+  failReason: string,
+): void {
+  db.prepare(
+    `UPDATE sessions
+     SET status = 'failed', pid = NULL, ended_at = datetime('now')
+     WHERE id = ? AND status NOT IN ('completed', 'killed')`,
+  ).run(sessionId);
+
+  const session = db
+    .prepare("SELECT task_id FROM sessions WHERE id = ?")
+    .get(sessionId) as { task_id: string | null } | undefined;
+  if (!session?.task_id) return;
+
+  const task = db
+    .prepare("SELECT id, status, session_id FROM tasks WHERE id = ?")
+    .get(session.task_id) as
+    | { id: string; status: Task["status"]; session_id: string | null }
+    | undefined;
+  if (!task || task.status !== "in_progress" || task.session_id !== sessionId) {
+    return;
+  }
+
+  db.prepare(
+    `UPDATE tasks
+     SET status = 'fail',
+         fail_reason = ?,
+         completed_at = NULL,
+         updated_at = datetime('now')
+     WHERE id = ? AND status = 'in_progress' AND session_id = ?`,
+  ).run(failReason, task.id, sessionId);
+}
+
+export type TaskSessionLaunchEligibility =
+  | { ok: true; task: Pick<Task, "id" | "status"> }
+  | { ok: false; status: 400 | 404; error: string };
+
+export function validateTaskSessionLaunch(
+  db: Database.Database,
+  taskId: string,
+  projectId: string,
+): TaskSessionLaunchEligibility {
+  const task = db
+    .prepare("SELECT id, status FROM tasks WHERE id = ? AND project_id = ?")
+    .get(taskId, projectId) as Pick<Task, "id" | "status"> | undefined;
+
+  if (!task) {
+    return { ok: false, status: 404, error: "Task not found" };
+  }
+
+  if (!isTaskExecutableStatus(task.status)) {
+    return {
+      ok: false,
+      status: 400,
+      error: `Cannot launch session for task with status '${task.status}'`,
+    };
+  }
+
+  return { ok: true, task };
+}
+
 export async function onSessionExit(sessionId: string): Promise<void> {
   const db = getDb();
   const session = db
diff --git a/src/core/task-retry-request.ts b/src/core/task-retry-request.ts
new file mode 100644
index 0000000..b050b8a
--- /dev/null
+++ b/src/core/task-retry-request.ts
@@ -0,0 +1,11 @@
+import type { SessionRuntimeAuthInput } from "./session-runtime-auth";
+
+export function buildTaskRetryRequestBody(
+  feedback: string,
+  runtimePayload: SessionRuntimeAuthInput,
+): { feedback: string } & SessionRuntimeAuthInput {
+  return {
+    feedback: feedback.trim(),
+    ...runtimePayload,
+  };
+}
diff --git a/src/core/task-retry.ts b/src/core/task-retry.ts
new file mode 100644
index 0000000..c1c3f29
--- /dev/null
+++ b/src/core/task-retry.ts
@@ -0,0 +1,48 @@
+import { buildPromptTemplate } from "./task-lifecycle";
+import type { AgentExecutionConfig } from "./agent-presets";
+import type { SessionRuntimeAuthConfig } from "./session-runtime-auth";
+import type { Task } from "./types-dashboard";
+import type { ProjectConfig } from "./types-project";
+
+export function buildTaskRetryPrompt({
+  task,
+  project,
+  worktreePath,
+  branchName,
+  feedback,
+  previousBrief,
+  agentConfig,
+  runtimeAuthConfig,
+}: {
+  task: Task;
+  project: ProjectConfig;
+  worktreePath: string;
+  branchName: string;
+  feedback: string;
+  previousBrief?: string;
+  agentConfig: AgentExecutionConfig;
+  runtimeAuthConfig: SessionRuntimeAuthConfig;
+}): string {
+  const basePrompt = buildPromptTemplate(
+    task,
+    project,
+    worktreePath,
+    branchName,
+    agentConfig,
+    runtimeAuthConfig,
+  );
+
+  return [
+    basePrompt,
+    "",
+    "## Previous Attempt Feedback",
+    feedback,
+    previousBrief
+      ? `\n## Previous Session Summary\n\`\`\`\n${previousBrief}\n\`\`\``
+      : "",
+    "",
+    "Address the feedback above and complete the task.",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
diff --git a/src/core/task-status-flow.ts b/src/core/task-status-flow.ts
new file mode 100644
index 0000000..4b6ed34
--- /dev/null
+++ b/src/core/task-status-flow.ts
@@ -0,0 +1,52 @@
+import type { TaskStatus } from "./types-dashboard";
+
+export type TaskBoardColumn =
+  | {
+      id: TaskStatus;
+      type: "status";
+      label: string;
+      status: TaskStatus;
+    }
+  | {
+      id: "queue_failed";
+      type: "group";
+      label: string;
+      statuses: TaskStatus[];
+    };
+
+const TASK_BOARD_COLUMNS: readonly TaskBoardColumn[] = [
+  { id: "todo", type: "status", label: "Todo", status: "todo" },
+  {
+    id: "queue_failed",
+    type: "group",
+    label: "Queue / Failed",
+    statuses: ["in_queue", "fail"],
+  },
+  {
+    id: "in_progress",
+    type: "status",
+    label: "In Progress",
+    status: "in_progress",
+  },
+  { id: "review", type: "status", label: "Review", status: "review" },
+  { id: "blocked", type: "status", label: "Blocked", status: "blocked" },
+  { id: "done", type: "status", label: "Done", status: "done" },
+];
+
+const EXECUTABLE_TASK_STATUSES = new Set<TaskStatus>([
+  "todo",
+  "blocked",
+  "fail",
+]);
+
+export function getTaskBoardColumns(): TaskBoardColumn[] {
+  return TASK_BOARD_COLUMNS.map((column) =>
+    column.type === "group"
+      ? { ...column, statuses: [...column.statuses] }
+      : { ...column },
+  );
+}
+
+export function isTaskExecutableStatus(status: TaskStatus): boolean {
+  return EXECUTABLE_TASK_STATUSES.has(status);
+}
diff --git a/src/hooks/use-agent-settings.ts b/src/hooks/use-agent-settings.ts
index 0e6e17e..ccb6d97 100644
--- a/src/hooks/use-agent-settings.ts
+++ b/src/hooks/use-agent-settings.ts
@@ -4,6 +4,7 @@ import { useCallback, useEffect, useMemo, useState } from "react";
 import {
   AGENT_SETTINGS_STORAGE_KEY,
   DEFAULT_AGENT_SETTINGS,
+  buildSessionContinuationRuntimePayload,
   buildSessionRuntimePayload,
   buildStoredAgentSettings,
   getScopedBrowserApiKey,
@@ -11,6 +12,7 @@ import {
   setScopedBrowserApiKey,
   type AgentSettings,
   type BrowserApiKeyScopes,
+  type SessionContinuationRuntimeSnapshot,
 } from "@/core/agent-settings";
 
 let browserOnlyApiKeysByScope: BrowserApiKeyScopes = {};
@@ -28,7 +30,9 @@ function isLoopbackApiBaseUrl(value: string): boolean {
   }
 }
 
-function isApiKeyRequired(settings: AgentSettings): boolean {
+function isApiKeyRequired(
+  settings: Pick<AgentSettings, "apiProtocol" | "apiBaseUrl">,
+): boolean {
   return !(
     settings.apiProtocol === "ollama" &&
     isLoopbackApiBaseUrl(settings.apiBaseUrl)
@@ -113,17 +117,51 @@ export function useAgentSettings() {
     () => buildSessionRuntimePayload(settings),
     [settings],
   );
+  const getRuntimePayloadForSession = useCallback(
+    (session: SessionContinuationRuntimeSnapshot) =>
+      buildSessionContinuationRuntimePayload(
+        session,
+        settings,
+        browserOnlyApiKeysByScope,
+      ),
+    [settings],
+  );
+  const isRuntimeReadyForSession = useCallback(
+    (session: SessionContinuationRuntimeSnapshot) => {
+      const payload = buildSessionContinuationRuntimePayload(
+        session,
+        settings,
+        browserOnlyApiKeysByScope,
+      );
+      if (payload.session_auth_mode !== "anthropic-api-key") {
+        return true;
+      }
+      return (
+        !isApiKeyRequired({
+          apiProtocol: (payload.agent_api_protocol ??
+            settings.apiProtocol) as AgentSettings["apiProtocol"],
+          apiBaseUrl: payload.agent_base_url ?? settings.apiBaseUrl,
+        }) || Boolean(payload.anthropic_api_key?.trim())
+      );
+    },
+    [settings],
+  );
+  const byokReady =
+    settings.executionMode !== "anthropic-api" ||
+    ((!isApiKeyRequired(settings) ||
+      settings.anthropicApiKey.trim().length > 0) &&
+      settings.apiModel.trim().length > 0 &&
+      settings.apiBaseUrl.trim().length > 0);
+  const settingsReady = loaded && byokReady;
 
   return {
     settings,
     setSettings,
     runtimePayload,
+    getRuntimePayloadForSession,
+    isRuntimeReadyForSession,
     loaded,
-    byokReady:
-      settings.executionMode !== "anthropic-api" ||
-      ((!isApiKeyRequired(settings) ||
-        settings.anthropicApiKey.trim().length > 0) &&
-        settings.apiModel.trim().length > 0 &&
-        settings.apiBaseUrl.trim().length > 0),
+    byokReady,
+    settingsReady,
   };
 }
diff --git a/src/hooks/use-session-chat.ts b/src/hooks/use-session-chat.ts
index 8e3c8b9..1b3c69e 100644
--- a/src/hooks/use-session-chat.ts
+++ b/src/hooks/use-session-chat.ts
@@ -1,7 +1,8 @@
 "use client";
 
-import { useState, useEffect, useRef, useCallback } from "react";
+import { useState, useEffect, useRef, useCallback, useMemo } from "react";
 import { useAgentSettings } from "@/hooks/use-agent-settings";
+import type { SessionContinuationRuntimeSnapshot } from "@/core/agent-settings";
 
 export interface ChatMsg {
   id: number;
@@ -20,8 +21,18 @@ export interface PermissionRequest {
   toolInput: Record<string, unknown>;
 }
 
+export interface SessionActivityEntry {
+  id: number;
+  kind: "status" | "system" | "log";
+  level?: "info" | "success" | "warning" | "error";
+  stream?: "stdout" | "stderr";
+  message: string;
+  timestamp?: string;
+}
+
 interface StreamEvent {
   type: string;
+  id?: number;
   text?: string;
   name?: string;
   input?: Record<string, unknown>;
@@ -35,6 +46,13 @@ interface StreamEvent {
   status?: string;
   message?: string;
   session_id?: string;
+  stream?: "stdout" | "stderr";
+  chunk?: string;
+  timestamp?: string;
+  level?: "info" | "success" | "warning" | "error";
+  pid?: number;
+  started_at?: string;
+  ended_at?: string;
   // Permission events
   tool_name?: string;
   tool_input?: Record<string, unknown>;
@@ -50,8 +68,153 @@ function nextId(): number {
   return ++_idCounter;
 }
 
-export function useSessionChat(sessionId: string | null) {
-  const { runtimePayload } = useAgentSettings();
+const ACTIVITY_ENTRY_LIMIT = 100;
+
+function capActivityEntries(
+  entries: SessionActivityEntry[],
+): SessionActivityEntry[] {
+  return entries.slice(Math.max(0, entries.length - ACTIVITY_ENTRY_LIMIT));
+}
+
+function withActivityId(
+  entry: Omit<SessionActivityEntry, "id">,
+): SessionActivityEntry {
+  return {
+    id: nextId(),
+    ...entry,
+  };
+}
+
+function getStatusActivityMessage(data: StreamEvent): string {
+  const status = data.status ?? "idle";
+  if (status === "running" && data.pid) {
+    return `Agent process running as PID ${data.pid}`;
+  }
+
+  if (data.message) {
+    return data.message;
+  }
+
+  switch (status) {
+    case "running":
+      return "Agent process running";
+    case "completed":
+      return "Agent process completed";
+    case "failed":
+      return "Agent process failed";
+    case "killed":
+      return "Agent process killed";
+    case "paused":
+      return "Agent process paused";
+    case "idle":
+      return "Agent process idle";
+    default:
+      return `Session status: ${status}`;
+  }
+}
+
+function getStatusActivityLevel(status: string | undefined): SessionActivityEntry["level"] {
+  switch (status) {
+    case "completed":
+      return "success";
+    case "failed":
+      return "error";
+    case "killed":
+    case "paused":
+      return "warning";
+    default:
+      return "info";
+  }
+}
+
+function getActivityEntryFromEvent(
+  data: StreamEvent,
+): Omit<SessionActivityEntry, "id"> | null {
+  switch (data.type) {
+    case "status": {
+      const status = data.status ?? "idle";
+      return {
+        kind: "status",
+        level: getStatusActivityLevel(status),
+        message: getStatusActivityMessage(data),
+        timestamp: data.timestamp ?? data.started_at ?? data.ended_at,
+      };
+    }
+    case "log":
+      if (!data.chunk) return null;
+      return {
+        kind: "log",
+        stream: data.stream,
+        message: data.chunk,
+        timestamp: data.timestamp,
+      };
+    case "system_log":
+      if (!data.message) return null;
+      return {
+        kind: "system",
+        level: data.level ?? "info",
+        message: data.message,
+        timestamp: data.timestamp,
+      };
+    default:
+      return null;
+  }
+}
+
+export function createReplayChatMessage(data: StreamEvent): ChatMsg | null {
+  if (data.type !== "message" || !data.role || !data.content) {
+    return null;
+  }
+
+  return {
+    id: data.id ?? nextId(),
+    role: data.role as "user" | "assistant",
+    content: data.content,
+  };
+}
+
+export function mergeReplayMessagesWithQueuedPlaceholders(
+  replayMessages: ChatMsg[],
+  currentMessages: ChatMsg[],
+): ChatMsg[] {
+  const replayedUserContentCounts = new Map<string, number>();
+  for (const message of replayMessages) {
+    if (message.role !== "user") continue;
+    replayedUserContentCounts.set(
+      message.content,
+      (replayedUserContentCounts.get(message.content) ?? 0) + 1,
+    );
+  }
+
+  return [
+    ...replayMessages,
+    ...currentMessages.filter((message) => {
+      if (!message.isQueued) return false;
+
+      const replayedCount = replayedUserContentCounts.get(message.content) ?? 0;
+      if (replayedCount === 0) return true;
+
+      if (replayedCount === 1) {
+        replayedUserContentCounts.delete(message.content);
+      } else {
+        replayedUserContentCounts.set(message.content, replayedCount - 1);
+      }
+      return false;
+    }),
+  ];
+}
+
+export function useSessionChat(
+  sessionId: string | null,
+  sessionRuntime?: SessionContinuationRuntimeSnapshot,
+) {
+  const {
+    runtimePayload,
+    settingsReady,
+    loaded,
+    getRuntimePayloadForSession,
+    isRuntimeReadyForSession,
+  } = useAgentSettings();
   const [messages, setMessages] = useState<ChatMsg[]>([]);
   const [streamingText, setStreamingText] = useState("");
   const [streamingTools, setStreamingTools] = useState<
@@ -65,21 +228,88 @@ export function useSessionChat(sessionId: string | null) {
   const [sessionStatus, setSessionStatus] = useState<string>("idle");
   const [error, setError] = useState<string | null>(null);
   const [turnCost, setTurnCost] = useState<number | undefined>();
+  const [activityEntries, setActivityEntries] = useState<SessionActivityEntry[]>([]);
 
   // Interactive session state
   const [pendingPermission, setPendingPermission] = useState<PermissionRequest | null>(null);
   const [queuedCount, setQueuedCount] = useState(0);
 
   const esRef = useRef<EventSource | null>(null);
+  const reconnectTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const syncedRef = useRef(false);
   const streamTextRef = useRef("");
+  const replayMessagesRef = useRef<ChatMsg[]>([]);
+  const replayActivityEntriesRef = useRef<SessionActivityEntry[]>([]);
   // Capture streaming tools in a ref for finalization
   const streamToolsRef = useRef<{ name: string; input: Record<string, unknown> }[]>([]);
   const streamToolResultsRef = useRef<{ name: string; output: string; is_error?: boolean }[]>([]);
+  const continuationRuntimePayload = useMemo(
+    () =>
+      sessionRuntime
+        ? getRuntimePayloadForSession(sessionRuntime)
+        : runtimePayload,
+    [getRuntimePayloadForSession, runtimePayload, sessionRuntime],
+  );
+  const continuationRuntimeReady = useMemo(
+    () =>
+      loaded &&
+      (sessionRuntime
+        ? isRuntimeReadyForSession(sessionRuntime)
+        : settingsReady),
+    [loaded, settingsReady, isRuntimeReadyForSession, sessionRuntime],
+  );
+
+  const appendActivityEntry = useCallback(
+    (entry: Omit<SessionActivityEntry, "id">) => {
+      setActivityEntries((prev) => capActivityEntries([...prev, withActivityId(entry)]));
+    },
+    [],
+  );
+
+  const updateStatusState = useCallback((data: StreamEvent) => {
+    const status = data.status ?? "idle";
+    setSessionStatus(status);
+    if (status === "running") {
+      setProcessing(true);
+    } else if (
+      status === "idle" ||
+      status === "paused" ||
+      status === "completed" ||
+      status === "failed" ||
+      status === "killed"
+    ) {
+      setProcessing(false);
+    }
+  }, []);
+
+  const handleActivityEvent = useCallback(
+    (data: StreamEvent): boolean => {
+      if (data.type === "status") {
+        updateStatusState(data);
+      }
+
+      const entry = getActivityEntryFromEvent(data);
+      if (entry) {
+        appendActivityEntry(entry);
+        return true;
+      }
+
+      return data.type === "status" || data.type === "log" || data.type === "system_log";
+    },
+    [appendActivityEntry, updateStatusState],
+  );
+
+  const clearReconnectTimeout = useCallback(() => {
+    if (reconnectTimeoutRef.current) {
+      clearTimeout(reconnectTimeoutRef.current);
+      reconnectTimeoutRef.current = null;
+    }
+  }, []);
 
   // Connect SSE
   const connect = useCallback(() => {
     if (!sessionId) return;
+    clearReconnectTimeout();
 
     if (esRef.current) {
       esRef.current.close();
@@ -89,37 +319,60 @@ export function useSessionChat(sessionId: string | null) {
     const es = new EventSource(`/api/sessions/${sessionId}/stream`);
     esRef.current = es;
     syncedRef.current = false;
+    replayMessagesRef.current = [];
+    replayActivityEntriesRef.current = [];
 
-    es.onopen = () => setConnected(true);
+    es.onopen = () => {
+      if (esRef.current !== es) return;
+      setConnected(true);
+    };
 
     es.onmessage = (evt) => {
+      if (esRef.current !== es) return;
+
       try {
         const data = JSON.parse(evt.data) as StreamEvent;
 
         // Sync marker — replay complete
         if (data.type === "sync") {
+          setMessages((prev) =>
+            mergeReplayMessagesWithQueuedPlaceholders(
+              replayMessagesRef.current,
+              prev,
+            ),
+          );
+          setActivityEntries(capActivityEntries(replayActivityEntriesRef.current));
           syncedRef.current = true;
           return;
         }
 
-        // Replayed message (before sync)
-        if (!syncedRef.current && data.type === "message") {
-          if (data.role && data.content) {
-            setMessages((prev) => [
-              ...prev,
-              {
-                id: nextId(),
-                role: data.role as "user" | "assistant",
-                content: data.content!,
-              },
+        // Replayed events (before sync)
+        if (!syncedRef.current) {
+          if (data.type === "message") {
+            const replayMessage = createReplayChatMessage(data);
+            if (replayMessage) {
+              replayMessagesRef.current = [
+                ...replayMessagesRef.current,
+                replayMessage,
+              ];
+            }
+            return;
+          }
+
+          if (data.type === "status") {
+            updateStatusState(data);
+          }
+          const entry = getActivityEntryFromEvent(data);
+          if (entry) {
+            replayActivityEntriesRef.current = capActivityEntries([
+              ...replayActivityEntriesRef.current,
+              withActivityId(entry),
             ]);
           }
           return;
         }
 
         // Live events (after sync)
-        if (!syncedRef.current) return;
-
         switch (data.type) {
           case "message":
             // User message echo from backend
@@ -158,6 +411,12 @@ export function useSessionChat(sessionId: string | null) {
               const newTool = { name: data.name, input: data.input ?? {} };
               streamToolsRef.current = [...streamToolsRef.current, newTool];
               setStreamingTools(streamToolsRef.current);
+              appendActivityEntry({
+                kind: "system",
+                level: "info",
+                message: `Started tool ${data.name}`,
+                timestamp: data.timestamp,
+              });
             }
             break;
 
@@ -170,6 +429,12 @@ export function useSessionChat(sessionId: string | null) {
               };
               streamToolResultsRef.current = [...streamToolResultsRef.current, newResult];
               setStreamingToolResults(streamToolResultsRef.current);
+              appendActivityEntry({
+                kind: "system",
+                level: data.is_error ? "error" : "success",
+                message: `Completed tool ${data.name}`,
+                timestamp: data.timestamp,
+              });
             }
             break;
 
@@ -241,12 +506,9 @@ export function useSessionChat(sessionId: string | null) {
             break;
 
           case "status":
-            setSessionStatus(data.status ?? "idle");
-            if (data.status === "running") {
-              setProcessing(true);
-            } else if (data.status === "idle" || data.status === "completed" || data.status === "killed") {
-              setProcessing(false);
-            }
+          case "log":
+          case "system_log":
+            handleActivityEvent(data);
             break;
         }
       } catch {
@@ -255,12 +517,20 @@ export function useSessionChat(sessionId: string | null) {
     };
 
     es.onerror = () => {
+      if (esRef.current !== es) return;
       setConnected(false);
       es.close();
       esRef.current = null;
-      setTimeout(connect, 3000);
+      clearReconnectTimeout();
+      reconnectTimeoutRef.current = setTimeout(connect, 3000);
     };
-  }, [sessionId]);
+  }, [
+    appendActivityEntry,
+    clearReconnectTimeout,
+    handleActivityEvent,
+    sessionId,
+    updateStatusState,
+  ]);
 
   useEffect(() => {
     setMessages([]);
@@ -269,20 +539,24 @@ export function useSessionChat(sessionId: string | null) {
     setStreamingToolResults([]);
     setError(null);
     setProcessing(false);
+    setActivityEntries([]);
     setPendingPermission(null);
     setQueuedCount(0);
     streamTextRef.current = "";
     streamToolsRef.current = [];
     streamToolResultsRef.current = [];
+    replayMessagesRef.current = [];
+    replayActivityEntriesRef.current = [];
     syncedRef.current = false;
 
     connect();
     return () => {
+      clearReconnectTimeout();
       esRef.current?.close();
       esRef.current = null;
       setConnected(false);
     };
-  }, [connect]);
+  }, [clearReconnectTimeout, connect]);
 
   // Send a follow-up message — always allowed, queued if processing
   const sendMessage = useCallback(
@@ -295,11 +569,11 @@ export function useSessionChat(sessionId: string | null) {
         body: JSON.stringify({
           action: "send",
           message: content.trim(),
-          ...runtimePayload,
+          ...continuationRuntimePayload,
         }),
       });
     },
-    [runtimePayload, sessionId]
+    [continuationRuntimePayload, sessionId]
   );
 
   // Respond to a permission request
@@ -329,7 +603,9 @@ export function useSessionChat(sessionId: string | null) {
     sessionStatus,
     error,
     turnCost,
+    activityEntries,
     sendMessage,
+    byokReady: continuationRuntimeReady,
     // Interactive session features
     pendingPermission,
     respondToPermission,