webmux 0.18.0 → 0.19.0

package/backend/dist/server.js

@@ -6905,6 +6905,7 @@ var require_public_api = __commonJS((exports) => {
 });
 
 // backend/src/server.ts
+import { randomUUID as randomUUID3 } from "crypto";
 import { join as join6, resolve as resolve6 } from "path";
 import { mkdirSync } from "fs";
 import { networkInterfaces } from "os";
@@ -6997,13 +6998,13 @@ function killTmuxSession(name) {
     }
   }
 }
-async function attach(worktreeId, target, cols, rows, initialPane) {
-  log.debug(`[term] attach(${worktreeId}) cols=${cols} rows=${rows} existing=${sessions.has(worktreeId)}`);
-  if (sessions.has(worktreeId)) {
-    await detach(worktreeId);
+async function attach(attachId, target, cols, rows, initialPane) {
+  log.debug(`[term] attach(${attachId}) cols=${cols} rows=${rows} existing=${sessions.has(attachId)}`);
+  if (sessions.has(attachId)) {
+    await detach(attachId);
   }
   const gName = groupedName();
-  log.debug(`[term] attach(${worktreeId}) ownerSession=${target.ownerSessionName} gName=${gName} window=${target.windowName}`);
+  log.debug(`[term] attach(${attachId}) ownerSession=${target.ownerSessionName} gName=${gName} window=${target.windowName}`);
   killTmuxSession(gName);
   const cmd = buildAttachCmd({
     gName,
@@ -7030,8 +7031,8 @@ async function attach(worktreeId, target, cols, rows, initialPane) {
     onExit: null,
     cancelled: false
   };
-  sessions.set(worktreeId, session);
-  log.debug(`[term] attach(${worktreeId}) spawned pid=${proc.pid}`);
+  sessions.set(attachId, session);
+  log.debug(`[term] attach(${attachId}) spawned pid=${proc.pid}`);
   (async () => {
     const reader = proc.stdout.getReader();
     try {
@@ -7052,7 +7053,7 @@ async function attach(worktreeId, target, cols, rows, initialPane) {
       }
     } catch (err) {
       if (!session.cancelled) {
-        log.error(`[term] stdout reader error(${worktreeId})`, err);
+        log.error(`[term] stdout reader error(${attachId})`, err);
       }
     }
   })();
@@ -7063,55 +7064,55 @@ async function attach(worktreeId, target, cols, rows, initialPane) {
         const { done, value } = await reader.read();
         if (done)
           break;
-        log.debug(`[term] stderr(${worktreeId}): ${textDecoder.decode(value).trimEnd()}`);
+        log.debug(`[term] stderr(${attachId}): ${textDecoder.decode(value).trimEnd()}`);
       }
     } catch {}
   })();
   proc.exited.then((exitCode) => {
-    log.debug(`[term] proc exited(${worktreeId}) pid=${proc.pid} code=${exitCode}`);
-    if (sessions.get(worktreeId) === session) {
+    log.debug(`[term] proc exited(${attachId}) pid=${proc.pid} code=${exitCode}`);
+    if (sessions.get(attachId) === session) {
       session.onExit?.(exitCode);
-      sessions.delete(worktreeId);
+      sessions.delete(attachId);
     } else {
-      log.debug(`[term] proc exited(${worktreeId}) stale session, skipping cleanup`);
+      log.debug(`[term] proc exited(${attachId}) stale session, skipping cleanup`);
     }
     killTmuxSession(gName);
   });
 }
-async function detach(worktreeId) {
-  const session = sessions.get(worktreeId);
+async function detach(attachId) {
+  const session = sessions.get(attachId);
   if (!session) {
-    log.debug(`[term] detach(${worktreeId}) no session found`);
+    log.debug(`[term] detach(${attachId}) no session found`);
     return;
   }
-  log.debug(`[term] detach(${worktreeId}) killing pid=${session.proc.pid} tmux=${session.groupedSessionName}`);
+  log.debug(`[term] detach(${attachId}) killing pid=${session.proc.pid} tmux=${session.groupedSessionName}`);
   session.cancelled = true;
   session.proc.kill();
-  sessions.delete(worktreeId);
+  sessions.delete(attachId);
   killTmuxSession(session.groupedSessionName);
 }
-function write(worktreeId, data) {
-  const session = sessions.get(worktreeId);
+function write(attachId, data) {
+  const session = sessions.get(attachId);
   if (!session) {
-    log.warn(`[term] write(${worktreeId}) NO SESSION - input dropped (${data.length} bytes)`);
+    log.warn(`[term] write(${attachId}) NO SESSION - input dropped (${data.length} bytes)`);
     return;
   }
   try {
     session.proc.stdin.write(textEncoder.encode(data));
     session.proc.stdin.flush();
   } catch (err) {
-    log.error(`[term] write(${worktreeId}) stdin closed`, err);
+    log.error(`[term] write(${attachId}) stdin closed`, err);
   }
 }
-async function sendKeys(worktreeId, hexBytes) {
-  const session = sessions.get(worktreeId);
+async function sendKeys(attachId, hexBytes) {
+  const session = sessions.get(attachId);
   if (!session)
     return;
   const windowTarget = `${session.groupedSessionName}:${session.windowName}`;
   await tmuxExec(["tmux", "send-keys", "-t", windowTarget, "-H", ...hexBytes]);
 }
-async function resize(worktreeId, cols, rows) {
-  const session = sessions.get(worktreeId);
+async function resize(attachId, cols, rows) {
+  const session = sessions.get(attachId);
   if (!session)
     return;
   const windowTarget = `${session.groupedSessionName}:${session.windowName}`;
@@ -7119,32 +7120,32 @@ async function resize(worktreeId, cols, rows) {
   if (result.exitCode !== 0)
     log.warn(`[term] resize failed: ${result.stderr}`);
 }
-function getScrollback(worktreeId) {
-  return sessions.get(worktreeId)?.scrollback.join("") ?? "";
+function getScrollback(attachId) {
+  return sessions.get(attachId)?.scrollback.join("") ?? "";
 }
-function setCallbacks(worktreeId, onData, onExit) {
-  const session = sessions.get(worktreeId);
+function setCallbacks(attachId, onData, onExit) {
+  const session = sessions.get(attachId);
   if (session) {
     session.onData = onData;
     session.onExit = onExit;
   }
 }
-async function selectPane(worktreeId, paneIndex) {
-  const session = sessions.get(worktreeId);
+async function selectPane(attachId, paneIndex) {
+  const session = sessions.get(attachId);
   if (!session) {
-    log.debug(`[term] selectPane(${worktreeId}) no session found`);
+    log.debug(`[term] selectPane(${attachId}) no session found`);
     return;
   }
   const target = `${session.groupedSessionName}:${session.windowName}.${paneIndex}`;
-  log.debug(`[term] selectPane(${worktreeId}) pane=${paneIndex} target=${target}`);
+  log.debug(`[term] selectPane(${attachId}) pane=${paneIndex} target=${target}`);
   const [r1, r2] = await Promise.all([
     tmuxExec(["tmux", "select-pane", "-t", target]),
     tmuxExec(["tmux", "resize-pane", "-Z", "-t", target])
   ]);
-  log.debug(`[term] selectPane(${worktreeId}) select=${r1.exitCode} zoom=${r2.exitCode}`);
+  log.debug(`[term] selectPane(${attachId}) select=${r1.exitCode} zoom=${r2.exitCode}`);
 }
-function clearCallbacks(worktreeId) {
-  const session = sessions.get(worktreeId);
+function clearCallbacks(attachId) {
+  const session = sessions.get(attachId);
   if (session) {
     session.onData = null;
     session.onExit = null;
@@ -7268,7 +7269,7 @@ var DEFAULT_CONFIG = {
   startupEnvs: {},
   integrations: {
     github: { linkedRepos: [] },
-    linear: { enabled: true }
+    linear: { enabled: true, autoCreateWorktrees: false, createTicketOption: false }
   },
   lifecycleHooks: {},
   autoName: null
@@ -7469,7 +7470,10 @@ function parseProjectConfig(parsed) {
         linkedRepos: isRecord(parsed.integrations) && isRecord(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github.linkedRepos) : isRecord(parsed.integrations) && Array.isArray(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github) : []
       },
       linear: {
-        enabled: isRecord(parsed.integrations) && isRecord(parsed.integrations.linear) && typeof parsed.integrations.linear.enabled === "boolean" ? parsed.integrations.linear.enabled : DEFAULT_CONFIG.integrations.linear.enabled
+        enabled: isRecord(parsed.integrations) && isRecord(parsed.integrations.linear) && typeof parsed.integrations.linear.enabled === "boolean" ? parsed.integrations.linear.enabled : DEFAULT_CONFIG.integrations.linear.enabled,
+        autoCreateWorktrees: isRecord(parsed.integrations) && isRecord(parsed.integrations.linear) && typeof parsed.integrations.linear.autoCreateWorktrees === "boolean" ? parsed.integrations.linear.autoCreateWorktrees : DEFAULT_CONFIG.integrations.linear.autoCreateWorktrees,
+        createTicketOption: isRecord(parsed.integrations) && isRecord(parsed.integrations.linear) && typeof parsed.integrations.linear.createTicketOption === "boolean" ? parsed.integrations.linear.createTicketOption : DEFAULT_CONFIG.integrations.linear.createTicketOption,
+        ...isRecord(parsed.integrations) && isRecord(parsed.integrations.linear) && typeof parsed.integrations.linear.teamId === "string" && parsed.integrations.linear.teamId.trim() ? { teamId: parsed.integrations.linear.teamId.trim() } : {}
       }
     },
     lifecycleHooks: parseLifecycleHooks(parsed.lifecycleHooks),
@@ -7479,21 +7483,39 @@ function parseProjectConfig(parsed) {
 function defaultConfig() {
   return parseProjectConfig({});
 }
+function parseLocalLinearOverlay(parsed) {
+  if (!isRecord(parsed.integrations))
+    return null;
+  const linear = parsed.integrations.linear;
+  if (!isRecord(linear))
+    return null;
+  const overlay = {};
+  if (typeof linear.enabled === "boolean")
+    overlay.enabled = linear.enabled;
+  if (typeof linear.autoCreateWorktrees === "boolean")
+    overlay.autoCreateWorktrees = linear.autoCreateWorktrees;
+  if (typeof linear.createTicketOption === "boolean")
+    overlay.createTicketOption = linear.createTicketOption;
+  if (typeof linear.teamId === "string" && linear.teamId.trim())
+    overlay.teamId = linear.teamId.trim();
+  return Object.keys(overlay).length > 0 ? overlay : null;
+}
 function loadLocalProjectConfigOverlay(root) {
   try {
     const text = readLocalConfigFile(root).trim();
     if (!text) {
-      return { worktreeRoot: null, profiles: {}, lifecycleHooks: {} };
+      return { worktreeRoot: null, profiles: {}, lifecycleHooks: {}, linear: null };
     }
     const parsed = parseConfigDocument(text);
     const ws = isRecord(parsed.workspace) ? parsed.workspace : null;
     return {
       worktreeRoot: ws && typeof ws.worktreeRoot === "string" ? ws.worktreeRoot : null,
       profiles: parseProfiles(parsed.profiles, false),
-      lifecycleHooks: parseLifecycleHooks(parsed.lifecycleHooks)
+      lifecycleHooks: parseLifecycleHooks(parsed.lifecycleHooks),
+      linear: parseLocalLinearOverlay(parsed)
     };
   } catch {
-    return { worktreeRoot: null, profiles: {}, lifecycleHooks: {} };
+    return { worktreeRoot: null, profiles: {}, lifecycleHooks: {}, linear: null };
   }
 }
 function mergeHookCommand(projectCommand, localCommand) {
@@ -7544,9 +7566,31 @@ function loadConfig(dir, options = {}) {
       ...cloneProfiles(projectConfig.profiles),
       ...cloneProfiles(localOverlay.profiles)
     },
-    lifecycleHooks: mergeLifecycleHooks(projectConfig.lifecycleHooks, localOverlay.lifecycleHooks)
+    lifecycleHooks: mergeLifecycleHooks(projectConfig.lifecycleHooks, localOverlay.lifecycleHooks),
+    ...localOverlay.linear ? {
+      integrations: {
+        ...projectConfig.integrations,
+        linear: { ...projectConfig.integrations.linear, ...localOverlay.linear }
+      }
+    } : {}
   };
 }
+async function persistLocalLinearConfig(dir, changes) {
+  const root = projectRoot(dir);
+  const localPath = join(root, ".webmux.local.yaml");
+  let existing = {};
+  try {
+    const text = readFileSync(localPath, "utf8").trim();
+    if (text)
+      existing = parseConfigDocument(text);
+  } catch {}
+  const integrations = isRecord(existing.integrations) ? { ...existing.integrations } : {};
+  const linear = isRecord(integrations.linear) ? { ...integrations.linear } : {};
+  Object.assign(linear, changes);
+  integrations.linear = linear;
+  existing.integrations = integrations;
+  await Bun.write(localPath, $stringify(existing));
+}
 function expandTemplate(template, env) {
   return template.replace(/\$\{(\w+)\}/g, (_, key) => env[key] ?? "");
 }
@@ -7601,32 +7645,166 @@ var ASSIGNED_ISSUES_QUERY = `
     }
   }
 `;
+var VIEWER_QUERY = `
+  query Viewer {
+    viewer {
+      id
+    }
+  }
+`;
+var TEAM_STATES_QUERY = `
+  query TeamStates($teamId: String!) {
+    team(id: $teamId) {
+      states {
+        nodes {
+          id
+          name
+          type
+        }
+      }
+    }
+  }
+`;
+var ISSUE_CREATE_MUTATION = `
+  mutation IssueCreate($input: IssueCreateInput!) {
+    issueCreate(input: $input) {
+      success
+      issue {
+        id
+        identifier
+        title
+        url
+        branchName
+      }
+    }
+  }
+`;
+function gqlErrorMessage(raw) {
+  return raw.errors && raw.errors.length > 0 ? raw.errors.map((error) => error.message).join("; ") : null;
+}
 function parseIssuesResponse(raw) {
-  if (raw.errors && raw.errors.length > 0) {
-    return { ok: false, error: raw.errors.map((e) => e.message).join("; ") };
+  const error = gqlErrorMessage(raw);
+  if (error) {
+    return { ok: false, error };
   }
   if (!raw.data) {
     return { ok: false, error: "No data in response" };
   }
-  const nodes = raw.data.viewer.assignedIssues.nodes;
-  const issues = nodes.map((n) => ({
-    id: n.id,
-    identifier: n.identifier,
-    title: n.title,
-    description: n.description,
-    priority: n.priority,
-    priorityLabel: n.priorityLabel,
-    url: n.url,
-    branchName: n.branchName,
-    dueDate: n.dueDate,
-    updatedAt: n.updatedAt,
-    state: n.state,
-    team: n.team,
-    labels: n.labels.nodes,
-    project: n.project?.name ?? null
+  const issues = raw.data.viewer.assignedIssues.nodes.map((node) => ({
+    id: node.id,
+    identifier: node.identifier,
+    title: node.title,
+    description: node.description,
+    priority: node.priority,
+    priorityLabel: node.priorityLabel,
+    url: node.url,
+    branchName: node.branchName,
+    dueDate: node.dueDate,
+    updatedAt: node.updatedAt,
+    state: node.state,
+    team: node.team,
+    labels: node.labels.nodes,
+    project: node.project?.name ?? null
   }));
   return { ok: true, data: issues };
 }
+function buildLinearIssuesResponse(input) {
+  if (!input.integrationEnabled) {
+    return {
+      ok: true,
+      data: {
+        availability: "disabled",
+        issues: []
+      }
+    };
+  }
+  if (!input.apiKey?.trim()) {
+    return {
+      ok: true,
+      data: {
+        availability: "missing_api_key",
+        issues: []
+      }
+    };
+  }
+  if (!input.fetchResult) {
+    return { ok: false, error: "Linear fetch result required when LINEAR_API_KEY is set" };
+  }
+  if (!input.fetchResult.ok) {
+    return input.fetchResult;
+  }
+  return {
+    ok: true,
+    data: {
+      availability: "ready",
+      issues: input.fetchResult.data
+    }
+  };
+}
+function parseViewerIdResponse(raw) {
+  const error = gqlErrorMessage(raw);
+  if (error) {
+    return { ok: false, error };
+  }
+  const viewerId = raw.data?.viewer.id;
+  if (!viewerId) {
+    return { ok: false, error: "No viewer id in response" };
+  }
+  return { ok: true, data: viewerId };
+}
+function parseInProgressStateIdResponse(raw) {
+  const error = gqlErrorMessage(raw);
+  if (error) {
+    return { ok: false, error };
+  }
+  const states = raw.data?.team?.states.nodes;
+  if (!states) {
+    return { ok: false, error: "No team states in response" };
+  }
+  const preferredState = states.find((state) => state.type === "started" && state.name.trim().toLowerCase() === "in progress");
+  if (preferredState) {
+    return { ok: true, data: preferredState.id };
+  }
+  const startedState = states.find((state) => state.type === "started");
+  if (!startedState) {
+    return { ok: false, error: "No started workflow state found for team" };
+  }
+  return { ok: true, data: startedState.id };
+}
+function parseIssueCreateResponse(raw) {
+  const error = gqlErrorMessage(raw);
+  if (error) {
+    return { ok: false, error };
+  }
+  const payload = raw.data?.issueCreate;
+  if (!payload) {
+    return { ok: false, error: "No issueCreate payload in response" };
+  }
+  if (!payload.success || !payload.issue) {
+    return { ok: false, error: "Linear issue creation was not successful" };
+  }
+  if (!payload.issue.branchName) {
+    return { ok: false, error: "Linear issue did not return a branch name" };
+  }
+  return {
+    ok: true,
+    data: {
+      id: payload.issue.id,
+      identifier: payload.issue.identifier,
+      title: payload.issue.title,
+      url: payload.issue.url,
+      branchName: payload.issue.branchName
+    }
+  };
+}
+function deriveLinearIssueTitle(explicitTitle, prompt) {
+  const trimmedTitle = explicitTitle?.trim();
+  if (trimmedTitle) {
+    return trimmedTitle;
+  }
+  const firstPromptLine = prompt?.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0);
+  return firstPromptLine ?? null;
+}
 function branchMatchesIssue(worktreeBranch, issueBranchName) {
   if (!worktreeBranch || !issueBranchName)
     return false;
@@ -7650,15 +7828,13 @@ function branchMatchesIssue(worktreeBranch, issueBranchName) {
 }
 var CACHE_TTL_MS = 300000;
 var issueCache = null;
-async function fetchAssignedIssues() {
+var viewerIdCache = null;
+var inProgressStateIdCache = new Map;
+async function postLinearGraphql(query, variables) {
   const apiKey = Bun.env.LINEAR_API_KEY;
   if (!apiKey) {
     return { ok: false, error: "LINEAR_API_KEY not set" };
   }
-  const now = Date.now();
-  if (issueCache && now < issueCache.expiry) {
-    return issueCache.data;
-  }
   try {
     const res = await fetch("https://api.linear.app/graphql", {
       method: "POST",
@@ -7666,28 +7842,106 @@ async function fetchAssignedIssues() {
         "Content-Type": "application/json",
         Authorization: apiKey
       },
-      body: JSON.stringify({ query: ASSIGNED_ISSUES_QUERY })
+      body: JSON.stringify(variables ? { query, variables } : { query })
     });
     if (!res.ok) {
       const text = await res.text();
-      const result2 = { ok: false, error: `Linear API ${res.status}: ${text.slice(0, 200)}` };
-      return result2;
-    }
-    const json = await res.json();
-    const result = parseIssuesResponse(json);
-    if (result.ok) {
-      issueCache = { data: result, expiry: now + CACHE_TTL_MS };
-      log.debug(`[linear] fetched ${result.data.length} assigned issues`);
-    } else {
-      log.error(`[linear] GraphQL error: ${result.error}`);
+      return { ok: false, error: `Linear API ${res.status}: ${text.slice(0, 200)}` };
     }
-    return result;
+    return {
+      ok: true,
+      data: await res.json()
+    };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log.error(`[linear] fetch failed: ${msg}`);
     return { ok: false, error: msg };
   }
 }
+async function fetchViewerId() {
+  if (viewerIdCache) {
+    return { ok: true, data: viewerIdCache };
+  }
+  const response = await postLinearGraphql(VIEWER_QUERY);
+  if (!response.ok) {
+    log.error(`[linear] viewer fetch failed: ${response.error}`);
+    return { ok: false, error: response.error };
+  }
+  const result = parseViewerIdResponse(response.data);
+  if (!result.ok) {
+    log.error(`[linear] viewer GraphQL error: ${result.error}`);
+    return result;
+  }
+  viewerIdCache = result.data;
+  return result;
+}
+async function fetchInProgressStateId(teamId) {
+  const cachedStateId = inProgressStateIdCache.get(teamId);
+  if (cachedStateId) {
+    return { ok: true, data: cachedStateId };
+  }
+  const response = await postLinearGraphql(TEAM_STATES_QUERY, { teamId });
+  if (!response.ok) {
+    log.error(`[linear] team states fetch failed: ${response.error}`);
+    return { ok: false, error: response.error };
+  }
+  const result = parseInProgressStateIdResponse(response.data);
+  if (!result.ok) {
+    log.error(`[linear] team states GraphQL error: ${result.error}`);
+    return result;
+  }
+  inProgressStateIdCache.set(teamId, result.data);
+  return result;
+}
+async function fetchAssignedIssues(options) {
+  const now = Date.now();
+  if (!options?.skipCache && issueCache && now < issueCache.expiry) {
+    return issueCache.data;
+  }
+  const response = await postLinearGraphql(ASSIGNED_ISSUES_QUERY);
+  if (!response.ok) {
+    log.error(`[linear] fetch failed: ${response.error}`);
+    return { ok: false, error: response.error };
+  }
+  const result = parseIssuesResponse(response.data);
+  if (result.ok) {
+    issueCache = { data: result, expiry: now + CACHE_TTL_MS };
+    log.debug(`[linear] fetched ${result.data.length} assigned issues`);
+  } else {
+    log.error(`[linear] GraphQL error: ${result.error}`);
+  }
+  return result;
+}
+async function createLinearIssue(input) {
+  const viewerResult = await fetchViewerId();
+  if (!viewerResult.ok) {
+    return { ok: false, error: viewerResult.error };
+  }
+  const stateResult = await fetchInProgressStateId(input.teamId);
+  if (!stateResult.ok) {
+    return { ok: false, error: stateResult.error };
+  }
+  const response = await postLinearGraphql(ISSUE_CREATE_MUTATION, {
+    input: {
+      title: input.title,
+      description: input.description,
+      teamId: input.teamId,
+      assigneeId: viewerResult.data,
+      stateId: stateResult.data
+    }
+  });
+  if (!response.ok) {
+    log.error(`[linear] create failed: ${response.error}`);
+    return { ok: false, error: response.error };
+  }
+  const result = parseIssueCreateResponse(response.data);
+  if (result.ok) {
+    issueCache = null;
+    log.debug(`[linear] created issue ${result.data.identifier} branch=${result.data.branchName}`);
+  } else {
+    log.error(`[linear] issueCreate error: ${result.error}`);
+  }
+  return result;
+}
 
 // backend/src/services/lifecycle-service.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -8897,7 +9151,7 @@ class LifecycleService {
         agent,
         phase: "reconciling"
       });
-      await this.deps.reconciliation.reconcile(this.deps.projectRoot);
+      await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
       return {
         branch,
         worktreeId: initialized.meta.worktreeId
@@ -8932,7 +9186,7 @@ class LifecycleService {
         worktreePath: resolved.entry.path,
         launchMode
       });
-      await this.deps.reconciliation.reconcile(this.deps.projectRoot);
+      await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
       return {
         branch,
         worktreeId: initialized.meta.worktreeId
@@ -8945,7 +9199,7 @@ class LifecycleService {
     try {
       const resolved = await this.resolveExistingWorktree(branch);
       this.deps.tmux.killWindow(buildProjectSessionName(this.deps.projectRoot), buildWorktreeWindowName(branch));
-      await this.deps.reconciliation.reconcile(this.deps.projectRoot);
+      await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
     } catch (error) {
       throw this.wrapOperationError(error);
     }
@@ -9271,15 +9525,15 @@ class LifecycleService {
       deleteBranch: true,
       deleteBranchForce: true
     }, this.deps.git);
-    await this.deps.reconciliation.reconcile(this.deps.projectRoot);
+    await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
   }
   async runLifecycleHook(input) {
-    console.debug(`[lifecycle-hook] name=${input.name} command=${input.command ?? "UNDEFINED"} meta=${input.meta ? "present" : "NULL"} cwd=${input.worktreePath}`);
+    log.debug(`[lifecycle-hook] name=${input.name} command=${input.command ?? "UNDEFINED"} meta=${input.meta ? "present" : "NULL"} cwd=${input.worktreePath}`);
     if (!input.command || !input.meta) {
-      console.debug(`[lifecycle-hook] SKIPPING ${input.name}: command=${!!input.command} meta=${!!input.meta}`);
+      log.debug(`[lifecycle-hook] SKIPPING ${input.name}: command=${!!input.command} meta=${!!input.meta}`);
       return;
     }
-    console.debug(`[lifecycle-hook] RUNNING ${input.name}: ${input.command} in ${input.worktreePath}`);
+    log.debug(`[lifecycle-hook] RUNNING ${input.name}: ${input.command} in ${input.worktreePath}`);
     const dotenvValues = await loadDotenvLocal(input.worktreePath);
     await this.deps.hooks.run({
       name: input.name,
@@ -9289,7 +9543,7 @@ class LifecycleService {
         WEBMUX_WORKTREE_PATH: input.worktreePath
       }, dotenvValues)
     });
-    console.debug(`[lifecycle-hook] COMPLETED ${input.name}`);
+    log.debug(`[lifecycle-hook] COMPLETED ${input.name}`);
   }
   async reportCreateProgress(progress) {
     await this.deps.onCreateProgress?.(progress);
@@ -9305,6 +9559,117 @@ class LifecycleService {
   }
 }
 
+// backend/src/services/native-terminal-service.ts
+function quoteShell2(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function sanitizeSessionSuffix(value) {
+  const sanitized = value.toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/-{2,}/g, "-").replace(/^[.-]+|[.-]+$/g, "");
+  const trimmed = sanitized.slice(0, 24);
+  return trimmed || "x";
+}
+function buildNativeTerminalTmuxCommand(env) {
+  const socket = env.WEBMUX_ISOLATED_TMUX_SOCKET;
+  const config = env.WEBMUX_ISOLATED_TMUX_CONFIG;
+  if (socket && config) {
+    return `tmux -L ${quoteShell2(socket)} -f ${quoteShell2(config)}`;
+  }
+  if (socket) {
+    return `tmux -L ${quoteShell2(socket)}`;
+  }
+  return "tmux";
+}
+function buildNativeTerminalLaunch(input) {
+  const { branch, state, tmuxCommand } = input;
+  if (!state || !state.git.exists) {
+    return {
+      ok: false,
+      reason: "not_found",
+      message: `Worktree not found: ${branch}`
+    };
+  }
+  if (!state.session.exists || !state.session.sessionName) {
+    return {
+      ok: false,
+      reason: "closed",
+      message: `No open tmux window found for worktree: ${branch}`
+    };
+  }
+  const sessionPrefix = input.sessionPrefix ?? "wm-native-launch-";
+  const groupedSessionPrefix = `${sessionPrefix}${sanitizeSessionSuffix(state.worktreeId)}`;
+  const attachScript = [
+    `g_name="${groupedSessionPrefix}-${"$"}$-$(date +%s)"`,
+    `owner_session_name=${quoteShell2(state.session.sessionName)}`,
+    `window_name=${quoteShell2(state.session.windowName)}`,
+    `grouped_window_target="${"$"}g_name:${"$"}window_name"`,
+    `grouped_pane_target="${"$"}grouped_window_target.0"`,
+    `cleanup() { ${tmuxCommand} kill-session -t "${"$"}g_name" >/dev/null 2>&1 || true; }`,
+    "cleanup",
+    `${tmuxCommand} new-session -d -s "${"$"}g_name" -t "${"$"}owner_session_name"`,
+    `${tmuxCommand} set-option -t "${"$"}owner_session_name" window-size latest`,
+    `${tmuxCommand} set-option -t "${"$"}g_name" mouse on`,
+    `${tmuxCommand} set-option -t "${"$"}g_name" set-clipboard on`,
+    `${tmuxCommand} select-window -t "${"$"}grouped_window_target"`,
+    `if [ "$(${tmuxCommand} display-message -t "${"$"}grouped_window_target" -p '#{window_zoomed_flag}')" = "1" ]; then ${tmuxCommand} resize-pane -Z -t "${"$"}grouped_window_target"; fi`,
+    `${tmuxCommand} select-pane -t "${"$"}grouped_pane_target"`,
+    "trap cleanup EXIT INT TERM",
+    `exec ${tmuxCommand} attach-session -t "${"$"}g_name"`
+  ].join(" && ");
+  return {
+    ok: true,
+    data: {
+      worktreeId: state.worktreeId,
+      branch: state.branch,
+      path: state.path,
+      shellCommand: `/bin/sh -lc ${quoteShell2(attachScript)}`
+    }
+  };
+}
+
+// backend/src/lib/async.ts
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const concurrency = Math.max(1, Math.min(limit, items.length || 1));
+  async function worker() {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await fn(items[index]);
+    }
+  }
+  await Promise.all(Array.from({ length: concurrency }, () => worker()));
+  return results;
+}
+function startSerializedInterval(run, intervalMs, deps = {}) {
+  const scheduleEvery = deps.scheduleEvery ?? ((handler, ms) => setInterval(handler, ms));
+  const cancelSchedule = deps.cancelSchedule ?? ((handle2) => clearInterval(handle2));
+  let running = false;
+  let rerunRequested = false;
+  let stopped = false;
+  const execute = () => {
+    if (stopped)
+      return;
+    if (running) {
+      rerunRequested = true;
+      return;
+    }
+    running = true;
+    Promise.resolve().then(run).finally(() => {
+      running = false;
+      if (stopped || !rerunRequested)
+        return;
+      rerunRequested = false;
+      execute();
+    });
+  };
+  execute();
+  const handle = scheduleEvery(execute, intervalMs);
+  return () => {
+    stopped = true;
+    cancelSchedule(handle);
+  };
+}
+
 // backend/src/services/pr-service.ts
 var PR_FETCH_LIMIT = 50;
 var GH_TIMEOUT_MS = 15000;
@@ -9424,18 +9789,6 @@ async function fetchAllPrs(repoSlug, repoLabel, cwd) {
     return { ok: false, error: `failed to parse gh output for ${label}: ${err}` };
   }
 }
-async function mapWithConcurrency(items, limit, fn) {
-  const results = new Array(items.length);
-  let next = 0;
-  async function worker() {
-    while (next < items.length) {
-      const idx = next++;
-      results[idx] = await fn(items[idx]);
-    }
-  }
-  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
-  return results;
-}
 async function fetchReviewComments(prNumber, repoSlug, cwd) {
   const repoFlag = repoSlug ? repoSlug : "{owner}/{repo}";
   const apiPath = `repos/${repoFlag}/pulls/${prNumber}/comments?per_page=100`;
@@ -9621,21 +9974,76 @@ async function syncPrStatus(getWorktreeGitDirs, linkedRepos, projectDir) {
       etagCache.delete(key);
   }
 }
-function startPrMonitor(getWorktreeGitDirs, linkedRepos, projectDir, intervalMs = 20000, isActive) {
-  const run = () => {
+function startPrMonitor(getWorktreeGitDirs, linkedRepos, projectDir, intervalMs = 1e4, isActive) {
+  const run = async () => {
     if (isActive && !isActive()) {
       log.debug("[pr] skipping PR sync: no active clients");
       return;
     }
-    syncPrStatus(getWorktreeGitDirs, linkedRepos, projectDir).catch((err) => {
+    await syncPrStatus(getWorktreeGitDirs, linkedRepos, projectDir).catch((err) => {
       log.error(`[pr] sync error: ${err}`);
     });
   };
-  run();
-  const timer = setInterval(run, intervalMs);
-  return () => {
-    clearInterval(timer);
-  };
+  return startSerializedInterval(run, intervalMs);
+}
+
+// backend/src/services/linear-auto-create-service.ts
+var POLL_INTERVAL_MS = 15000;
+var processedIssueIds = new Set;
+var AUTO_CREATE_LABEL = "webmux";
+function filterAutoCreateIssues(issues, existingBranches) {
+  return issues.filter((issue) => {
+    if (issue.state.name !== "Todo")
+      return false;
+    if (!issue.labels.some((l) => l.name.toLowerCase() === AUTO_CREATE_LABEL))
+      return false;
+    if (processedIssueIds.has(issue.id))
+      return false;
+    return !existingBranches.some((branch) => branchMatchesIssue(branch, issue.branchName));
+  });
+}
+async function runAutoCreate(deps) {
+  if (!deps.isActive()) {
+    log.debug("[linear-auto-create] skipping: no active clients");
+    return;
+  }
+  const result = await fetchAssignedIssues({ skipCache: true });
+  if (!result.ok) {
+    log.error(`[linear-auto-create] failed to fetch issues: ${result.error}`);
+    return;
+  }
+  const projectRoot2 = deps.projectRoot;
+  const existingBranches = deps.git.listWorktrees(projectRoot2).filter((entry) => !entry.bare && entry.branch !== null).map((entry) => entry.branch);
+  const newIssues = filterAutoCreateIssues(result.data, existingBranches);
+  if (newIssues.length === 0) {
+    log.debug(`[linear-auto-create] no new labeled issues (${result.data.length} assigned, ${existingBranches.length} worktrees)`);
+    return;
+  }
+  log.info(`[linear-auto-create] found ${newIssues.length} new issue(s) with "${AUTO_CREATE_LABEL}" label`);
+  for (const issue of newIssues) {
+    try {
+      log.info(`[linear-auto-create] creating worktree for ${issue.identifier}: ${issue.title}`);
+      await deps.lifecycleService.createWorktree({
+        mode: "new",
+        branch: issue.branchName,
+        prompt: `${issue.title}
+
+${issue.description ?? ""}`.trim()
+      });
+      processedIssueIds.add(issue.id);
+      log.info(`[linear-auto-create] created worktree for ${issue.identifier}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log.error(`[linear-auto-create] failed to create worktree for ${issue.identifier}: ${msg}`);
+    }
+  }
+}
+function startLinearAutoCreateMonitor(deps) {
+  log.info("[linear-auto-create] monitor started");
+  return startSerializedInterval(() => runAutoCreate(deps), POLL_INTERVAL_MS);
+}
+function resetProcessedIssues() {
+  processedIssueIds.clear();
 }
 
 // backend/src/services/snapshot-service.ts
@@ -10058,8 +10466,8 @@ class BunLifecycleHookRunner {
   }
   async run(input) {
     const cmd = await this.buildCommand(input.cwd, input.command);
-    console.debug(`[hook-runner] Spawning: ${cmd.join(" ")} cwd=${input.cwd}`);
-    console.debug(`[hook-runner] Env keys: ${Object.keys(input.env).join(", ")}`);
+    log.debug(`[hook-runner] Spawning: ${cmd.join(" ")} cwd=${input.cwd}`);
+    log.debug(`[hook-runner] envKeys=${Object.keys(input.env).length}`);
     const proc = Bun.spawn(cmd, {
       cwd: input.cwd,
       env: {
@@ -10074,11 +10482,11 @@ class BunLifecycleHookRunner {
       new Response(proc.stdout).text(),
       new Response(proc.stderr).text()
     ]);
-    console.debug(`[hook-runner] ${input.name} exitCode=${exitCode}`);
+    log.debug(`[hook-runner] ${input.name} exitCode=${exitCode}`);
     if (stdout.trim())
-      console.debug(`[hook-runner] stdout: ${stdout.trim()}`);
+      log.debug(`[hook-runner] stdout: ${stdout.trim()}`);
     if (stderr.trim())
-      console.debug(`[hook-runner] stderr: ${stderr.trim()}`);
+      log.debug(`[hook-runner] stderr: ${stderr.trim()}`);
     if (exitCode !== 0) {
       throw new Error(buildErrorMessage(input.name, exitCode, stdout, stderr));
     }
@@ -10562,11 +10970,34 @@ function resolveBranch(entry, metaBranch) {
 
 class ReconciliationService {
   deps;
-  constructor(deps) {
+  freshnessMs;
+  now;
+  concurrency;
+  inFlight = null;
+  lastReconciledAt = 0;
+  constructor(deps, options = {}) {
     this.deps = deps;
+    this.freshnessMs = options.freshnessMs ?? 500;
+    this.now = options.now ?? Date.now;
+    this.concurrency = options.concurrency ?? 4;
   }
-  async reconcile(repoRoot) {
+  async reconcile(repoRoot, options = {}) {
+    if (this.inFlight) {
+      return await this.inFlight;
+    }
+    if (!options.force && this.now() - this.lastReconciledAt < this.freshnessMs) {
+      return;
+    }
     const normalizedRepoRoot = resolve5(repoRoot);
+    const reconcilePromise = this.runReconcile(normalizedRepoRoot).then(() => {
+      this.lastReconciledAt = this.now();
+    });
+    this.inFlight = reconcilePromise.finally(() => {
+      this.inFlight = null;
+    });
+    return await this.inFlight;
+  }
+  async runReconcile(normalizedRepoRoot) {
     const worktrees = this.deps.git.listWorktrees(normalizedRepoRoot);
     const sessionName = buildProjectSessionName(normalizedRepoRoot);
     let windows = [];
@@ -10576,40 +11007,32 @@ class ReconciliationService {
       windows = [];
     }
     const seenWorktreeIds = new Set;
-    for (const entry of worktrees) {
-      if (entry.bare)
-        continue;
-      if (resolve5(entry.path) === normalizedRepoRoot)
-        continue;
+    const candidateEntries = worktrees.filter((entry) => !entry.bare && resolve5(entry.path) !== normalizedRepoRoot);
+    const reconciledStates = await mapWithConcurrency(candidateEntries, this.concurrency, async (entry) => {
       const gitDir = this.deps.git.resolveWorktreeGitDir(entry.path);
       const meta = await readWorktreeMeta(gitDir);
       const branch = resolveBranch(entry, meta?.branch ?? null);
       const worktreeId = meta?.worktreeId ?? makeUnmanagedWorktreeId(entry.path);
-      seenWorktreeIds.add(worktreeId);
-      this.deps.runtime.upsertWorktree({
+      const gitStatus = this.deps.git.readWorktreeStatus(entry.path);
+      const window = findWindow(windows, sessionName, branch);
+      return {
         worktreeId,
         branch,
         path: entry.path,
         profile: meta?.profile ?? null,
         agentName: meta?.agent ?? null,
-        runtime: meta?.runtime ?? "host"
-      });
-      const gitStatus = this.deps.git.readWorktreeStatus(entry.path);
-      this.deps.runtime.setGitState(worktreeId, {
-        exists: true,
-        branch,
-        dirty: gitStatus.dirty,
-        aheadCount: gitStatus.aheadCount,
-        currentCommit: gitStatus.currentCommit
-      });
-      const window = findWindow(windows, sessionName, branch);
-      this.deps.runtime.setSessionState(worktreeId, {
-        exists: window !== null,
-        sessionName: window?.sessionName ?? null,
-        paneCount: window?.paneCount ?? 0
-      });
-      if (meta) {
-        this.deps.runtime.setServices(worktreeId, await buildServiceStates(this.deps, {
+        runtime: meta?.runtime ?? "host",
+        git: {
+          dirty: gitStatus.dirty,
+          aheadCount: gitStatus.aheadCount,
+          currentCommit: gitStatus.currentCommit
+        },
+        session: {
+          exists: window !== null,
+          sessionName: window?.sessionName ?? null,
+          paneCount: window?.paneCount ?? 0
+        },
+        services: meta ? await buildServiceStates(this.deps, {
           allocatedPorts: meta.allocatedPorts,
           startupEnvValues: meta.startupEnvValues,
           worktreeId: meta.worktreeId,
@@ -10617,11 +11040,34 @@ class ReconciliationService {
           profile: meta.profile,
           agent: meta.agent,
           runtime: meta.runtime
-        }));
-      } else {
-        this.deps.runtime.setServices(worktreeId, []);
-      }
-      this.deps.runtime.setPrs(worktreeId, await readWorktreePrs(gitDir));
+        }) : [],
+        prs: await readWorktreePrs(gitDir)
+      };
+    });
+    for (const state of reconciledStates) {
+      seenWorktreeIds.add(state.worktreeId);
+      this.deps.runtime.upsertWorktree({
+        worktreeId: state.worktreeId,
+        branch: state.branch,
+        path: state.path,
+        profile: state.profile,
+        agentName: state.agentName,
+        runtime: state.runtime
+      });
+      this.deps.runtime.setGitState(state.worktreeId, {
+        exists: true,
+        branch: state.branch,
+        dirty: state.git.dirty,
+        aheadCount: state.git.aheadCount,
+        currentCommit: state.git.currentCommit
+      });
+      this.deps.runtime.setSessionState(state.worktreeId, {
+        exists: state.session.exists,
+        sessionName: state.session.sessionName,
+        paneCount: state.session.paneCount
+      });
+      this.deps.runtime.setServices(state.worktreeId, state.services);
+      this.deps.runtime.setPrs(state.worktreeId, state.prs);
     }
     for (const state of this.deps.runtime.listWorktrees()) {
       if (!seenWorktreeIds.has(state.worktreeId)) {
@@ -10729,6 +11175,24 @@ var runtimeNotifications = runtime.runtimeNotifications;
 var reconciliationService = runtime.reconciliationService;
 var removingBranches = new Set;
 var lifecycleService = runtime.lifecycleService;
+var linearAutoCreateEnabled = config.integrations.linear.autoCreateWorktrees;
+var stopLinearAutoCreate = null;
+function startLinearAutoCreate() {
+  if (stopLinearAutoCreate)
+    return;
+  stopLinearAutoCreate = startLinearAutoCreateMonitor({
+    lifecycleService,
+    git,
+    projectRoot: PROJECT_DIR,
+    isActive: hasRecentDashboardActivity
+  });
+}
+function stopLinearAutoCreateMonitor() {
+  if (stopLinearAutoCreate) {
+    stopLinearAutoCreate();
+    stopLinearAutoCreate = null;
+  }
+}
 function getFrontendConfig() {
   const defaultProfileName = getDefaultProfileName(config);
   const orderedProfileEntries = Object.entries(config.profiles).sort(([left], [right]) => {
@@ -10747,11 +11211,13 @@ function getFrontendConfig() {
     })),
     defaultProfileName,
     autoName: config.autoName !== null,
+    linearCreateTicketOption: config.integrations.linear.enabled && config.integrations.linear.createTicketOption,
     startupEnvs: config.startupEnvs,
     linkedRepos: config.integrations.github.linkedRepos.map((lr) => ({
       alias: lr.alias,
       ...lr.dir ? { dir: resolve6(PROJECT_DIR, lr.dir) } : {}
-    }))
+    })),
+    linearAutoCreateWorktrees: linearAutoCreateEnabled
   };
 }
 function parseWsMessage(raw) {
@@ -10829,8 +11295,11 @@ async function withRemovingBranch(branch, fn) {
 }
 async function resolveTerminalWorktree(branch) {
   ensureBranchNotBusy(branch);
-  await reconciliationService.reconcile(PROJECT_DIR);
-  const state = projectRuntime.getWorktreeByBranch(branch);
+  let state = projectRuntime.getWorktreeByBranch(branch);
+  if (!state || !state.session.exists || !state.session.sessionName) {
+    await reconciliationService.reconcile(PROJECT_DIR);
+    state = projectRuntime.getWorktreeByBranch(branch);
+  }
   if (!state) {
     throw new Error(`Worktree not found: ${branch}`);
   }
@@ -10845,9 +11314,24 @@ async function resolveTerminalWorktree(branch) {
     }
   };
 }
-function getAttachedWorktreeId(ws) {
-  if (ws.data.attached && ws.data.worktreeId) {
-    return ws.data.worktreeId;
+async function apiGetNativeTerminalLaunch(branch) {
+  touchDashboardActivity();
+  ensureBranchNotBusy(branch);
+  await reconciliationService.reconcile(PROJECT_DIR);
+  const launch = buildNativeTerminalLaunch({
+    branch,
+    state: projectRuntime.getWorktreeByBranch(branch),
+    tmuxCommand: buildNativeTerminalTmuxCommand(Bun.env),
+    sessionPrefix: `wm-native-${PORT}-`
+  });
+  if (!launch.ok) {
+    return errorResponse(launch.message, launch.reason === "not_found" ? 404 : 409);
+  }
+  return jsonResponse(launch.data);
+}
+function getAttachedSessionId(ws) {
+  if (ws.data.attached && ws.data.attachId) {
+    return ws.data.attachId;
   }
   sendWs(ws, { type: "error", message: "Terminal not attached" });
   return null;
@@ -10881,7 +11365,8 @@ function makeCallbacks(ws) {
 }
 async function apiGetProject() {
   touchDashboardActivity();
-  const linearIssuesPromise = config.integrations.linear.enabled ? fetchAssignedIssues() : Promise.resolve({ ok: true, data: [] });
+  const linearApiKey = Bun.env.LINEAR_API_KEY;
+  const linearIssuesPromise = config.integrations.linear.enabled && linearApiKey?.trim() ? fetchAssignedIssues() : Promise.resolve({ ok: true, data: [] });
   const [, linearResult] = await Promise.all([
     reconciliationService.reconcile(PROJECT_DIR),
     linearIssuesPromise
@@ -10916,15 +11401,24 @@ async function apiRuntimeEvent(req) {
   const event = parseRuntimeEvent(raw);
   if (!event)
     return errorResponse("Invalid runtime event body", 400);
-  await reconciliationService.reconcile(PROJECT_DIR);
   try {
     projectRuntime.applyEvent(event);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (message.includes("Unknown worktree id")) {
-      return errorResponse(message, 404);
+      await reconciliationService.reconcile(PROJECT_DIR);
+      try {
+        projectRuntime.applyEvent(event);
+      } catch (retryError) {
+        const retryMessage = retryError instanceof Error ? retryError.message : String(retryError);
+        if (retryMessage.includes("Unknown worktree id")) {
+          return errorResponse(retryMessage, 404);
+        }
+        throw retryError;
+      }
+    } else {
+      throw error;
     }
-    throw error;
   }
   const notification = runtimeNotifications.recordEvent(event);
   return jsonResponse({
@@ -10954,21 +11448,56 @@ async function apiCreateWorktree(req) {
     if (Object.keys(parsed).length > 0)
       envOverrides = parsed;
   }
-  const branch = typeof body.branch === "string" ? body.branch : undefined;
-  const prompt = typeof body.prompt === "string" ? body.prompt : undefined;
+  const branch = typeof body.branch === "string" && body.branch.trim() ? body.branch.trim() : undefined;
+  const prompt = typeof body.prompt === "string" && body.prompt.trim() ? body.prompt.trim() : undefined;
   const profile = typeof body.profile === "string" ? body.profile : undefined;
   const agent = body.agent === "claude" || body.agent === "codex" ? body.agent : undefined;
-  const mode = body.mode;
-  if (mode !== undefined && mode !== "new" && mode !== "existing") {
+  const createLinearTicket = body.createLinearTicket === true;
+  const linearTitle = typeof body.linearTitle === "string" && body.linearTitle.trim() ? body.linearTitle.trim() : undefined;
+  const mode = body.mode === "new" || body.mode === "existing" ? body.mode : undefined;
+  if (body.mode !== undefined && body.mode !== "new" && body.mode !== "existing") {
     return errorResponse("Invalid worktree create mode", 400);
   }
-  if (branch) {
-    ensureBranchNotCreating(branch);
+  if (createLinearTicket && mode === "existing") {
+    return errorResponse("Linear ticket creation is only supported for new branches", 400);
+  }
+  if (createLinearTicket && !config.integrations.linear.enabled) {
+    return errorResponse("Linear integration is disabled", 400);
+  }
+  if (createLinearTicket && !config.integrations.linear.createTicketOption) {
+    return errorResponse("Linear ticket creation is not enabled for this project", 400);
+  }
+  if (createLinearTicket && !prompt) {
+    return errorResponse("Prompt is required when creating a Linear ticket", 400);
+  }
+  let resolvedBranch = branch;
+  if (createLinearTicket) {
+    const title = deriveLinearIssueTitle(linearTitle, prompt);
+    if (!title) {
+      return errorResponse("Linear ticket title could not be derived from the prompt", 400);
+    }
+    const teamId = config.integrations.linear.teamId;
+    if (!teamId) {
+      return errorResponse("Linear teamId is not configured", 503);
+    }
+    const linearResult = await createLinearIssue({
+      title,
+      description: prompt ?? "",
+      teamId
+    });
+    if (!linearResult.ok) {
+      return errorResponse(linearResult.error, 502);
+    }
+    resolvedBranch = linearResult.data.branchName;
+    ensureBranchNotCreating(resolvedBranch);
+    log.info(`[linear] created ticket ${linearResult.data.identifier} branch=${linearResult.data.branchName} title="${linearResult.data.title.slice(0, 80)}"`);
+  } else if (resolvedBranch) {
+    ensureBranchNotCreating(resolvedBranch);
   }
-  log.info(`[worktree:add] mode=${mode ?? "new"}${branch ? ` branch=${branch}` : ""}${profile ? ` profile=${profile}` : ""}${agent ? ` agent=${agent}` : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
+  log.info(`[worktree:add] mode=${mode ?? "new"}${resolvedBranch ? ` branch=${resolvedBranch}` : ""}${profile ? ` profile=${profile}` : ""}${agent ? ` agent=${agent}` : ""}${createLinearTicket ? " linearTicket=true" : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
   const result = await lifecycleService.createWorktree({
     mode,
-    branch,
+    branch: resolvedBranch,
     prompt,
     profile,
     agent,
@@ -11024,8 +11553,35 @@ async function apiMergeWorktree(name) {
   log.debug(`[worktree:merge] done name=${name}`);
   return jsonResponse({ ok: true });
 }
+async function apiSetLinearAutoCreate(req) {
+  const raw = await req.json();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return errorResponse("Invalid request body", 400);
+  }
+  const body = raw;
+  if (typeof body.enabled !== "boolean") {
+    return errorResponse("Missing boolean 'enabled' field", 400);
+  }
+  linearAutoCreateEnabled = body.enabled;
+  if (linearAutoCreateEnabled) {
+    resetProcessedIssues();
+    startLinearAutoCreate();
+    log.info("[config] Linear auto-create worktrees enabled");
+  } else {
+    stopLinearAutoCreateMonitor();
+    log.info("[config] Linear auto-create worktrees disabled");
+  }
+  await persistLocalLinearConfig(PROJECT_DIR, { autoCreateWorktrees: linearAutoCreateEnabled });
+  return jsonResponse({ ok: true, enabled: linearAutoCreateEnabled });
+}
 async function apiGetLinearIssues() {
-  const result = await fetchAssignedIssues();
+  const apiKey = Bun.env.LINEAR_API_KEY;
+  const fetchResult = config.integrations.linear.enabled && apiKey?.trim() ? await fetchAssignedIssues() : undefined;
+  const result = buildLinearIssuesResponse({
+    integrationEnabled: config.integrations.linear.enabled,
+    apiKey,
+    fetchResult
+  });
   if (!result.ok)
     return errorResponse(result.error, 502);
   return jsonResponse(result.data);
@@ -11113,7 +11669,7 @@ Bun.serve({
   routes: {
     "/ws/:worktree": (req, server) => {
       const branch = decodeURIComponent(req.params.worktree);
-      return server.upgrade(req, { data: { branch, worktreeId: null, attached: false } }) ? undefined : new Response("WebSocket upgrade failed", { status: 400 });
+      return server.upgrade(req, { data: { branch, worktreeId: null, attachId: null, attached: false } }) ? undefined : new Response("WebSocket upgrade failed", { status: 400 });
     },
     "/api/config": {
       GET: () => jsonResponse(getFrontendConfig())
@@ -11146,6 +11702,14 @@ Bun.serve({
         return catching(`POST /api/worktrees/${name}/open`, () => apiOpenWorktree(name));
       }
     },
+    "/api/worktrees/:name/terminal-launch": {
+      GET: (req) => {
+        const name = decodeURIComponent(req.params.name);
+        if (!isValidWorktreeName(name))
+          return errorResponse("Invalid worktree name", 400);
+        return catching(`GET /api/worktrees/${name}/terminal-launch`, () => apiGetNativeTerminalLaunch(name));
+      }
+    },
     "/api/worktrees/:name/close": {
       POST: (req) => {
         const name = decodeURIComponent(req.params.name);
@@ -11189,6 +11753,9 @@ Bun.serve({
     "/api/linear/issues": {
       GET: () => catching("GET /api/linear/issues", () => apiGetLinearIssues())
     },
+    "/api/linear/auto-create": {
+      PUT: (req) => catching("PUT /api/linear/auto-create", () => apiSetLinearAutoCreate(req))
+    },
     "/api/ci-logs/:runId": {
       GET: (req) => catching(`GET /api/ci-logs/${req.params.runId}`, () => apiCiLogs(req.params.runId))
     },
@@ -11242,26 +11809,26 @@ Bun.serve({
       const { branch } = ws.data;
       switch (msg.type) {
         case "input": {
-          const worktreeId = getAttachedWorktreeId(ws);
-          if (!worktreeId)
+          const attachId = getAttachedSessionId(ws);
+          if (!attachId)
             return;
-          write(worktreeId, msg.data);
+          write(attachId, msg.data);
           break;
         }
         case "sendKeys": {
-          const worktreeId = getAttachedWorktreeId(ws);
-          if (!worktreeId)
+          const attachId = getAttachedSessionId(ws);
+          if (!attachId)
             return;
-          await sendKeys(worktreeId, msg.hexBytes);
+          await sendKeys(attachId, msg.hexBytes);
           break;
         }
         case "selectPane":
           {
-            const worktreeId = getAttachedWorktreeId(ws);
-            if (!worktreeId)
+            const attachId = getAttachedSessionId(ws);
+            if (!attachId)
               return;
-            log.debug(`[ws] selectPane pane=${msg.pane} branch=${branch} worktreeId=${worktreeId}`);
-            await selectPane(worktreeId, msg.pane);
+            log.debug(`[ws] selectPane pane=${msg.pane} branch=${branch} attachId=${attachId}`);
+            await selectPane(attachId, msg.pane);
           }
           break;
         case "resize":
@@ -11273,12 +11840,14 @@ Bun.serve({
                 log.debug(`[ws] initialPane=${msg.initialPane} branch=${branch}`);
               }
               const terminalWorktree = await resolveTerminalWorktree(branch);
+              const attachId = `${terminalWorktree.worktreeId}:${randomUUID3()}`;
               ws.data.worktreeId = terminalWorktree.worktreeId;
-              await attach(terminalWorktree.worktreeId, terminalWorktree.attachTarget, msg.cols, msg.rows, msg.initialPane);
+              ws.data.attachId = attachId;
+              await attach(attachId, terminalWorktree.attachTarget, msg.cols, msg.rows, msg.initialPane);
               const { onData, onExit } = makeCallbacks(ws);
-              setCallbacks(terminalWorktree.worktreeId, onData, onExit);
-              const scrollback = getScrollback(terminalWorktree.worktreeId);
-              log.debug(`[ws] attached branch=${branch} worktreeId=${terminalWorktree.worktreeId} scrollback=${scrollback.length} bytes`);
+              setCallbacks(attachId, onData, onExit);
+              const scrollback = getScrollback(attachId);
+              log.debug(`[ws] attached branch=${branch} worktreeId=${terminalWorktree.worktreeId} attachId=${attachId} scrollback=${scrollback.length} bytes`);
               if (scrollback.length > 0) {
                 sendWs(ws, { type: "scrollback", data: scrollback });
               }
@@ -11286,24 +11855,25 @@ Bun.serve({
               const errMsg = err instanceof Error ? err.message : String(err);
               ws.data.attached = false;
               ws.data.worktreeId = null;
+              ws.data.attachId = null;
               log.error(`[ws] attach failed branch=${branch}: ${errMsg}`);
               sendWs(ws, { type: "error", message: errMsg });
               ws.close(1011, errMsg.slice(0, 123));
             }
           } else {
-            const worktreeId = getAttachedWorktreeId(ws);
-            if (!worktreeId)
+            const attachId = getAttachedSessionId(ws);
+            if (!attachId)
               return;
-            await resize(worktreeId, msg.cols, msg.rows);
+            await resize(attachId, msg.cols, msg.rows);
           }
           break;
       }
     },
     async close(ws, code, reason) {
-      log.debug(`[ws] close branch=${ws.data.branch} code=${code} reason=${reason} attached=${ws.data.attached} worktreeId=${ws.data.worktreeId}`);
-      if (ws.data.worktreeId) {
-        clearCallbacks(ws.data.worktreeId);
-        await detach(ws.data.worktreeId);
+      log.debug(`[ws] close branch=${ws.data.branch} code=${code} reason=${reason} attached=${ws.data.attached} worktreeId=${ws.data.worktreeId} attachId=${ws.data.attachId}`);
+      if (ws.data.attachId) {
+        clearCallbacks(ws.data.attachId);
+        await detach(ws.data.attachId);
       }
     }
   }
@@ -11315,6 +11885,9 @@ if (tmuxCheck.exitCode !== 0) {
 }
 cleanupStaleSessions();
 startPrMonitor(getWorktreeGitDirs, config.integrations.github.linkedRepos, PROJECT_DIR, undefined, hasRecentDashboardActivity);
+if (linearAutoCreateEnabled) {
+  startLinearAutoCreate();
+}
 log.info(`Dev Dashboard API running at http://localhost:${PORT}`);
 var nets = networkInterfaces();
 for (const addrs of Object.values(nets)) {