diff --git a/electron/automation-destination.js b/electron/automation-destination.js
new file mode 100644
index 000000000..e252df0ed
--- /dev/null
+++ b/electron/automation-destination.js
@@ -0,0 +1,56 @@
+"use strict";
+
+/** Missing mode keeps legacy new-thread-per-run definitions unchanged. */
+function destinationFields(input, base = {}) {
+  const sessionMode = input.sessionMode === undefined
+    ? (base.sessionMode || "new-thread") : input.sessionMode;
+  if (!["new-thread", "continue", "fresh"].includes(sessionMode)) {
+    throw new Error("Invalid automation session mode");
+  }
+  const raw = input.destinationThreadId === undefined
+    ? base.destinationThreadId : input.destinationThreadId;
+  const destinationThreadId = sessionMode === "new-thread" ? null : String(raw || "").trim();
+  if (sessionMode !== "new-thread" && !destinationThreadId) {
+    throw new Error("Destination thread is required");
+  }
+  return { sessionMode, destinationThreadId };
+}
+
+/** Save validates identity and authority; execution additionally requires an idle target. */
+function destinationThread(store, auto, runner, staticOnly = false) {
+  const { sessionMode, destinationThreadId } = destinationFields(auto);
+  if (sessionMode === "new-thread") return null;
+  const t = store.getThread(destinationThreadId);
+  if (!t || t.projectId !== auto.projectId) {
+    throw new Error("Automation destination must exist in its project");
+  }
+  if (t.archived || t.trashedAt || t.deletedAt || t.teleportedTo ||
+      t.memoryConsolidate || t.ask || t.pendingFork) {
+    throw new Error("Automation destination is unavailable");
+  }
+  if (!staticOnly && (runner?.isRunning?.(t.id) ||
+      t.status === "working" || t.status === "quota-wait" ||
+      t.quotaWaitUntil || t.quotaFailoverPending || t.pendingPlan ||
+      t.pendingQuestion || t.pendingApproval || t.pendingSecret || t.awaitingInput ||
+      t.runQueue || t.queued || t.interruptedAt || t.btw?.length ||
+      runner?.getPendingPermission?.(t.id))) {
+    throw Object.assign(
+      new Error("Automation destination has unfinished work or pending input; run skipped"),
+      { code: "AUTOMATION_DESTINATION_BUSY" },
+    );
+  }
+  // Fixed destinations retain identity, but cannot lend their additional authority.
+  if (t.provider !== auto.provider || (t.model || null) !== (auto.model || null) ||
+      t.providerInstance || t.agentProfileId || t.autoApprove ||
+      (t.permissionMode && t.permissionMode !== "default") ||
+      t.folderWriteGrants?.length || t.restartGrant || t.alwaysAllowKeys?.length ||
+      t.alwaysAllowRules?.length || t.route || auto.tier) {
+    throw new Error("Automation destination must match provider/model with default permissions, no account override, grants, or routing");
+  }
+  if (!staticOnly && t.freshContextPending && sessionMode !== "fresh") {
+    throw new Error("Automation destination is waiting for a user message after fresh context");
+  }
+  return t;
+}
+
+module.exports = { destinationFields, destinationThread };
diff --git a/electron/automations-file.js b/electron/automations-file.js
index cb03b12fd..760cd4654 100644
--- a/electron/automations-file.js
+++ b/electron/automations-file.js
@@ -25,7 +25,7 @@ const MAX_SHARED_AUTOMATIONS = 16;
 const PROMPT_MAX = 4000;
 const PRESETS = new Set(["hourly", "daily", "weekly", "cron", "once"]);
 /** canonical()'s keys: anything else in a row is a typo (#438). */
