webmux 0.31.1 → 0.32.0

package/backend/dist/server.js

@@ -6959,9 +6959,67 @@ var require_public_api = __commonJS((exports) => {
 
 // backend/src/server.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { join as join8, resolve as resolve9 } from "path";
+import { join as join7, resolve as resolve9 } from "path";
 import { mkdirSync } from "fs";
 import { networkInterfaces } from "os";
+// package.json
+var package_default = {
+  name: "webmux",
+  version: "0.32.0",
+  description: "Web dashboard for workmux \u2014 browser UI with embedded terminals, PR monitoring, and CI integration",
+  type: "module",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/windmill-labs/workmux-web.git"
+  },
+  homepage: "https://github.com/windmill-labs/workmux-web",
+  keywords: [
+    "workmux",
+    "git-worktree",
+    "tmux",
+    "dashboard",
+    "terminal",
+    "ai-agent"
+  ],
+  bin: {
+    webmux: "bin/webmux.js"
+  },
+  workspaces: [
+    "backend",
+    "frontend",
+    "packages/*"
+  ],
+  dependencies: {},
+  scripts: {
+    dev: "bash dev.sh",
+    start: "bun bin/webmux.js",
+    build: "cd frontend && bun run build && cd .. && bun build backend/src/server.ts --target=bun --outfile=backend/dist/server.js && bun build bin/src/webmux.ts --target=bun --outfile=bin/webmux.js",
+    prepublishOnly: "bun run build",
+    test: "bun run --cwd backend test && bun test packages/api-contract/src && bun test bin/src && bun run --cwd frontend test",
+    "test:coverage": "bun run --cwd backend test --coverage && bun test --coverage packages/api-contract/src && bun test --coverage bin/src && bun run --cwd frontend test:coverage"
+  },
+  files: [
+    "bin/webmux.js",
+    "backend/dist/",
+    "frontend/dist/"
+  ],
+  devDependencies: {
+    "@webmux/api-contract": "workspace:*",
+    "@clack/prompts": "^1.1.0",
+    "@sveltejs/vite-plugin-svelte": "^5.0.0",
+    "@tailwindcss/vite": "^4.2.0",
+    "@types/bun": "latest",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/addon-web-links": "^0.11.0",
+    "@xterm/xterm": "^5.5.0",
+    svelte: "^5.0.0",
+    "svelte-check": "^4.0.0",
+    tailwindcss: "^4.2.0",
+    typescript: "^5.0.0",
+    vite: "^6.0.0"
+  },
+  license: "MIT"
+};
 
 // node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
@@ -10936,7 +10994,7 @@ var coerce = {
   date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
 var NEVER = INVALID;
-// node_modules/.bun/@ts-rest+core@3.52.1+1c8a9bbc689bc595/node_modules/@ts-rest/core/index.esm.mjs
+// node_modules/.bun/@ts-rest+core@3.52.1+596964f7fee2c930/node_modules/@ts-rest/core/index.esm.mjs
 var isZodObjectStrict = (obj) => {
   return typeof (obj === null || obj === undefined ? undefined : obj.passthrough) === "function";
 };
@@ -11028,6 +11086,30 @@ var EnabledResponseSchema = exports_external.object({
 var BuiltInAgentIdSchema = exports_external.enum(["claude", "codex"]);
 var AgentIdSchema = exports_external.string().trim().min(1);
 var WorktreeCreateModeSchema = exports_external.enum(["new", "existing"]);
+var LinearIssueIdSchema = exports_external.string().regex(/^[A-Z]+-\d+$/, "Expected Linear issue id (e.g. ENG-123)");
+var LinearTeamKeySchema = exports_external.string().regex(/^[A-Z]+$/, "Expected Linear team key (e.g. ENG)");
+var PostWorktreeToLinearTargetSchema = exports_external.discriminatedUnion("kind", [
+  exports_external.object({ kind: exports_external.literal("issue"), issueId: LinearIssueIdSchema }),
+  exports_external.object({ kind: exports_external.literal("team"), teamKey: LinearTeamKeySchema, title: exports_external.string().trim().min(1).optional() })
+]);
+var PostWorktreeToLinearRequestSchema = exports_external.object({
+  target: PostWorktreeToLinearTargetSchema
+});
+var PostWorktreeToLinearResponseSchema = exports_external.object({
+  ok: exports_external.literal(true),
+  issueId: exports_external.string(),
+  issueUrl: exports_external.string(),
+  commentUrl: exports_external.string().nullable(),
+  attachmentUrl: exports_external.string()
+});
+var FromLinearInputSchema = exports_external.object({
+  issueId: LinearIssueIdSchema,
+  conversationContext: exports_external.string().optional()
+});
+var OneshotConfigSchema = exports_external.object({
+  autoCloseOnDone: exports_external.boolean().optional(),
+  postToLinearOnDone: PostWorktreeToLinearTargetSchema.optional()
+});
 var AgentCapabilitiesSchema = exports_external.object({
   terminal: exports_external.literal(true),
   inAppChat: exports_external.boolean(),
@@ -11084,6 +11166,7 @@ var NumberLikePathParamSchema = exports_external.union([
 var BranchListResponseSchema = exports_external.object({
   branches: exports_external.array(AvailableBranchSchema)
 });
+var WorktreeSourceSchema = exports_external.enum(["ui", "oneshot"]);
 var CreateWorktreeRequestSchema = exports_external.object({
   mode: WorktreeCreateModeSchema.optional(),
   branch: exports_external.string().optional(),
@@ -11094,7 +11177,14 @@ var CreateWorktreeRequestSchema = exports_external.object({
   prompt: exports_external.string().optional(),
   envOverrides: exports_external.record(exports_external.string()).optional(),
   createLinearTicket: exports_external.literal(true).optional(),
-  linearTitle: exports_external.string().optional()
+  linearTitle: exports_external.string().optional(),
+  fromLinear: FromLinearInputSchema.optional(),
+  source: WorktreeSourceSchema.optional(),
+  oneshot: OneshotConfigSchema.optional()
+});
+var OpenWorktreeRequestSchema = exports_external.object({
+  prompt: exports_external.string().optional(),
+  oneshot: OneshotConfigSchema.optional()
 });
 var CreateWorktreeResponseSchema = exports_external.object({
   primaryBranch: exports_external.string(),
@@ -11240,7 +11330,9 @@ var ProjectWorktreeSnapshotSchema = exports_external.object({
   services: exports_external.array(ServiceStatusSchema),
   prs: exports_external.array(PrEntrySchema),
   linearIssue: LinkedLinearIssueSchema.nullable(),
-  creation: WorktreeCreationStateSchema.nullable()
+  creation: WorktreeCreationStateSchema.nullable(),
+  source: WorktreeSourceSchema,
+  oneshot: OneshotConfigSchema.nullable()
 });
 var ProjectSnapshotSchema = exports_external.object({
   project: exports_external.object({
@@ -11289,13 +11381,16 @@ var AgentsUiWorktreeSummarySchema = exports_external.object({
 });
 var AgentsUiConversationMessageRoleSchema = exports_external.enum(["user", "assistant"]);
 var AgentsUiConversationMessageStatusSchema = exports_external.enum(["completed", "inProgress"]);
+var AgentsUiConversationMessageKindSchema = exports_external.enum(["text", "toolUse", "toolResult"]);
 var AgentsUiConversationMessageSchema = exports_external.object({
   id: exports_external.string(),
   turnId: exports_external.string(),
   role: AgentsUiConversationMessageRoleSchema,
   text: exports_external.string(),
   status: AgentsUiConversationMessageStatusSchema,
-  createdAt: exports_external.string().nullable()
+  createdAt: exports_external.string().nullable(),
+  kind: AgentsUiConversationMessageKindSchema.optional(),
+  toolName: exports_external.string().optional()
 });
 var AgentsUiConversationStateSchema = exports_external.object({
   provider: WorktreeConversationProviderSchema,
@@ -11419,6 +11514,8 @@ var apiPaths = {
   openWorktree: "/api/worktrees/:name/open",
   closeWorktree: "/api/worktrees/:name/close",
   setWorktreeArchived: "/api/worktrees/:name/archive",
+  syncWorktreePrs: "/api/worktrees/:name/sync-prs",
+  postWorktreeToLinear: "/api/worktrees/:name/linear/post",
   setWorktreeLabel: "/api/worktrees/:name/label",
   sendWorktreePrompt: "/api/worktrees/:name/send",
   mergeWorktree: "/api/worktrees/:name/merge",
@@ -11597,7 +11694,7 @@ var apiContract = c.router({
     method: "POST",
     path: apiPaths.openWorktree,
     pathParams: WorktreeNameParamsSchema,
-    body: c.noBody(),
+    body: OpenWorktreeRequestSchema,
     responses: {
       200: OkResponseSchema,
       ...commonErrorResponses
@@ -11623,6 +11720,26 @@ var apiContract = c.router({
       ...commonErrorResponses
     }
   },
+  postWorktreeToLinear: {
+    method: "POST",
+    path: apiPaths.postWorktreeToLinear,
+    pathParams: WorktreeNameParamsSchema,
+    body: PostWorktreeToLinearRequestSchema,
+    responses: {
+      200: PostWorktreeToLinearResponseSchema,
+      ...commonErrorResponses
+    }
+  },
+  syncWorktreePrs: {
+    method: "POST",
+    path: apiPaths.syncWorktreePrs,
+    pathParams: WorktreeNameParamsSchema,
+    body: c.noBody(),
+    responses: {
+      200: ProjectWorktreeSnapshotSchema,
+      ...commonErrorResponses
+    }
+  },
   setWorktreeLabel: {
     method: "PUT",
     path: apiPaths.setWorktreeLabel,
@@ -12066,26 +12183,43 @@ function isRecord(raw) {
 function readString(raw) {
   return typeof raw === "string" && raw.length > 0 ? raw : null;
 }
-function extractClaudeMessageText(raw) {
-  if (typeof raw === "string") {
-    return raw.trim();
-  }
-  if (!Array.isArray(raw)) {
-    return "";
+var TOOL_PAYLOAD_TRUNCATE_LIMIT = 2000;
+function compactJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
   }
-  return raw.map((entry) => {
+}
+function truncate(text, limit = TOOL_PAYLOAD_TRUNCATE_LIMIT) {
+  if (text.length <= limit)
+    return text;
+  return `${text.slice(0, limit)}\u2026 (truncated, ${text.length - limit} more chars)`;
+}
+function extractToolResultText(content) {
+  if (typeof content === "string")
+    return truncate(content.trim());
+  if (!Array.isArray(content))
+    return truncate(compactJson(content));
+  const text = content.map((entry) => {
     if (!isRecord(entry))
       return "";
-    if (entry.type !== "text")
-      return "";
-    return typeof entry.text === "string" ? entry.text : "";
+    if (entry.type === "text" && typeof entry.text === "string")
+      return entry.text;
+    return compactJson(entry);
   }).join("").trim();
+  return truncate(text);
 }
 function isTopLevelClaudeUserPrompt(raw) {
   if (raw.type !== "user" || !isRecord(raw.message))
     return false;
   return raw.message.role === "user" && typeof raw.message.content === "string" && typeof raw.uuid === "string" && raw.message.content.trim().length > 0;
 }
+function isClaudeUserToolResultRecord(raw) {
+  if (raw.type !== "user" || !isRecord(raw.message))
+    return false;
+  return raw.message.role === "user" && Array.isArray(raw.message.content) && typeof raw.uuid === "string";
+}
 function isClaudeAssistantRecord(raw) {
   if (raw.type !== "assistant" || !isRecord(raw.message))
     return false;
@@ -12132,11 +12266,10 @@ async function findClaudeSessionPath(sessionId, cwd) {
 }
 function parseClaudeSessionRecords(text) {
   return text.split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0).flatMap((line) => {
+`).map((line) => line.trim()).filter((line) => line.length > 0 && line.startsWith("{")).flatMap((line) => {
     try {
-      const parsed = JSON.parse(line);
-      return [parsed];
-    } catch (error) {
+      return [JSON.parse(line)];
+    } catch {
       log.warn(`[agents] failed to parse Claude session line: ${line.slice(0, 120)}`);
       return [];
     }
@@ -12144,12 +12277,17 @@ function parseClaudeSessionRecords(text) {
 }
 function buildClaudeSessionFromText(input) {
   const records = parseClaudeSessionRecords(input.text);
-  const turns = [];
+  const messages = [];
   let cwd = null;
   let gitBranch = null;
   let createdAt = null;
   let lastSeenAt = null;
-  let currentTurn = null;
+  let currentTurnId = null;
+  let blockIndex = 0;
+  const pushMessage = (message) => {
+    messages.push(message);
+    blockIndex += 1;
+  };
   for (const record of records) {
     cwd ??= readString(record.cwd);
     gitBranch ??= readString(record.gitBranch);
@@ -12158,38 +12296,74 @@ function buildClaudeSessionFromText(input) {
     }
     lastSeenAt = readString(record.timestamp) ?? lastSeenAt;
     if (isTopLevelClaudeUserPrompt(record)) {
-      if (currentTurn) {
-        turns.push(currentTurn);
-      }
-      currentTurn = {
-        user: {
-          id: record.uuid,
-          turnId: record.uuid,
+      currentTurnId = record.uuid;
+      blockIndex = 0;
+      pushMessage({
+        id: record.uuid,
+        turnId: record.uuid,
+        role: "user",
+        kind: "text",
+        text: record.message.content.trim(),
+        createdAt: readString(record.timestamp)
+      });
+      continue;
+    }
+    if (!currentTurnId)
+      continue;
+    if (isClaudeUserToolResultRecord(record)) {
+      for (const entry of record.message.content) {
+        if (!isRecord(entry) || entry.type !== "tool_result")
+          continue;
+        const text = extractToolResultText(entry.content);
+        if (text.length === 0)
+          continue;
+        pushMessage({
+          id: `${record.uuid}:${blockIndex}`,
+          turnId: currentTurnId,
           role: "user",
-          text: record.message.content.trim(),
+          kind: "toolResult",
+          text,
           createdAt: readString(record.timestamp)
-        },
-        assistant: null
-      };
+        });
+      }
       continue;
     }
-    if (!currentTurn || !isClaudeAssistantRecord(record)) {
+    if (!isClaudeAssistantRecord(record))
       continue;
-    }
-    const text = extractClaudeMessageText(record.message.content);
-    if (text.length === 0 || record.message.stop_reason !== "end_turn") {
+    if (!Array.isArray(record.message.content))
       continue;
+    for (const block of record.message.content) {
+      if (!isRecord(block))
+        continue;
+      if (block.type === "text" && typeof block.text === "string") {
+        const text = block.text.trim();
+        if (text.length === 0)
+          continue;
+        pushMessage({
+          id: `${record.uuid}:${blockIndex}`,
+          turnId: currentTurnId,
+          role: "assistant",
+          kind: "text",
+          text,
+          createdAt: readString(record.timestamp)
+        });
+        continue;
+      }
+      if (block.type === "tool_use") {
+        const toolName = typeof block.name === "string" ? block.name : "tool";
+        const text = truncate(compactJson(block.input ?? {}));
+        pushMessage({
+          id: `${record.uuid}:${blockIndex}`,
+          turnId: currentTurnId,
+          role: "assistant",
+          kind: "toolUse",
+          toolName,
+          text,
+          createdAt: readString(record.timestamp)
+        });
+        continue;
+      }
     }
-    currentTurn.assistant = {
-      id: record.uuid,
-      turnId: currentTurn.user.turnId,
-      role: "assistant",
-      text,
-      createdAt: readString(record.timestamp)
-    };
-  }
-  if (currentTurn) {
-    turns.push(currentTurn);
   }
   return {
     sessionId: input.sessionId,
@@ -12198,7 +12372,7 @@ function buildClaudeSessionFromText(input) {
     gitBranch,
     createdAt,
     lastSeenAt,
-    messages: turns.flatMap((turn) => turn.assistant ? [turn.user, turn.assistant] : [turn.user])
+    messages
   };
 }
 
@@ -12824,6 +12998,15 @@ var DEFAULT_PANES = [
   { id: "agent", kind: "agent", focus: true },
   { id: "shell", kind: "shell", split: "right", sizePct: 25 }
 ];
+function DEFAULT_ONESHOT_SYSTEM_PROMPT() {
+  return [
+    "You are running in webmux ONESHOT mode. There is NO interactive user \u2014 nobody is watching the chat or will respond to questions, approvals, or status checks. Any message asking the user to review, approve, confirm, take a look, or 'let you know' is wasted output: it will not be answered.",
+    "Your job is to take the task to its real conclusion without pausing:",
+    "1) Make the change. 2) Validate it (run the relevant tests, typecheck, build, or quick manual check). 3) Commit. 4) Push. 5) Open a pull request. Only then are you done.",
+    "When something is ambiguous, pick the most reasonable default and proceed. When you would normally ask 'should I X or Y?', just pick one and continue \u2014 note the choice in the PR description if it matters.",
+    "Never end your turn with a question, a suggestion to 'take a look', or a request for approval. Stop only when the PR is open, or when you hit a technical error you cannot recover from yourself (in which case clearly state the blocker)."
+  ].join(" ");
+}
 var DEFAULT_CONFIG = {
   name: "Webmux",
   workspace: {
@@ -12847,7 +13030,8 @@ var DEFAULT_CONFIG = {
     linear: { enabled: true, autoCreateWorktrees: false, createTicketOption: false }
   },
   lifecycleHooks: {},
-  autoName: null
+  autoName: null,
+  oneshot: { systemPrompt: DEFAULT_ONESHOT_SYSTEM_PROMPT() }
 };
 function clonePanes(panes) {
   return panes.map((pane) => ({ ...pane }));
@@ -13025,6 +13209,12 @@ function parseLifecycleHooks(raw) {
   }
   return hooks;
 }
+function parseOneshot(raw) {
+  if (!isRecord3(raw))
+    return { systemPrompt: DEFAULT_ONESHOT_SYSTEM_PROMPT() };
+  const systemPrompt = typeof raw.systemPrompt === "string" && raw.systemPrompt.trim() ? raw.systemPrompt.trim() : DEFAULT_ONESHOT_SYSTEM_PROMPT();
+  return { systemPrompt };
+}
 function parseAutoName(raw) {
   if (!isRecord3(raw))
     return null;
@@ -13097,7 +13287,8 @@ function parseProjectConfig(parsed) {
       }
     },
     lifecycleHooks: parseLifecycleHooks(parsed.lifecycleHooks),
-    autoName: parseAutoName(parsed.auto_name)
+    autoName: parseAutoName(parsed.auto_name),
+    oneshot: parseOneshot(parsed.oneshot)
   };
 }
 function defaultConfig() {
@@ -13603,6 +13794,46 @@ function validateCustomAgentInput(input) {
 }
 
 // backend/src/services/linear-service.ts
+import { request as httpsRequest } from "https";
+function getHeader(headers, name) {
+  const lower = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lower)
+      return value;
+  }
+  return;
+}
+function hasHeader(headers, name) {
+  return getHeader(headers, name) !== undefined;
+}
+function putViaNodeHttps(url, headers, body) {
+  return new Promise((resolve3, reject) => {
+    const parsed = new URL(url);
+    const req = httpsRequest({
+      method: "PUT",
+      hostname: parsed.hostname,
+      port: parsed.port || 443,
+      path: parsed.pathname + parsed.search,
+      headers: {
+        ...headers,
+        "Content-Length": String(body.byteLength)
+      }
+    }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        resolve3({
+          status: res.statusCode ?? 0,
+          body: Buffer.concat(chunks).toString("utf8")
+        });
+      });
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    req.write(Buffer.from(body));
+    req.end();
+  });
+}
 var ASSIGNED_ISSUES_QUERY = `
   query AssignedIssues {
     viewer {
@@ -13897,6 +14128,278 @@ async function fetchAssignedIssues(options) {
   }
   return result;
 }
+var ISSUE_WITH_ATTACHMENTS_QUERY = `
+  query IssueWithAttachments($id: String!) {
+    issue(id: $id) {
+      id
+      identifier
+      title
+      description
+      url
+      branchName
+      attachments {
+        nodes {
+          id
+          url
+          title
+          subtitle
+          sourceType
+          metadata
+          createdAt
+        }
+      }
+    }
+  }
+`;
+var TEAM_BY_KEY_QUERY = `
+  query TeamByKey($key: String!) {
+    teams(filter: { key: { eq: $key } }, first: 1) {
+      nodes {
+        id
+        key
+        name
+      }
+    }
+  }
+`;
+var FILE_UPLOAD_MUTATION = `
+  mutation FileUpload($contentType: String!, $filename: String!, $size: Int!) {
+    fileUpload(contentType: $contentType, filename: $filename, size: $size) {
+      success
+      uploadFile {
+        uploadUrl
+        assetUrl
+        headers {
+          key
+          value
+        }
+      }
+    }
+  }
+`;
+var ATTACHMENT_CREATE_MUTATION = `
+  mutation AttachmentCreate($issueId: String!, $title: String!, $url: String!, $subtitle: String) {
+    attachmentCreate(input: { issueId: $issueId, title: $title, url: $url, subtitle: $subtitle }) {
+      success
+      attachment {
+        id
+        url
+      }
+    }
+  }
+`;
+var COMMENT_CREATE_MUTATION = `
+  mutation CommentCreate($issueId: String!, $body: String!) {
+    commentCreate(input: { issueId: $issueId, body: $body }) {
+      success
+      comment {
+        id
+        url
+      }
+    }
+  }
+`;
+var WEBMUX_ATTACHMENT_TITLE_PREFIX = "webmux-state:";
+function buildWebmuxAttachmentTitle(branch) {
+  return `${WEBMUX_ATTACHMENT_TITLE_PREFIX}${branch}`;
+}
+function findWebmuxAttachment(issue, branch) {
+  const candidates = issue.attachments.filter((a) => a.title.startsWith(WEBMUX_ATTACHMENT_TITLE_PREFIX));
+  if (candidates.length === 0)
+    return null;
+  if (branch) {
+    const exact = candidates.find((a) => a.title === buildWebmuxAttachmentTitle(branch));
+    if (exact)
+      return exact;
+  }
+  return [...candidates].sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0] ?? null;
+}
+function inferPrStateFromAttachment(attachment) {
+  const meta = attachment.metadata ?? {};
+  const rawState = typeof meta.state === "string" ? meta.state.toLowerCase() : null;
+  if (rawState === "open" || rawState === "closed" || rawState === "merged")
+    return rawState;
+  const status = typeof meta.status === "string" ? meta.status.toLowerCase() : null;
+  if (status === "open" || status === "closed" || status === "merged")
+    return status;
+  return "unknown";
+}
+function inferPrBranchFromAttachment(attachment) {
+  const meta = attachment.metadata ?? {};
+  if (typeof meta.branchName === "string" && meta.branchName.trim())
+    return meta.branchName.trim();
+  if (typeof meta.headRefName === "string" && meta.headRefName.trim())
+    return meta.headRefName.trim();
+  return null;
+}
+var STATE_PRIORITY = {
+  open: 0,
+  merged: 1,
+  closed: 2,
+  unknown: 3
+};
+function findLinkedGitHubPr(issue) {
+  const githubAttachments = issue.attachments.filter((a) => {
+    if (a.sourceType === "github" || a.sourceType === "githubPR" || a.sourceType === "github_pull_request") {
+      return true;
+    }
+    return /github\.com\/.+\/pull\/\d+/i.test(a.url);
+  });
+  if (githubAttachments.length === 0)
+    return null;
+  const prs = githubAttachments.map((a) => ({
+    url: a.url,
+    branch: inferPrBranchFromAttachment(a),
+    state: inferPrStateFromAttachment(a)
+  }));
+  const indexed = prs.map((pr, idx) => ({ pr, idx, attachment: githubAttachments[idx] }));
+  indexed.sort((a, b) => {
+    const stateDiff = STATE_PRIORITY[a.pr.state] - STATE_PRIORITY[b.pr.state];
+    if (stateDiff !== 0)
+      return stateDiff;
+    return b.attachment.createdAt.localeCompare(a.attachment.createdAt);
+  });
+  return indexed[0].pr;
+}
+function buildLinearSummaryMarkdown(input) {
+  const lines = [
+    `**Webmux session \u2014 branch \`${input.branch}\`**`,
+    ""
+  ];
+  if (input.baseBranch)
+    lines.push(`- Base: \`${input.baseBranch}\``);
+  lines.push(`- Turns: ${input.turns}`);
+  if (input.prUrl)
+    lines.push(`- PR: ${input.prUrl}`);
+  lines.push(`- Transcript: see attachment \`${input.attachmentTitle}\``);
+  if (input.webmuxVersion)
+    lines.push(`- webmux: ${input.webmuxVersion}`);
+  lines.push("");
+  lines.push("_Resume on another machine with_ `webmux oneshot --linear <issue-id>`.");
+  return lines.join(`
+`);
+}
+async function fetchIssueWithAttachments(issueIdentifierOrId) {
+  const response = await postLinearGraphql(ISSUE_WITH_ATTACHMENTS_QUERY, {
+    id: issueIdentifierOrId
+  });
+  if (!response.ok) {
+    return { ok: false, error: response.error, status: 502 };
+  }
+  const error = gqlErrorMessage(response.data);
+  if (error) {
+    return { ok: false, error, status: 502 };
+  }
+  const issue = response.data.data?.issue;
+  if (!issue) {
+    return { ok: false, error: `Linear issue not found: ${issueIdentifierOrId}`, status: 404 };
+  }
+  return {
+    ok: true,
+    data: {
+      id: issue.id,
+      identifier: issue.identifier,
+      title: issue.title,
+      description: issue.description,
+      url: issue.url,
+      branchName: issue.branchName,
+      attachments: issue.attachments.nodes.map((node) => ({
+        id: node.id,
+        url: node.url,
+        title: node.title,
+        subtitle: node.subtitle,
+        sourceType: node.sourceType,
+        metadata: node.metadata,
+        createdAt: node.createdAt
+      }))
+    }
+  };
+}
+async function fetchTeamByKey(teamKey) {
+  const response = await postLinearGraphql(TEAM_BY_KEY_QUERY, { key: teamKey });
+  if (!response.ok) {
+    return { ok: false, error: response.error, status: 502 };
+  }
+  const error = gqlErrorMessage(response.data);
+  if (error) {
+    return { ok: false, error, status: 502 };
+  }
+  const team = response.data.data?.teams.nodes[0];
+  if (!team) {
+    return { ok: false, error: `Linear team not found for key: ${teamKey}`, status: 404 };
+  }
+  return { ok: true, data: team };
+}
+async function uploadAttachmentFile(input) {
+  const response = await postLinearGraphql(FILE_UPLOAD_MUTATION, {
+    contentType: input.contentType,
+    filename: input.filename,
+    size: input.body.byteLength
+  });
+  if (!response.ok)
+    return { ok: false, error: response.error };
+  const error = gqlErrorMessage(response.data);
+  if (error)
+    return { ok: false, error };
+  const upload = response.data.data?.fileUpload;
+  if (!upload?.success || !upload.uploadFile) {
+    return { ok: false, error: "Linear fileUpload did not return an upload URL" };
+  }
+  const headers = {};
+  for (const h of upload.uploadFile.headers)
+    headers[h.key] = h.value;
+  if (!hasHeader(headers, "content-type")) {
+    headers["Content-Type"] = input.contentType;
+  }
+  if (!hasHeader(headers, "x-goog-content-length-range")) {
+    const size = input.body.byteLength;
+    headers["x-goog-content-length-range"] = `${size},${size}`;
+  }
+  try {
+    const { status, body } = await putViaNodeHttps(upload.uploadFile.uploadUrl, headers, input.body);
+    if (status < 200 || status >= 300) {
+      return { ok: false, error: `Asset upload failed ${status}: ${body.slice(0, 1000)}` };
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `Asset upload error: ${msg}` };
+  }
+  return { ok: true, data: { assetUrl: upload.uploadFile.assetUrl } };
+}
+async function attachToIssue(input) {
+  const response = await postLinearGraphql(ATTACHMENT_CREATE_MUTATION, {
+    issueId: input.issueId,
+    title: input.title,
+    url: input.url,
+    subtitle: input.subtitle ?? null
+  });
+  if (!response.ok)
+    return { ok: false, error: response.error };
+  const error = gqlErrorMessage(response.data);
+  if (error)
+    return { ok: false, error };
+  const payload = response.data.data?.attachmentCreate;
+  if (!payload?.success || !payload.attachment) {
+    return { ok: false, error: "Linear attachmentCreate did not succeed" };
+  }
+  return { ok: true, data: payload.attachment };
+}
+async function createIssueComment(input) {
+  const response = await postLinearGraphql(COMMENT_CREATE_MUTATION, {
+    issueId: input.issueId,
+    body: input.body
+  });
+  if (!response.ok)
+    return { ok: false, error: response.error };
+  const error = gqlErrorMessage(response.data);
+  if (error)
+    return { ok: false, error };
+  const payload = response.data.data?.commentCreate;
+  if (!payload?.success || !payload.comment) {
+    return { ok: false, error: "Linear commentCreate did not succeed" };
+  }
+  return { ok: true, data: payload.comment };
+}
 async function createLinearIssue(input) {
   const viewerResult = await fetchViewerId();
   if (!viewerResult.ok) {
@@ -13929,6 +14432,202 @@ async function createLinearIssue(input) {
   return result;
 }
 
+// backend/src/services/conversation-export-service.ts
+var WebmuxConversationAttachmentPayloadSchema = exports_external.object({
+  webmux: exports_external.literal(1),
+  branch: exports_external.string(),
+  baseBranch: exports_external.string().nullable(),
+  agent: AgentIdSchema.nullable(),
+  createdAt: exports_external.string(),
+  conversation: exports_external.array(AgentsUiConversationMessageSchema)
+});
+var defaultSeedFromLinearDeps = {
+  fetchIssueWithAttachments,
+  downloadWebmuxAttachment: downloadWebmuxAttachmentDefault
+};
+function countConversationTurns(conversation) {
+  return new Set(conversation.messages.map((m) => m.turnId)).size;
+}
+function escapeFence(text) {
+  return text.replace(/```/g, "``\u200B`");
+}
+function buildConversationAttachmentPayload(input) {
+  const now = input.now ?? (() => new Date);
+  return {
+    webmux: 1,
+    branch: input.branch,
+    baseBranch: input.baseBranch,
+    agent: input.agent,
+    createdAt: now().toISOString(),
+    conversation: input.conversation.messages
+  };
+}
+async function resolveIssue(input, deps) {
+  if (input.target.kind === "issue") {
+    const issue = await deps.fetchIssueWithAttachments(input.target.issueId);
+    if (!issue.ok)
+      return issue;
+    return { ok: true, issueId: issue.data.id, issueUrl: issue.data.url };
+  }
+  const team = await deps.fetchTeamByKey(input.target.teamKey);
+  if (!team.ok)
+    return team;
+  const titleFromPrompt = input.target.title?.trim();
+  const title = titleFromPrompt && titleFromPrompt.length > 0 ? titleFromPrompt : `Webmux session: ${input.branch}`;
+  const description = [
+    `Created from a webmux session on branch \`${input.branch}\`.`,
+    input.prUrl ? `
+PR: ${input.prUrl}` : ""
+  ].filter(Boolean).join(`
+`);
+  const created = await deps.createLinearIssue({
+    teamId: team.data.id,
+    title,
+    description
+  });
+  if (!created.ok)
+    return { ok: false, error: created.error, status: 502 };
+  return { ok: true, issueId: created.data.id, issueUrl: created.data.url };
+}
+async function exportConversationToLinear(input, deps) {
+  const issue = await resolveIssue(input, deps);
+  if (!issue.ok)
+    return issue;
+  const payload = buildConversationAttachmentPayload(input);
+  const attachmentTitle = buildWebmuxAttachmentTitle(input.branch);
+  const bodyBytes = new TextEncoder().encode(JSON.stringify(payload, null, 2));
+  const filename = `${attachmentTitle}.json`;
+  const upload = await deps.uploadAttachmentFile({
+    filename,
+    contentType: "application/json",
+    body: bodyBytes.buffer
+  });
+  if (!upload.ok) {
+    return { ok: false, error: `Linear file upload failed: ${upload.error}`, status: 502 };
+  }
+  const attached = await deps.attachToIssue({
+    issueId: issue.issueId,
+    title: attachmentTitle,
+    url: upload.data.assetUrl,
+    subtitle: input.prUrl ?? undefined
+  });
+  if (!attached.ok) {
+    return { ok: false, error: `Linear attachmentCreate failed: ${attached.error}`, status: 502 };
+  }
+  const summary = buildLinearSummaryMarkdown({
+    branch: input.branch,
+    baseBranch: input.baseBranch ?? undefined,
+    turns: countConversationTurns(input.conversation),
+    prUrl: input.prUrl ?? undefined,
+    attachmentTitle,
+    webmuxVersion: input.webmuxVersion
+  });
+  const comment = await deps.createIssueComment({
+    issueId: issue.issueId,
+    body: summary
+  });
+  let commentUrl = null;
+  if (comment.ok) {
+    commentUrl = comment.data.url;
+  } else {
+    log.error(`[linear] comment creation failed (attachment still saved): ${comment.error}`);
+  }
+  return {
+    ok: true,
+    data: {
+      issueId: issue.issueId,
+      issueUrl: issue.issueUrl,
+      attachmentUrl: upload.data.assetUrl,
+      commentUrl
+    }
+  };
+}
+function buildIssueHeader(issue) {
+  const lines = [];
+  lines.push(`This worktree is for Linear issue **${issue.identifier}** \u2014 ${issue.url}`);
+  lines.push("");
+  lines.push(`When opening a PR, reference \`Fixes ${issue.identifier}\` in the title or body so Linear links it back automatically (Linear also auto-links PRs on the branch \`${issue.branchName}\`).`);
+  lines.push("");
+  lines.push(`## Issue: ${issue.title}`);
+  if (issue.description?.trim()) {
+    lines.push("");
+    lines.push(escapeFence(issue.description.trim()));
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function buildPriorConversationSection(payload) {
+  const lines = [];
+  lines.push(`---`);
+  lines.push("");
+  lines.push(`A previous webmux session for this issue was saved here (branch \`${payload.branch}\`${payload.baseBranch ? `, base \`${payload.baseBranch}\`` : ""}).`);
+  lines.push("");
+  lines.push("Previous conversation (chronological):");
+  lines.push("");
+  for (const message of payload.conversation) {
+    lines.push(`### ${message.role}`);
+    lines.push("");
+    lines.push(escapeFence(message.text));
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+async function buildSeedFromLinear(input, deps) {
+  const issue = await deps.fetchIssueWithAttachments(input.issueId);
+  if (!issue.ok)
+    return issue;
+  const issueHeader = buildIssueHeader(issue.data);
+  const webmuxAttachment = findWebmuxAttachment(issue.data, input.preferBranch);
+  const pr = findLinkedGitHubPr(issue.data);
+  let attachmentPayload = null;
+  if (webmuxAttachment) {
+    const payloadResult = await deps.downloadWebmuxAttachment(webmuxAttachment.url);
+    if (payloadResult.ok) {
+      attachmentPayload = payloadResult.data;
+    } else {
+      log.error(`[linear] webmux attachment download failed: ${payloadResult.error}`);
+    }
+  }
+  const source = attachmentPayload ? "webmux-attachment" : pr ? "github-integration" : "none";
+  const branch = attachmentPayload?.branch ?? pr?.branch ?? (issue.data.branchName || null);
+  const baseBranch = attachmentPayload?.baseBranch ?? null;
+  const conversationMarkdown = attachmentPayload ? `${issueHeader}${buildPriorConversationSection(attachmentPayload)}` : issueHeader;
+  return {
+    ok: true,
+    data: {
+      source,
+      branch,
+      baseBranch,
+      prUrl: pr?.url ?? null,
+      conversationMarkdown
+    }
+  };
+}
+async function downloadWebmuxAttachmentDefault(url) {
+  const apiKey = Bun.env.LINEAR_API_KEY;
+  if (!apiKey)
+    return { ok: false, error: "LINEAR_API_KEY not set" };
+  try {
+    const res = await fetch(url, {
+      headers: { Authorization: apiKey }
+    });
+    if (!res.ok) {
+      return { ok: false, error: `Asset download failed ${res.status}` };
+    }
+    const text = await res.text();
+    const parsed = WebmuxConversationAttachmentPayloadSchema.safeParse(JSON.parse(text));
+    if (!parsed.success) {
+      return { ok: false, error: "Asset is not a webmux conversation payload" };
+    }
+    return { ok: true, data: parsed.data };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: msg };
+  }
+}
+
 // backend/src/services/lifecycle-service.ts
 import { mkdir as mkdir4 } from "fs/promises";
 import { dirname as dirname4, resolve as resolve7 } from "path";
@@ -14797,23 +15496,22 @@ function buildDockerRuntimeBootstrap(runtimeEnvPath) {
   return `${buildRuntimeBootstrap(runtimeEnvPath)}; export PATH="$PATH:${DOCKER_PATH_FALLBACK}"`;
 }
 function buildBuiltInAgentInvocation(input) {
+  const promptSuffix = input.prompt ? ` -- ${quoteShell(input.prompt)}` : "";
   if (input.agent === "codex") {
     const hooksFlag = " --enable codex_hooks";
     const yoloFlag2 = input.yolo ? " --yolo" : "";
     if (input.launchMode === "resume") {
-      return `codex${hooksFlag}${yoloFlag2} resume --last`;
+      return `codex${hooksFlag}${yoloFlag2} resume --last${promptSuffix}`;
     }
-    const promptSuffix2 = input.prompt ? ` -- ${quoteShell(input.prompt)}` : "";
     if (input.systemPrompt) {
-      return `codex${hooksFlag}${yoloFlag2} -c ${quoteShell(`developer_instructions=${input.systemPrompt}`)}${promptSuffix2}`;
+      return `codex${hooksFlag}${yoloFlag2} -c ${quoteShell(`developer_instructions=${input.systemPrompt}`)}${promptSuffix}`;
     }
-    return `codex${hooksFlag}${yoloFlag2}${promptSuffix2}`;
+    return `codex${hooksFlag}${yoloFlag2}${promptSuffix}`;
   }
   const yoloFlag = input.yolo ? " --dangerously-skip-permissions" : "";
   if (input.launchMode === "resume") {
-    return `claude${yoloFlag} --continue`;
+    return `claude${yoloFlag} --continue${promptSuffix}`;
   }
-  const promptSuffix = input.prompt ? ` -- ${quoteShell(input.prompt)}` : "";
   if (input.systemPrompt) {
     return `claude${yoloFlag} --append-system-prompt ${quoteShell(input.systemPrompt)}${promptSuffix}`;
   }
@@ -14975,12 +15673,26 @@ import { randomUUID } from "crypto";
 // backend/src/adapters/git.ts
 import { readdirSync, rmSync, statSync } from "fs";
 import { resolve as resolve6, join as join5 } from "path";
+function spawnGit(args, cwd) {
+  try {
+    return {
+      ok: true,
+      result: Bun.spawnSync(["git", ...args], {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe"
+      })
+    };
+  } catch (error) {
+    return { ok: false, stderr: `spawn error (cwd=${cwd}): ${errorMessage(error)}` };
+  }
+}
 function runGit(args, cwd) {
-  const result = Bun.spawnSync(["git", ...args], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
+  const spawned = spawnGit(args, cwd);
+  if (!spawned.ok) {
+    throw new Error(`git ${args.join(" ")} failed: ${spawned.stderr}`);
+  }
+  const { result } = spawned;
   if (result.exitCode !== 0) {
     const stderr = new TextDecoder().decode(result.stderr).trim();
     throw new Error(`git ${args.join(" ")} failed: ${stderr || `exit ${result.exitCode}`}`);
@@ -14988,11 +15700,11 @@ function runGit(args, cwd) {
   return new TextDecoder().decode(result.stdout).trim();
 }
 function tryRunGit(args, cwd) {
-  const result = Bun.spawnSync(["git", ...args], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
+  const spawned = spawnGit(args, cwd);
+  if (!spawned.ok) {
+    return { ok: false, stderr: spawned.stderr };
+  }
+  const { result } = spawned;
   if (result.exitCode !== 0) {
     return {
       ok: false,
@@ -15113,6 +15825,16 @@ function listGitWorktrees(cwd) {
   const output = runGit(["worktree", "list", "--porcelain"], cwd);
   return parseGitWorktreePorcelain(output);
 }
+function worktreeEntryPathExists(entry) {
+  try {
+    return statSync(entry.path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function filterLiveWorktreeEntries(entries) {
+  return entries.filter(worktreeEntryPathExists);
+}
 function listLocalGitBranches(cwd) {
   const output = runGit(["for-each-ref", "--format=%(refname:short)", "refs/heads"], cwd);
   return output.split(`
@@ -15173,6 +15895,9 @@ class BunGitGateway {
   listWorktrees(cwd) {
     return listGitWorktrees(cwd);
   }
+  listLiveWorktrees(cwd) {
+    return filterLiveWorktreeEntries(listGitWorktrees(cwd));
+  }
   listLocalBranches(cwd) {
     return listLocalGitBranches(cwd);
   }
@@ -15326,7 +16051,9 @@ async function initializeManagedWorktree(opts) {
     agent: opts.agent,
     runtime: opts.runtime,
     startupEnvValues: { ...opts.startupEnvValues ?? {} },
-    allocatedPorts: { ...opts.allocatedPorts ?? {} }
+    allocatedPorts: { ...opts.allocatedPorts ?? {} },
+    ...opts.source ? { source: opts.source } : {},
+    ...opts.oneshot ? { oneshot: opts.oneshot } : {}
   };
   const paths = await ensureWorktreeStorageDirs(opts.gitDir);
   await writeWorktreeMeta(opts.gitDir, meta);
@@ -15379,7 +16106,9 @@ async function createManagedWorktree(opts, deps = {}) {
       controlUrl: opts.controlUrl,
       controlToken: opts.controlToken,
       now: opts.now,
-      worktreeId: opts.worktreeId
+      worktreeId: opts.worktreeId,
+      ...opts.source ? { source: opts.source } : {},
+      ...opts.oneshot ? { oneshot: opts.oneshot } : {}
     });
     if (deps.tmux) {
       sessionLayoutPlan = sessionLayoutPlan ?? opts.sessionLayoutPlanBuilder?.(initialized);
@@ -15528,10 +16257,15 @@ class LifecycleService {
       agent: agent.id
     });
   }
-  async openWorktree(branch) {
+  async openWorktree(branch, options = {}) {
     try {
       const resolved = await this.resolveExistingWorktree(branch);
-      const initialized = resolved.meta ? await this.refreshManagedArtifacts(resolved) : await this.initializeUnmanagedWorktree(resolved);
+      let initialized = resolved.meta ? await this.refreshManagedArtifacts(resolved) : await this.initializeUnmanagedWorktree(resolved);
+      if (options.oneshot) {
+        const nextMeta = { ...initialized.meta, oneshot: options.oneshot };
+        await writeWorktreeMeta(initialized.paths.gitDir, nextMeta);
+        initialized = { ...initialized, meta: nextMeta };
+      }
       const { profileName, profile } = this.resolveProfile(initialized.meta.profile);
       const agent = this.resolveAgentDefinition(initialized.meta.agent);
       const launchMode = resolved.meta && agent.capabilities.resume ? "resume" : "fresh";
@@ -15546,7 +16280,8 @@ class LifecycleService {
         agent,
         initialized,
         worktreePath: resolved.entry.path,
-        launchMode
+        launchMode,
+        followUpPrompt: options.prompt
       });
       await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
       return {
@@ -15557,6 +16292,20 @@ class LifecycleService {
       throw this.wrapOperationError(error);
     }
   }
+  async disarmOneshot(branch) {
+    let resolved;
+    try {
+      resolved = await this.resolveExistingWorktree(branch);
+    } catch {
+      return false;
+    }
+    if (!resolved.meta?.oneshot)
+      return false;
+    const nextMeta = { ...resolved.meta };
+    delete nextMeta.oneshot;
+    await writeWorktreeMeta(resolved.gitDir, nextMeta);
+    return true;
+  }
   async closeWorktree(branch) {
     try {
       await this.resolveExistingWorktree(branch);
@@ -15736,7 +16485,7 @@ class LifecycleService {
   }
   listProjectWorktrees() {
     const projectRoot2 = resolve7(this.deps.projectRoot);
-    return this.deps.git.listWorktrees(projectRoot2).filter((entry) => !entry.bare && resolve7(entry.path) !== projectRoot2);
+    return this.deps.git.listLiveWorktrees(projectRoot2).filter((entry) => !entry.bare && resolve7(entry.path) !== projectRoot2);
   }
   async readManagedMetas() {
     const metas = await Promise.all(this.listProjectWorktrees().map(async (entry) => {
@@ -15843,8 +16592,10 @@ class LifecycleService {
         agent: input.agent,
         initialized: input.initialized,
         worktreePath: input.worktreePath,
-        prompt: input.prompt,
+        creationPrompt: input.creationPrompt,
+        followUpPrompt: input.followUpPrompt,
         launchMode: input.launchMode,
+        source: input.source,
         containerName
       }));
       return;
@@ -15856,12 +16607,19 @@ class LifecycleService {
       agent: input.agent,
       initialized: input.initialized,
       worktreePath: input.worktreePath,
-      prompt: input.prompt,
-      launchMode: input.launchMode
+      creationPrompt: input.creationPrompt,
+      followUpPrompt: input.followUpPrompt,
+      launchMode: input.launchMode,
+      source: input.source
     }));
   }
   buildSessionLayout(input) {
-    const systemPrompt = input.launchMode === "fresh" && input.profile.systemPrompt ? expandTemplate(input.profile.systemPrompt, input.initialized.runtimeEnv) : undefined;
+    const baseSystemPrompt = input.launchMode === "fresh" && input.profile.systemPrompt ? expandTemplate(input.profile.systemPrompt, input.initialized.runtimeEnv) : undefined;
+    const oneshotPrompt = input.launchMode === "fresh" && input.source === "oneshot" ? this.deps.config.oneshot.systemPrompt : undefined;
+    const systemPrompt = baseSystemPrompt && oneshotPrompt ? `${baseSystemPrompt}
+
+${oneshotPrompt}` : oneshotPrompt ?? baseSystemPrompt;
+    const prompt = input.launchMode === "resume" ? input.followUpPrompt : input.creationPrompt;
     const containerName = input.containerName;
     return planSessionLayout(this.deps.projectRoot, input.branch, input.profile.panes, {
       repoRoot: this.deps.projectRoot,
@@ -15876,7 +16634,7 @@ class LifecycleService {
           profileName: input.profileName,
           yolo: input.profile.yolo === true,
           systemPrompt,
-          prompt: input.launchMode === "fresh" ? input.prompt : undefined,
+          prompt,
           launchMode: input.launchMode
         }),
         shell: buildDockerShellCommand(containerName, input.worktreePath, input.initialized.paths.runtimeEnvPath)
@@ -15890,7 +16648,7 @@ class LifecycleService {
           profileName: input.profileName,
           yolo: input.profile.yolo === true,
           systemPrompt,
-          prompt: input.launchMode === "fresh" ? input.prompt : undefined,
+          prompt,
           launchMode: input.launchMode
         }),
         shell: buildManagedShellCommand(input.initialized.paths.runtimeEnvPath)
@@ -16014,12 +16772,14 @@ class LifecycleService {
     const { profileName, profile } = this.resolveProfile(input.profile);
     const agent = this.resolveAgentDefinition(input.agent);
     const worktreePath = this.resolveWorktreePath(input.branch);
+    const source = input.source ?? "ui";
     const createProgressBase = {
       branch: input.branch,
       ...baseBranch ? { baseBranch } : {},
       path: worktreePath,
       profile: profileName,
-      agent: input.agent
+      agent: input.agent,
+      source
     };
     const deleteBranchOnRollback = input.mode === "new" || branchAvailability.deleteBranchOnRollback;
     let initialized = null;
@@ -16044,7 +16804,9 @@ class LifecycleService {
         runtimeEnvExtras: { WEBMUX_WORKTREE_PATH: worktreePath },
         controlUrl: this.controlUrl(profile.runtime),
         controlToken: await this.deps.getControlToken(),
-        deleteBranchOnRollback
+        deleteBranchOnRollback,
+        source,
+        ...input.oneshot ? { oneshot: input.oneshot } : {}
       }, {
         git: this.deps.git
       });
@@ -16082,8 +16844,9 @@ class LifecycleService {
         agent,
         initialized,
         worktreePath,
-        prompt: input.prompt,
-        launchMode: "fresh"
+        creationPrompt: input.prompt,
+        launchMode: "fresh",
+        source
       });
       await this.reportCreateProgress({
         ...createProgressBase,
@@ -16569,17 +17332,27 @@ function startPrMonitor(getWorktreeGitDirs, linkedRepos, projectDir, intervalMs
 var LINEAR_AUTO_CREATE_POLL_INTERVAL_MS = 60000;
 var processedIssueIds = new Set;
 var AUTO_CREATE_LABEL = "webmux";
-function filterAutoCreateIssues(issues, existingBranches) {
+var AUTO_ONESHOT_LABEL = "webmux_oneshot";
+function hasLabel(issue, name) {
+  return issue.labels.some((l) => l.name.toLowerCase() === name);
+}
+function filterTriggerableIssues(issues, existingBranches, matchesLabelRule) {
   return issues.filter((issue) => {
     if (issue.state.name !== "Todo")
       return false;
-    if (!issue.labels.some((l) => l.name.toLowerCase() === AUTO_CREATE_LABEL))
+    if (!matchesLabelRule(issue))
       return false;
     if (processedIssueIds.has(issue.id))
       return false;
     return !existingBranches.some((branch) => branchMatchesIssue(branch, issue.branchName));
   });
 }
+function filterAutoCreateIssues(issues, existingBranches) {
+  return filterTriggerableIssues(issues, existingBranches, (issue) => hasLabel(issue, AUTO_CREATE_LABEL) && !hasLabel(issue, AUTO_ONESHOT_LABEL));
+}
+function filterAutoOneshotIssues(issues, existingBranches) {
+  return filterTriggerableIssues(issues, existingBranches, (issue) => hasLabel(issue, AUTO_ONESHOT_LABEL));
+}
 async function runLinearAutoCreateOnce(deps) {
   const fetchIssues = deps.fetchIssues ?? fetchAssignedIssues;
   const result = await fetchIssues({ skipCache: true });
@@ -16587,29 +17360,53 @@ async function runLinearAutoCreateOnce(deps) {
     log.error(`[linear-auto-create] failed to fetch issues: ${result.error}`);
     return;
   }
+  const eligibleIssueIds = new Set(result.data.filter((issue) => issue.state.name === "Todo" && (hasLabel(issue, AUTO_CREATE_LABEL) || hasLabel(issue, AUTO_ONESHOT_LABEL))).map((issue) => issue.id));
+  for (const id of processedIssueIds) {
+    if (!eligibleIssueIds.has(id))
+      processedIssueIds.delete(id);
+  }
   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) {
+  const oneshotIssues = deps.runOneshotForIssue ? filterAutoOneshotIssues(result.data, existingBranches) : [];
+  const createIssues = filterAutoCreateIssues(result.data, existingBranches);
+  if (oneshotIssues.length === 0 && createIssues.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}
+  if (oneshotIssues.length > 0) {
+    log.info(`[linear-auto-create] found ${oneshotIssues.length} new issue(s) with "${AUTO_ONESHOT_LABEL}" label`);
+    for (const issue of oneshotIssues) {
+      try {
+        log.info(`[linear-auto-create] launching oneshot for ${issue.identifier}: ${issue.title}`);
+        await deps.runOneshotForIssue(issue.identifier);
+        processedIssueIds.add(issue.id);
+        log.info(`[linear-auto-create] launched oneshot for ${issue.identifier}`);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log.error(`[linear-auto-create] failed to launch oneshot for ${issue.identifier}: ${msg}`);
+        processedIssueIds.add(issue.id);
+      }
+    }
+  }
+  if (createIssues.length > 0) {
+    log.info(`[linear-auto-create] found ${createIssues.length} new issue(s) with "${AUTO_CREATE_LABEL}" label`);
+    for (const issue of createIssues) {
+      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}`);
+        });
+        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}`);
+        processedIssueIds.add(issue.id);
+      }
     }
   }
 }
@@ -16621,9 +17418,93 @@ function resetProcessedIssues() {
   processedIssueIds.clear();
 }
 
+// backend/src/services/oneshot-watcher-service.ts
+var POLL_INTERVAL_MS = 3000;
+var IDLE_GRACE_MS = 15000;
+var states = new Map;
+function getState(branch) {
+  let state = states.get(branch);
+  if (!state) {
+    state = { idleSinceMs: null, inFlight: false };
+    states.set(branch, state);
+  }
+  return state;
+}
+async function processWorktree(branch, path, agentLifecycle, hasPr, deps) {
+  const readMeta = deps.readWorktreeMeta ?? readWorktreeMeta;
+  const idleGrace = deps.idleGraceMs ?? IDLE_GRACE_MS;
+  const now = deps.now ?? (() => Date.now());
+  const meta = await readMeta(path);
+  if (!meta?.oneshot) {
+    states.delete(branch);
+    return;
+  }
+  const state = getState(branch);
+  if (state.inFlight)
+    return;
+  const isTerminal = agentLifecycle === "stopped" || agentLifecycle === "error";
+  const needsGrace = agentLifecycle === "idle" || agentLifecycle === "closed";
+  if (!isTerminal && !needsGrace) {
+    state.idleSinceMs = null;
+    return;
+  }
+  if (state.idleSinceMs === null)
+    state.idleSinceMs = now();
+  const stable = isTerminal || now() - state.idleSinceMs >= idleGrace;
+  if (!stable)
+    return;
+  state.inFlight = true;
+  try {
+    const reason = isTerminal ? `agent ${agentLifecycle}` : agentLifecycle === "closed" ? "agent closed without resuming" : hasPr ? "agent idle after opening PR" : "agent idle without opening a PR";
+    log.info(`[oneshot-watcher] ${branch}: ${reason} \u2014 firing end-of-run actions`);
+    if (meta.oneshot.postToLinearOnDone) {
+      try {
+        await deps.postToLinear(branch, meta.oneshot.postToLinearOnDone);
+        log.info(`[oneshot-watcher] ${branch}: posted conversation to Linear`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        log.error(`[oneshot-watcher] ${branch}: post-to-Linear failed \u2014 ${msg}`);
+      }
+    }
+    if (meta.oneshot.autoCloseOnDone) {
+      const fresh = await readMeta(path);
+      if (!fresh?.oneshot) {
+        log.info(`[oneshot-watcher] ${branch}: disarmed during post-to-Linear \u2014 skipping close`);
+        return;
+      }
+      try {
+        await deps.lifecycleService.closeWorktree(branch);
+        log.info(`[oneshot-watcher] ${branch}: closed session`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        log.error(`[oneshot-watcher] ${branch}: close failed \u2014 ${msg}`);
+      }
+    }
+    await deps.lifecycleService.disarmOneshot(branch);
+    const runtimeState = deps.projectRuntime.getWorktreeByBranch(branch);
+    if (runtimeState)
+      deps.projectRuntime.setOneshot(runtimeState.worktreeId, null);
+  } finally {
+    states.delete(branch);
+  }
+}
+async function runOneshotWatch(deps) {
+  const worktrees = deps.projectRuntime.listWorktrees();
+  for (const wt of worktrees) {
+    if (wt.source !== "oneshot")
+      continue;
+    const hasPr = wt.prs.length > 0;
+    await processWorktree(wt.branch, wt.path, wt.agent.lifecycle, hasPr, deps);
+  }
+}
+function startOneshotWatcher(deps) {
+  log.info("[oneshot-watcher] monitor started");
+  return startSerializedInterval(() => runOneshotWatch(deps), deps.pollIntervalMs ?? POLL_INTERVAL_MS);
+}
+
 // backend/src/services/auto-remove-service.ts
 async function runAutoRemove(deps) {
-  const worktrees = deps.git.listWorktrees(deps.projectRoot).filter((e) => !e.bare && e.branch !== null && e.path !== deps.projectRoot);
+  const worktrees = deps.git.listLiveWorktrees(deps.projectRoot).filter((e) => !e.bare && e.branch !== null && e.path !== deps.projectRoot);
   for (const entry of worktrees) {
     const branch = entry.branch;
     if (deps.isRemoving(branch))
@@ -16833,7 +17714,9 @@ function mapWorktreeSnapshot(state, now, creating, isArchived, findLinearIssue,
     services: state.services.map((service) => ({ ...service })),
     prs: state.prs.map((pr) => clonePrEntry(pr)),
     linearIssue: findLinearIssue ? findLinearIssue(state.branch) : null,
-    creation: mapCreationSnapshot(creating)
+    creation: mapCreationSnapshot(creating),
+    source: state.source,
+    oneshot: state.oneshot
   };
 }
 function mapCreatingWorktreeSnapshot(creating, isArchived, findLinearIssue, findAgentLabel) {
@@ -16856,7 +17739,9 @@ function mapCreatingWorktreeSnapshot(creating, isArchived, findLinearIssue, find
     services: [],
     prs: [],
     linearIssue: findLinearIssue ? findLinearIssue(creating.branch) : null,
-    creation: mapCreationSnapshot(creating)
+    creation: mapCreationSnapshot(creating),
+    source: creating.source,
+    oneshot: null
   };
 }
 function buildWorktreeSnapshots(input) {
@@ -17014,13 +17899,18 @@ class ClaudeConversationService {
   }
   async resolveSession(meta, cwd) {
     const savedSessionId = isClaudeConversationMeta(meta.conversation) ? meta.conversation.sessionId : null;
+    const discovered = (await this.deps.claude.listSessions(cwd))[0] ?? null;
+    if (discovered && discovered.sessionId !== savedSessionId) {
+      const session = await this.deps.claude.readSession(discovered.sessionId, cwd);
+      if (session)
+        return session;
+    }
     if (savedSessionId) {
       const savedSession = await this.deps.claude.readSession(savedSessionId, cwd);
       if (savedSession)
         return savedSession;
       log.warn(`[agents] saved Claude session missing, rediscovering cwd=${cwd} sessionId=${savedSessionId}`);
     }
-    const discovered = (await this.deps.claude.listSessions(cwd))[0] ?? null;
     if (!discovered)
       return null;
     return await this.deps.claude.readSession(discovered.sessionId, cwd);
@@ -17534,7 +18424,7 @@ async function removeContainer(branch) {
 }
 
 // backend/src/adapters/hooks.ts
-import { join as join7 } from "path";
+import { join as join6 } from "path";
 function buildErrorMessage(name, exitCode, stdout, stderr) {
   const output = stderr.trim() || stdout.trim();
   if (output) {
@@ -17559,7 +18449,7 @@ class BunLifecycleHookRunner {
     return this.direnvAvailable;
   }
   async buildCommand(cwd, command) {
-    if (this.checkDirenv() && await Bun.file(join7(cwd, ".envrc")).exists()) {
+    if (this.checkDirenv() && await Bun.file(join6(cwd, ".envrc")).exists()) {
       Bun.spawnSync(["direnv", "allow"], { cwd, stdout: "pipe", stderr: "pipe" });
       return ["direnv", "exec", cwd, "bash", "-c", command];
     }
@@ -17979,6 +18869,8 @@ function makeDefaultState(input) {
     path: input.path,
     profile: input.profile ?? null,
     agentName: input.agentName ?? null,
+    source: input.source ?? "ui",
+    oneshot: input.oneshot ?? null,
     git: {
       exists: true,
       branch: input.branch,
@@ -18028,6 +18920,10 @@ class ProjectRuntime {
       existing.agentName = input.agentName ?? existing.agentName;
       if (input.runtime)
         existing.agent.runtime = input.runtime;
+      if (input.source !== undefined)
+        existing.source = input.source;
+      if (input.oneshot !== undefined)
+        existing.oneshot = input.oneshot;
       existing.git.exists = true;
       existing.git.branch = input.branch;
       existing.session.windowName = buildWorktreeWindowName(input.branch);
@@ -18038,6 +18934,11 @@ class ProjectRuntime {
     this.worktreeIdsByBranch.set(input.branch, input.worktreeId);
     return created;
   }
+  setOneshot(worktreeId, oneshot) {
+    const state = this.requireWorktree(worktreeId);
+    state.oneshot = oneshot;
+    return state;
+  }
   removeWorktree(worktreeId) {
     const state = this.worktrees.get(worktreeId);
     if (!state)
@@ -18205,7 +19106,7 @@ class ReconciliationService {
     return await this.inFlight;
   }
   async runReconcile(normalizedRepoRoot) {
-    const worktrees = this.deps.git.listWorktrees(normalizedRepoRoot);
+    const worktrees = this.deps.git.listLiveWorktrees(normalizedRepoRoot);
     const sessionName = buildProjectSessionName(normalizedRepoRoot);
     let windows = [];
     try {
@@ -18231,6 +19132,8 @@ class ReconciliationService {
         profile: meta?.profile ?? null,
         agentName: meta?.agent ?? null,
         runtime: meta?.runtime ?? "host",
+        source: meta?.source ?? "ui",
+        oneshot: meta?.oneshot ?? null,
         git: {
           dirty: gitStatus.dirty,
           aheadCount: gitStatus.aheadCount,
@@ -18263,7 +19166,9 @@ class ReconciliationService {
         path: state.path,
         profile: state.profile,
         agentName: state.agentName,
-        runtime: state.runtime
+        runtime: state.runtime,
+        source: state.source,
+        oneshot: state.oneshot
       });
       this.deps.runtime.setGitState(state.worktreeId, {
         exists: true,
@@ -18298,7 +19203,8 @@ class WorktreeCreationTracker {
       path: progress.path,
       profile: progress.profile,
       agentName: progress.agent,
-      phase: progress.phase
+      phase: progress.phase,
+      source: progress.source
     };
     this.worktrees.set(progress.branch, next);
   }
@@ -18408,15 +19314,60 @@ var lifecycleService = runtime.lifecycleService;
 var linearAutoCreateEnabled = config.integrations.linear.autoCreateWorktrees;
 var stopLinearAutoCreate = null;
 var autoRemoveOnMergeEnabled = config.integrations.github.autoRemoveOnMerge;
+async function runOneshotForIssue(issueId) {
+  const seed = await buildSeedFromLinear({ issueId }, defaultSeedFromLinearDeps);
+  if (!seed.ok) {
+    throw new Error(`Linear seed failed for ${issueId}: ${seed.error}`);
+  }
+  const branch = seed.data.branch;
+  if (!branch) {
+    throw new Error(`Linear seed for ${issueId} did not resolve to a branch`);
+  }
+  const mode = seed.data.source !== "none" ? "existing" : "new";
+  const prompt = seed.data.conversationMarkdown?.trim() ?? "";
+  await lifecycleService.createWorktree({
+    mode,
+    branch,
+    ...prompt ? { prompt } : {},
+    source: "oneshot",
+    oneshot: {
+      autoCloseOnDone: true,
+      postToLinearOnDone: { kind: "issue", issueId }
+    }
+  });
+}
 function startLinearAutoCreate() {
   if (stopLinearAutoCreate)
     return;
   stopLinearAutoCreate = startLinearAutoCreateMonitor({
     lifecycleService,
     git,
-    projectRoot: PROJECT_DIR
+    projectRoot: PROJECT_DIR,
+    runOneshotForIssue
   });
 }
+function normalizeOneshotConfig(input) {
+  if (!input)
+    return;
+  return {
+    autoCloseOnDone: input.autoCloseOnDone ?? true,
+    ...input.postToLinearOnDone ? { postToLinearOnDone: input.postToLinearOnDone } : {}
+  };
+}
+async function disarmOneshotIfArmed(branch, reason) {
+  try {
+    const disarmed = await lifecycleService.disarmOneshot(branch);
+    if (!disarmed)
+      return;
+    log.info(`[oneshot-watcher] ${branch}: disarmed by ${reason}`);
+    const state = projectRuntime.getWorktreeByBranch(branch);
+    if (state)
+      projectRuntime.setOneshot(state.worktreeId, null);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    log.warn(`[oneshot-watcher] disarm failed for ${branch} (${reason}): ${msg}`);
+  }
+}
 function stopLinearAutoCreateMonitor() {
   if (stopLinearAutoCreate) {
     stopLinearAutoCreate();
@@ -18610,7 +19561,7 @@ async function hasValidControlToken(req) {
 async function getWorktreeGitDirs() {
   const gitDirs = new Map;
   const projectRoot2 = resolve9(PROJECT_DIR);
-  for (const entry of git.listWorktrees(projectRoot2)) {
+  for (const entry of git.listLiveWorktrees(projectRoot2)) {
     if (entry.bare || resolve9(entry.path) === projectRoot2 || !entry.branch)
       continue;
     gitDirs.set(entry.branch, git.resolveWorktreeGitDir(entry.path));
@@ -18726,6 +19677,7 @@ async function apiGetAgentsWorktreeHistory(branch) {
 }
 async function apiSendAgentsWorktreeMessage(branch, req) {
   touchDashboardActivity();
+  await disarmOneshotIfArmed(branch, "agents-send-message");
   const parsed = await parseJsonBody(req, AgentsSendMessageRequestSchema);
   if (!parsed.ok)
     return parsed.response;
@@ -18758,6 +19710,7 @@ async function apiSendAgentsWorktreeMessage(branch, req) {
 }
 async function apiInterruptAgentsWorktree(branch) {
   touchDashboardActivity();
+  await disarmOneshotIfArmed(branch, "agents-interrupt");
   const resolved = await resolveAgentsWorktree(branch);
   if (!resolved.ok)
     return resolved.response;
@@ -18943,6 +19896,37 @@ async function apiCreateWorktree(req) {
     return errorResponse("Prompt is required when creating a Linear ticket", 400);
   }
   let resolvedBranch = branch;
+  let resolvedPrompt = prompt;
+  let resolvedMode = mode;
+  if (body.fromLinear) {
+    if (createLinearTicket) {
+      return errorResponse("fromLinear cannot be combined with createLinearTicket", 400);
+    }
+    let conversationContext = body.fromLinear.conversationContext?.trim() ?? "";
+    let seedBranch = null;
+    if (!conversationContext || !resolvedBranch) {
+      const seedResult = await buildSeedFromLinear({ issueId: body.fromLinear.issueId }, defaultSeedFromLinearDeps);
+      if (!seedResult.ok) {
+        return errorResponse(`Linear seed lookup failed: ${seedResult.error}`, seedResult.status);
+      }
+      if (!conversationContext && seedResult.data.conversationMarkdown) {
+        conversationContext = seedResult.data.conversationMarkdown;
+      }
+      seedBranch = seedResult.data.branch;
+      if (!resolvedBranch && seedBranch) {
+        resolvedBranch = seedBranch;
+        if (seedResult.data.source !== "none")
+          resolvedMode = "existing";
+      }
+    }
+    if (conversationContext) {
+      resolvedPrompt = resolvedPrompt ? `${conversationContext}
+
+---
+
+${resolvedPrompt}` : conversationContext;
+    }
+  }
   if (createLinearTicket) {
     const title = deriveLinearIssueTitle(linearTitle, prompt);
     if (!title) {
@@ -18954,7 +19938,7 @@ async function apiCreateWorktree(req) {
     }
     const linearResult = await createLinearIssue({
       title,
-      description: prompt ?? "",
+      description: resolvedPrompt ?? "",
       teamId
     });
     if (!linearResult.ok) {
@@ -18972,15 +19956,18 @@ async function apiCreateWorktree(req) {
       return errorResponse("Base branch must differ from branch name", 400);
     }
   }
-  log.info(`[worktree:add] mode=${mode ?? "new"}${resolvedBranch ? ` branch=${resolvedBranch}` : ""}${baseBranch ? ` base=${baseBranch}` : ""}${profile ? ` profile=${profile}` : ""} agents=${selectedAgents.join(",")}${createLinearTicket ? " linearTicket=true" : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
+  const oneshot = normalizeOneshotConfig(body.oneshot);
+  log.info(`[worktree:add] mode=${mode ?? "new"}${resolvedBranch ? ` branch=${resolvedBranch}` : ""}${baseBranch ? ` base=${baseBranch}` : ""}${profile ? ` profile=${profile}` : ""} agents=${selectedAgents.join(",")}${createLinearTicket ? " linearTicket=true" : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}${oneshot ? " oneshot=armed" : ""}`);
   const result = await lifecycleService.createWorktrees({
-    mode,
+    mode: resolvedMode,
     branch: resolvedBranch,
     baseBranch,
-    prompt,
+    prompt: resolvedPrompt,
     profile,
     ...agents && agents.length > 0 ? { agents } : { agent },
-    envOverrides
+    envOverrides,
+    ...body.source ? { source: body.source } : {},
+    ...oneshot ? { oneshot } : {}
   });
   log.debug(`[worktree:add] done branches=${result.branches.join(",")}`);
   return jsonResponse({
@@ -18996,16 +19983,22 @@ async function apiDeleteWorktree(name) {
     return jsonResponse({ ok: true });
   });
 }
-async function apiOpenWorktree(name) {
+async function apiOpenWorktree(name, req) {
   ensureBranchNotBusy(name);
-  log.info(`[worktree:open] name=${name}`);
-  const result = await lifecycleService.openWorktree(name);
+  const parsed = await parseJsonBody(req, OpenWorktreeRequestSchema);
+  if (!parsed.ok)
+    return parsed.response;
+  const prompt = parsed.data.prompt?.trim() ? parsed.data.prompt.trim() : undefined;
+  const oneshot = normalizeOneshotConfig(parsed.data.oneshot);
+  log.info(`[worktree:open] name=${name}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}${oneshot ? " oneshot=armed" : ""}`);
+  const result = await lifecycleService.openWorktree(name, { prompt, ...oneshot ? { oneshot } : {} });
   log.debug(`[worktree:open] done name=${name} worktreeId=${result.worktreeId}`);
   return jsonResponse({ ok: true });
 }
 async function apiCloseWorktree(name) {
   ensureBranchNotBusy(name);
   log.info(`[worktree:close] name=${name}`);
+  await disarmOneshotIfArmed(name, "close-worktree");
   await lifecycleService.closeWorktree(name);
   log.debug(`[worktree:close] done name=${name}`);
   return jsonResponse({ ok: true });
@@ -19017,6 +20010,7 @@ async function apiSetWorktreeArchived(name, req) {
     return parsed.response;
   const body = parsed.data;
   log.info(`[worktree:archive] name=${name} archived=${body.archived}`);
+  await disarmOneshotIfArmed(name, "archive-worktree");
   await lifecycleService.setWorktreeArchived(name, body.archived);
   log.debug(`[worktree:archive] done name=${name} archived=${body.archived}`);
   return jsonResponse({ ok: true, archived: body.archived });
@@ -19041,6 +20035,7 @@ async function apiSendPrompt(name, req) {
   const text = body.text;
   const preamble = body.preamble;
   log.info(`[worktree:send] name=${name} text="${text.slice(0, 80)}"`);
+  await disarmOneshotIfArmed(name, "send-prompt");
   const terminalWorktree = await resolveTerminalWorktree(name);
   const submitDelayMs = resolveWorktreeTerminalSubmitDelayMs(terminalWorktree.agentName);
   const result = await sendPrompt(terminalWorktree.worktreeId, terminalWorktree.attachTarget, text, 0, preamble, submitDelayMs);
@@ -19051,6 +20046,7 @@ async function apiSendPrompt(name, req) {
 async function apiMergeWorktree(name) {
   ensureBranchNotBusy(name);
   log.info(`[worktree:merge] name=${name}`);
+  await disarmOneshotIfArmed(name, "merge-worktree");
   await lifecycleService.mergeWorktree(name);
   log.debug(`[worktree:merge] done name=${name}`);
   return jsonResponse({ ok: true });
@@ -19174,6 +20170,74 @@ async function apiPullMain(req) {
   log.info(`[pull-main] ${repo || "main"} ${force ? "force " : ""}pull: ${result.status}`);
   return jsonResponse(result);
 }
+async function postWorktreeConversationToLinear(branch, target) {
+  if (!config.integrations.linear.enabled) {
+    return { ok: false, error: "Linear integration is disabled", status: 400 };
+  }
+  const apiKey = Bun.env.LINEAR_API_KEY;
+  if (!apiKey?.trim()) {
+    return { ok: false, error: "LINEAR_API_KEY not set", status: 503 };
+  }
+  await reconciliationService.reconcile(PROJECT_DIR);
+  const state = projectRuntime.getWorktreeByBranch(branch);
+  if (!state)
+    return { ok: false, error: `Worktree not found: ${branch}`, status: 404 };
+  const resolved = await resolveAgentsWorktree(branch);
+  if (!resolved.ok) {
+    return { ok: false, error: `Worktree not found: ${branch}`, status: 404 };
+  }
+  const chatSupport = resolveWorktreeAgentChatSupport(resolved.worktree, "chat");
+  if (!chatSupport.ok)
+    return { ok: false, error: chatSupport.error, status: chatSupport.status };
+  const conversationResult = chatSupport.data.provider === "claude" ? await claudeConversationService.readWorktreeConversation(resolved.worktree) : await worktreeConversationService.readWorktreeConversation(resolved.worktree);
+  if (!conversationResult.ok)
+    return { ok: false, error: conversationResult.error, status: conversationResult.status };
+  const prUrl = (state.prs ?? []).find((pr) => pr.state === "open" || pr.state === "merged")?.url ?? null;
+  const exportInput = {
+    target,
+    branch,
+    baseBranch: state.baseBranch ?? null,
+    agent: resolved.worktree.agentName ?? null,
+    prUrl,
+    conversation: conversationResult.data.conversation,
+    webmuxVersion: package_default.version
+  };
+  const deps = {
+    fetchIssueWithAttachments,
+    fetchTeamByKey,
+    createLinearIssue,
+    uploadAttachmentFile,
+    attachToIssue,
+    createIssueComment
+  };
+  const result = await exportConversationToLinear(exportInput, deps);
+  if (!result.ok)
+    return { ok: false, error: result.error, status: result.status };
+  return { ok: true, data: result.data };
+}
+async function apiPostWorktreeToLinear(name, req) {
+  const parsed = await parseJsonBody(req, PostWorktreeToLinearRequestSchema);
+  if (!parsed.ok)
+    return parsed.response;
+  const outcome = await postWorktreeConversationToLinear(name, parsed.data.target);
+  if (!outcome.ok)
+    return errorResponse(outcome.error, outcome.status);
+  return jsonResponse({
+    ok: true,
+    issueId: outcome.data.issueId,
+    issueUrl: outcome.data.issueUrl,
+    commentUrl: outcome.data.commentUrl,
+    attachmentUrl: outcome.data.attachmentUrl
+  });
+}
+async function apiSyncWorktreePrs(name) {
+  await syncPrStatus(getWorktreeGitDirs, config.integrations.github.linkedRepos, PROJECT_DIR);
+  const snapshot = await readProjectSnapshot();
+  const worktree = snapshot.worktrees.find((w) => w.branch === name);
+  if (!worktree)
+    return errorResponse(`Worktree not found: ${name}`, 404);
+  return jsonResponse(worktree);
+}
 async function apiGetLinearIssues() {
   const apiKey = Bun.env.LINEAR_API_KEY;
   const fetchResult = config.integrations.linear.enabled && apiKey?.trim() ? await fetchAssignedIssues() : undefined;
@@ -19231,6 +20295,7 @@ async function apiUploadFiles(name, req) {
   const state = projectRuntime.getWorktreeByBranch(name);
   if (!state)
     return errorResponse(`Worktree not found: ${name}`, 404);
+  await disarmOneshotIfArmed(name, "upload-files");
   let formData;
   try {
     formData = await req.formData();
@@ -19253,7 +20318,7 @@ async function apiUploadFiles(name, req) {
       return errorResponse(`File too large: ${entry.name} (max 10MB)`, 400);
     }
     const safeName = `${Date.now()}_${sanitizeFilename(entry.name)}`;
-    const destPath = join8(uploadDir, safeName);
+    const destPath = join7(uploadDir, safeName);
     if (!resolve9(destPath).startsWith(uploadDir + "/")) {
       return errorResponse("Invalid filename", 400);
     }
@@ -19417,7 +20482,7 @@ Bun.serve({
         if (!parsed.ok)
           return parsed.response;
         const name = parsed.data;
-        return catching(`POST /api/worktrees/${name}/open`, () => apiOpenWorktree(name));
+        return catching(`POST /api/worktrees/${name}/open`, () => apiOpenWorktree(name, req));
       }
     },
     "/api/worktrees/:name/terminal-launch": {
@@ -19447,6 +20512,24 @@ Bun.serve({
         return catching(`PUT /api/worktrees/${name}/archive`, () => apiSetWorktreeArchived(name, req));
       }
     },
+    [apiPaths.postWorktreeToLinear]: {
+      POST: (req) => {
+        const parsed = parseWorktreeNameParam(req.params);
+        if (!parsed.ok)
+          return parsed.response;
+        const name = parsed.data;
+        return catching(`POST /api/worktrees/${name}/linear/post`, () => apiPostWorktreeToLinear(name, req));
+      }
+    },
+    [apiPaths.syncWorktreePrs]: {
+      POST: (req) => {
+        const parsed = parseWorktreeNameParam(req.params);
+        if (!parsed.ok)
+          return parsed.response;
+        const name = parsed.data;
+        return catching(`POST /api/worktrees/${name}/sync-prs`, () => apiSyncWorktreePrs(name));
+      }
+    },
     [apiPaths.setWorktreeLabel]: {
       PUT: (req) => {
         const parsed = parseWorktreeNameParam(req.params);
@@ -19531,7 +20614,7 @@ Bun.serve({
     const url = new URL(req.url);
     if (STATIC_DIR) {
       const rawPath = url.pathname === "/" ? "index.html" : url.pathname;
-      const filePath = join8(STATIC_DIR, rawPath);
+      const filePath = join7(STATIC_DIR, rawPath);
       const staticRoot = resolve9(STATIC_DIR);
       if (!resolve9(filePath).startsWith(staticRoot + "/")) {
         return new Response("Forbidden", { status: 403 });
@@ -19541,7 +20624,7 @@ Bun.serve({
         const headers = rawPath.startsWith("/assets/") ? { "Cache-Control": "public, max-age=31536000, immutable" } : {};
         return new Response(file, { headers });
       }
-      return new Response(Bun.file(join8(STATIC_DIR, "index.html")), {
+      return new Response(Bun.file(join7(STATIC_DIR, "index.html")), {
         headers: { "Cache-Control": "no-cache" }
       });
     }
@@ -19577,6 +20660,9 @@ Bun.serve({
           const attachId = getAttachedSessionId(data, ws);
           if (!attachId)
             return;
+          if (projectRuntime.getWorktreeByBranch(branch)?.oneshot) {
+            disarmOneshotIfArmed(branch, "terminal-ws-input");
+          }
           write(attachId, msg.data);
           break;
         }
@@ -19584,6 +20670,9 @@ Bun.serve({
           const attachId = getAttachedSessionId(data, ws);
           if (!attachId)
             return;
+          if (projectRuntime.getWorktreeByBranch(branch)?.oneshot) {
+            disarmOneshotIfArmed(branch, "terminal-ws-send-keys");
+          }
           await sendKeys(attachId, msg.hexBytes);
           break;
         }
@@ -19664,6 +20753,15 @@ startPrMonitor(getWorktreeGitDirs, config.integrations.github.linkedRepos, PROJE
 if (linearAutoCreateEnabled) {
   startLinearAutoCreate();
 }
+startOneshotWatcher({
+  projectRuntime,
+  lifecycleService,
+  postToLinear: async (branch, target) => {
+    const outcome = await postWorktreeConversationToLinear(branch, target);
+    if (!outcome.ok)
+      throw new Error(outcome.error);
+  }
+});
 if (config.workspace.autoPull.enabled) {
   startAutoPullMonitor({ git, projectRoot: PROJECT_DIR, mainBranch: config.workspace.mainBranch }, config.workspace.autoPull.intervalSeconds * 1000);
 }