-const ROW_KEYS = new Set(["id", "name", "prompt", "provider", "model", "preset", "hour", "cron", "runAt", "trigger", "tier", "budget"]);
+const ROW_KEYS = new Set(["sessionMode", "destinationThreadId", "id", "name", "prompt", "provider", "model", "preset", "hour", "cron", "runAt", "trigger", "tier", "budget"]);
 
 /**
  * Overlay / merge id for a shared automation row.
@@ -71,6 +71,8 @@ function slugFromName(name, taken) {
  */
 function canonical(row) {
   return {
+    sessionMode: row.sessionMode,
+    destinationThreadId: row.destinationThreadId,
     id: row.id,
     name: row.name,
     prompt: row.prompt,
@@ -238,8 +240,12 @@ function parseRow(raw, index, seen) {
     return { error: `solenta.json: ${at}.${msg}` };
   }
 
+  let destination;
+  try { destination = require("./automation-destination.js").destinationFields(r); }
+  catch (err) { return { error: `solenta.json: ${at}: ${err.message}` }; }
   return {
     row: {
+      ...(r.sessionMode !== undefined || r.destinationThreadId !== undefined ? destination : {}),
       id,
       name,
       prompt,
@@ -338,7 +344,7 @@ function isLocalProject(project) {
  * @returns {object[]}
  */
 function mergeAutomations(store, nowMs) {
-  const { nextFire } = require("./automations.js");
+  const { nextFire, MAX_THREADS_PER_AUTOMATION } = require("./automations.js");
   const privates = (store.getAutomations() || []).filter(
     (a) => a && a.scope !== "project",
   );
@@ -363,6 +369,10 @@ function mergeAutomations(store, nowMs) {
             lastError: overlay.lastError,
             consecutiveFailures: overlay.consecutiveFailures,
             pendingRunThreadId: overlay.pendingRunThreadId,
+            ...(overlay.pendingRunId !== undefined ? { pendingRunId: overlay.pendingRunId } : {}),
+            ...(Array.isArray(overlay.runHistory)
+              ? { runHistory: overlay.runHistory.slice(0, MAX_THREADS_PER_AUTOMATION) }
+              : {}),
             nextRunAt: overlay.nextRunAt,
             stage: overlay.stage,
             graduate: overlay.graduate,
@@ -388,6 +398,8 @@ function mergeAutomations(store, nowMs) {
         projectId: project.id,
         name: row.name,
         prompt: row.prompt,
+        sessionMode: row.sessionMode,
+        destinationThreadId: row.destinationThreadId,
         provider: row.provider,
         model: row.model,
         preset: row.preset,
@@ -500,6 +512,8 @@ function ensureOverlay(store, auto) {
     scope: "project",
     name: auto.name,
     prompt: auto.prompt,
+    sessionMode: auto.sessionMode,
+    destinationThreadId: auto.destinationThreadId,
     provider: auto.provider,
     model: auto.model,
     preset: auto.preset,
diff --git a/electron/automations.js b/electron/automations.js
index c7231da4b..95615cc77 100644
--- a/electron/automations.js
+++ b/electron/automations.js
@@ -304,8 +304,14 @@ function settleAutomationRuns(ctx) {
     const t = ctx.store.getThread(auto.pendingRunThreadId);
     if (t && (t.status === "working" || t.status === "quota-wait")) continue;
     changed = true;
+    if (auto.pendingRunId && auto.runHistory?.length) patchAutomation(ctx.store, auto.id, {
+      pendingRunId: null,
+      runHistory: auto.runHistory.map((r) => r.runId === auto.pendingRunId ? { ...r, status: t?.status || "failed" } : r),
+    });
     if (t) {
-      const last = ctx.store.getLastAssistantMessage(t.id);
+      const last = auto.pendingRunId
+        ? ctx.store.getMessages(t.id).filter((m) => m.role === "assistant" && m.runId === auto.pendingRunId).at(-1)
+        : ctx.store.getLastAssistantMessage(t.id);
       const memory = extractMemory(last && last.text);
       if (memory != null) patchAutomation(ctx.store, auto.id, { memory });
     }
@@ -368,7 +374,7 @@ function pruneAutomationThreads(store, automationId) {
   indexed.sort((a, b) => (b.t.createdAt - a.t.createdAt) || (b.i - a.i));
   for (let i = MAX_THREADS_PER_AUTOMATION; i < indexed.length; i++) {
     const t = indexed[i].t;
-    if (isRetainedAutomationThread(t)) continue;
+    if (isRetainedAutomationThread(t) || require("./automations-file.js").mergeAutomations(store, Date.now()).some((a) => a.destinationThreadId === t.id || a.runHistory?.some((r) => r.threadId === t.id))) continue;
     services.purgeThread(store, t.id);
   }
 }
@@ -383,7 +389,25 @@ function pruneAutomationThreads(store, automationId) {
  * @param {number} now
  * @param {{ rethrow?: boolean, triggerNote?: string }} [opts]
  */
+const firingByStore = new WeakMap();
 async function runAutomation(ctx, auto, now, opts) {
+  let firing = firingByStore.get(ctx.store);
+  if (!firing) firingByStore.set(ctx.store, firing = new Set());
+  const keys = [`automation:${auto.id}`];
+  if (auto.sessionMode && auto.sessionMode !== "new-thread") keys.push(`thread:${auto.destinationThreadId}`);
+  if (keys.some((key) => firing.has(key))) {
+    const error = new Error("Automation destination is already starting a run");
+    if (opts?.rethrow) throw error;
+    return;
+  }
+  for (const key of keys) firing.add(key);
+  try {
+    return await fireAutomation(ctx, auto, now, opts);
+  } finally {
+    for (const key of keys) firing.delete(key);
+  }
+}
+async function fireAutomation(ctx, auto, now, opts) {
   const services = require("./services.js");
   const nextRunAt = nextFire(auto.preset, auto.hour, now, auto.nextRunAt, auto.cron, auto.runAt);
   // #388: settle ran first in the tick, so the breaker count is current.
@@ -400,7 +424,12 @@ async function runAutomation(ctx, auto, now, opts) {
 
   let runErr = null;
   try {
-    const thread = services.createThread(ctx.store, {
+    settleAutomationRuns(ctx);
+    const pending = ctx.store.getAutomation(auto.id)?.pendingRunThreadId;
+    const pendingThread = pending && ctx.store.getThread(pending);
+    if (auto.sessionMode && auto.sessionMode !== "new-thread" && pendingThread && (pendingThread.status === "working" || pendingThread.status === "quota-wait")) throw Object.assign(new Error("Automation still has an unfinished run; run skipped"), { code: "AUTOMATION_DESTINATION_BUSY" });
+    const target = require("./automation-destination.js").destinationThread(ctx.store, auto, ctx.runner);
+    const thread = target || services.createThread(ctx.store, {
       projectId: auto.projectId,
       title: auto.name,
       automationId: auto.id,
@@ -409,8 +438,12 @@ async function runAutomation(ctx, auto, now, opts) {
     // #286: the automation's cap is harness state on the thread it fires.
     const { budgetPatchFrom } = require("./budgetCaps.js");
     const capped = budgetPatchFrom(auto);
-    if (capped.budget) ctx.store.updateThread(thread.id, capped);
-    services.setProvider(ctx.store, {
+    if (capped.budget) {
+      const budget = { ...(thread.budget || {}) };
+      for (const [key, limit] of Object.entries(capped.budget)) budget[key] = Math.min(budget[key] ?? Infinity, limit);
+      ctx.store.updateThread(thread.id, { budget });
+    }
+    if (!target) services.setProvider(ctx.store, {
       threadId: thread.id,
       provider: auto.provider,
       model: auto.model,
@@ -420,25 +453,31 @@ async function runAutomation(ctx, auto, now, opts) {
     if (typeof ctx.broadcast === "function") {
       ctx.broadcast("threads:changed", services.listThreads(ctx.store));
     }
-    await ctx.runner.startRun({
+    const launch = await (target ? ctx.runner.startAutomationRun.bind(ctx.runner) : ctx.runner.startRun.bind(ctx.runner))({
+      ...(target ? { automationId: auto.id } : {}),
       threadId: thread.id,
       prompt: buildRunPrompt({ ...auto, ...life }, opts && opts.triggerNote),
     });
     patchAutomation(ctx.store, auto.id, {
       lastError: null,
       pendingRunThreadId: thread.id,
+      ...((target || ctx.store.getAutomation(auto.id)?.runHistory?.length) && launch?.runId ? { pendingRunId: launch.runId, runHistory: [
+        { id: require("node:crypto").randomUUID(), threadId: thread.id, newThread: !target, runId: launch.runId, startedAt: now, status: "working" },
+        ...(ctx.store.getAutomation(auto.id)?.runHistory || []),
+      ].slice(0, MAX_THREADS_PER_AUTOMATION) } : {}),
     });
     ctx.store.save();
   } catch (err) {
     runErr = err;
-    recordFailure(ctx, auto.id, errorText(err));
+    if (err?.code === "AUTOMATION_DESTINATION_BUSY") patchAutomation(ctx.store, auto.id, { lastError: errorText(err) });
+    else recordFailure(ctx, auto.id, errorText(err));
     ctx.store.save();
   }
 
   // #134: prune after startRun so a thrown purge cannot undo a completed fire.
   // Own try/catch: retention failure must not stamp lastError or fail the run.
   try {
-    pruneAutomationThreads(ctx.store, auto.id);
+    if (!auto.sessionMode || auto.sessionMode === "new-thread") pruneAutomationThreads(ctx.store, auto.id);
     ctx.store.save();
     const { scheduleImagePruneFromStore } = require("./image-store.js");
     void scheduleImagePruneFromStore(ctx.store);
@@ -473,6 +512,7 @@ function listAutomationRuns(store, automationId) {
   if (!auto) {
     throw new Error(`Unknown automation: ${id}`);
   }
+  const fixedRuns = (auto.runHistory || []).map(({ id, threadId, runId, startedAt, status }, i) => ({ id, threadId, runId, startedAt, status, pending: auto.pendingRunId === runId && auto.pendingRunThreadId === threadId }));
   const indexed = store
     .getThreads()
     .map((t, i) => ({ t, i }))
@@ -480,15 +520,16 @@ function listAutomationRuns(store, automationId) {
       ({ t }) =>
         t &&
         t.automationId === id &&
+        !auto.runHistory?.some((r) => r.newThread && r.threadId === t.id) &&
         t.projectId === auto.projectId &&
         t.memoryConsolidate !== true,
     );
   indexed.sort((a, b) => b.t.createdAt - a.t.createdAt || b.i - a.i);
-  const runs = indexed.map(({ t }) => ({
+  const runs = [...fixedRuns, ...indexed.map(({ t }) => ({
     threadId: t.id,
     startedAt: t.createdAt,
     status: t.status || "idle",
-  }));
+  }))].sort((a, b) => b.startedAt - a.startedAt);
   return {
     automationId: id,
     runs,
diff --git a/electron/ipc-git.js b/electron/ipc-git.js
index 709e80eb2..02add6f98 100644
--- a/electron/ipc-git.js
+++ b/electron/ipc-git.js
@@ -325,6 +325,7 @@ module.exports = {
   "git:prTemplate": async (_ctx, input) => {
     return readPrTemplate(input && input.projectPath);
   },
+  "git:prCompletions": async (_ctx, input) => require("./prCompletions.js").prCompletions(input),
   "git:prDetail": async (_ctx, input) => {
     return viewPrDetail(input && input.projectPath, input && input.prNumber, {
       repo: input && input.repo,
diff --git a/electron/orchServer.js b/electron/orchServer.js
index 4e6dd4651..236e441f4 100644
--- a/electron/orchServer.js
+++ b/electron/orchServer.js
@@ -1440,6 +1440,8 @@ function createToolHandlers(deps) {
     }
     const created = addAutomation(store, {
       projectId: thread.projectId,
+      sessionMode: args && args.sessionMode,
+      destinationThreadId: args && args.destinationThreadId,
       name: args && args.name,
       prompt: args && args.prompt,
       provider: (args && args.provider) || thread.provider,
@@ -1460,6 +1462,8 @@ function createToolHandlers(deps) {
       ok: true,
       id: created.id,
       name: created.name,
+      sessionMode: created.sessionMode || "new-thread",
+      destinationThreadId: created.destinationThreadId || null,
       projectId: created.projectId,
       prompt: created.prompt,
       provider: created.provider,
@@ -2452,6 +2456,8 @@ function buildMcpServer(sdk, handlers, opts = {}) {
       inputSchema: {
         threadId: z.string().min(1),
         projectId: z.string().min(1),
+        sessionMode: z.enum(["new-thread", "continue", "fresh"]).optional(),
+        destinationThreadId: z.string().optional(),
         name: z.string().min(1),
         prompt: z.string().min(1),
         provider: z.string().min(1).optional(),
diff --git a/electron/prCompletions.js b/electron/prCompletions.js
new file mode 100644
index 000000000..0836540e8
--- /dev/null
+++ b/electron/prCompletions.js
@@ -0,0 +1,70 @@
+"use strict";
+const { gitTryAsync, ghApiTryAsync, tailErr } = require('./worktrees.js');
+const { gitlabRemote, glabApi } = require('./gitlab.js');
+const { parseRepoSlug } = require('./prLinks.js');
+
+// Every request resolves origin anew. Never search all users or all accounts.
+async function prCompletions(input) {
+  const cwd = String(input?.projectPath || '');
+  const kind = input?.kind;
+  if (!cwd || !['@', '#', '!'].includes(kind)) return { ok: false, reason: 'Invalid completion request' };
+  // Match the textarea token grammar at the trust boundary too. In particular,
+  // GitHub search qualifiers, spaces and quotes must never augment repo scope.
+  const query = input.query == null ? '' : input.query;
+  if (typeof query !== 'string' || !/^[\w.-]{0,100}$/.test(query)) {
+    return { ok: false, reason: 'Invalid completion query' };
+  }
+  const page = Math.max(1, Math.min(10, Math.trunc(Number(input.page) || 1)));
+  const remote = await gitTryAsync(cwd, ['remote', 'get-url', 'origin']);
+  if (!remote.ok) return { ok: false, reason: 'Repository unavailable' };
+  const origin = String(remote.stdout || '').trim();
+  const gl = gitlabRemote(origin);
+  let rows;
+  let exact = null;
+  const numeric = kind !== "@" && page === 1 && /^[1-9]\d*$/.test(query) && Number.isSafeInteger(Number(query));
+  if (gl) {
+    // Explicit cross-repo requests stay on the origin host and its authenticated account.
+    if (input.repo) gl.path = String(input.repo);
+    const endpoint = kind === '@' ? '/members/all' : kind === '!' ? '/merge_requests' : '/issues';
+    const [result, direct] = await Promise.all([
+      glabApi(cwd, gl, 'GET', `${endpoint}?per_page=20&page=${page}&${kind === '@' ? 'query' : 'search'}=${encodeURIComponent(query)}`),
+      numeric ? glabApi(cwd, gl, 'GET', `${endpoint}/${Number(query)}`) : null,
+    ]);
+    if (direct?.ok && Number(direct.data?.iid) === Number(query)) exact = direct.data;
+    if (!result.ok && !exact) return result;
+    rows = result.ok && Array.isArray(result.data) ? result.data : [];
+  } else {
+    if (kind === '!') return { ok: true, items: [], hasMore: false };
+    const slug = parseRepoSlug(input.repo || origin);
+    if (!slug) return { ok: false, reason: 'Repository unavailable' };
+    const endpoint = kind === '@'
+      ? `repos/${slug}/assignees?per_page=20&page=${page}`
+      : `search/issues?q=${encodeURIComponent(`repo:${slug} ${query}`)}&per_page=20&page=${page}`;
+    const host = origin.match(/^[^@/]+@([^:]+):/)?.[1] || (() => { try { return new URL(origin).hostname; } catch { return null; } })();
+    if (!host) return { ok: false, reason: 'Repository host unavailable' };
+    const request = endpoint => ghApiTryAsync(cwd, ['api', endpoint, '--hostname', host], { originUrl: origin, timeout: 15000 });
+    const [result, direct] = await Promise.all([
+      request(endpoint), numeric ? request(`repos/${slug}/issues/${Number(query)}`) : null,
+    ]);
+    if (direct?.ok) {
+      try { const data = JSON.parse(direct.stdout); if (Number(data?.number) === Number(query)) exact = data; } catch { /* search remains available */ }
+    }
+    if (!result.ok && !exact) return { ok: false, reason: tailErr(result.stderr || result.combined, 'Completion search failed') };
+    try { const data = result.ok ? JSON.parse(result.stdout) : []; rows = Array.isArray(data) ? data : data.items || []; }
+    catch { if (!exact) return { ok: false, reason: 'Invalid completion response' }; rows = []; }
+  }
+  const hasMore = rows.length >= 20 && page < 10;
+  // Pin the exact reference without displacing any of the 20 search rows or
+  // shifting subsequent search pages. A first numeric page has at most 21 items.
+  if (exact) rows = [exact, ...rows.filter(row => Number(row.iid || row.number) !== Number(query))];
+  const items = rows.map(row => kind === '@'
+    ? { value: `@${row.username || row.login}`, label: row.name || row.username || row.login }
+    : { value: `${kind}${row.iid || row.number}`, label: row.title || '' })
+    .filter(row => row.value.toLowerCase().includes(query.toLowerCase()) || row.label.toLowerCase().includes(query.toLowerCase()))
+    .slice(0, exact ? 21 : 20);
+  return { ok: true, items, hasMore };
+}
+module.exports = { prCompletions: async input => {
+  try { return await prCompletions(input); }
+  catch { return { ok: false, reason: 'Completion search unavailable' }; }
+} };
diff --git a/electron/prWorkspace.js b/electron/prWorkspace.js
index 8ae88ba47..a080c37a4 100644
--- a/electron/prWorkspace.js
+++ b/electron/prWorkspace.js
@@ -184,6 +184,40 @@ function parsePrNumber(value) {
  * @param {string} projectPath
  * @returns {Promise<{ ok: true, cwd: string } | { ok: false, reason: string }>}
  */
+async function gitlabWorkspaceRemote(projectPath, repo) {
+  const remote = await gitTryAsync(String(projectPath || ""), ["remote", "get-url", "origin"]);
+  const gl = remote.ok ? require("./gitlab.js").gitlabRemote(String(remote.stdout || "").trim()) : null;
+  if (gl && repo) gl.path = String(repo);
+  return gl;
+}
+
+async function viewGitlabWorkspace(projectPath, number, remote) {
+  const { glabApi } = require("./gitlab.js");
+  const result = await glabApi(projectPath, remote, "GET", `/merge_requests/${number}`);
+  if (!result.ok) return result;
+  const mr = result.data;
+  if (!mr || !mr.iid || !mr.web_url) return { ok: false, reason: "Invalid merge request response" };
+  const comments = [];
+  let commentsError;
+  // Keep transcript bounded, as with the GitHub workspace comment budget.
+  for (let page = 1; page <= 5; page++) {
+    const notes = await glabApi(projectPath, remote, "GET", `/merge_requests/${number}/notes?per_page=100&page=${page}&sort=asc&order_by=created_at`);
+    if (!notes.ok) { commentsError = notes.reason; break; }
+    const rows = Array.isArray(notes.data) ? notes.data : [];
+    for (const note of rows) {
+      if (!note.system) comments.push({ id: note.id, type: "issue", author: note.author?.username || "", body: note.body || "", createdAt: note.created_at || "", url: `${mr.web_url}#note_${note.id}` });
+    }
+    if (rows.length < 100) break;
+    if (page === 5) commentsError = "Showing the first 500 discussion notes. Open GitLab for the full conversation.";
+  }
+  return { ok: true, pr: {
+    forge: "gitlab", number: mr.iid, title: mr.title || "", body: mr.description || "", url: mr.web_url,
+    state: mr.state === "merged" ? "MERGED" : mr.state === "closed" ? "CLOSED" : "OPEN",
+    isDraft: Boolean(mr.draft || mr.work_in_progress), headRefName: mr.source_branch || "", baseRefName: mr.target_branch || "",
+    author: mr.author?.username || "", updatedAt: mr.updated_at, comments, ...(commentsError ? { commentsError } : {}),
+  } };
+}
+
 async function requireGitHubRepo(projectPath) {
   const cwd = String(projectPath || "");
   if (!cwd) return { ok: false, reason: "not a GitHub repo" };
@@ -576,6 +610,8 @@ async function loadPrComments(cwd, number, other, info) {
 async function viewPrDetail(projectPath, prNumber, opts) {
   const number = parsePrNumber(prNumber);
   if (number == null) return { ok: false, reason: "invalid PR number" };
+  const gl = await gitlabWorkspaceRemote(projectPath, opts && opts.repo);
+  if (gl) return viewGitlabWorkspace(projectPath, number, gl);
   const repo = await requireGitHubRepo(projectPath);
   if (!repo.ok) return repo;
   const other = parseRepoSlug(opts && opts.repo);
@@ -673,6 +709,14 @@ async function editPr(projectPath, input, opts) {
   const blocked = scanOutbound(outbound, "PR");
   if (blocked) return { ok: false, reason: blocked };
 
+  const gl = await gitlabWorkspaceRemote(projectPath, input && input.repo);
+  if (gl) {
+    const fields = {};
+    if (title != null) fields.title = title;
+    if (body != null) fields.description = body;
+    const edited = await require("./gitlab.js").glabApi(projectPath, gl, "PUT", `/merge_requests/${number}`, fields);
+    return edited.ok ? viewGitlabWorkspace(projectPath, number, gl) : edited;
+  }
   const repo = await requireGitHubRepo(projectPath);
   if (!repo.ok) return repo;
   const other = parseRepoSlug(input && input.repo);
@@ -715,6 +759,11 @@ async function commentPr(projectPath, input) {
   const blocked = scanOutbound(text, "PR comment");
   if (blocked) return { ok: false, reason: blocked };
 
+  const gl = await gitlabWorkspaceRemote(projectPath, input && input.repo);
+  if (gl) {
+    const posted = await require("./gitlab.js").glabApi(projectPath, gl, "POST", `/merge_requests/${number}/notes`, { body: text });
+    return posted.ok ? { ok: true } : posted;
+  }
   const repo = await requireGitHubRepo(projectPath);
   if (!repo.ok) return repo;
 
diff --git a/electron/preload.js b/electron/preload.js
index c0cd07453..5f040b736 100644
--- a/electron/preload.js
+++ b/electron/preload.js
@@ -342,6 +342,7 @@ const IPC_CHANNELS = Object.freeze([
   { ns: "git", method: "listPrs" },
   { ns: "git", method: "checkoutPr" },
   { ns: "git", method: "prTemplate" },
+  { ns: "git", method: "prCompletions" },
   { ns: "git", method: "prDetail" },
   { ns: "git", method: "prEdit" },
   { ns: "git", method: "prComment" },
diff --git a/electron/runner.js b/electron/runner.js
index eefbc4937..74183bf80 100644
--- a/electron/runner.js
+++ b/electron/runner.js
@@ -1798,7 +1798,14 @@ function createRunner(opts) {
    * appended) any throw — budget, missing CLI, worktree setup — puts that
    * queue back in front of whatever was queued since.
    */
+  const automationStart = Symbol("configured automation start");
+  function startAutomationRun(input) {
+    return startRun({ threadId: input.threadId, prompt: input.prompt, [automationStart]: input.automationId });
+  }
+
   async function startRun(input) {
+    // Capture completed fixed-destination automation outcomes before a manual turn changes the row.
+    if (require("./automations.js").settleAutomationRuns({ store })) store.save();
     const fold = { taken: null };
     try {
       return await startRunFolded(input, fold);
@@ -1836,7 +1843,7 @@ function createRunner(opts) {
     // queued as the next prompt. fromNotice is skipped so a worker
     // quoting `/btw` cannot open a card on itself. fromInbound is skipped
     // so a cross-thread body that happens to start with `/btw` is data.
-    if (!input.fromNotice && !input.fromInbound) {
+    if (!input[automationStart] && !input.fromNotice && !input.fromInbound) {
       const question = btw.parseBtwCommand(prompt);
       if (question) {
         const thread = await startBtw({ threadId, question });
@@ -1855,10 +1862,18 @@ function createRunner(opts) {
       );
     }
 
-    const thread = store.getThread(threadId);
+    let thread = store.getThread(threadId);
     if (!thread) {
       throw new Error(`Unknown thread: ${threadId}`);
     }
+    const configuredAutomationId = input[automationStart];
+    const automation = configuredAutomationId
+      ? require("./automations-file.js").mergeAutomations(store, Date.now()).find((a) => a.id === configuredAutomationId)
+      : null;
+    if (configuredAutomationId) {
+      if (!automation || automation.destinationThreadId !== threadId || !automation.sessionMode || automation.sessionMode === "new-thread") throw new Error("Automation destination configuration changed before launch");
+      require("./automation-destination.js").destinationThread(store, automation, { isRunning, getPendingPermission });
+    }
     if (services.isTrashed(thread)) {
       throw new Error("Cannot start a run on a deleted thread");
     }
@@ -1930,6 +1945,7 @@ function createRunner(opts) {
     // otherwise fan out again — and the cheap `/` test keeps the provider
     // probe (`which`) off the ordinary send path.
     if (
+      !input[automationStart] &&
       !input.fromNotice &&
       !input.fromInbound &&
       String(prompt).trimStart().startsWith("/")
@@ -2128,6 +2144,7 @@ function createRunner(opts) {
         (store.getSettings().maxConcurrentRuns != null &&
           (!runSlotsFree() || runQueueOrder().length > 0)))
     ) {
+      if (automation) throw Object.assign(new Error("Automation destination is waiting for a run slot; run skipped"), { code: "AUTOMATION_DESTINATION_BUSY" });
       fold.taken = null;
       return enqueueRun(threadId, input, prompt, attachments);
     }
@@ -2154,6 +2171,13 @@ function createRunner(opts) {
       }
     }
 
+    // Only explicitly configured fixed fresh-session fires may reset context,
+    // after all admission and preflight gates have accepted the run.
+    if (automation?.sessionMode === "fresh") {
+      freshAgentContext({ threadId });
+      thread = store.getThread(threadId);
+    }
+
     // Prefix is CLI-only and must see the retained tail BEFORE this turn's
     // user message is appended (rewind replay would otherwise digest itself).
     const prefix = services.buildHandoffPrefix(
@@ -3357,6 +3381,7 @@ function createRunner(opts) {
   queueMicrotask(admitQueuedRuns);
 
   return {
+    startAutomationRun,
     startRun,
     steerRun,
     startBtw,
diff --git a/electron/services-settings.js b/electron/services-settings.js
index f61243957..e07d3bfe6 100644
--- a/electron/services-settings.js
+++ b/electron/services-settings.js
@@ -377,7 +377,16 @@ function normalizeAutomationInput(store, input, existing) {
     scope = "private";
   }
 
+  const destination = require("./automation-destination.js").destinationFields(src, base);
+  // A stale destination must never prevent pausing an automation. Inactive
+  // definitions can be repaired incrementally; enabling validates them again.
+  if ((!existing || enabled) && destination.sessionMode !== "new-thread") {
+    require("./automation-destination.js").destinationThread(
+      store, { ...destination, projectId, provider, model, tier }, null, true,
+    );
+  }
   return {
+    ...destination,
     name,
     projectId,
     prompt,
@@ -479,6 +488,7 @@ function sharedSlug(auto) {
 }
 
 const DEFINITION_KEYS = [
+  "sessionMode", "destinationThreadId",
   "name",
   "prompt",
   "provider",
@@ -498,6 +508,8 @@ const DEFINITION_KEYS = [
  */
 function definitionChanged(fields, existing) {
   return DEFINITION_KEYS.some((key) => {
+    if (key === "sessionMode") return (fields[key] || "new-thread") !== (existing[key] || "new-thread");
+    if (key === "destinationThreadId") return (fields[key] || null) !== (existing[key] || null);
     if (key === "trigger" || key === "budget") {
       return JSON.stringify(fields[key]) !== JSON.stringify(existing[key] || null);
     }
@@ -512,6 +524,8 @@ function definitionChanged(fields, existing) {
 function definitionRow(fields, slug) {
   return {
     id: slug,
+    sessionMode: fields.sessionMode,
+    destinationThreadId: fields.destinationThreadId,
     name: fields.name,
     prompt: fields.prompt,
     provider: fields.provider,
@@ -570,6 +584,8 @@ function addAutomation(store, input) {
       id,
       projectId: project.id,
       scope: "project",
+      sessionMode: fields.sessionMode,
+      destinationThreadId: fields.destinationThreadId,
       name: fields.name,
       prompt: fields.prompt,
       provider: fields.provider,
diff --git a/electron/test/automation-triggers.test.js b/electron/test/automation-triggers.test.js
index 2bbf19389..4bd2636dc 100644
--- a/electron/test/automation-triggers.test.js
+++ b/electron/test/automation-triggers.test.js
@@ -280,6 +280,7 @@ describe("event-triggered automations", () => {
     return startScheduler({
       store,
       runner: {
+        startAutomationRun: async (input) => { started.push(input); return { runId: "fixed" }; },
         startRun: async (input) => {
           started.push(input);
           return { runId: "r" };
@@ -309,6 +310,25 @@ describe("event-triggered automations", () => {
     });
   }
 
+  it("GitHub events continue the configured fixed destination without changing ownership", async () => {
+    const t = services.createThread(store, { projectId: "p1", provider: "claude", model: null });
+    services.setProvider(store, { threadId: t.id, provider: "claude", model: null });
+    addPrOpened({ sessionMode: "continue", destinationThreadId: t.id });
+    const started = [];
+    const sched = scheduler(started);
+    try {
+      rows = [{ number: 10, title: "old", user: { login: "x" } }];
+      await sched.tick();
+      rows = [{ number: 11, title: "new", user: { login: "x" } }, ...rows];
+      await sched.tick();
+      assert.equal(started.length, 1);
+      assert.equal(started[0].threadId, t.id);
+      assert.match(started[0].prompt, /GitHub pr_opened/);
+      assert.equal(store.getThreads().length, 1);
+      assert.equal(store.getThread(t.id).automationId, null);
+    } finally { sched.stop(); }
+  });
+
   it("baselines on the first poll, then batches new PRs into one run", async () => {
     const auto = addPrOpened();
     assert.equal(auto.trigger.event, "pr_opened");
diff --git a/electron/test/automations-file.test.js b/electron/test/automations-file.test.js
index 5ac3656d4..cc97f8a57 100644
--- a/electron/test/automations-file.test.js
+++ b/electron/test/automations-file.test.js
@@ -326,6 +326,20 @@ describe("project-scope writes", () => {
     assert.equal(services.listAutomations(store)[0].memory, "notes");
   });
 
+  it("legacy shared overlay edits preserve exact file bytes, hash, and trust", () => {
+    const dir = tempRepo([ROW]);
+    const store = new Store(path.join(dir, "store.json"));
+    store.setProjects([{ id: "p1", name: "p", path: dir }]);
+    const before = fs.readFileSync(path.join(dir, "solenta.json"), "utf8");
+    const hash = readAutomations(dir).hash;
+    services.trustFile(store, { projectId: "p1", hash });
+    services.updateAutomation(store, { id: "shared:p1:pr-triage", enabled: true });
+    services.updateAutomation(store, { id: "shared:p1:pr-triage", memory: "notes", enabled: false });
+    assert.equal(fs.readFileSync(path.join(dir, "solenta.json"), "utf8"), before);
+    assert.equal(readAutomations(dir).hash, hash);
+    assert.equal(store.getProject("p1").automationsTrust, hash);
+  });
+
   it("remove drops the slug; invalid JSON is not clobbered; remote is rejected", () => {
     const dir = tempRepo([ROW]);
     const store = new Store(path.join(dir, "store.json"));
diff --git a/electron/test/automations.test.js b/electron/test/automations.test.js
index bbadb33ff..5050c6b35 100644
--- a/electron/test/automations.test.js
+++ b/electron/test/automations.test.js
@@ -202,6 +202,111 @@ describe("automation CRUD + scheduler", () => {
     fs.rmSync(tmpDir, { recursive: true, force: true });
   });
 
+  it("persists fixed destinations, continues identity, and starts fresh only when configured", async () => {
+    const target = services.createThread(store, { projectId: "p1", provider: "claude", model: null });
+    services.setProvider(store, { threadId: target.id, provider: "claude", model: null });
+    store.updateThread(target.id, { sessionId: "existing", budget: { turns: 2 } });
+    const created = services.addAutomation(store, { projectId: "p1", name: "Fixed", prompt: "go", provider: "claude", model: null, preset: "hourly", sessionMode: "continue", destinationThreadId: target.id, budget: { turns: 10 } });
+    let starts = 0, resets = 0;
+    const runner = { startRun: async ({ threadId }) => { assert.equal(threadId, target.id); starts++; return { runId: `run-${starts}` }; }, startAutomationRun: async (input) => { if (store.getAutomation(input.automationId).sessionMode === "fresh") resets++; return runner.startRun(input); } };
+    await runNow({ store, runner }, created.id);
+    assert.equal(store.getThread(target.id).sessionId, "existing");
+    assert.equal(store.getThread(target.id).automationId, null);
+    assert.equal(store.getThread(target.id).budget.turns, 2);
+    assert.equal(resets, 0);
+    services.updateAutomation(store, { id: created.id, sessionMode: "fresh" });
+    await runNow({ store, runner }, created.id);
+    assert.equal(resets, 1);
+    assert.equal(starts, 2);
+    assert.equal(listAutomationRuns(store, created.id).runs.length, 2);
+    store.saveNow();
+    const restored = new Store(path.join(tmpDir, "store.json"));
+    assert.equal(restored.getAutomation(created.id).destinationThreadId, target.id);
+    assert.equal(restored.getAutomation(created.id).sessionMode, "fresh");
+  });
+
+  it("rejects missing, cross-project, busy and elevated destinations without creating another thread", async () => {
+    const t = services.createThread(store, { projectId: "p1", provider: "claude", model: null });
+    services.setProvider(store, { threadId: t.id, provider: "claude", model: null });
+    const input = { projectId: "p1", name: "Fixed", prompt: "go", provider: "claude", model: null, preset: "hourly", sessionMode: "continue", destinationThreadId: t.id };
+    assert.throws(() => services.addAutomation(store, { ...input, destinationThreadId: "missing" }), /must exist/);
+    const a = services.addAutomation(store, input);
+    for (const patch of [{ status: "working" }, { status: "idle", pendingQuestion: {} }, { pendingQuestion: null, queued: "user draft" }, { queued: null, permissionMode: "bypassPermissions" }, { permissionMode: "default", alwaysAllowKeys: ["grant"] }, { alwaysAllowKeys: [], archived: true }]) {
+      store.updateThread(t.id, patch);
+      await assert.rejects(runNow({ store, runner: { startRun: () => assert.fail("must not start") } }, a.id), /destination/);
+    }
+    assert.equal(store.getThreads().length, 1);
+  });
+
+  it("can disable and edit inactive automations after their destination becomes invalid", () => {
+    for (const patch of [{ archived: true }, { trashedAt: Date.now() }, { provider: "codex" }, { model: "different" }, { permissionMode: "bypassPermissions" }, null]) {
+      const t = services.createThread(store, { projectId: "p1", provider: "claude", model: null });
+      services.setProvider(store, { threadId: t.id, provider: "claude", model: null });
+      const a = services.addAutomation(store, { projectId: "p1", name: "Fixed", prompt: "go", provider: "claude", model: null, preset: "hourly", sessionMode: "continue", destinationThreadId: t.id });
+      if (patch) store.updateThread(t.id, patch);
+      else store.setThreads(store.getThreads().filter((row) => row.id !== t.id));
+      assert.equal(services.updateAutomation(store, { id: a.id, enabled: false }).enabled, false);
+      assert.equal(services.updateAutomation(store, { id: a.id, name: "Paused" }).name, "Paused");
+      assert.throws(() => services.updateAutomation(store, { id: a.id, enabled: true }), /destination/i);
+      assert.equal(store.getAutomation(a.id).enabled, false);
+    }
+  });
+
+  it("scheduled busy destinations skip without pausing and remain editable", async () => {
+    const t = services.createThread(store, { projectId: "p1", provider: "claude", model: null });
+    services.setProvider(store, { threadId: t.id, provider: "claude", model: null });
+    const a = services.addAutomation(store, { projectId: "p1", name: "Fixed", prompt: "go", provider: "claude", preset: "hourly", sessionMode: "continue", destinationThreadId: t.id });
+    store.updateThread(t.id, { status: "working", queued: "user input" });
+    services.updateAutomation(store, { id: a.id, name: "Renamed" });
+    const scheduler = startScheduler({ store, runner: { startRun: () => assert.fail("must skip") }, intervalMs: 3600000 });
+    try {
+      for (let i = 0; i < 4; i++) {
+        store.setAutomations(store.getAutomations().map((row) => ({ ...row, nextRunAt: 0 })));
+        await scheduler.tick();
+      }
+      const updated = store.getAutomation(a.id);
+      assert.equal(updated.enabled, true);
+      assert.equal(updated.consecutiveFailures, 0);
+      assert.match(updated.lastError, /skipped/);
+      assert.equal(store.getThread(t.id).queued, "user input");
+    } finally { scheduler.stop(); }
+  });
+
+  it("mode changes retain legacy, fixed, and later new-thread run history independently", async () => {
+    const t = services.createThread(store, { projectId: "p1", provider: "claude", model: null });
+    services.setProvider(store, { threadId: t.id, provider: "claude", model: null });
+    const a = services.addAutomation(store, { projectId: "p1", name: "Modes", prompt: "go", provider: "claude", preset: "hourly" });
+    let n = 0;
+    const start = async () => ({ runId: `run-${++n}` });
+    const runner = { startRun: start, startAutomationRun: start };
+    await runNow({ store, runner }, a.id);
+    services.updateAutomation(store, { id: a.id, sessionMode: "continue", destinationThreadId: t.id });
+    await runNow({ store, runner }, a.id);
+    const fixed = store.getAutomation(a.id).runHistory[0];
+    services.updateAutomation(store, { id: a.id, sessionMode: "new-thread" });
+    await runNow({ store, runner }, a.id);
+    const latest = store.getAutomation(a.id).pendingRunThreadId;
+    store.updateThread(latest, { status: "failed" });
+    require("../automations.js").settleAutomationRuns({ store });
+    const runs = listAutomationRuns(store, a.id).runs;
+    assert.equal(runs.length, 3);
+    assert.equal(runs.find((r) => r.id === fixed.id).status, "idle");
+    assert.equal(runs.find((r) => r.threadId === latest).status, "failed");
+    assert.equal(new Set(runs.map((r) => r.id || r.threadId)).size, 3);
+  });
+
+  it("serializes concurrent manual fires at a fixed destination", async () => {
+    const t = services.createThread(store, { projectId: "p1", provider: "claude", model: null });
+    services.setProvider(store, { threadId: t.id, provider: "claude", model: null });
+    const a = services.addAutomation(store, { projectId: "p1", name: "Fixed", prompt: "go", provider: "claude", preset: "hourly", sessionMode: "continue", destinationThreadId: t.id });
+    let release;
+    const runner = { startAutomationRun: () => new Promise((r) => { release = r; }) };
+    const first = runNow({ store, runner }, a.id);
+    await assert.rejects(runNow({ store, runner }, a.id), /already starting/);
+    release({ runId: "one" });
+    await first;
+  });
+
   it("add/list/update/remove persist", () => {
     const created = services.addAutomation(store, {
       projectId: "p1",
diff --git a/electron/test/pr-branch-delete.test.js b/electron/test/pr-branch-delete.test.js
index e51719500..332f66593 100644
--- a/electron/test/pr-branch-delete.test.js
+++ b/electron/test/pr-branch-delete.test.js
@@ -38,9 +38,6 @@ const fs = require("fs");
 const statePath = process.env.CODER_FAKE_GH_STATE;
 const args = process.argv.slice(2);
 const state = JSON.parse(fs.readFileSync(statePath, "utf8"));
-state.calls = state.calls || [];
-state.calls.push(args.slice());
-fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
 
 function findPr(key) {
   return (state.prs || []).find(
@@ -121,7 +118,7 @@ describe("maybeDeleteHeadBranch over gh (#1763)", () => {
     statePath = path.join(tmp, "gh-state.json");
     fs.writeFileSync(
       statePath,
-      JSON.stringify({ prs: [{ number: 12, branch: "feat", state: "MERGED" }], calls: [] }),
+      JSON.stringify({ prs: [{ number: 12, branch: "feat", state: "MERGED" }] }),
     );
     prevGh = process.env.CODER_GH_BIN;
     prevState = process.env.CODER_FAKE_GH_STATE;
@@ -226,7 +223,7 @@ describe("closePr / mergePrAt delete the branch (#1763)", () => {
     statePath = path.join(tmp, "gh-state.json");
     fs.writeFileSync(
       statePath,
-      JSON.stringify({ prs: [{ number: 12, branch: "feat", state: "OPEN" }], calls: [] }),
+      JSON.stringify({ prs: [{ number: 12, branch: "feat", state: "OPEN" }] }),
     );
     prevGh = process.env.CODER_GH_BIN;
     prevState = process.env.CODER_FAKE_GH_STATE;
diff --git a/electron/test/pr-completions.test.js b/electron/test/pr-completions.test.js
new file mode 100644
index 000000000..b02e1a02c
--- /dev/null
+++ b/electron/test/pr-completions.test.js
@@ -0,0 +1,165 @@
+"use strict";
+const { it, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const vm = require('node:vm');
+const fs = require('node:fs');
+let spawn;
+function setExecFile(fn) { spawn = fn; }
+function setGithubApi() {}
+const run = (cwd, args, bin) => new Promise(resolve => spawn(bin, args, { cwd }, (err, stdout, stderr) => resolve({ ok: !err, stdout, stderr })));
+const moduleStub = { exports: {} };
+vm.runInNewContext(fs.readFileSync(require.resolve('../prCompletions.js'), 'utf8'), { module: moduleStub, URL, require(name) {
+  if (name === './worktrees.js') return { gitTryAsync: (cwd, args) => run(cwd, args, 'git'), ghApiTryAsync: (cwd, args) => run(cwd, args, 'gh'), tailErr: (text, fallback) => text || fallback };
+  if (name === './gitlab.js') return { gitlabRemote: require('../gitlab.js').gitlabRemote, glabApi: async (cwd, remote, method, endpoint) => {
+    const r = await run(cwd, ['api', '--hostname', remote.host, '-X', method, `projects/${encodeURIComponent(remote.path)}${endpoint}`], 'glab');
+    return r.ok ? { ok: true, data: JSON.parse(r.stdout) } : { ok: false, reason: r.stderr };
+  } };
+  return require(name === './prLinks.js' ? '../prLinks.js' : name);
+} });
+const { prCompletions } = moduleStub.exports;
+afterEach(() => { spawn = null; });
+it('keeps GitHub reference search bounded to the selected repository and origin host', async () => {
+  const calls = [];
+  setGithubApi(false);
+  setExecFile((bin, args, opts, cb) => {
+    calls.push({ bin, args, cwd: opts.cwd });
+    cb(null, args[0] === 'remote' ? 'git@github.com:owner/private.git\n' : JSON.stringify({ items: [{ number: 12, title: 'Fix' }] }), '');
+  });
+  const result = await prCompletions({ projectPath: '/repo', repo: 'owner/selected', kind: '#', query: '12' });
+  assert.equal(result.ok, true);
+  assert.deepEqual(JSON.parse(JSON.stringify(result.items)), [{ value: '#12', label: 'Fix' }]);
+  const search = calls.find(c => c.args[0] === 'api');
+  assert.match(decodeURIComponent(search.args[1]), /repo:owner\/selected 12/);
+  assert.deepEqual(Array.from(search.args.slice(-2)), ['--hostname', 'github.com']);
+  assert.match(search.args[1], /per_page=20&page=1/);
+});
+it('uses GitLab project members and MR iid notation on the original host', async () => {
+  const calls = [];
+  setExecFile((bin, args, opts, cb) => {
+    calls.push(args);
+    cb(null, args[0] === 'remote' ? 'git@gitlab.example:team/private.git\n' : JSON.stringify([{ iid: 7, title: 'Patch' }]), '');
+  });
+  const result = await prCompletions({ projectPath: '/repo', kind: '!', query: '' });
+  assert.deepEqual(JSON.parse(JSON.stringify(result.items)), [{ value: '!7', label: 'Patch' }]);
+  assert.deepEqual(calls[1].slice(0, 5), ['api', '--hostname', 'gitlab.example', '-X', 'GET']);
+  assert.match(calls[1][5], /^projects\/team%2Fprivate\/merge_requests\?/);
+});
+it('never falls back to global user search and reports denied access', async () => {
+  setGithubApi(false);
+  setExecFile((bin, args, opts, cb) => {
+    if (args[0] === 'remote') return cb(null, 'git@github.com:owner/private.git\n', '');
+    assert.match(args[1], /^repos\/owner\/private\/assignees\?/);
+    cb(new Error('denied'), '', 'HTTP 403: permission denied');
+  });
+  assert.equal((await prCompletions({ projectPath: '/repo', kind: '@', query: '' })).ok, false);
+});
+
+it('includes repository assignees who have never contributed', async () => {
+  setExecFile((bin, args, opts, cb) => {
+    if (args[0] === 'remote') return cb(null, 'git@github.com:owner/private.git', '');
+    assert.match(args[1], /\/assignees\?/);
+    cb(null, JSON.stringify([{ login: 'maintainer', name: 'Review maintainer' }]), '');
+  });
+  const result = await prCompletions({ projectPath: '/repo', kind: '@', query: 'maint' });
+  assert.equal(result.items[0].value, '@maintainer');
+});
+
+it('finds numeric GitHub references independently of title text and deduplicates them', async () => {
+  const calls = [];
+  setExecFile((bin, args, opts, cb) => {
+    calls.push(args);
+    if (args[0] === 'remote') return cb(null, 'git@github.com:owner/private.git', '');
+    cb(null, JSON.stringify(args[1].endsWith('/issues/42')
+      ? { number: 42, title: 'Unrelated title' }
+      : { items: [{ number: 142, title: 'Text 42 match' }] }), '');
+  });
+  const result = await prCompletions({ projectPath: '/repo', kind: '#', query: '42' });
+  assert.equal(result.items[0].value, '#42');
+  assert.equal(result.items[0].label, 'Unrelated title');
+  assert.equal(result.items[1].value, '#142');
+  assert.ok(calls.some(args => args[1] === 'repos/owner/private/issues/42'));
+  calls.length = 0;
+  await prCompletions({ projectPath: '/repo', kind: '#', query: '42', page: 2 });
+  assert.equal(calls.some(args => args[1]?.endsWith('/issues/42')), false);
+});
+
+it('finds numeric GitLab issues and merge requests even without text search matches', async () => {
+  for (const kind of ['#', '!']) {
+    const calls = [];
+    setExecFile((bin, args, opts, cb) => {
+      calls.push(args);
+      if (args[0] === 'remote') return cb(null, 'git@gitlab.example:team/private.git', '');
+      cb(null, JSON.stringify(args[5].endsWith('/42') ? { iid: 42, title: 'Unrelated title' } : []), '');
+    });
+    const result = await prCompletions({ projectPath: '/repo', kind, query: '42' });
+    assert.equal(result.items[0].value, `${kind}42`);
+    assert.equal(result.items[0].label, 'Unrelated title');
+    assert.equal(result.hasMore, false);
+    assert.ok(calls.some(args => args[5] === `projects/team%2Fprivate/${kind === '#' ? 'issues' : 'merge_requests'}/42`));
+    calls.length = 0;
+    await prCompletions({ projectPath: '/repo', kind, query: '42', page: 2 });
+    assert.equal(calls.some(args => args[5]?.endsWith('/42')), false);
+  }
+});
+
+it('preserves a full search page beside an exact hit and tolerates unavailable exact references', async () => {
+  let missing = false;
+  setExecFile((bin, args, opts, cb) => {
+    if (args[0] === 'remote') return cb(null, 'git@github.com:owner/private.git', '');
+    if (args[1].endsWith('/issues/42')) return missing
+      ? cb(new Error('missing'), '', '404 not found')
+      : cb(null, JSON.stringify({ number: 42, title: 'Unrelated title' }), '');
+    cb(null, JSON.stringify({ items: Array.from({ length: 20 }, (_, i) => ({ number: 420 + i, title: 'Matching 42' })) }), '');
+  });
+  const result = await prCompletions({ projectPath: '/repo', kind: '#', query: '42' });
+  assert.equal(result.items.length, 21);
+  assert.equal(result.hasMore, true);
+  assert.equal(result.items.at(-1).value, '#439');
+  missing = true;
+  const fallback = await prCompletions({ projectPath: '/repo', kind: '#', query: '42' });
+  assert.equal(fallback.items.length, 20);
+  assert.equal(fallback.hasMore, true);
+});
+
+it('deduplicates an exact search hit and keeps exact lookup available when search fails', async () => {
+  let searchFails = false;
+  setExecFile((bin, args, opts, cb) => {
+    if (args[0] === 'remote') return cb(null, 'git@github.com:owner/private.git', '');
+    const issue = { number: 42, title: 'Unrelated title' };
+    if (args[1].endsWith('/issues/42')) return cb(null, JSON.stringify(issue), '');
+    if (searchFails) return cb(new Error('unavailable'), '', '503 search unavailable');
+    cb(null, JSON.stringify({ items: [issue] }), '');
+  });
+  for (const fail of [false, true]) {
+    searchFails = fail;
+    const result = await prCompletions({ projectPath: '/repo', kind: '#', query: '42' });
+    assert.equal(result.items.length, 1);
+    assert.equal(result.items[0].value, '#42');
+    assert.equal(result.hasMore, false);
+  }
+});
+
+it('rejects query qualifiers, whitespace, quoting and non-token Unicode before any repository or API call', async () => {
+  let calls = 0;
+  setExecFile(() => { calls++; throw new Error('must not reach network'); });
+  for (const query of ['repo:other/private secret', 'repo:other', 'hello world', 'hello\tworld', 'hello\nworld', '"secret"', "'secret'", 'bob@example.com', 'café', '用户', 'x'.repeat(101), { query: 'escape' }]) {
+    const result = await prCompletions({ projectPath: '/repo', kind: '#', query });
+    assert.equal(result.ok, false, String(query));
+    assert.equal(result.reason, 'Invalid completion query');
+  }
+  assert.equal(calls, 0);
+});
+
+it('accepts the same bounded ASCII token grammar as the textarea, including empty query', async () => {
+  const queries = [];
+  setExecFile((bin, args, opts, cb) => {
+    if (args[0] === 'remote') return cb(null, 'git@github.com:owner/private.git', '');
+    queries.push(args[1]);
+    cb(null, JSON.stringify({ items: [] }), '');
+  });
+  for (const query of ['', 'maintainer-name', 'feature.name', 'under_score', 'Release123', 'x'.repeat(100)]) {
+    assert.equal((await prCompletions({ projectPath: '/repo', kind: '#', query })).ok, true);
+  }
+  assert.equal(queries.length, 6);
+  for (const endpoint of queries) assert.ok(decodeURIComponent(endpoint).includes('q=repo:owner/private '));
+});
diff --git a/electron/test/pr-gitlab-workspace.test.js b/electron/test/pr-gitlab-workspace.test.js
new file mode 100644
index 000000000..f88164426
--- /dev/null
+++ b/electron/test/pr-gitlab-workspace.test.js
@@ -0,0 +1,34 @@
+"use strict";
+const { it } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const vm = require('node:vm');
+const { createRequire } = require('node:module');
+const source = require.resolve('../prWorkspace.js');
+const localRequire = createRequire(source);
+it('loads and edits GitLab descriptions and comments on the origin host/project', async () => {
+  const calls = [];
+  const mr = { iid: 7, web_url: 'https://gitlab.example/team/private/-/merge_requests/7', title: 'MR', description: '@alice !7', source_branch: 'feature', state: 'opened' };
+  const mod = { exports: {} };
+  vm.runInNewContext(fs.readFileSync(source, 'utf8'), { module: mod, require(name) {
+    if (name === './worktrees.js') return { ...localRequire(name), gitTryAsync: async () => ({ ok: true, stdout: 'git@gitlab.example:team/private.git' }) };
+    if (name === './gitlab.js') return { ...localRequire(name), glabApi: async (cwd, remote, method, endpoint, fields) => {
+      calls.push({ cwd, remote, method, endpoint, fields });
+      if (method === 'PUT') Object.assign(mr, fields);
+      return { ok: true, data: endpoint.includes('/notes') ? [] : mr };
+    } };
+    return localRequire(name);
+  } });
+  const detail = await mod.exports.viewPrDetail('/repo', 7);
+  assert.equal(detail.pr.forge, 'gitlab');
+  assert.equal(detail.pr.body, '@alice !7');
+  const edited = await mod.exports.editPr('/repo', { prNumber: 7, body: '@bob #2 !8' });
+  assert.equal(edited.pr.body, '@bob #2 !8');
+  assert.equal((await mod.exports.commentPr('/repo', { prNumber: 7, body: '@bob !7' })).ok, true);
+  assert.equal(calls.find(c => c.method === 'POST').fields.body, '@bob !7');
+  for (const call of calls) {
+    assert.equal(call.remote.host, 'gitlab.example');
+    assert.equal(call.remote.path, 'team/private');
+    assert.equal(call.cwd, '/repo');
+  }
+});
diff --git a/electron/test/provider-switch-context.test.js b/electron/test/provider-switch-context.test.js
index 50c30e896..b6683c43b 100644
--- a/electron/test/provider-switch-context.test.js
+++ b/electron/test/provider-switch-context.test.js
@@ -130,6 +130,96 @@ describe("provider switch keeps context (#1493)", () => {
     return store.getThread(thread.id);
   }
 
+  it("fresh automation preflight failures retain the human session and context", async () => {
+    const thread = threadWithHistory();
+    const automation = services.addAutomation(store, { projectId: project.id, name: "Fresh", prompt: "go", provider: thread.provider, model: thread.model, preset: "hourly", sessionMode: "fresh", destinationThreadId: thread.id });
+    const { runNow } = require("../automations.js");
+    process.env.CODER_AGENT_CMD = agentCmd(logFile);
+    const before = store.getMessages(thread.id).slice();
+    store.updateThread(thread.id, { budget: { usd: 1 } });
+    store.setUsage(thread.id, { costUsd: 2, inputTokens: 5, turns: 1 });
+    await assert.rejects(runNow({ store, runner }, automation.id), /Thread budget reached/);
+    store.updateThread(thread.id, { budget: null });
+    store.setSettings({ dailyBudgetUsd: 1 });
+    const spendToday = store.getSpendToday;
+    store.getSpendToday = () => 2;
+    await assert.rejects(runNow({ store, runner }, automation.id), /Daily budget reached/);
+    store.getSpendToday = spendToday;
+    store.setSettings({ dailyBudgetUsd: null });
+    delete process.env.CODER_AGENT_CMD;
+    const binEnv = getProvider(thread.provider).binEnv;
+    const priorBin = process.env[binEnv];
+    process.env[binEnv] = path.join(tmpDir, "missing-provider");
+    try {
+      await assert.rejects(runNow({ store, runner }, automation.id), /Provider binary not found/);
+    } finally {
+      if (priorBin === undefined) delete process.env[binEnv]; else process.env[binEnv] = priorBin;
+    }
+    assert.equal(store.getThread(thread.id).sessionId, "sess-claude");
+    assert.equal(store.getThread(thread.id).contextBoundaryId, undefined);
+    assert.deepEqual(store.getMessages(thread.id), before);
+    assert.equal(store.getUsage(thread.id).costUsd, 2);
+  });
+
+  it("project-scoped fixed fires preserve per-run history and pending IDs across presentation and reload", async () => {
+    const thread = threadWithHistory();
+    process.env.CODER_AGENT_CMD = agentCmd(logFile);
+    const automation = services.addAutomation(store, { projectId: project.id, scope: "project", name: "Shared review", prompt: "review", provider: thread.provider, model: thread.model, preset: "hourly", sessionMode: "continue", destinationThreadId: thread.id });
+    const { runNow, listAutomationRuns, settleAutomationRuns } = require("../automations.js");
+    await runNow({ store, runner }, automation.id);
+    const presented = services.listAutomations(store).find((a) => a.id === automation.id);
+    assert.ok(presented.pendingRunId);
+    assert.equal(presented.runHistory.length, 1);
+    const first = listAutomationRuns(store, automation.id).runs[0];
+    assert.equal(first.threadId, thread.id);
+    assert.equal(first.runId, presented.pendingRunId);
+    assert.equal(first.pending, true);
+    store.saveNow();
+    const restored = new Store(path.join(tmpDir, "store.json"));
+    assert.equal(services.listAutomations(restored).find((a) => a.id === automation.id).pendingRunId, first.runId);
+    assert.equal(listAutomationRuns(restored, automation.id).runs[0].id, first.id);
+    await waitFor(() => !runner.isRunning(thread.id));
+    settleAutomationRuns({ store });
+    await runNow({ store, runner }, automation.id);
+    await waitFor(() => !runner.isRunning(thread.id));
+    settleAutomationRuns({ store });
+    const runs = listAutomationRuns(store, automation.id).runs;
+    assert.equal(runs.length, 2);
+    assert.notEqual(runs[0].id, runs[1].id);
+    assert.ok(runs.every((r) => !r.pending));
+    const definition = JSON.parse(fs.readFileSync(path.join(project.path, "solenta.json"), "utf8")).automations[0];
+    assert.equal(definition.runHistory, undefined);
+    assert.equal(definition.pendingRunId, undefined);
+    store.saveNow();
+    assert.deepEqual(listAutomationRuns(new Store(path.join(tmpDir, "store.json")), automation.id).runs, runs);
+  });
+
+  it("fixed automation continuation preserves context while explicit fresh mode excludes old history", async () => {
+    const thread = threadWithHistory();
+    process.env.CODER_AGENT_CMD = agentCmd(logFile);
+    const automation = services.addAutomation(store, {
+      projectId: project.id, name: "Review", prompt: "AUTOMATION REQUEST", provider: thread.provider,
+      model: thread.model, preset: "hourly", sessionMode: "continue", destinationThreadId: thread.id,
+    });
+    const { runNow, settleAutomationRuns, listAutomationRuns } = require("../automations.js");
+    await runNow({ store, runner }, automation.id);
+    await waitFor(() => !runner.isRunning(thread.id));
+    assert.equal(store.getThread(thread.id).contextBoundaryId, undefined);
+    assert.equal(store.getThread(thread.id).sessionId, "sess-claude");
+    settleAutomationRuns({ store });
+    services.updateAutomation(store, { id: automation.id, sessionMode: "fresh" });
+    await runNow({ store, runner }, automation.id);
+    await waitFor(() => !runner.isRunning(thread.id));
+    settleAutomationRuns({ store });
+    assert.ok(store.getThread(thread.id).contextBoundaryId);
+    assert.equal(store.getThread(thread.id).freshContextPending, false);
+    assert.ok(store.getMessages(thread.id).some((m) => m.text === "PARSER HALF DONE"));
+    assert.ok(!store.getContextMessages(thread.id).some((m) => m.text === "PARSER HALF DONE"));
+    assert.equal(store.getThreads().length, 1);
+    assert.equal(listAutomationRuns(store, automation.id).runs.length, 2);
+    assert.notEqual(listAutomationRuns(store, automation.id).runs[0].id, listAutomationRuns(store, automation.id).runs[1].id);
+  });
+
   it("fresh context retains visible history and identity across reload without old handoff", async () => {
     const thread = threadWithHistory();
     store.updateThread(thread.id, { handoffFrom: "old-source", replayContext: true,
diff --git a/electron/test/run-queue.test.js b/electron/test/run-queue.test.js
index 3be9416ef..9da56f099 100644
--- a/electron/test/run-queue.test.js
+++ b/electron/test/run-queue.test.js
@@ -53,6 +53,23 @@ describe("run queue (maxConcurrentRuns)", () => {
     else process.env.CODER_SIMULATE = prevSimulate;
   });
 
+  it("a fixed fresh automation skips a full run slot without resetting or queuing its destination", async () => {
+    const [a, b] = ids;
+    const target = store.getThread(b);
+    store.updateThread(b, { sessionId: "human-session" });
+    store.appendMessage(b, { id: "human", role: "assistant", text: "HUMAN CONTEXT", createdAt: 1 });
+    const automation = services.addAutomation(store, { projectId: target.projectId, name: "Fresh", prompt: "go", provider: target.provider, model: target.model, preset: "hourly", sessionMode: "fresh", destinationThreadId: b });
+    await runner.startRun({ threadId: a, prompt: "occupy slot" });
+    const before = store.getMessages(b).slice();
+    await assert.rejects(require("../automations.js").runNow({ store, runner }, automation.id), /run slot.*skipped/);
+    assert.equal(store.getThread(b).sessionId, "human-session");
+    assert.equal(store.getThread(b).contextBoundaryId, undefined);
+    assert.equal(store.getThread(b).runQueue, undefined);
+    assert.deepEqual(store.getMessages(b), before);
+    assert.equal(store.getAutomation(automation.id).pendingRunThreadId, null);
+    assert.equal(store.getAutomation(automation.id).consecutiveFailures, 0);
+  });
+
   it("defaults to 4 and validates", () => {
     assert.equal(new Store(path.join(tmpDir, "x.json")).getSettings().maxConcurrentRuns, 4);
     assert.throws(() => store.setSettings({ maxConcurrentRuns: 0 }));
diff --git a/electron/webScopes.js b/electron/webScopes.js
index 6da8d6c8c..9c36e92a1 100644
--- a/electron/webScopes.js
+++ b/electron/webScopes.js
@@ -98,6 +98,7 @@ const BY_SCOPE = {
     "git:mergeOptions",
     "git:listPrs",
     "git:prTemplate",
+    "git:prCompletions",
     "git:prDetail",
     "git:prDiff",
     "git:prViewed",
diff --git a/package-lock.json b/package-lock.json
index 33904ed23..7bd56b4fb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -25,7 +25,9 @@
         "react-markdown": "^10.1.0",
         "remark-gfm": "^4.0.1",
         "ws": "8.21.3",
-        "yauzl": "^3.4.0"
+        "yauzl": "^3.4.0",
+        "unified": "^11.0.5",
+        "remark-parse": "^11.0.0"
       },
       "devDependencies": {
         "@types/react": "^19.1.2",
diff --git a/package.json b/package.json
index 70d00dccd..5493b2377 100644
--- a/package.json
+++ b/package.json
@@ -42,7 +42,9 @@
     "react-markdown": "^10.1.0",
     "remark-gfm": "^4.0.1",
     "ws": "8.21.3",
-    "yauzl": "^3.4.0"
+    "yauzl": "^3.4.0",
+    "unified": "^11.0.5",
+    "remark-parse": "^11.0.0"
   },
   "devDependencies": {
     "@types/react": "^19.1.2",
diff --git a/scripts/test-electron.js b/scripts/test-electron.js
index e2bddcd0c..fc8540b45 100644
--- a/scripts/test-electron.js
+++ b/scripts/test-electron.js
@@ -80,6 +80,8 @@ const WIN32_FILES = [
   "electron/test/reasoning-effort.test.js",
   "electron/test/ultracode.test.js",
   "electron/test/stop-on-settle.test.js",
+  "electron/test/pr-completions.test.js",
+  "electron/test/pr-gitlab-workspace.test.js",
   "electron/test/rewind.test.js",
   "electron/test/session-record.test.js",
   "electron/test/secrets.test.js",
diff --git a/site-content/docs.html b/site-content/docs.html
index 92657da2e..da81478e3 100644
--- a/site-content/docs.html
+++ b/site-content/docs.html
@@ -1124,6 +1124,20 @@ <h2 id="automations">Automations</h2>
       </p>
 
       <p>
+        <strong>Session mode</strong> defaults to a new thread for every run.
+        Choose <strong>Continue a fixed thread</strong> to keep its provider conversation,
+        or <strong>Fixed thread, fresh agent context</strong> to start each run with clean
+        agent context while keeping visible history, workspace and accumulated usage.
+        Select a destination in the same project with the same provider and model,
+        default permissions, and no account override, additional grants or routing.
+        Busy destinations and unresolved input are skipped without pausing the automation.
+        Automation budgets can tighten a fixed thread's limits and count its existing
+        lifetime spend, tokens and turns; fresh context does not reset these counters.
+        Project definitions persist <code>sessionMode</code> (<code>new-thread</code>,
+        <code>continue</code> or <code>fresh</code>) and <code>destinationThreadId</code>.
+        A destination missing on another machine fails visibly rather than creating a thread.
+      </p>
+<p>
         Use <strong>Edit</strong> to change an automation in place. Its recent
         runs link to the corresponding transcripts, including live and
         quota-wait runs. Changing a name, prompt or model keeps the schedule's
diff --git a/site/docs/automations/index.html b/site/docs/automations/index.html
index 92a7481aa..5abd5eb43 100644
--- a/site/docs/automations/index.html
+++ b/site/docs/automations/index.html
@@ -102,6 +102,20 @@
         into a <a href="docs/workflows">Build workflow</a> when the shape of it is
         worth keeping.
       </p>
+<p>
+        <strong>Session mode</strong> defaults to a new thread for every run.
+        Choose <strong>Continue a fixed thread</strong> to keep its provider conversation,
+        or <strong>Fixed thread, fresh agent context</strong> to start each run with clean
+        agent context while keeping visible history, workspace and accumulated usage.
+        Select a destination in the same project with the same provider and model,
+        default permissions, and no account override, additional grants or routing.
+        Busy destinations and unresolved input are skipped without pausing the automation.
+        Automation budgets can tighten a fixed thread's limits and count its existing
+        lifetime spend, tokens and turns; fresh context does not reset these counters.
+        Project definitions persist <code>sessionMode</code> (<code>new-thread</code>,
+        <code>continue</code> or <code>fresh</code>) and <code>destinationThreadId</code>.
+        A destination missing on another machine fails visibly rather than creating a thread.
+      </p>
 <p>
         Use <strong>Edit</strong> to change an automation in place. Its recent
         runs link to the corresponding transcripts, including live and
diff --git a/site/llms-full.txt b/site/llms-full.txt
index 370cd018a..9b03b55bc 100644
--- a/site/llms-full.txt
+++ b/site/llms-full.txt
@@ -363,6 +363,8 @@ Automations run a prompt on a schedule: hourly, daily at an hour, or weekly. Eac
 
 A finished thread can be **repeated** rather than retyped: put its prompt on a schedule as a new automation, or distill the run into a [Build workflow](https://solenta.app/docs/workflows) when the shape of it is worth keeping.
 
+**Session mode** defaults to a new thread for every run. Choose **Continue a fixed thread** to keep its provider conversation, or **Fixed thread, fresh agent context** to start each run with clean agent context while keeping visible history, workspace and accumulated usage. Select a destination in the same project with the same provider and model, default permissions, and no account override, additional grants or routing. Busy destinations and unresolved input are skipped without pausing the automation. Automation budgets can tighten a fixed thread's limits and count its existing lifetime spend, tokens and turns; fresh context does not reset these counters. Project definitions persist `sessionMode` (`new-thread`, `continue` or `fresh`) and `destinationThreadId`. A destination missing on another machine fails visibly rather than creating a thread.
+
 Use **Edit** to change an automation in place. Its recent runs link to the corresponding transcripts, including live and quota-wait runs. Changing a name, prompt or model keeps the schedule's identity; changing the schedule recalculates its next run. History retention removes completed old runs, preserving unfinished work.
 
 You can also describe an automation in a thread. The agent creates it and a card links to it with **Open in Automations**.
diff --git a/site/sitemap.xml b/site/sitemap.xml
index 6c9e66fff..45d76d819 100644
--- a/site/sitemap.xml
+++ b/site/sitemap.xml
@@ -6,7 +6,7 @@
   <url><loc>https://solenta.app/docs/analytics</loc><lastmod>2026-11-02</lastmod></url>
   <url><loc>https://solenta.app/docs/architecture</loc><lastmod>2026-11-02</lastmod></url>
   <url><loc>https://solenta.app/docs/ask</loc><lastmod>2026-11-02</lastmod></url>
-  <url><loc>https://solenta.app/docs/automations</loc><lastmod>2026-11-02</lastmod></url>
+  <url><loc>https://solenta.app/docs/automations</loc><lastmod>2026-11-07</lastmod></url>
   <url><loc>https://solenta.app/docs/cli-sessions</loc><lastmod>2026-11-02</lastmod></url>
   <url><loc>https://solenta.app/docs/codex</loc><lastmod>2026-11-02</lastmod></url>
   <url><loc>https://solenta.app/docs/dev-servers</loc><lastmod>2026-11-02</lastmod></url>
diff --git a/site/solenta.schema.json b/site/solenta.schema.json
index a33cb1ce0..b67fe997d 100644
--- a/site/solenta.schema.json
+++ b/site/solenta.schema.json
@@ -72,6 +72,8 @@
         "additionalProperties": false,
         "required": ["id", "name", "prompt", "provider", "preset"],
         "properties": {
+          "sessionMode": { "enum": ["new-thread", "continue", "fresh"] },
+          "destinationThreadId": { "type": ["string", "null"] },
           "id": { "type": "string", "pattern": "^[a-z][a-z0-9-]{0,47}$" },
           "name": { "type": "string", "minLength": 1 },
           "prompt": { "type": "string", "minLength": 1, "maxLength": 4000 },
diff --git a/src/components/AutomationsView.tsx b/src/components/AutomationsView.tsx
index 16618e402..a83546ac6 100644
--- a/src/components/AutomationsView.tsx
+++ b/src/components/AutomationsView.tsx
@@ -48,7 +48,7 @@ export interface AutomationsViewProps {
    * thread when a retained id has since been deleted. Omit while the
    * list is still loading — treat runs as openable.
    */
-  liveThreads?: Array<{ id: string; status: ThreadStatus }>;
+  liveThreads?: Array<{ id: string; status: ThreadStatus; projectId?: string; title?: string; provider?: string; model?: string | null; archived?: boolean; permissionMode?: string }>;
   /** Open this row in the form (automation_create card, #1599). */
   focusId?: string | null;
   onCreate: (input: AutomationWrite) => Promise<void> | void;
@@ -63,6 +63,8 @@ export interface AutomationsViewProps {
 /** Same keys `updateAutomation` uses to decide whether to rewrite solenta.json. */
 function definitionChanged(
   fields: {
+    sessionMode?: "new-thread" | "continue" | "fresh";
+    destinationThreadId?: string | null;
     name: string;
     prompt: string;
     provider: string;
@@ -78,6 +80,8 @@ function definitionChanged(
   existing: AutomationInfo,
 ): boolean {
   return (
+    (fields.sessionMode || "new-thread") !== (existing.sessionMode || "new-thread") ||
+    (fields.destinationThreadId || null) !== (existing.destinationThreadId || null) ||
     fields.name !== existing.name ||
     fields.prompt !== existing.prompt ||
     fields.provider !== existing.provider ||
@@ -104,7 +108,7 @@ function liveThreadKey(
   threads: AutomationsViewProps["liveThreads"],
 ): string {
   if (!threads) return "";
-  return threads.map((t) => t.id).join("\n");
+  return threads.map((t) => `${t.id}:${t.status}`).join("\n");
 }
 
 function AutomationRunHistory({
@@ -117,7 +121,7 @@ function AutomationRunHistory({
   automation: AutomationInfo;
   loadRuns: (id: string) => Promise<AutomationRunsResult>;
   onSelectThread?: (id: string) => void;
-  liveThreads?: Array<{ id: string; status: ThreadStatus }>;
+  liveThreads?: Array<{ id: string; status: ThreadStatus; projectId?: string; title?: string; provider?: string; model?: string | null; archived?: boolean; permissionMode?: string }>;
   now: number;
 }) {
   const [result, setResult] = useState<AutomationRunsResult | null>(null);
@@ -145,7 +149,7 @@ function AutomationRunHistory({
     return () => {
       cancelled = true;
     };
-  }, [automation.id, idsKey]);
+  }, [automation.id, automation.lastRunAt, automation.pendingRunThreadId, idsKey]);
 
   const liveById = useMemo(() => {
     const map = new Map<string, ThreadStatus>();
@@ -156,7 +160,7 @@ function AutomationRunHistory({
 
   const resolved = (result?.runs ?? []).map((run) => {
     const missing = liveLoaded && !liveById.has(run.threadId);
-    const status = liveById.get(run.threadId) ?? run.status;
+    const status = !run.id || run.pending ? (liveById.get(run.threadId) ?? run.status) : run.status;
     return { ...run, status, missing };
   });
   const latest = resolved[0] ?? null;
@@ -224,7 +228,7 @@ function AutomationRunHistory({
           {expanded ? (
             <ul className={styles.runs} data-automation-runs="">
               {resolved.map((run) => (
-                <li key={run.threadId}>
+                <li key={run.id || run.threadId}>
                   {run.missing ? (
                     <div
                       className={styles.runRow}
@@ -301,6 +305,8 @@ export function AutomationsView({
   const [provider, setProvider] = useState(
     draft?.provider ?? providers[0]?.id ?? "claude",
   );
+  const [sessionMode, setSessionMode] = useState<"new-thread" | "continue" | "fresh">("new-thread");
+  const [destinationThreadId, setDestinationThreadId] = useState("");
   const [model, setModel] = useState(draft?.model ?? "");
   const [preset, setPreset] = useState<AutomationPreset>("hourly");
   // #246: "" = run on the provider/model above.
@@ -356,6 +362,8 @@ export function AutomationsView({
     setName(auto.name);
     setProjectId(auto.projectId);
     setPrompt(auto.prompt);
+    setSessionMode(auto.sessionMode || "new-thread");
+    setDestinationThreadId(auto.destinationThreadId || "");
     setProvider(auto.provider);
     setModel(auto.model ?? "");
     setPreset(auto.preset);
@@ -393,6 +401,8 @@ export function AutomationsView({
     setEditingId(null);
     setName("");
     setPrompt("");
+    setSessionMode("new-thread");
+    setDestinationThreadId("");
     setModel("");
     setPreset("hourly");
     setTier("");
@@ -515,6 +525,7 @@ export function AutomationsView({
    */
   const submit = async () => {
     if (savingRef.current) return;
+    if (sessionMode !== "new-thread" && !destinationThreadId) { setFormError("Choose a destination thread"); return; }
     const error = createFormError({
       name,
       projectId,
@@ -547,6 +558,8 @@ export function AutomationsView({
         const editing = automations.find((a) => a.id === editingId);
         const hadTier = editing?.tier;
         const nextDef = {
+          sessionMode,
+          destinationThreadId: sessionMode === "new-thread" ? null : destinationThreadId.trim(),
           name: name.trim(),
           prompt,
           provider,
@@ -561,6 +574,8 @@ export function AutomationsView({
         };
         await onUpdate({
           id: editingId,
+          sessionMode,
+          destinationThreadId: sessionMode === "new-thread" ? null : destinationThreadId.trim(),
           name: nextDef.name,
           prompt: nextDef.prompt,
           provider: nextDef.provider,
@@ -588,6 +603,8 @@ export function AutomationsView({
       } else {
         const writeScope = projectScopeBlocked ? "private" : scope;
         await onCreate({
+          sessionMode,
+          destinationThreadId: sessionMode === "new-thread" ? null : destinationThreadId.trim(),
           name: name.trim(),
           projectId,
           prompt,
@@ -609,7 +626,9 @@ export function AutomationsView({
         setWroteFile(writeScope === "project");
         setName("");
         setPrompt("");
-        setModel("");
+        setSessionMode("new-thread");
+    setDestinationThreadId("");
+    setModel("");
         setTier("");
         setBudget(budgetToDraft(null));
         setScope("private");
@@ -1056,6 +1075,23 @@ export function AutomationsView({
             />
           </label>
         ) : null}
+        <label className={styles.field}>
+          <span className={styles.label}>Session mode</span>
+          <select className={styles.select} aria-label="Session mode" value={sessionMode} onChange={(e) => setSessionMode(e.target.value as typeof sessionMode)}>
+            <option value="new-thread">New thread for every run</option>
+            <option value="continue">Continue a fixed thread</option>
+            <option value="fresh">Fixed thread, fresh agent context</option>
+          </select>
+        </label>
+        {sessionMode !== "new-thread" && <label className={styles.field}>
+          <span className={styles.label}>Destination thread</span>
+          <select className={styles.select} aria-label="Destination thread" value={destinationThreadId} onChange={(e) => setDestinationThreadId(e.target.value)} required>
+            <option value="">Choose a thread</option>
+            {destinationThreadId && !liveThreads?.some((t) => t.id === destinationThreadId && t.projectId === projectId && !t.archived && t.provider === provider && (t.model || "") === model && (!t.permissionMode || t.permissionMode === "default")) && <option value={destinationThreadId}>Saved destination unavailable or incompatible</option>}
+            {liveThreads?.filter((t) => t.projectId === projectId && !t.archived && t.provider === provider && (t.model || "") === model && (!t.permissionMode || t.permissionMode === "default")).map((t) => <option key={t.id} value={t.id}>{t.title || "Untitled thread"} · {t.model || "Default model"}</option>)}
+          </select>
+          <span>Use a thread in this project with the same provider and model and default permissions. Busy threads are skipped. Fixed threads keep lifetime usage; automation caps can tighten their existing limits.</span>
+        </label>}
         <label className={styles.field}>
           <span className={styles.label}>Prompt</span>
           <textarea
diff --git a/src/components/Markdown.tsx b/src/components/Markdown.tsx
index b13cad290..d9bc65ed7 100644
--- a/src/components/Markdown.tsx
+++ b/src/components/Markdown.tsx
@@ -1,4 +1,6 @@
 import {
+  cloneElement,
+  Children,
   createContext,
   Fragment,
   isValidElement,
@@ -16,6 +18,7 @@ import {
 import ReactMarkdown, {
   defaultUrlTransform,
   type Components,
+  type ExtraProps,
 } from "react-markdown";
 import remarkGfm from "remark-gfm";
 import { lazyNamed } from "../lazyNamed";
@@ -293,6 +296,35 @@ function useThrottledText(text: string, lastCost: { current: number }): string {
 
 const REMARK_PLUGINS = [remarkGfm];
 
+export interface MarkdownTask { start: number; end: number }
+const TaskContext = createContext<{ onToggle: (task: MarkdownTask) => void; disabled: boolean } | null>(null);
+
+function TaskListItem(props: { children?: ReactNode } & ExtraProps) {
+  const tasks = useContext(TaskContext);
+  const start = props.node?.position?.start.offset;
+  const end = props.node?.position?.end.offset;
+  type ChildProps = { children?: ReactNode; node?: { tagName?: string }; type?: string; disabled?: boolean; onChange?: () => void; "aria-label"?: string };
+  const ownChildren = Children.toArray(props.children).filter((child) =>
+    !isValidElement<ChildProps>(child) || !["ul", "ol"].includes(child.props.node?.tagName ?? String(child.type)));
+  const label = flattenText(ownChildren).trim() || "Checklist item";
+  function editable(children: ReactNode): ReactNode {
+    return Children.map(children, (child) => {
+      if (!isValidElement<ChildProps>(child)) return child;
+      if (child.props.type === "checkbox" && tasks && start != null && end != null) {
+        return cloneElement(child, { disabled: tasks.disabled, onChange: () => tasks.onToggle({ start, end }), "aria-label": `Toggle ${label}` });
+      }
+      // Loose task items wrap their own input in a paragraph. Nested lists
+      // have their own list-item source positions and must keep that mapping.
+      if ((child.props.node?.tagName ?? child.type) === "p") {
+        return cloneElement(child, { children: editable(child.props.children) });
+      }
+      return child;
+    });
+  }
+  const children = tasks ? editable(props.children) : props.children;
+  return <li>{linkifyNode(children)}</li>;
+}
+
 const COMPONENTS: Components = {
   pre: (props) => <CodeBlock>{props.children}</CodeBlock>,
   // Double-click takes the whole span: word selection stops at `-` and `/`,
@@ -308,7 +340,7 @@ const COMPONENTS: Components = {
     </code>
   ),
   p: (props) => <p>{linkifyNode(props.children)}</p>,
-  li: (props) => <li>{linkifyNode(props.children)}</li>,
+  li: TaskListItem,
   td: (props) => <td>{linkifyNode(props.children)}</td>,
   th: (props) => <th>{linkifyNode(props.children)}</th>,
   h1: (props) => <h1>{linkifyNode(props.children)}</h1>,
@@ -412,13 +444,18 @@ const MarkdownChunk = memo(function MarkdownChunk({
 export function MarkdownBody({
   text,
   streaming = false,
+  onTaskToggle,
+  tasksDisabled = false,
 }: {
   text: string;
   streaming?: boolean;
+  onTaskToggle?: (task: MarkdownTask) => void;
+  tasksDisabled?: boolean;
 }) {
   const chunks = streaming ? markdownChunks(text) : [text];
   const wrap = useWrapCodeBlocksEnabled();
   return (
+    <TaskContext.Provider value={onTaskToggle ? { onToggle: onTaskToggle, disabled: tasksDisabled } : null}>
     <div className={styles.md} data-wrap-code={wrap ? "" : undefined}>
       {chunks.map((chunk, i) => (
         <Fragment key={i}>
@@ -430,6 +467,7 @@ export function MarkdownBody({
         </Fragment>
       ))}
     </div>
+    </TaskContext.Provider>
   );
 }
 
diff --git a/src/components/PrCompletionTextarea.module.css b/src/components/PrCompletionTextarea.module.css
new file mode 100644
index 000000000..1713dcd61
--- /dev/null
+++ b/src/components/PrCompletionTextarea.module.css
@@ -0,0 +1,14 @@
+.root { position: relative; }
+.menu {
+  margin-top: 4px;
+  max-height: 240px;
+  overflow-y: auto;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  background: var(--card);
+  color: var(--text);
+  font-size: 12px;
+}
+.option { padding: 6px 8px; cursor: pointer; }
+.option[aria-selected="true"] { background: var(--border); }
+.status { padding: 6px 8px; }
diff --git a/src/components/PrCompletionTextarea.tsx b/src/components/PrCompletionTextarea.tsx
new file mode 100644
index 000000000..1fd38b06b
--- /dev/null
+++ b/src/components/PrCompletionTextarea.tsx
@@ -0,0 +1,114 @@
+import { useEffect, useId, useRef, useState } from "react";
+import type { TextareaHTMLAttributes } from "react";
+import type { CoderApi } from "../shared/ipc";
+import styles from "./PrCompletionTextarea.module.css";
+
+type Token = { start: number; end: number; kind: "@" | "#" | "!"; query: string };
+export function prCompletionToken(value: string, start: number, end: number): Token | null {
+  if (start !== end) return null;
+  const before = value.slice(0, start);
+  // Markdown fences and inline code, URLs and email addresses are literal text.
+  if ((before.match(/^\s*(```|~~~)/gm)?.length || 0) % 2) return null;
+  const line = before.slice(before.lastIndexOf("\n") + 1);
+  if ((line.match(/`/g)?.length || 0) % 2) return null;
+  const match = /(?:^|[\s(])([@#!])([\w.-]*)$/.exec(before);
+  if (!match) return null;
+  return { start: start - match[2].length - 1, end: start + (value.slice(start).match(/^[\w.-]*/)?.[0].length || 0), kind: match[1] as Token["kind"], query: match[2] };
+}
+
+type Props = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "onChange"> & {
+  value: string;
+  onChange: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
+  projectPath: string;
+  repo?: string;
+  scope: string;
+  lookup?: CoderApi["git"]["prCompletions"];
+};
+export function PrCompletionTextarea({ projectPath, repo, scope, lookup, value, onChange, ...props }: Props) {
+  const ref = useRef<HTMLTextAreaElement>(null);
+  const id = useId();
+  const [token, setToken] = useState<Token | null>(null);
+  const [items, setItems] = useState<Array<{ value: string; label: string }>>([]);
+  const [status, setStatus] = useState("");
+  const [selected, setSelected] = useState(0);
+  const [page, setPage] = useState(1);
+  const [more, setMore] = useState(false);
+  const [focused, setFocused] = useState(false);
+  const request = useRef(0);
+  const draftValue = useRef(value);
+  const lastSelection = useRef("");
+  const read = (element: HTMLTextAreaElement) => {
+    const selection = `${element.value}\0${element.selectionStart}:${element.selectionEnd}`;
+    if (lastSelection.current === selection) return;
+    lastSelection.current = selection;
+    draftValue.current = element.value;
+    request.current++;
+    setItems([]);
+    setPage(1);
+    setToken(prCompletionToken(element.value, element.selectionStart, element.selectionEnd));
+  };
+  useEffect(() => {
+    if (draftValue.current !== value) { draftValue.current = value; request.current++; setToken(null); setItems([]); }
+  }, [value]);
+  useEffect(() => { setToken(null); setItems([]); request.current++; }, [projectPath, repo, scope]);
+  useEffect(() => {
+    const version = ++request.current;
+    if (!token || !focused) return;
+    setStatus("Loading suggestions…");
+    setSelected(0);
+    const timer = setTimeout(async () => {
+      const search = lookup ?? window.coder?.git.prCompletions;
+      try {
+        if (!search) throw new Error("Suggestions unavailable");
+        const result = await search({ projectPath, repo, kind: token.kind, query: token.query, page });
+        if (version !== request.current) return;
+        if (!result.ok) throw new Error(result.reason);
+        setItems(result.items);
+        setMore(result.hasMore);
+        setStatus(result.items.length ? "" : "No matches");
+      } catch (error) {
+        if (version === request.current) { setItems([]); setMore(false); setStatus(error instanceof Error ? error.message : "Search failed"); }
+      }
+    }, 250);
+    return () => { clearTimeout(timer); request.current++; };
+  }, [token, focused, projectPath, repo, scope, lookup, page]);
+  const choose = (index: number) => {
+    const element = ref.current;
+    const row = items[index];
+    if (!element || !token || !row) return;
+    const separator = /^\s/.test(value.slice(token.end)) ? "" : " ";
+    const next = value.slice(0, token.start) + row.value + separator + value.slice(token.end);
+    const caret = token.start + row.value.length + (separator.length || 1);
+    // Use the controlled input's existing change path, without triggering form submission.
+    onChange({ target: { value: next }, currentTarget: { value: next } } as React.ChangeEvent<HTMLTextAreaElement>);
+    setToken(null); request.current++;
+    requestAnimationFrame(() => { element.focus(); element.setSelectionRange(caret, caret); });
+  };
+  const visible = focused && token != null;
+  return <div className={styles.root}>
+    <textarea {...props} ref={ref} value={value} aria-controls={visible ? id : undefined}
+      aria-expanded={visible} aria-autocomplete="list" aria-activedescendant={visible && items.length ? `${id}-${selected}` : undefined}
+      onChange={event => { onChange(event); read(event.currentTarget); }}
+      onSelect={event => read(event.currentTarget)}
+      onFocus={event => { lastSelection.current = ""; setFocused(true); read(event.currentTarget); }}
+      onBlur={() => { setFocused(false); request.current++; }}
+      onKeyDown={event => {
+        if (!visible) return;
+        if (event.key === "Escape") { event.preventDefault(); event.stopPropagation(); setToken(null); request.current++; }
+        else if (event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) return;
+        else if (event.key === "PageDown" && more) { event.preventDefault(); event.stopPropagation(); setItems([]); setPage(p => p + 1); }
+        else if (["ArrowDown", "ArrowUp", "Enter", "Tab"].includes(event.key)) {
+          if (!items.length) return;
+          event.preventDefault(); event.stopPropagation();
+          if (event.key === "ArrowDown" || event.key === "ArrowUp") setSelected(index => items.length ? (index + (event.key === "ArrowDown" ? 1 : -1) + items.length) % items.length : 0);
+          else choose(selected);
+        }
+      }} />
+    {visible && <div className={styles.menu} id={id} role="listbox" aria-label="Repository suggestions">
+      {status && <div className={styles.status} role="status">{status}</div>}
+      {items.map((row, index) => <div id={`${id}-${index}`} key={row.value} role="option" className={styles.option} aria-selected={selected === index}
+        onMouseDown={event => { event.preventDefault(); choose(index); }}>{row.value} {row.label}</div>)}
+      {more && <button type="button" onMouseDown={event => event.preventDefault()} onClick={() => { setItems([]); setPage(p => p + 1); }}>More suggestions (Page Down)</button>}
+    </div>}
+  </div>;
+}
diff --git a/src/components/PrWorkspacePanel.tsx b/src/components/PrWorkspacePanel.tsx
index cbec0fcc4..3e1f6e6ef 100644
--- a/src/components/PrWorkspacePanel.tsx
+++ b/src/components/PrWorkspacePanel.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { formatRelativeAge, middleTruncate } from "../format";
 import { normalizePrLinks } from "../prLinks";
 import { canSubmitComment, canSubmitPr } from "../prUi";
@@ -15,7 +15,9 @@ import type {
   ReactionContent,
   ThreadInfo,
 } from "../shared/ipc";
-import { Markdown } from "./Markdown";
+import { Markdown, MarkdownBody, type MarkdownTask } from "./Markdown";
+import { toggleDescriptionTask } from "../descriptionTasks";
+import { PrCompletionTextarea } from "./PrCompletionTextarea";
 import { PrCodeTab } from "./PrCodeTab";
 import styles from "./PrWorkspacePanel.module.css";
 
@@ -143,6 +145,7 @@ export function PrWorkspacePanel({
   const [pr, setPr] = useState<PrDetail | null>(null);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
+  const [checklistError, setChecklistError] = useState(false);
   const [title, setTitle] = useState("");
   const [body, setBody] = useState("");
   const [comment, setComment] = useState("");
@@ -178,6 +181,15 @@ export function PrWorkspacePanel({
   const [tab, setTab] = useState<"conversation" | "code">("conversation");
   const [activePr, setActivePr] = useState(prNumber);
   const [activeRepo, setActiveRepo] = useState<string | undefined>(undefined);
+  const identity = `${projectPath}\0${prNumber}\0${activeRepo || ""}\0${activePr}`;
+  const selection = useRef({ identity, generation: 0 });
+  if (selection.current.identity !== identity) selection.current = { identity, generation: selection.current.generation + 1 };
+  const generation = selection.current.generation;
+  const taskBusy = useRef<number | null>(null);
+  useEffect(() => { setPending(null); setChecklistError(false); }, [identity]);
+  const mounted = useRef(true);
+  useEffect(() => { mounted.current = true; return () => { mounted.current = false; }; }, []);
+
   const [stack, setStack] = useState<PrStackEntry[]>([]);
   const [stackBusy, setStackBusy] = useState<string | null>(null);
   const links = normalizePrLinks(matchedThread || { prNumber, prUrl: null, prState: null });
@@ -189,6 +201,7 @@ export function PrWorkspacePanel({
   }, [prNumber]);
 
   const load = useCallback(async (commentsOnly = false) => {
+    const requestedGeneration = generation;
     setLoading(true);
     try {
       const result = await prDetail({
@@ -196,6 +209,7 @@ export function PrWorkspacePanel({
         prNumber: activePr,
         ...(activeRepo ? { repo: activeRepo } : {}),
       });
+      if (!mounted.current || selection.current.generation !== requestedGeneration) return;
       if (!result.ok) {
         setError(result.reason);
         if (!commentsOnly) setPr(null);
@@ -217,13 +231,15 @@ export function PrWorkspacePanel({
         setBody(result.pr.body);
       }
       setError(null);
+      setChecklistError(false);
     } catch (err) {
+      if (!mounted.current || selection.current.generation !== requestedGeneration) return;
       setError(rejectReason(err, "Couldn't load this pull request"));
       if (!commentsOnly) setPr(null);
     } finally {
-      setLoading(false);
+      if (mounted.current && selection.current.generation === requestedGeneration) setLoading(false);
     }
-  }, [prDetail, projectPath, activePr, activeRepo]);
+  }, [prDetail, projectPath, activePr, activeRepo, generation]);
 
   useEffect(() => {
     void load();
@@ -394,6 +410,37 @@ export function PrWorkspacePanel({
   const dirty =
     pr != null && (title.trim() !== pr.title || body !== pr.body);
   const titleOk = canSubmitPr(title);
+  const toggleTask = async (task: MarkdownTask) => {
+    if (!pr || !open || dirty || pending || taskBusy.current === generation) return;
+    taskBusy.current = generation;
+    const requestedGeneration = generation;
+    setPending("checklist");
+    setChecklistError(false);
+    try {
+      const latest = await prDetail(prArgs);
+      if (!mounted.current || selection.current.generation !== requestedGeneration) return;
+      if (!latest.ok) throw new Error(latest.reason);
+      if (latest.pr.url !== pr.url || latest.pr.state !== "OPEN") throw new Error("This pull request changed. Reload and try again.");
+      const patched = toggleDescriptionTask(body, latest.pr.body, task);
+      // The forge CLI has no conditional description write. Fetching directly
+      // before writing narrows, but cannot eliminate, the remote write race.
+      const saved = await prEdit({ ...prArgs, body: patched });
+      if (!mounted.current || selection.current.generation !== requestedGeneration) return;
+      if (!saved.ok) throw new Error(saved.reason);
+      setPr(saved.pr);
+      setTitle(saved.pr.title);
+      setBody(saved.pr.body);
+      setError(null);
+    } catch (err) {
+      if (mounted.current && selection.current.generation === requestedGeneration) {
+        setError(rejectReason(err, "Couldn't update checklist"));
+        setChecklistError(true);
+      }
+    } finally {
+      if (taskBusy.current === requestedGeneration) taskBusy.current = null;
+      if (mounted.current && selection.current.generation === requestedGeneration) setPending(null);
+    }
+  };
 
   return (
     <aside className={styles.panel} data-pr-workspace="" data-pr-tab={tab}>
@@ -445,6 +492,7 @@ export function PrWorkspacePanel({
           role="tab"
           className={styles.tab}
           data-pr-tab="code"
+          disabled={pr?.forge === "gitlab"}
           aria-selected={tab === "code"}
           onClick={() => setTab("code")}
         >
@@ -513,13 +561,13 @@ export function PrWorkspacePanel({
             {preview ? (
               <div className={styles.preview}>
                 {body.trim() ? (
-                  <Markdown text={body} />
+                  <MarkdownBody text={body} onTaskToggle={toggleTask} tasksDisabled={!open || dirty || pending != null} />
                 ) : (
                   <p className={styles.hint}>Nothing to preview</p>
                 )}
               </div>
             ) : (
-              <textarea
+              <PrCompletionTextarea projectPath={projectPath} repo={activeRepo} scope={String(activePr)}
                 className={styles.textarea}
                 data-pr-edit-body=""
                 value={body}
@@ -551,7 +599,7 @@ export function PrWorkspacePanel({
           ) : null}
 
           <div className={styles.actions}>
-            {open && prUpdateBranch && pr.mergeStateStatus === "BEHIND" ? (
+            {open && pr.forge !== "gitlab" && prUpdateBranch && pr.mergeStateStatus === "BEHIND" ? (
               <button
                 type="button"
                 className={styles.ghost}
@@ -564,7 +612,7 @@ export function PrWorkspacePanel({
                 {pending === "updateBranch" ? "Updating…" : "Update branch"}
               </button>
             ) : null}
-            {open && pr.isDraft ? (
+            {open && pr.forge !== "gitlab" && pr.isDraft ? (
               <button
                 type="button"
                 className={styles.ghost}
@@ -579,7 +627,7 @@ export function PrWorkspacePanel({
                 {pending === "ready" ? "Updating…" : "Mark ready"}
               </button>
             ) : null}
-            {open && !pr.isDraft ? (
+            {open && pr.forge !== "gitlab" && !pr.isDraft ? (
               <button
                 type="button"
                 className={styles.ghost}
@@ -599,7 +647,7 @@ export function PrWorkspacePanel({
                 type="button"
                 className={styles.primary}
                 data-pr-merge=""
-                disabled={pending != null}
+                disabled={pending != null || pr.forge === "gitlab"}
                 onClick={() => setConfirm("merge")}
               >
                 Merge
@@ -610,7 +658,7 @@ export function PrWorkspacePanel({
                 type="button"
                 className={styles.danger}
                 data-pr-close=""
-                disabled={pending != null}
+                disabled={pending != null || pr.forge === "gitlab"}
                 onClick={() => setConfirm("close")}
               >
                 Close
@@ -713,6 +761,12 @@ export function PrWorkspacePanel({
             </div>
           ) : null}
 
+          {checklistError && error ? (
+            <button type="button" className={styles.ghost} data-pr-checklist-reload=""
+              disabled={dirty || pending != null || loading} onClick={() => void load()}>
+              Reload pull request
+            </button>
+          ) : null}
           {error ? (
             <p className={styles.error} data-pr-workspace-error="">
               {error}
@@ -783,7 +837,7 @@ export function PrWorkspacePanel({
                           Add to agent
                         </button>
                       ) : null}
-                      {prCommentEdit && row.type !== "review-summary" && row.mine && row.id != null && !editing ? (
+                      {pr.forge !== "gitlab" && prCommentEdit && row.type !== "review-summary" && row.mine && row.id != null && !editing ? (
                         <button
                           type="button"
                           className={styles.ghost}
@@ -801,7 +855,7 @@ export function PrWorkspacePanel({
                     {row.path ? <span className={styles.hint}>{row.path}{row.line != null ? `:${row.line}` : ""}{row.outdated ? " (outdated)" : ""}</span> : null}
                     {editing ? (
                       <div className={styles.commentForm} data-pr-comment-edit-form="">
-                        <textarea
+                        <PrCompletionTextarea projectPath={projectPath} repo={activeRepo} scope={String(activePr)}
                           className={styles.textarea}
                           data-pr-comment-edit-body=""
                           value={editCommentBody}
@@ -833,7 +887,7 @@ export function PrWorkspacePanel({
                     ) : (
                       <Markdown text={row.body} />
                     )}
-                    {prReaction && row.type === "issue" && row.id != null ? (
+                    {pr.forge !== "gitlab" && prReaction && row.type === "issue" && row.id != null ? (
                       <div className={styles.reactionsRow} data-pr-reactions="">
                         {(row.reactions || [])
                           .filter((r) => r.count > 0)
@@ -903,7 +957,7 @@ export function PrWorkspacePanel({
                   );
                 }}
               >
-                <textarea
+                <PrCompletionTextarea projectPath={projectPath} repo={activeRepo} scope={String(activePr)}
                   className={styles.textarea}
                   data-pr-comment=""
                   placeholder="Leave a comment"
diff --git a/src/descriptionTasks.ts b/src/descriptionTasks.ts
new file mode 100644
index 000000000..a4bec0a3d
--- /dev/null
+++ b/src/descriptionTasks.ts
@@ -0,0 +1,49 @@
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkGfm from "remark-gfm";
+
+export interface DescriptionTask { start: number; end: number }
+const parser = unified().use(remarkParse).use(remarkGfm);
+
+/** Source offsets come from the same GFM parser used by the rendered markdown. */
+export function descriptionTasks(body: string): DescriptionTask[] {
+  const result: DescriptionTask[] = [];
+  function visit(node: { type: string; checked?: boolean | null; position?: { start: { offset?: number }; end: { offset?: number } }; children?: typeof node[] }) {
+    if (node.type === "listItem" && "checked" in node && typeof node.checked === "boolean") {
+      const start = node.position?.start.offset;
+      const end = node.position?.end.offset;
+      if (start != null && end != null) result.push({ start, end });
+    }
+    if (node.children) for (const child of node.children) visit(child);
+  }
+  visit(parser.parse(body));
+  return result;
+}
+
+function taskLabel(raw: string): string {
+  return raw.split(/\r?\n/, 1)[0].replace(/^(?:[-+*]|\d+[.)])[ \t]+\[[ xX]\][ \t]*/, "");
+}
+
+const conflict = () => new Error("This checklist changed on the server. Reload the pull request and try again.");
+
+/** Change one marker byte only. Never match by label or touch code-fence text. */
+export function toggleDescriptionTask(original: string, latest: string, task: DescriptionTask): string {
+  if (!descriptionTasks(original).some((t) => t.start === task.start && t.end === task.end)) throw conflict();
+  const raw = original.slice(task.start, task.end);
+  const marker = /^(?:[-+*]|\d+[.)])[ \t]+\[([ xX])\]/.exec(raw);
+  if (!marker) throw conflict();
+  let start = task.start;
+  if (original !== latest) {
+    // Ambiguous duplicate task items deliberately require a reload, even when
+    // their current order happens to look unchanged. A reorder is not identity.
+    const label = taskLabel(raw);
+    const oldMatches = descriptionTasks(original).filter((t) => taskLabel(original.slice(t.start, t.end)) === label);
+    const latestTasks = descriptionTasks(latest);
+    const latestMatches = latestTasks.filter((t) => taskLabel(latest.slice(t.start, t.end)) === label);
+    const matches = latestTasks.filter((t) => latest.slice(t.start, t.end) === raw);
+    if (oldMatches.length !== 1 || latestMatches.length !== 1 || matches.length !== 1) throw conflict();
+    start = matches[0].start;
+  }
+  const offset = start + marker[0].length - 2;
+  return latest.slice(0, offset) + (marker[1] === " " ? "x" : " ") + latest.slice(offset + 1);
+}
diff --git a/src/dev/automations.ts b/src/dev/automations.ts
index 63cfa6cb8..9ccae50aa 100644
--- a/src/dev/automations.ts
+++ b/src/dev/automations.ts
@@ -1,6 +1,7 @@
 /** Scheduled automations for the browser-dev fixture. */
 import type {
   AutomationInfo,
+  AutomationRunInfo,
   AutomationRunsResult,
   AutomationScope,
   AutomationWrite,
@@ -142,7 +143,14 @@ export function normalizeDevAutomation(
   const graduate = Object.prototype.hasOwnProperty.call(input, "graduate")
     ? input.graduate !== false
     : existing?.graduate !== false;
+  const sessionMode = input.sessionMode ?? existing?.sessionMode ?? "new-thread";
+  if (!["new-thread", "continue", "fresh"].includes(sessionMode)) throw new Error("Invalid automation session mode");
+  const destinationThreadId = sessionMode === "new-thread" ? null : (input.destinationThreadId ?? existing?.destinationThreadId ?? "").trim();
+  if (sessionMode !== "new-thread" && !destinationThreadId) throw new Error("Destination thread is required");
   return {
+    sessionMode, destinationThreadId,
+    tier: input.tier === undefined ? existing?.tier : input.tier,
+    budget: input.budget === undefined ? existing?.budget : input.budget,
     name,
     projectId,
     scope,
@@ -165,6 +173,16 @@ export function createAutomations(ctx: DevCtx): Pick<CoderApi, "automations"> {
   let automationsList: AutomationInfo[] = [];
   const automationIdByThread = new Map<string, string>();
   const trustByProject: Record<string, string> = {};
+  const firing = new Set<string>();
+  const fixedRuns = new Map<string, AutomationRunInfo[]>();
+  function destination(a: Pick<AutomationInfo, "sessionMode" | "destinationThreadId" | "projectId" | "provider" | "model" | "tier">, runtime = false) {
+    if (!a.sessionMode || a.sessionMode === "new-thread") return null;
+    const t = ctx.threads.find((t) => t.id === a.destinationThreadId);
+    if (!t || t.projectId !== a.projectId || t.archived || t.teleportedTo || t.provider !== a.provider || (t.model || null) !== (a.model || null) || t.permissionMode !== "default" || t.providerInstance || t.agentProfileId || t.autoApprove || t.route || a.tier) throw new Error("Automation destination must be an available thread in its project with matching provider/model, default permissions, no account override, grants, or routing");
+    const detail = ctx.details.get(t.id);
+    if (runtime && (t.status === "working" || t.status === "quota-wait" || t.quotaWaitUntil || t.queued || t.runQueue || t.pendingQuestion || t.pendingPlan || t.awaitingInput || detail?.pendingPermission || t.pendingSecret || t.btw?.length || (t.freshContextPending && a.sessionMode !== "fresh"))) throw new Error("Automation destination has unfinished work or pending input; run skipped");
+    return t;
+  }
 
   function sharedRows(projectId: string) {
     return automationsList.filter(
@@ -236,6 +254,7 @@ export function createAutomations(ctx: DevCtx): Pick<CoderApi, "automations"> {
       },
       async add(input: AutomationWrite) {
         const fields = normalizeDevAutomation(input, ctx.projects, null);
+        destination(fields);
         const project = ctx.projects.find((p) => p.id === fields.projectId);
         if (!project) throw new Error(`Unknown project: ${fields.projectId}`);
         let createdId = id("auto");
@@ -281,6 +300,7 @@ export function createAutomations(ctx: DevCtx): Pick<CoderApi, "automations"> {
           throw new Error(`Unknown automation: ${input.id}`);
         }
         const fields = normalizeDevAutomation(input, ctx.projects, existing);
+        if (fields.enabled) destination(fields);
         const scheduleChanged =
           fields.preset !== existing.preset ||
           fields.hour !== existing.hour ||
@@ -337,6 +357,9 @@ export function createAutomations(ctx: DevCtx): Pick<CoderApi, "automations"> {
             if (project) persistTrust(project, input.hash);
           }
         }
+        const key = existing.sessionMode && existing.sessionMode !== "new-thread" ? `thread:${existing.destinationThreadId}` : existing.id;
+        if (firing.has(key)) throw new Error("Automation destination is already starting a run");
+        firing.add(key);
         const firedAt = now();
         const nextRunAt = nextAutomationFire(
           existing.preset,
@@ -345,20 +368,25 @@ export function createAutomations(ctx: DevCtx): Pick<CoderApi, "automations"> {
           existing.cron,
         );
         try {
-          const thread = await ctx.api().threads.create({
+          const target = destination(existing, true);
+          const prior = (fixedRuns.get(existing.id) || []).map((r) => r.pending ? { ...r, pending: false, status: ctx.threads.find((t) => t.id === r.threadId)?.status || r.status } : r);
+          const thread = target || await ctx.api().threads.create({
             projectId: existing.projectId,
             title: existing.name,
           });
-          automationIdByThread.set(thread.id, existing.id);
-          await ctx.api().threads.setProvider({
+          if (!target) automationIdByThread.set(thread.id, existing.id);
+          if (!target) await ctx.api().threads.setProvider({
             threadId: thread.id,
             provider: existing.provider,
             model: existing.model,
           });
-          await ctx.api().runs.start({
+          ctx.assertUnderBudget();
+          if (target && existing.sessionMode === "fresh") await ctx.api().threads.freshAgentContext({ threadId: target.id });
+          const launch = await ctx.api().runs.start({
             threadId: thread.id,
             prompt: existing.prompt,
           });
+          if (target) fixedRuns.set(existing.id, [{ id: id("fire"), runId: launch.runId, threadId: target.id, startedAt: firedAt, status: "working" as const, pending: true }, ...prior].slice(0, 20));
           const updated: AutomationInfo = {
             ...existing,
             lastRunAt: firedAt,
@@ -380,13 +408,15 @@ export function createAutomations(ctx: DevCtx): Pick<CoderApi, "automations"> {
             a.id === existing.id ? updated : a,
           );
           throw err;
-        }
+        } finally { firing.delete(key); }
       },
       async listRuns(input: { id: string }): Promise<AutomationRunsResult> {
         const existing = automationsList.find((a) => a.id === input.id);
         if (!existing) {
           throw new Error(`Unknown automation: ${input.id}`);
         }
+        const fixed = fixedRuns.get(existing.id);
+        if (fixed) return { automationId: existing.id, runs: fixed, retentionLimitReached: fixed.length >= 20 };
         const indexed = ctx.threads
           .map((t, i) => ({ t, i }))
           .filter(({ t }) => automationIdByThread.get(t.id) === existing.id);
diff --git a/src/dev/git.ts b/src/dev/git.ts
index 9d35eac2d..b98d1162c 100644
--- a/src/dev/git.ts
+++ b/src/dev/git.ts
@@ -190,6 +190,7 @@ export function createGit(ctx: DevCtx): Pick<CoderApi, "git" | "mergeQueue"> {
       async prTemplate(_input: { projectPath: string }): Promise<PrTemplateResult> {
         return { ok: true, body: "", path: null, templates: [] };
       },
+      async prCompletions() { return { ok: true as const, items: [], hasMore: false }; },
       async prDetail(input: {
         projectPath: string;
         prNumber: number;
diff --git a/src/shared/ipc.ts b/src/shared/ipc.ts
index a086f77c8..3ed2c2820 100644
--- a/src/shared/ipc.ts
+++ b/src/shared/ipc.ts
@@ -3261,6 +3261,7 @@ export interface PrComment {
 
 /** Full PR for the in-app workspace (issue #154). */
 export interface PrDetail {
+  forge?: "github" | "gitlab";
   number: number;
   title: string;
   body: string;
@@ -3929,6 +3930,8 @@ export type AutomationStage = "observe" | "draft" | "act";
 
 /** A scheduled agent run (Synara-style automation). */
 export interface AutomationInfo {
+  sessionMode?: "new-thread" | "continue" | "fresh";
+  destinationThreadId?: string | null;
   id: string;
   projectId: string;
   /** Private rows stay on this machine; project rows come from solenta.json. */
@@ -3971,6 +3974,8 @@ export interface AutomationInfo {
 }
 
 export interface AutomationWrite {
+  sessionMode?: "new-thread" | "continue" | "fresh";
+  destinationThreadId?: string | null;
   projectId: string;
   name: string;
   prompt: string;
@@ -4002,6 +4007,10 @@ export interface AutomationWrite {
  * typed `automationId` stamp on the thread, not the title.
  */
 export interface AutomationRunInfo {
+  /** Stable per-fire identity for fixed destinations. */
+  id?: string;
+  runId?: string | null;
+  pending?: boolean;
   threadId: string;
   /** Thread create time; the fire that minted this run. */
   startedAt: number;
@@ -7224,6 +7233,7 @@ export interface CoderApi {
      * Full PR (title, body, comments, draft) for the in-app workspace.
      * Failures stay in-band like listPrs.
      */
+    prCompletions(input: { projectPath: string; repo?: string; kind: "@" | "#" | "!"; query: string; page?: number }): Promise<{ ok: true; items: Array<{ value: string; label: string }>; hasMore: boolean } | { ok: false; reason: string }>;
     prDetail(input: {
       projectPath: string;
       prNumber: number;
diff --git a/src/shared/ipcChannels.ts b/src/shared/ipcChannels.ts
index dc3c7ea98..77b1b00f6 100644
--- a/src/shared/ipcChannels.ts
+++ b/src/shared/ipcChannels.ts
@@ -296,6 +296,7 @@ export const IPC_CHANNELS = [
   { ns: "git", method: "listPrs" },
   { ns: "git", method: "checkoutPr" },
   { ns: "git", method: "prTemplate" },
+  { ns: "git", method: "prCompletions" },
   { ns: "git", method: "prDetail" },
   { ns: "git", method: "prEdit" },
   { ns: "git", method: "prComment" },
diff --git a/test/automationsView.test.tsx b/test/automationsView.test.tsx
index d70287423..e7cd0d0b7 100644
--- a/test/automationsView.test.tsx
+++ b/test/automationsView.test.tsx
@@ -67,6 +67,46 @@ function deferred() {
 }
 
 describe("AutomationsView", () => {
+  it("submits an explicit fresh destination selected by title", async () => {
+    const writes: AutomationWrite[] = [];
+    const m = await mount(<AutomationsView automations={[]} projects={[p1]} providers={providers}
+      liveThreads={[{ id: "fixed", status: "idle", projectId: "p1", title: "Daily review", provider: "claude", model: null, permissionMode: "default" }]}
+      onCreate={(input) => { writes.push(input); }} onUpdate={() => {}} onRemove={() => {}} onRunNow={() => {}} />);
+    await m.type(m.query('[name="name"]'), "Review");
+    await m.type(m.query('[name="prompt"]'), "Review the changes");
+    await m.change(m.query('[aria-label="Session mode"]'), "fresh");
+    const picker = m.query('[aria-label="Destination thread"]');
+    assert.ok(picker?.textContent?.includes("Daily review"));
+    await m.change(picker, "fixed");
+    await m.click(m.query('[data-automation-create] button[type="submit"]'));
+    assert.equal(writes.length, 1);
+    assert.equal(writes[0].sessionMode, "fresh");
+    assert.equal(writes[0].destinationThreadId, "fixed");
+    m.unmount();
+  });
+
+  it("shows fixed destination titles and keeps repeated-run historical outcomes", async () => {
+    const m = await mount(<AutomationsView
+      focusId="a1" automations={[auto({ id: "a1", sessionMode: "fresh", destinationThreadId: "fixed" })]}
+      projects={[p1]} providers={providers}
+      liveThreads={[{ id: "fixed", status: "working", projectId: "p1", title: "Daily review", provider: "claude", model: null, permissionMode: "default" }]}
+      loadRuns={async () => runs({ runs: [
+        { id: "fire2", runId: "r2", threadId: "fixed", startedAt: Date.now(), status: "working", pending: true },
+        { id: "fire1", runId: "r1", threadId: "fixed", startedAt: Date.now() - 60000, status: "failed", pending: false },
+      ] })}
+      onCreate={() => {}} onUpdate={() => {}} onRemove={() => {}} onRunNow={() => {}} />);
+    await m.flush();
+    await m.click(m.query("[data-automation-runs-toggle]"));
+    assert.ok(m.text().includes("Failed"));
+    assert.ok(m.text().includes("Working"));
+    const mode = m.query('[aria-label="Session mode"]');
+    assert.ok(mode);
+    const destination = m.query('[aria-label="Destination thread"]');
+    assert.ok(destination);
+    assert.ok(destination.textContent?.includes("Daily review"));
+    m.unmount();
+  });
+
   it("prefills the create form from a RepeatDraft", async () => {
     const m = await mount(
       <AutomationsView
@@ -982,6 +1022,26 @@ describe("AutomationsView", () => {
     m.unmount();
   });
 
+  it("Edit and Cancel replace incomplete fixed-destination drafts without validation", async () => {
+    const writes: unknown[] = [];
+    const m = await mount(<AutomationsView focusId="first"
+      automations={[auto({ id: "first", name: "First" }), auto({ id: "second", name: "Second" })]}
+      projects={[p1]} providers={providers} onCreate={(input) => { writes.push(input); }}
+      onUpdate={(input) => { writes.push(input); }} onRemove={() => {}} onRunNow={() => {}} />);
+    await m.change(m.query('[aria-label="Session mode"]'), "fresh");
+    await m.click(m.query('[data-automation-row="second"] [data-automation-edit]'));
+    assert.equal((m.query('[name="name"]') as HTMLInputElement).value, "Second");
+    assert.equal((m.query('[aria-label="Session mode"]') as HTMLSelectElement).value, "new-thread");
+    await m.change(m.query('[aria-label="Session mode"]'), "continue");
+    await m.click(m.query('[data-automation-cancel]'));
+    assert.equal(m.query('[data-automation-cancel]'), null);
+    assert.equal((m.query('[name="name"]') as HTMLInputElement).value, "");
+    assert.equal((m.query('[aria-label="Session mode"]') as HTMLSelectElement).value, "new-thread");
+    assert.equal(m.query('[data-form-error]'), null);
+    assert.deepEqual(writes, []);
+    m.unmount();
+  });
+
   it("Cancel discards edits and does not call onUpdate", async () => {
     const updates: unknown[] = [];
     const m = await mount(
diff --git a/test/descriptionTasks.test.ts b/test/descriptionTasks.test.ts
new file mode 100644
index 000000000..fd37431bf
--- /dev/null
+++ b/test/descriptionTasks.test.ts
@@ -0,0 +1,33 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { descriptionTasks, toggleDescriptionTask } from "../src/descriptionTasks.ts";
+
+describe("description task source patches", () => {
+  it("preserves every other byte including CRLF, nesting, list style and uppercase X", () => {
+    const body = "Intro\r\n\r\n+ [ ] parent\r\n  1. [X] child\r\n\r\n```md\r\n- [ ] fake\r\n```\r\n";
+    const tasks = descriptionTasks(body);
+    assert.equal(tasks.length, 2);
+    assert.equal(toggleDescriptionTask(body, body, tasks[1]), body.replace("[X]", "[ ]"));
+    assert.equal(toggleDescriptionTask(body, body, tasks[0]), body.replace("+ [ ]", "+ [x]"));
+  });
+  it("uses the precise duplicate source position", () => {
+    const body = "- [ ] same\n- [ ] same\n";
+    assert.equal(toggleDescriptionTask(body, body, descriptionTasks(body)[1]), "- [ ] same\n- [x] same\n");
+  });
+  it("rebases an unchanged unique task while preserving unrelated server edits", () => {
+    const body = "Header\n\n- [ ] task\n\nFooter";
+    const latest = "New header\n\n- [ ] task\n\nNew footer\n";
+    assert.equal(toggleDescriptionTask(body, latest, descriptionTasks(body)[0]), latest.replace("[ ]", "[x]"));
+  });
+  it("conflicts for ambiguous duplicates, removed/changed tasks and code-fence lookalikes", () => {
+    const body = "- [ ] same\n- [ ] same\n";
+    assert.throws(() => toggleDescriptionTask(body, "Intro\n" + body, descriptionTasks(body)[1]), /Reload/);
+    const mixed = "- [ ] same\n* [X] same\n";
+    assert.throws(() => toggleDescriptionTask(mixed, "- [X] same\n* [ ] same\n", descriptionTasks(mixed)[0]), /Reload/);
+    const one = "- [ ] same";
+    for (const latest of ["- [ ] different", "- [x] same", "```\n- [ ] same\n```", ""]) {
+      assert.throws(() => toggleDescriptionTask(one, latest, descriptionTasks(one)[0]), /Reload/);
+    }
+    assert.throws(() => toggleDescriptionTask("```\n- [ ] fake\n```", "", { start: 4, end: 14 }), /Reload/);
+  });
+});
diff --git a/test/prCompletionTextarea.test.tsx b/test/prCompletionTextarea.test.tsx
new file mode 100644
index 000000000..cae52c02a
--- /dev/null
+++ b/test/prCompletionTextarea.test.tsx
@@ -0,0 +1,166 @@
+import assert from "node:assert/strict";
+import { it } from "node:test";
+import * as React from "react";
+import { act } from "react";
+import { mount } from "./support/dom";
+import { PrCompletionTextarea, prCompletionToken } from "../src/components/PrCompletionTextarea";
+
+it("recognizes only caret-local references outside literal markdown, email and URLs", () => {
+  for (const value of ["a@bob", "https://host/#12", "`@bob", "```js\n@bob", "~~~\n#12"]) assert.equal(prCompletionToken(value, value.length, value.length), null);
+  for (const kind of ["@", "#", "!"]) assert.equal(prCompletionToken(`before ${kind}abc`, 11, 11)?.kind, kind);
+  assert.equal(prCompletionToken("@bob", 1, 3), null);
+});
+
+it("inserts at the caret and consumes Enter without submitting", async () => {
+  let submitted = 0;
+  function Editor() {
+    const [value, setValue] = React.useState("hello @bo tail");
+    return <form onSubmit={e => { e.preventDefault(); submitted++; }}><PrCompletionTextarea
+      value={value} onChange={e => setValue(e.target.value)} projectPath="/repo" scope="1"
+      lookup={async () => ({ ok: true, items: [{ value: "@bob", label: "Bob" }], hasMore: false })} /></form>;
+  }
+  const m = await mount(<Editor />);
+  const input = m.query("textarea") as HTMLTextAreaElement;
+  await act(async () => { input.setSelectionRange(9, 9); input.focus(); });
+  await act(async () => { await new Promise(r => setTimeout(r, 300)); });
+  assert.ok(m.query('[role="option"]'));
+  await m.press(input, "Enter");
+  assert.equal(input.value, "hello @bob tail");
+  assert.equal(submitted, 0);
+});
+
+it("ignores a lookup resolving after repository selection changes", async () => {
+  let resolve!: (v: any) => void;
+  const lookup = () => new Promise<any>(r => { resolve = r; });
+  const props = { value: "#1", onChange: () => {}, projectPath: "/repo", scope: "1", lookup };
+  const m = await mount(<PrCompletionTextarea {...props} />);
+  const input = m.query("textarea") as HTMLTextAreaElement;
+  await act(async () => { input.setSelectionRange(2, 2); input.focus(); });
+  await act(async () => { await new Promise(r => setTimeout(r, 300)); });
+  await m.rerender(<PrCompletionTextarea {...props} repo="other/repo" scope="2" />);
+  await act(async () => { resolve({ ok: true, items: [{ value: "#1", label: "private old repo" }], hasMore: false }); });
+  assert.equal(m.query('[role="option"]'), null);
+});
+
+it("completes GitLab MR notation with Tab and Escape preserves literal input", async () => {
+  const calls: string[] = [];
+  function Editor() {
+    const [value, setValue] = React.useState("!7");
+    return <PrCompletionTextarea value={value} onChange={e => setValue(e.target.value)} projectPath="/gitlab" scope="7"
+      lookup={async input => { calls.push(input.kind); return { ok: true, items: [{ value: "!72", label: "Merge request" }], hasMore: false }; }} />;
+  }
+  const m = await mount(<Editor />);
+  const input = m.query("textarea") as HTMLTextAreaElement;
+  await act(async () => { input.setSelectionRange(2, 2); input.focus(); });
+  await act(async () => { await new Promise(r => setTimeout(r, 300)); });
+  await m.press(input, "Escape");
+  assert.equal(input.value, "!7");
+  assert.equal(m.query('[role="listbox"]'), null);
+  await m.type(input, "!72");
+  await act(async () => { await new Promise(r => setTimeout(r, 300)); });
+  await m.press(input, "Tab");
+  assert.equal(input.value, "!72 ");
+  assert.deepEqual(calls, ["!", "!"]);
+});
+
+it("offers GitLab completions in the actual description and comment editors without posting", async () => {
+  const { PrWorkspacePanel } = await import("../src/components/PrWorkspacePanel");
+  const shell = await mount(<div />);
+  const previous = window.coder;
+  const lookups: string[] = [];
+  window.coder = { git: { prCompletions: async input => {
+    lookups.push(input.kind);
+    return { ok: true, items: [{ value: "!72", label: "MR" }], hasMore: false };
+  } } } as any;
+  shell.unmount();
+  try {
+    const pr = { forge: "gitlab" as const, number: 7, title: "MR", body: "", url: "https://gitlab.example/team/repo/-/merge_requests/7", state: "OPEN" as const, isDraft: false, headRefName: "feature", comments: [] };
+    const detail = async () => ({ ok: true as const, pr });
+    let posted = 0;
+    const m = await mount(<PrWorkspacePanel projectPath="/gitlab" prNumber={7} matchedThread={null}
+      prDetail={detail} prEdit={detail} prClose={detail} prReady={detail} prMergeAt={detail}
+      prComment={async () => { posted++; return { ok: true }; }} onClose={() => {}} onSelectThread={() => {}} />);
+    for (const selector of ["[data-pr-edit-body]", "[data-pr-comment]"]) {
+      const input = m.query(selector) as HTMLTextAreaElement;
+      await act(async () => input.focus());
+      await m.type(input, "!7");
+      await act(async () => { await new Promise(r => setTimeout(r, 300)); });
+      await m.press(input, "Enter");
+      assert.equal(input.value, "!72 ");
+    }
+    assert.equal(posted, 0);
+    assert.deepEqual(lookups, ["!", "!"]);
+    assert.equal((m.query('[data-pr-merge]') as HTMLButtonElement).disabled, true);
+    assert.equal(m.query('[data-pr-draft]'), null);
+  } finally { window.coder = previous; }
+});
+
+it("drops rapid typing responses and supports arrow selection at a mid-token caret", async () => {
+  const pending: Array<(result: any) => void> = [];
+  const lookup = () => new Promise<any>(resolve => pending.push(resolve));
+  function Editor() {
+    const [value, setValue] = React.useState("@a");
+    return <PrCompletionTextarea value={value} onChange={e => setValue(e.target.value)} projectPath="/repo" scope="1" lookup={lookup} />;
+  }
+  const m = await mount(<Editor />);
+  const input = m.query("textarea") as HTMLTextAreaElement;
+  await act(async () => { input.setSelectionRange(2, 2); input.focus(); });
+  await act(async () => { await new Promise(r => setTimeout(r, 300)); });
+  await m.type(input, "@ab");
+  await act(async () => { await new Promise(r => setTimeout(r, 300)); });
+  await act(async () => pending[0]({ ok: true, items: [{ value: "@ancient", label: "Old" }], hasMore: false }));
+  assert.equal(m.query('[role="option"]'), null);
+  await act(async () => pending[1]({ ok: true, items: [{ value: "@abel", label: "First" }, { value: "@abby", label: "Second" }], hasMore: false }));
+  await m.press(input, "ArrowDown");
+  await m.press(input, "Tab");
+  assert.equal(input.value, "@abby ");
+  assert.equal(prCompletionToken("@abby tail", 2, 2)?.end, 5);
+});
+
+it("keeps native editing keys available while suggestions are pending, empty or failed", async () => {
+  for (const state of ["pending", "empty", "error"] as const) {
+    let submitted = 0;
+    const lookup = async () => state === "pending" ? new Promise<any>(() => {})
+      : state === "empty" ? { ok: true as const, items: [], hasMore: false }
+      : { ok: false as const, reason: "Search denied" };
+    const m = await mount(<form onSubmit={e => { e.preventDefault(); submitted++; }}>
+      <PrCompletionTextarea value="@missing" onChange={() => {}} projectPath="/repo" scope={state} lookup={lookup} />
+      <button type="submit">Post</button>
+    </form>);
+    const input = m.query("textarea") as HTMLTextAreaElement;
+    await act(async () => { input.setSelectionRange(8, 8); input.focus(); });
+    await act(async () => { await new Promise(r => setTimeout(r, 300)); });
+    assert.ok(m.query('[role="listbox"]'));
+    assert.equal(m.query('[role="option"]'), null);
+    for (const key of ["Enter", "ArrowUp", "ArrowDown", "Tab"]) {
+      const event = new window.KeyboardEvent("keydown", { key, bubbles: true, cancelable: true });
+      await act(async () => { input.dispatchEvent(event); });
+      assert.equal(event.defaultPrevented, false, `${state}: ${key} retains native editing intent`);
+    }
+    assert.equal(submitted, 0);
+    await m.press(input, "Escape");
+    assert.equal(m.query('[role="listbox"]'), null);
+    m.unmount();
+  }
+});
+
+it("preserves modified editing shortcuts even with selectable suggestions", async () => {
+  let submitted = 0;
+  const m = await mount(<form onSubmit={e => { e.preventDefault(); submitted++; }}>
+    <PrCompletionTextarea value="@bo" onChange={() => assert.fail("shortcut must not insert a completion")}
+      projectPath="/repo" scope="1" lookup={async () => ({ ok: true, items: [{ value: "@bob", label: "Bob" }], hasMore: false })} />
+  </form>);
+  const input = m.query("textarea") as HTMLTextAreaElement;
+  await act(async () => { input.setSelectionRange(3, 3); input.focus(); });
+  await act(async () => { await new Promise(r => setTimeout(r, 300)); });
+  assert.ok(m.query('[role="option"]'));
+  for (const modifier of ["shiftKey", "ctrlKey", "altKey", "metaKey"]) {
+    for (const key of ["Enter", "ArrowUp", "ArrowDown", "Tab", "PageDown"]) {
+      const event = new window.KeyboardEvent("keydown", { key, [modifier]: true, bubbles: true, cancelable: true });
+      await act(async () => { input.dispatchEvent(event); });
+      assert.equal(event.defaultPrevented, false, `${modifier}+${key} remains native`);
+    }
+  }
+  assert.equal(submitted, 0);
+  assert.equal(input.value, "@bo");
+});
diff --git a/test/prDescriptionTasks.test.tsx b/test/prDescriptionTasks.test.tsx
new file mode 100644
index 000000000..39e271c50
--- /dev/null
+++ b/test/prDescriptionTasks.test.tsx
@@ -0,0 +1,149 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import * as React from "react";
+import { mount } from "./support/dom.ts";
+import { PrWorkspacePanel } from "../src/components/PrWorkspacePanel";
+import { MarkdownBody } from "../src/components/Markdown";
+import type { PrDetail, PrDetailResult } from "../src/shared/ipc";
+const pr = { number: 11, title: "Feature", body: "- [ ] task\n", url: "https://github.com/acme/repo/pull/11", state: "OPEN", isDraft: false, comments: [] } as unknown as PrDetail;
+const ok = (p: PrDetail): PrDetailResult => ({ ok: true, pr: p });
+const defaults = {
+  projectPath: "/tmp/repo", prNumber: 11, matchedThread: null,
+  prDetail: async () => ok(pr), prEdit: async () => ok(pr),
+  prComment: async () => ({ ok: true as const, url: pr.url }),
+  prClose: async () => ok(pr), prReady: async () => ok(pr), prMergeAt: async () => ok(pr),
+  onSelectThread: () => {}, onClose: () => {},
+};
+const checkbox = 'input[type="checkbox"]';
+function deferred<T>() { let resolve!: (value: T) => void; const promise = new Promise<T>((r) => { resolve = r; }); return { promise, resolve }; }
+
+describe("rendered PR description checklists", () => {
+  it("loads and toggles in the application's StrictMode", async () => {
+    let server = pr;
+    const m = await mount(<React.StrictMode><PrWorkspacePanel {...defaults} prDetail={async () => ok(server)}
+      prEdit={async (input) => { server = { ...server, body: input.body! }; return ok(server); }} /></React.StrictMode>);
+    await m.click(m.query('[data-pr-preview]'));
+    await m.click(m.query(checkbox));
+    assert.equal(server.body, "- [x] task\n");
+    m.unmount();
+  });
+  it("keeps ordinary markdown and code fences inert", async () => {
+    const m = await mount(<MarkdownBody text={'- [ ] task\n\n```\n- [ ] fake\n```'} />);
+    assert.equal(m.queryAll(checkbox).length, 1);
+    assert.equal((m.query(checkbox) as HTMLInputElement).disabled, true);
+    m.unmount();
+  });
+  it("patches the latest body without sending a stale title and prevents overlapping clicks", async () => {
+    const read = deferred<PrDetailResult>();
+    let reads = 0;
+    let server = pr;
+    const writes: unknown[] = [];
+    const m = await mount(<PrWorkspacePanel {...defaults}
+      prDetail={async () => ++reads === 1 ? ok(pr) : reads === 2 ? read.promise : ok(server)}
+      prEdit={async (input) => { writes.push(input); server = { ...pr, title: "Remote title", body: input.body! }; return ok(server); }} />);
+    await m.click(m.query('[data-pr-preview]'));
+    await m.click(m.query(checkbox));
+    await m.click(m.query(checkbox));
+    assert.equal(reads, 2);
+    assert.equal((m.query(checkbox) as HTMLInputElement).disabled, true);
+    read.resolve(ok({ ...pr, body: "Remote intro\n\n" + pr.body, title: "Remote title" }));
+    await m.flush();
+    assert.deepEqual(writes, [{ projectPath: "/tmp/repo", prNumber: 11, body: "Remote intro\n\n- [x] task\n" }]);
+    assert.equal((m.query(checkbox) as HTMLInputElement).checked, true);
+    await m.click(m.query(checkbox));
+    await m.flush();
+    assert.equal(writes.length, 2, "a later click can start after completion");
+    m.unmount();
+  });
+  it("maps loose task paragraphs and nested duplicate labels to their own markers", async () => {
+    let server = { ...pr, body: "- [ ] same\n\n  Paragraph two.\n\n  - [ ] same\n\n- [X] final\n" };
+    const m = await mount(<PrWorkspacePanel {...defaults} prDetail={async () => ok(server)}
+      prEdit={async (input) => { server = { ...server, body: input.body! }; return ok(server); }} />);
+    await m.click(m.query('[data-pr-preview]'));
+    assert.equal(m.queryAll(checkbox).length, 3);
+    assert.equal((m.queryAll(checkbox)[0] as HTMLInputElement).disabled, false);
+    assert.match(m.queryAll(checkbox)[0].getAttribute("aria-label")!, /same/);
+    await m.click(m.queryAll(checkbox)[1]);
+    assert.equal(server.body, "- [ ] same\n\n  Paragraph two.\n\n  - [x] same\n\n- [X] final\n");
+    await m.click(m.queryAll(checkbox)[0]);
+    assert.equal(server.body, "- [x] same\n\n  Paragraph two.\n\n  - [x] same\n\n- [X] final\n");
+    m.unmount();
+  });
+  it("keeps closed and merged descriptions read-only like the existing description editor", async () => {
+    for (const state of ["CLOSED", "MERGED"] as const) {
+      let writes = 0;
+      const m = await mount(<PrWorkspacePanel {...defaults} prDetail={async () => ok({ ...pr, state })}
+        prEdit={async () => { writes++; return ok(pr); }} />);
+      await m.click(m.query('[data-pr-preview]'));
+      assert.equal((m.query(checkbox) as HTMLInputElement).disabled, true);
+      await m.click(m.query(checkbox));
+      assert.equal(writes, 0);
+      m.unmount();
+    }
+  });
+  it("surfaces forbidden writes without changing the body", async () => {
+    const m = await mount(<PrWorkspacePanel {...defaults} prEdit={async () => ({ ok: false, reason: "Forbidden" })} />);
+    await m.click(m.query('[data-pr-preview]'));
+    await m.click(m.query(checkbox));
+    assert.match(m.text(), /Forbidden/);
+    assert.equal((m.query(checkbox) as HTMLInputElement).checked, false);
+    assert.equal((m.query(checkbox) as HTMLInputElement).disabled, false);
+    m.unmount();
+  });
+  it("preserves unsaved description and title drafts by disabling toggles", async () => {
+    let writes = 0;
+    const m = await mount(<PrWorkspacePanel {...defaults} prEdit={async () => { writes++; return ok(pr); }} />);
+    await m.type(m.query('[data-pr-edit-body]'), "- [ ] unsaved\n");
+    await m.type(m.query('[data-pr-edit-title]'), "Draft title");
+    await m.click(m.query('[data-pr-preview]'));
+    assert.equal((m.query(checkbox) as HTMLInputElement).disabled, true);
+    await m.click(m.query(checkbox));
+    assert.equal(writes, 0);
+    await m.click(m.query('[data-pr-preview]'));
+    assert.equal((m.query('[data-pr-edit-body]') as HTMLTextAreaElement).value, "- [ ] unsaved\n");
+    assert.equal((m.query('[data-pr-edit-title]') as HTMLInputElement).value, "Draft title");
+    m.unmount();
+  });
+  it("requires reload on a conflicting server edit", async () => {
+    let reads = 0, writes = 0;
+    const m = await mount(<PrWorkspacePanel {...defaults}
+      prDetail={async () => ok(++reads === 1 ? pr : { ...pr, body: "- [ ] different\n" })}
+      prEdit={async () => { writes++; return ok(pr); }} />);
+    await m.click(m.query('[data-pr-preview]'));
+    await m.click(m.query(checkbox));
+    assert.equal(writes, 0);
+    assert.match(m.text(), /Reload the pull request/);
+    assert.equal((m.query(checkbox) as HTMLInputElement).checked, false);
+    await m.click(m.query("[data-pr-checklist-reload]"));
+    assert.match(m.text(), /different/);
+    assert.equal(m.query("[data-pr-workspace-error]"), null);
+    m.unmount();
+  });
+  it("ignores a stale fetch after switching project and PR", async () => {
+    let reads = 0, writes = 0;
+    const read = deferred<PrDetailResult>();
+    const props = { ...defaults, prDetail: async () => ++reads === 1 ? ok(pr) : read.promise, prEdit: async () => { writes++; return ok(pr); } };
+    const m = await mount(<PrWorkspacePanel {...props} />);
+    await m.click(m.query('[data-pr-preview]'));
+    await m.click(m.query(checkbox));
+    const next = { ...pr, number: 22, url: "https://github.com/other/repo/pull/22", body: "- [ ] next\n" };
+    await m.rerender(<PrWorkspacePanel {...props} projectPath="/tmp/other" prNumber={22} prDetail={async () => ok(next)} />);
+    read.resolve(ok(pr)); await m.flush();
+    assert.equal(writes, 0);
+    assert.match(m.text(), /next/);
+    assert.equal((m.query(checkbox) as HTMLInputElement).checked, false);
+    m.unmount();
+  });
+  it("ignores a stale save response after a PR switch", async () => {
+    const save = deferred<PrDetailResult>();
+    const m = await mount(<PrWorkspacePanel {...defaults} prEdit={async () => save.promise} />);
+    await m.click(m.query('[data-pr-preview]'));
+    await m.click(m.query(checkbox));
+    const next = { ...pr, number: 22, url: "https://github.com/acme/repo/pull/22", body: "- [ ] next\n" };
+    await m.rerender(<PrWorkspacePanel {...defaults} prNumber={22} prDetail={async () => ok(next)} />);
+    save.resolve(ok({ ...pr, body: "- [x] task\n" })); await m.flush();
+    assert.match(m.text(), /next/);
+    assert.equal((m.query(checkbox) as HTMLInputElement).checked, false);
+    m.unmount();
+  });
+});