webmux 0.31.2 → 0.32.0

package/bin/webmux.js

@@ -462,6 +462,7 @@ _webmux() {
     'service:Manage webmux as a system service'
     'update:Update webmux to the latest version'
     'add:Create a worktree'
+    'oneshot:Run a worktree start-to-finish, streaming logs to stdout'
     'list:List worktrees and their status'
     'open:Open an existing worktree session'
     'close:Close a worktree session'
@@ -472,6 +473,7 @@ _webmux() {
     'merge:Merge a worktree into main'
     'send:Send a prompt to a running worktree agent'
     'prune:Remove all worktrees in the current project'
+    'linear:Post a worktree conversation to a Linear issue/team'
     'completion:Generate shell completion script'
   )
 
@@ -490,6 +492,19 @@ _webmux() {
         fi
       fi
       ;;
+    linear)
+      if (( CURRENT == 3 )); then
+        local -a subs
+        subs=('post:Post a worktree conversation to a Linear issue or team')
+        _describe 'linear subcommand' subs
+      elif (( CURRENT == 4 )) && [[ "\${words[3]}" == "post" ]]; then
+        local -a branches
+        branches=(\${(f)"$(webmux --completions send 2>/dev/null)"})
+        if (( \${#branches} )); then
+          _describe 'worktree' branches
+        fi
+      fi
+      ;;
     completion)
       if (( CURRENT == 3 )); then
         local -a shells
@@ -519,7 +534,7 @@ compdef _webmux webmux`, BASH_SCRIPT = `_webmux() {
   prev="\${COMP_WORDS[COMP_CWORD-1]}"
 
   if [[ \${COMP_CWORD} -eq 1 ]]; then
-    COMPREPLY=($(compgen -W "serve init service update add list open close archive unarchive label remove merge send prune completion" -- "\${cur}"))
+    COMPREPLY=($(compgen -W "serve init service update add oneshot list open close archive unarchive label remove merge send prune linear completion" -- "\${cur}"))
     return
   fi
 
@@ -531,6 +546,15 @@ compdef _webmux webmux`, BASH_SCRIPT = `_webmux() {
         COMPREPLY=($(compgen -W "\${branches}" -- "\${cur}"))
       fi
       ;;
+    linear)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=($(compgen -W "post" -- "\${cur}"))
+      elif [[ \${COMP_CWORD} -eq 3 ]] && [[ "\${COMP_WORDS[2]}" == "post" ]]; then
+        local branches
+        branches=$(webmux --completions send 2>/dev/null)
+        COMPREPLY=($(compgen -W "\${branches}" -- "\${cur}"))
+      fi
+      ;;
     completion)
       if [[ \${COMP_CWORD} -eq 2 ]]; then
         COMPREPLY=($(compgen -W "bash zsh" -- "\${cur}"))
@@ -1837,7 +1861,29 @@ function detectProjectName(gitRoot) {
   }
   return basename2(gitRoot);
 }
-var init_shared = () => {};
+function formatServerError(error, port) {
+  if (error instanceof Error) {
+    if (error.message.startsWith("HTTP"))
+      return error.message;
+    if (error.message.includes("fetch")) {
+      return `Could not connect to webmux server on port ${port}. Is it running?`;
+    }
+    return error.message;
+  }
+  return String(error);
+}
+async function withServerConnection(port, fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    throw new Error(formatServerError(error, port));
+  }
+}
+var CommandUsageError;
+var init_shared = __esm(() => {
+  CommandUsageError = class CommandUsageError extends Error {
+  };
+});
 
 // bin/src/init-helpers.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync as rmSync2 } from "fs";
@@ -6970,7 +7016,7 @@ var init_zod = __esm(() => {
   init_external();
 });
 
-// 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 isZodType = (obj) => {
   return typeof (obj === null || obj === undefined ? undefined : obj.safeParse) === "function";
 }, isZodObjectStrict = (obj) => {
@@ -7284,7 +7330,15 @@ var init_index_esm = __esm(() => {
 });
 
 // packages/api-contract/src/schemas.ts
-var BooleanLikeSchema, ErrorResponseSchema, OkResponseSchema, EnabledResponseSchema, BuiltInAgentIdSchema, AgentIdSchema, WorktreeCreateModeSchema, AgentCapabilitiesSchema, AgentSummarySchema, AgentDetailsSchema, AgentListResponseSchema, UpsertCustomAgentRequestSchema, AgentResponseSchema, ValidateCustomAgentResponseSchema, WorktreeCreationPhaseSchema, AvailableBranchSchema, AvailableBranchesQuerySchema, NumberLikePathParamSchema, BranchListResponseSchema, CreateWorktreeRequestSchema, CreateWorktreeResponseSchema, SetWorktreeArchivedRequestSchema, SetWorktreeArchivedResponseSchema, SetWorktreeLabelRequestSchema, SetWorktreeLabelResponseSchema, ToggleEnabledRequestSchema, SendWorktreePromptRequestSchema, AgentsSendMessageRequestSchema, PullMainRequestSchema, PullMainStatusSchema, PullMainResponseSchema, ServiceStatusSchema, PrCommentSchema, CiCheckSchema, PrEntrySchema, LinearIssueLabelSchema, LinearIssueStateSchema, LinkedLinearIssueSchema, LinearIssueSchema, LinearIssueAvailabilitySchema, LinearIssuesResponseSchema, WorktreeCreationStateSchema, AppNotificationSchema, ProjectWorktreeSnapshotSchema, ProjectSnapshotSchema, WorktreeConversationProviderSchema, CodexWorktreeConversationRefSchema, ClaudeWorktreeConversationRefSchema, WorktreeConversationRefSchema, AgentsUiWorktreeSummarySchema, AgentsUiConversationMessageRoleSchema, AgentsUiConversationMessageStatusSchema, AgentsUiConversationMessageSchema, AgentsUiConversationStateSchema, AgentsUiWorktreeConversationResponseSchema, AgentsUiSendMessageResponseSchema, AgentsUiInterruptResponseSchema, AgentsUiConversationSnapshotEventSchema, AgentsUiConversationMessageDeltaEventSchema, AgentsUiConversationErrorEventSchema, AgentsUiConversationEventSchema, WorktreeListResponseSchema, UnpushedCommitSchema, WorktreeDiffResponseSchema, ServiceConfigSchema, ProfileConfigSchema, LinkedRepoInfoSchema, AppConfigSchema, CiLogsResponseSchema, WorktreeNameParamsSchema, NotificationIdParamsSchema, AgentIdParamsSchema, RunIdParamsSchema;
+function parseLinearTarget(raw) {
+  const trimmed = raw.trim();
+  if (LinearIssueIdSchema.safeParse(trimmed).success)
+    return { kind: "issue", issueId: trimmed };
+  if (LinearTeamKeySchema.safeParse(trimmed).success)
+    return { kind: "team", teamKey: trimmed };
+  return { kind: "invalid", raw: trimmed };
+}
+var BooleanLikeSchema, ErrorResponseSchema, OkResponseSchema, EnabledResponseSchema, BuiltInAgentIdSchema, AgentIdSchema, WorktreeCreateModeSchema, LinearIssueIdSchema, LinearTeamKeySchema, PostWorktreeToLinearTargetSchema, PostWorktreeToLinearRequestSchema, PostWorktreeToLinearResponseSchema, FromLinearInputSchema, OneshotConfigSchema, AgentCapabilitiesSchema, AgentSummarySchema, AgentDetailsSchema, AgentListResponseSchema, UpsertCustomAgentRequestSchema, AgentResponseSchema, ValidateCustomAgentResponseSchema, WorktreeCreationPhaseSchema, AvailableBranchSchema, AvailableBranchesQuerySchema, NumberLikePathParamSchema, BranchListResponseSchema, WorktreeSourceSchema, CreateWorktreeRequestSchema, OpenWorktreeRequestSchema, CreateWorktreeResponseSchema, SetWorktreeArchivedRequestSchema, SetWorktreeArchivedResponseSchema, SetWorktreeLabelRequestSchema, SetWorktreeLabelResponseSchema, ToggleEnabledRequestSchema, SendWorktreePromptRequestSchema, AgentsSendMessageRequestSchema, PullMainRequestSchema, PullMainStatusSchema, PullMainResponseSchema, ServiceStatusSchema, PrCommentSchema, CiCheckSchema, PrEntrySchema, LinearIssueLabelSchema, LinearIssueStateSchema, LinkedLinearIssueSchema, LinearIssueSchema, LinearIssueAvailabilitySchema, LinearIssuesResponseSchema, WorktreeCreationStateSchema, AppNotificationSchema, ProjectWorktreeSnapshotSchema, ProjectSnapshotSchema, WorktreeConversationProviderSchema, CodexWorktreeConversationRefSchema, ClaudeWorktreeConversationRefSchema, WorktreeConversationRefSchema, AgentsUiWorktreeSummarySchema, AgentsUiConversationMessageRoleSchema, AgentsUiConversationMessageStatusSchema, AgentsUiConversationMessageKindSchema, AgentsUiConversationMessageSchema, AgentsUiConversationStateSchema, AgentsUiWorktreeConversationResponseSchema, AgentsUiSendMessageResponseSchema, AgentsUiInterruptResponseSchema, AgentsUiConversationSnapshotEventSchema, AgentsUiConversationMessageDeltaEventSchema, AgentsUiConversationErrorEventSchema, AgentsUiConversationEventSchema, WorktreeListResponseSchema, UnpushedCommitSchema, WorktreeDiffResponseSchema, ServiceConfigSchema, ProfileConfigSchema, LinkedRepoInfoSchema, AppConfigSchema, CiLogsResponseSchema, WorktreeNameParamsSchema, NotificationIdParamsSchema, AgentIdParamsSchema, RunIdParamsSchema;
 var init_schemas = __esm(() => {
   init_zod();
   BooleanLikeSchema = exports_external.union([
@@ -7305,6 +7359,30 @@ var init_schemas = __esm(() => {
   BuiltInAgentIdSchema = exports_external.enum(["claude", "codex"]);
   AgentIdSchema = exports_external.string().trim().min(1);
   WorktreeCreateModeSchema = exports_external.enum(["new", "existing"]);
+  LinearIssueIdSchema = exports_external.string().regex(/^[A-Z]+-\d+$/, "Expected Linear issue id (e.g. ENG-123)");
+  LinearTeamKeySchema = exports_external.string().regex(/^[A-Z]+$/, "Expected Linear team key (e.g. ENG)");
+  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() })
+  ]);
+  PostWorktreeToLinearRequestSchema = exports_external.object({
+    target: PostWorktreeToLinearTargetSchema
+  });
+  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()
+  });
+  FromLinearInputSchema = exports_external.object({
+    issueId: LinearIssueIdSchema,
+    conversationContext: exports_external.string().optional()
+  });
+  OneshotConfigSchema = exports_external.object({
+    autoCloseOnDone: exports_external.boolean().optional(),
+    postToLinearOnDone: PostWorktreeToLinearTargetSchema.optional()
+  });
   AgentCapabilitiesSchema = exports_external.object({
     terminal: exports_external.literal(true),
     inAppChat: exports_external.boolean(),
@@ -7361,6 +7439,7 @@ var init_schemas = __esm(() => {
   BranchListResponseSchema = exports_external.object({
     branches: exports_external.array(AvailableBranchSchema)
   });
+  WorktreeSourceSchema = exports_external.enum(["ui", "oneshot"]);
   CreateWorktreeRequestSchema = exports_external.object({
     mode: WorktreeCreateModeSchema.optional(),
     branch: exports_external.string().optional(),
@@ -7371,7 +7450,14 @@ var init_schemas = __esm(() => {
     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()
+  });
+  OpenWorktreeRequestSchema = exports_external.object({
+    prompt: exports_external.string().optional(),
+    oneshot: OneshotConfigSchema.optional()
   });
   CreateWorktreeResponseSchema = exports_external.object({
     primaryBranch: exports_external.string(),
@@ -7517,7 +7603,9 @@ var init_schemas = __esm(() => {
     services: exports_external.array(ServiceStatusSchema),
     prs: exports_external.array(PrEntrySchema),
     linearIssue: LinkedLinearIssueSchema.nullable(),
-    creation: WorktreeCreationStateSchema.nullable()
+    creation: WorktreeCreationStateSchema.nullable(),
+    source: WorktreeSourceSchema,
+    oneshot: OneshotConfigSchema.nullable()
   });
   ProjectSnapshotSchema = exports_external.object({
     project: exports_external.object({
@@ -7566,13 +7654,16 @@ var init_schemas = __esm(() => {
   });
   AgentsUiConversationMessageRoleSchema = exports_external.enum(["user", "assistant"]);
   AgentsUiConversationMessageStatusSchema = exports_external.enum(["completed", "inProgress"]);
+  AgentsUiConversationMessageKindSchema = exports_external.enum(["text", "toolUse", "toolResult"]);
   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()
   });
   AgentsUiConversationStateSchema = exports_external.object({
     provider: WorktreeConversationProviderSchema,
@@ -7701,6 +7792,8 @@ var init_contract = __esm(() => {
     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",
@@ -7879,7 +7972,7 @@ var init_contract = __esm(() => {
       method: "POST",
       path: apiPaths.openWorktree,
       pathParams: WorktreeNameParamsSchema,
-      body: c.noBody(),
+      body: OpenWorktreeRequestSchema,
       responses: {
         200: OkResponseSchema,
         ...commonErrorResponses
@@ -7905,6 +7998,26 @@ var init_contract = __esm(() => {
         ...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,
@@ -7962,128 +8075,1464 @@ var init_contract = __esm(() => {
         ...commonErrorResponses
       }
     },
-    setAutoRemoveOnMerge: {
-      method: "PUT",
-      path: apiPaths.setAutoRemoveOnMerge,
-      body: ToggleEnabledRequestSchema,
-      responses: {
-        200: EnabledResponseSchema,
-        ...commonErrorResponses
-      }
+    setAutoRemoveOnMerge: {
+      method: "PUT",
+      path: apiPaths.setAutoRemoveOnMerge,
+      body: ToggleEnabledRequestSchema,
+      responses: {
+        200: EnabledResponseSchema,
+        ...commonErrorResponses
+      }
+    },
+    pullMain: {
+      method: "POST",
+      path: apiPaths.pullMain,
+      body: PullMainRequestSchema,
+      responses: {
+        200: PullMainResponseSchema,
+        ...commonErrorResponses
+      }
+    },
+    fetchCiLogs: {
+      method: "GET",
+      path: apiPaths.fetchCiLogs,
+      pathParams: RunIdParamsSchema,
+      responses: {
+        200: CiLogsResponseSchema,
+        ...commonErrorResponses
+      }
+    },
+    dismissNotification: {
+      method: "POST",
+      path: apiPaths.dismissNotification,
+      pathParams: NotificationIdParamsSchema,
+      body: c.noBody(),
+      responses: {
+        200: OkResponseSchema,
+        400: ErrorResponseSchema,
+        404: ErrorResponseSchema
+      }
+    }
+  }, {
+    strictStatusCodes: true
+  });
+});
+
+// packages/api-contract/src/client.ts
+function createApiClient(baseUrl, options = {}) {
+  return initClient(apiContract, {
+    baseUrl,
+    throwOnUnknownStatus: true,
+    baseHeaders: {},
+    ...options
+  });
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isRouteResponse(value) {
+  return isRecord2(value) && "status" in value && typeof value.status === "number" && "body" in value;
+}
+function unwrapResponse(response) {
+  if (!isRouteResponse(response)) {
+    throw new Error("Malformed API client response");
+  }
+  if (response.status < 200 || response.status >= 300) {
+    throw new Error(errorMessageFromResponse(response.body, response.status));
+  }
+  return response.body;
+}
+function errorMessageFromResponse(body, status2) {
+  if (typeof body === "string") {
+    try {
+      const parsed = JSON.parse(body);
+      return errorMessageFromResponse(parsed, status2);
+    } catch {
+      return body.trim() || `HTTP ${status2}`;
+    }
+  }
+  if (body && typeof body === "object" && "error" in body && typeof body.error === "string") {
+    return body.error;
+  }
+  return `HTTP ${status2}`;
+}
+function withEncodedPathParams(args) {
+  const [first, ...rest] = args;
+  if (!first || typeof first !== "object" || !("params" in first) || !first.params || typeof first.params !== "object") {
+    return args;
+  }
+  const encodedParams = Object.fromEntries(Object.entries(first.params).map(([key, value]) => [key, encodeURIComponent(String(value))]));
+  return [
+    {
+      ...first,
+      params: encodedParams
+    },
+    ...rest
+  ];
+}
+function wrapRouteCall(routeCall) {
+  return async (...args) => unwrapResponse(await routeCall(...withEncodedPathParams(args)));
+}
+function wrapClient(client) {
+  return Object.fromEntries(Object.entries(client).map(([key, value]) => {
+    if (typeof value === "function") {
+      return [key, wrapRouteCall((...args) => Promise.resolve(Reflect.apply(value, undefined, args)))];
+    }
+    if (isRecord2(value)) {
+      return [key, wrapClient(value)];
+    }
+    return [key, value];
+  }));
+}
+function createApi(baseUrl, options = {}) {
+  return wrapClient(createApiClient(baseUrl, options));
+}
+var init_client = __esm(() => {
+  init_index_esm();
+  init_contract();
+});
+
+// packages/api-contract/src/index.ts
+var init_src = __esm(() => {
+  init_contract();
+  init_client();
+  init_schemas();
+});
+
+// backend/src/lib/log.ts
+function ts() {
+  return new Date().toISOString().slice(11, 23);
+}
+var DEBUG, log;
+var init_log = __esm(() => {
+  DEBUG = Bun.env.WEBMUX_DEBUG === "1";
+  log = {
+    info(msg) {
+      console.log(`[${ts()}] ${msg}`);
+    },
+    debug(msg) {
+      if (DEBUG)
+        console.log(`[${ts()}] ${msg}`);
+    },
+    warn(msg) {
+      console.warn(`[${ts()}] ${msg}`);
+    },
+    error(msg, err) {
+      err !== undefined ? console.error(`[${ts()}] ${msg}`, err) : console.error(`[${ts()}] ${msg}`);
+    }
+  };
+});
+
+// backend/src/services/linear-service.ts
+function gqlErrorMessage(raw) {
+  return raw.errors && raw.errors.length > 0 ? raw.errors.map((error) => error.message).join("; ") : null;
+}
+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
+    }
+  };
+}
+async function postLinearGraphql(query, variables) {
+  const apiKey = Bun.env.LINEAR_API_KEY;
+  if (!apiKey) {
+    return { ok: false, error: "LINEAR_API_KEY not set" };
+  }
+  try {
+    const res = await fetch("https://api.linear.app/graphql", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: apiKey
+      },
+      body: JSON.stringify(variables ? { query, variables } : { query })
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      return { ok: false, error: `Linear API ${res.status}: ${text.slice(0, 200)}` };
+    }
+    return {
+      ok: true,
+      data: await res.json()
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    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;
+}
+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 status2 = typeof meta.status === "string" ? meta.status.toLowerCase() : null;
+  if (status2 === "open" || status2 === "closed" || status2 === "merged")
+    return status2;
+  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;
+}
+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;
+}
+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 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;
+}
+var VIEWER_QUERY = `
+  query Viewer {
+    viewer {
+      id
+    }
+  }
+`, TEAM_STATES_QUERY = `
+  query TeamStates($teamId: String!) {
+    team(id: $teamId) {
+      states {
+        nodes {
+          id
+          name
+          type
+        }
+      }
+    }
+  }
+`, ISSUE_CREATE_MUTATION = `
+  mutation IssueCreate($input: IssueCreateInput!) {
+    issueCreate(input: $input) {
+      success
+      issue {
+        id
+        identifier
+        title
+        url
+        branchName
+      }
+    }
+  }
+`, issueCache = null, viewerIdCache = null, inProgressStateIdCache, 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
+        }
+      }
+    }
+  }
+`, TEAM_BY_KEY_QUERY = `
+  query TeamByKey($key: String!) {
+    teams(filter: { key: { eq: $key } }, first: 1) {
+      nodes {
+        id
+        key
+        name
+      }
+    }
+  }
+`, WEBMUX_ATTACHMENT_TITLE_PREFIX = "webmux-state:", STATE_PRIORITY;
+var init_linear_service = __esm(() => {
+  init_log();
+  init_src();
+  inProgressStateIdCache = new Map;
+  STATE_PRIORITY = {
+    open: 0,
+    merged: 1,
+    closed: 2,
+    unknown: 3
+  };
+});
+
+// backend/src/services/conversation-export-service.ts
+function escapeFence(text) {
+  return text.replace(/```/g, "``\u200B`");
+}
+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, deps2) {
+  const issue = await deps2.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 deps2.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 };
+  }
+}
+var WebmuxConversationAttachmentPayloadSchema, defaultSeedFromLinearDeps;
+var init_conversation_export_service = __esm(() => {
+  init_src();
+  init_zod();
+  init_log();
+  init_linear_service();
+  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)
+  });
+  defaultSeedFromLinearDeps = {
+    fetchIssueWithAttachments,
+    downloadWebmuxAttachment: downloadWebmuxAttachmentDefault
+  };
+});
+
+// bin/src/oneshot.ts
+var exports_oneshot = {};
+__export(exports_oneshot, {
+  runOneshotCommand: () => runOneshotCommand,
+  runOneshot: () => runOneshot,
+  parseOneshotArgs: () => parseOneshotArgs,
+  getOneshotUsage: () => getOneshotUsage
+});
+function getOneshotUsage() {
+  return [
+    "Usage:",
+    "  webmux oneshot [branch] --prompt <text> [--agent <id>] [--base <branch>] [--profile <name>]",
+    "                          [--env KEY=VALUE]... [--keep-open] [--linear <issue-id|team-key>]",
+    "  webmux oneshot --resume <branch> --prompt <text>",
+    "",
+    "Runs an agent worktree start-to-finish, streaming the conversation to stdout.",
+    "Does not change the focused tmux session. The server-side oneshot watcher",
+    "closes the worktree session (and posts the conversation back to Linear, if",
+    "--linear is set) once the agent finishes \u2014 even if this CLI is killed mid-run.",
+    "Opening the worktree in the browser and interacting with it disarms the watcher.",
+    "",
+    "Exit codes: 0 if the agent opened a PR / the user took over via the browser;",
+    "1 if the agent went idle without opening a PR; 130 on Ctrl-C (worktree keeps",
+    "running, resume with `webmux oneshot --resume <branch>`).",
+    "",
+    "Options:",
+    "  --resume <branch>        Resume an existing local worktree instead of creating one",
+    "  --prompt <text>          Initial agent prompt (required; follow-up nudge when --resume)",
+    "  --agent <id>             Agent id to launch",
+    "  --base <branch>          Base branch for a new worktree (defaults to config)",
+    "  --profile <name>         Worktree profile from .webmux.yaml",
+    "  --env KEY=VALUE          Runtime env override (repeatable)",
+    "  --keep-open              Don't auto-close the worktree session when the agent finishes",
+    "  --linear ID|TEAM         Tie this oneshot to Linear:",
+    "                             ENG-123  \u2014 load the issue body as context, post results back",
+    "                             ENG      \u2014 create a new issue in that team when done",
+    "  --branch <name>          Override the branch when --linear resolves to one",
+    "  --help                   Show this help message"
+  ].join(`
+`);
+}
+function readOptionValue(args, index, flag) {
+  const arg = args[index];
+  if (!arg)
+    throw new CommandUsageError(`${flag} requires a value`);
+  const prefix = `${flag}=`;
+  if (arg.startsWith(prefix))
+    return { value: arg.slice(prefix.length), nextIndex: index };
+  const value = args[index + 1];
+  if (value === undefined)
+    throw new CommandUsageError(`${flag} requires a value`);
+  return { value, nextIndex: index + 1 };
+}
+function parseOneshotArgs(args) {
+  const body = {};
+  const envOverrides = {};
+  let branch = null;
+  let branchFlagUsed = false;
+  let prompt = null;
+  let resume = false;
+  let resumeBranch = null;
+  let keepOpen = false;
+  let fromLinearIssueId = null;
+  let postToLinearTarget = null;
+  for (let index = 0;index < args.length; index++) {
+    const arg = args[index];
+    if (!arg)
+      continue;
+    if (arg === "--help" || arg === "-h")
+      return null;
+    if (arg === "--resume" || arg.startsWith("--resume=")) {
+      const { value, nextIndex } = readOptionValue(args, index, "--resume");
+      resume = true;
+      resumeBranch = value.trim();
+      index = nextIndex;
+      continue;
+    }
+    if (arg === "--prompt" || arg.startsWith("--prompt=")) {
+      const { value, nextIndex } = readOptionValue(args, index, "--prompt");
+      prompt = value;
+      index = nextIndex;
+      continue;
+    }
+    if (arg === "--agent" || arg.startsWith("--agent=")) {
+      const { value, nextIndex } = readOptionValue(args, index, "--agent");
+      body.agent = value.trim();
+      index = nextIndex;
+      continue;
+    }
+    if (arg === "--base" || arg.startsWith("--base=")) {
+      const { value, nextIndex } = readOptionValue(args, index, "--base");
+      body.baseBranch = value;
+      index = nextIndex;
+      continue;
+    }
+    if (arg === "--profile" || arg.startsWith("--profile=")) {
+      const { value, nextIndex } = readOptionValue(args, index, "--profile");
+      body.profile = value;
+      index = nextIndex;
+      continue;
+    }
+    if (arg === "--env" || arg.startsWith("--env=")) {
+      const { value, nextIndex } = readOptionValue(args, index, "--env");
+      const sep = value.indexOf("=");
+      if (sep <= 0)
+        throw new CommandUsageError("--env must use KEY=VALUE");
+      envOverrides[value.slice(0, sep)] = value.slice(sep + 1);
+      index = nextIndex;
+      continue;
+    }
+    if (arg === "--keep-open") {
+      keepOpen = true;
+      continue;
+    }
+    if (arg === "--linear" || arg.startsWith("--linear=")) {
+      const { value, nextIndex } = readOptionValue(args, index, "--linear");
+      const target = parseLinearTarget(value);
+      if (target.kind === "issue") {
+        fromLinearIssueId = target.issueId;
+        postToLinearTarget = { kind: "issue", issueId: target.issueId };
+      } else if (target.kind === "team") {
+        postToLinearTarget = { kind: "team", teamKey: target.teamKey };
+      } else {
+        throw new CommandUsageError(`--linear expects either an issue id (ENG-123) or a team key (ENG); got "${target.raw}"`);
+      }
+      index = nextIndex;
+      continue;
+    }
+    if (arg === "--branch" || arg.startsWith("--branch=")) {
+      const { value, nextIndex } = readOptionValue(args, index, "--branch");
+      if (branch && branch !== value) {
+        throw new CommandUsageError(`Conflicting branch values: "${branch}" and "${value}"`);
+      }
+      branch = value.trim();
+      branchFlagUsed = true;
+      index = nextIndex;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new CommandUsageError(`Unknown option: ${arg}`);
+    }
+    if (branch) {
+      throw new CommandUsageError(`Unexpected argument: ${arg}`);
+    }
+    branch = arg;
+  }
+  if (resume) {
+    if (fromLinearIssueId) {
+      throw new CommandUsageError("Cannot use --resume with --linear <issue-id>");
+    }
+    if (branchFlagUsed) {
+      throw new CommandUsageError("Cannot use --branch with --resume; --resume already names the branch");
+    }
+    if (!resumeBranch)
+      throw new CommandUsageError("--resume requires a branch name");
+    if (branch && branch !== resumeBranch) {
+      throw new CommandUsageError("Cannot pass both a positional branch and --resume");
+    }
+    if (!prompt) {
+      throw new CommandUsageError("--resume requires --prompt; use the dashboard to re-attach without re-prompting");
+    }
+    branch = resumeBranch;
+  }
+  if (branchFlagUsed && !fromLinearIssueId) {
+    throw new CommandUsageError("--branch only applies with --linear; pass the branch as a positional argument otherwise");
+  }
+  if (!resume && !fromLinearIssueId && !prompt) {
+    throw new CommandUsageError("oneshot requires --prompt (or use --linear)");
+  }
+  if (branch)
+    body.branch = branch;
+  if (prompt)
+    body.prompt = prompt;
+  if (Object.keys(envOverrides).length > 0)
+    body.envOverrides = envOverrides;
+  return {
+    branch,
+    prompt,
+    resume,
+    body,
+    keepOpen,
+    fromLinearIssueId,
+    postToLinearTarget
+  };
+}
+function timestamp() {
+  const d = new Date;
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  return `${hh}:${mm}:${ss}`;
+}
+function formatLogLine(role, text) {
+  return `[${timestamp()}] [${role}] ${text}`;
+}
+function truncateInline(text, limit) {
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  if (collapsed.length <= limit)
+    return collapsed;
+  return `${collapsed.slice(0, limit)}\u2026`;
+}
+function summarizeToolInput(toolName, jsonText) {
+  let input = null;
+  try {
+    const parsed = JSON.parse(jsonText);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      input = parsed;
+    }
+  } catch {
+    return truncateInline(jsonText, 100);
+  }
+  if (!input)
+    return truncateInline(jsonText, 100);
+  const keys = TOOL_PRIMARY_KEY[toolName.toLowerCase()];
+  if (keys) {
+    const values = [];
+    for (const key of keys) {
+      const v2 = input[key];
+      if (typeof v2 === "string" && v2.length > 0)
+        values.push(v2);
+    }
+    if (values.length > 0)
+      return truncateInline(values.join(" "), 120);
+  }
+  const parts = [];
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof value === "string")
+      parts.push(`${key}=${truncateInline(value, 40)}`);
+  }
+  if (parts.length === 0)
+    return "";
+  return truncateInline(parts.join(" "), 120);
+}
+function summarizeToolResult(text) {
+  const lines = text.split(`
+`).map((l) => l.trimEnd()).filter((l) => l.length > 0);
+  if (lines.length === 0)
+    return "(empty)";
+  const first = truncateInline(lines[0], 200);
+  return lines.length > 1 ? `${first} (+${lines.length - 1} lines)` : first;
+}
+function formatConversationLine(message) {
+  const kind = message.kind ?? "text";
+  if (kind === "toolUse") {
+    const tool = message.toolName ?? "tool";
+    const summary = summarizeToolInput(tool, message.text);
+    return `[${timestamp()}] \u25CF ${tool}(${summary})`;
+  }
+  if (kind === "toolResult") {
+    return `[${timestamp()}]   \u23BF ${summarizeToolResult(message.text)}`;
+  }
+  return formatLogLine(message.role, message.text);
+}
+function flushStreamingLine(state) {
+  if (state.streamingItemId !== null) {
+    process.stdout.write(`
+`);
+    state.streamingItemId = null;
+    state.streamingNeedsHeader = false;
+  }
+}
+function printNewMessages(state, messages) {
+  for (const message of messages) {
+    if (state.printedMessageIds.has(message.id))
+      continue;
+    if (state.streamingItemId === message.id) {
+      state.printedMessageIds.add(message.id);
+      if (message.status === "completed")
+        flushStreamingLine(state);
+      continue;
+    }
+    flushStreamingLine(state);
+    if (message.text.trim().length === 0) {
+      state.printedMessageIds.add(message.id);
+      continue;
+    }
+    process.stdout.write(`${formatConversationLine(message)}
+`);
+    state.printedMessageIds.add(message.id);
+  }
+}
+function handleConversationEvent(event, state, stderr) {
+  if (event.type === "snapshot") {
+    printNewMessages(state, event.data.conversation.messages);
+    return;
+  }
+  if (event.type === "messageDelta") {
+    if (state.streamingItemId !== event.itemId) {
+      flushStreamingLine(state);
+      state.streamingItemId = event.itemId;
+      state.streamingNeedsHeader = true;
+    }
+    if (state.streamingNeedsHeader) {
+      process.stdout.write(`[${timestamp()}] [assistant] `);
+      state.streamingNeedsHeader = false;
+    }
+    process.stdout.write(event.delta);
+    return;
+  }
+  if (event.type === "error") {
+    flushStreamingLine(state);
+    stderr(`[${timestamp()}] [error] ${event.message}`);
+    return;
+  }
+}
+function streamConversation(branch, port, state, stderr, onFatal) {
+  let closed = false;
+  let socket = null;
+  let reconnectTimer = null;
+  let consecutiveFailures = 0;
+  const connect = () => {
+    if (closed)
+      return;
+    const url = `ws://localhost:${port}${apiPaths.streamAgentsWorktreeConversation.replace(":name", encodeURIComponent(branch))}`;
+    const ws = new WebSocket(url);
+    socket = ws;
+    ws.addEventListener("open", () => {
+      consecutiveFailures = 0;
+    });
+    ws.addEventListener("message", (event) => {
+      if (typeof event.data !== "string")
+        return;
+      try {
+        const parsed = AgentsUiConversationEventSchema.parse(JSON.parse(event.data));
+        handleConversationEvent(parsed, state, stderr);
+      } catch {
+        stderr(`[${timestamp()}] [error] received malformed conversation stream data`);
+      }
+    });
+    ws.addEventListener("close", () => {
+      socket = null;
+      if (closed)
+        return;
+      consecutiveFailures += 1;
+      if (RECONNECT_WARN_AT.includes(consecutiveFailures)) {
+        stderr(`[${timestamp()}] [warn] webmux server unreachable, retrying (${consecutiveFailures}/${MAX_CONSECUTIVE_RECONNECTS})`);
+      }
+      if (consecutiveFailures >= MAX_CONSECUTIVE_RECONNECTS) {
+        closed = true;
+        onFatal(`webmux server unreachable after ${consecutiveFailures} reconnect attempts`);
+        return;
+      }
+      reconnectTimer = setTimeout(connect, 2000);
+    });
+    ws.addEventListener("error", () => {});
+  };
+  connect();
+  return {
+    close: () => {
+      closed = true;
+      if (reconnectTimer)
+        clearTimeout(reconnectTimer);
+      if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) {
+        socket.close();
+      }
+    }
+  };
+}
+function recordPrEvents(state, worktree, onPrEvent) {
+  for (const pr of worktree.prs) {
+    if (!state.seenPrUrls.has(pr.url)) {
+      state.seenPrUrls.add(pr.url);
+      onPrEvent(`PR #${pr.number} opened: ${pr.url}`);
+    }
+    if (pr.state === "merged" && !state.seenMergedUrls.has(pr.url)) {
+      state.seenMergedUrls.add(pr.url);
+      onPrEvent(`PR #${pr.number} merged: ${pr.url}`);
+    }
+  }
+}
+function pollProjectState(branch, port, state, callbacks, stderr) {
+  const api = createApi(`http://localhost:${port}`);
+  let stopped = false;
+  let timer = null;
+  const forcePrSync = async () => {
+    try {
+      const refreshed = await api.syncWorktreePrs({ params: { name: branch } });
+      recordPrEvents(state, refreshed, callbacks.onPrEvent);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      stderr(`[${timestamp()}] [warn] failed to sync PRs from server: ${msg}`);
+    }
+  };
+  const tick = async () => {
+    if (stopped)
+      return;
+    try {
+      const response = await api.fetchWorktrees();
+      const worktree = response.worktrees.find((w3) => w3.branch === branch);
+      if (!worktree) {
+        if (state.hadOpenSession) {
+          callbacks.onWorktreeRemoved();
+          return;
+        }
+      } else {
+        if (worktree.mux) {
+          state.hadOpenSession = true;
+          state.consecutiveClosedReadings = 0;
+        }
+        recordPrEvents(state, worktree, callbacks.onPrEvent);
+        if (worktree.oneshot) {
+          state.watcherWasArmed = true;
+        } else if (state.watcherWasArmed && worktree.mux) {
+          callbacks.onUserTookOver();
+          return;
+        }
+        if (state.hadOpenSession && !worktree.mux) {
+          state.consecutiveClosedReadings += 1;
+          if (state.consecutiveClosedReadings >= 2) {
+            callbacks.onSessionClosed();
+            return;
+          }
+        }
+        const status2 = worktree.status;
+        const isTerminal = status2 === "stopped" || status2 === "error";
+        const isIdle = status2 === "idle";
+        if (isTerminal || isIdle) {
+          if (state.idleSinceMs === null)
+            state.idleSinceMs = Date.now();
+          const isStable = isTerminal || Date.now() - state.idleSinceMs >= IDLE_GRACE_MS;
+          if (isStable) {
+            await forcePrSync();
+            if (state.seenPrUrls.size > 0) {
+              callbacks.onAgentDone(`agent ${status2} after opening PR`);
+            } else {
+              callbacks.onAgentStuck(`agent ${status2} without opening a PR`);
+            }
+            return;
+          }
+        } else {
+          state.idleSinceMs = null;
+        }
+      }
+    } catch {}
+    timer = setTimeout(tick, 3000);
+  };
+  tick();
+  return {
+    stop: () => {
+      stopped = true;
+      if (timer)
+        clearTimeout(timer);
+    }
+  };
+}
+async function ensureWorktreeReady(branch, port, stderr) {
+  const api = createApi(`http://localhost:${port}`);
+  const deadline = Date.now() + 60000;
+  while (Date.now() < deadline) {
+    try {
+      const response = await api.fetchWorktrees();
+      const worktree = response.worktrees.find((w3) => w3.branch === branch);
+      if (worktree && worktree.mux && worktree.status !== "creating" && worktree.status !== "closed") {
+        return { ready: true, worktree };
+      }
+    } catch {}
+    await new Promise((resolve3) => setTimeout(resolve3, 500));
+  }
+  stderr(`[${timestamp()}] [error] timed out waiting for ${branch} session to start`);
+  return { ready: false };
+}
+function printConversationHistory(initial, state) {
+  printNewMessages(state, initial.conversation.messages);
+}
+function pollConversationHistory(branch, port, state) {
+  const api = createApi(`http://localhost:${port}`);
+  let stopped = false;
+  let timer = null;
+  const tick = async () => {
+    if (stopped)
+      return;
+    try {
+      const response = await api.fetchAgentsWorktreeConversationHistory({ params: { name: branch } });
+      printNewMessages(state, response.conversation.messages);
+    } catch {}
+    if (!stopped)
+      timer = setTimeout(tick, 2000);
+  };
+  tick();
+  return {
+    stop: () => {
+      stopped = true;
+      if (timer)
+        clearTimeout(timer);
+    }
+  };
+}
+function deriveOneshotIssueTitle(prompt) {
+  if (!prompt)
+    return null;
+  const firstLine = prompt.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0);
+  if (!firstLine)
+    return null;
+  return firstLine.length > 100 ? `${firstLine.slice(0, 97)}\u2026` : firstLine;
+}
+async function runOneshot(parsed, port) {
+  const stdout = (line) => {
+    process.stdout.write(`${line}
+`);
+  };
+  const stderr = (line) => {
+    process.stderr.write(`${line}
+`);
+  };
+  const api = createApi(`http://localhost:${port}`);
+  let branch = parsed.branch;
+  const body = { ...parsed.body };
+  let fromLinearIssueId = parsed.fromLinearIssueId;
+  let postToLinearTarget = parsed.postToLinearTarget;
+  try {
+    if (postToLinearTarget) {
+      const availability = await api.fetchLinearIssues();
+      if (availability.availability === "missing_api_key") {
+        stderr(`[${timestamp()}] [error] server has no LINEAR_API_KEY \u2014 the post-back to Linear at the end of the run will fail. Set the env var on the webmux server and restart it.`);
+        return 1;
+      }
+      if (availability.availability === "disabled") {
+        stderr(`[${timestamp()}] [error] Linear integration is disabled on the webmux server.`);
+        return 1;
+      }
+    }
+    if (postToLinearTarget?.kind === "team") {
+      const title = deriveOneshotIssueTitle(parsed.prompt);
+      if (!title) {
+        stderr(`[${timestamp()}] [error] --linear ${postToLinearTarget.teamKey} requires --prompt to derive an issue title`);
+        return 1;
+      }
+      if (parsed.resume) {
+        stdout(`[${timestamp()}] [event] no Linear issue for this resume; creating a fresh ${postToLinearTarget.teamKey}-N for the post-back`);
+      }
+      stdout(`[${timestamp()}] [event] creating Linear issue in team ${postToLinearTarget.teamKey}...`);
+      const team = await fetchTeamByKey(postToLinearTarget.teamKey);
+      if (!team.ok) {
+        stderr(`[${timestamp()}] [error] Linear team lookup failed: ${team.error}`);
+        return 1;
+      }
+      const created = await createLinearIssue({
+        teamId: team.data.id,
+        title,
+        description: ""
+      });
+      if (!created.ok) {
+        stderr(`[${timestamp()}] [error] Linear issue creation failed: ${created.error}`);
+        return 1;
+      }
+      stdout(`[${timestamp()}] [event] created Linear issue ${created.data.identifier} \u2192 ${created.data.url}`);
+      fromLinearIssueId = created.data.identifier;
+      postToLinearTarget = { kind: "issue", issueId: created.data.identifier };
+    }
+    if (fromLinearIssueId) {
+      stdout(`[${timestamp()}] [event] resolving Linear issue ${fromLinearIssueId}...`);
+      const seedResult = await buildSeedFromLinear({ issueId: fromLinearIssueId }, defaultSeedFromLinearDeps);
+      if (!seedResult.ok) {
+        stderr(`[${timestamp()}] [error] Linear seed lookup failed: ${seedResult.error}`);
+        return 1;
+      }
+      const seed = seedResult.data;
+      stdout(`[${timestamp()}] [event] seed source: ${seed.source}${seed.branch ? ` branch=${seed.branch}` : ""}${seed.prUrl ? ` pr=${seed.prUrl}` : ""}`);
+      const resolvedBranch = branch ?? seed.branch ?? null;
+      if (!resolvedBranch) {
+        stderr(`[${timestamp()}] [error] Linear issue did not resolve to a branch; pass --branch to override.`);
+        return 1;
+      }
+      branch = resolvedBranch;
+      body.branch = resolvedBranch;
+      if (seed.source !== "none")
+        body.mode = "existing";
+      body.fromLinear = {
+        issueId: fromLinearIssueId,
+        ...seed.conversationMarkdown ? { conversationContext: seed.conversationMarkdown } : {}
+      };
+    }
+    const existingWorktree = branch ? (await api.fetchWorktrees()).worktrees.find((w3) => w3.branch === branch) : undefined;
+    const oneshotConfig = {
+      autoCloseOnDone: !parsed.keepOpen,
+      ...postToLinearTarget ? { postToLinearOnDone: postToLinearTarget } : {}
+    };
+    if (parsed.resume || existingWorktree) {
+      if (!branch)
+        throw new Error("resume requires a branch name");
+      const reason = parsed.resume ? "resuming" : `worktree exists, resuming ${branch}`;
+      stdout(`[${timestamp()}] [event] ${reason}`);
+      if (fromLinearIssueId) {
+        stdout(`[${timestamp()}] [event] skipping Linear seed \u2014 agent's existing session history already covers it`);
+      }
+      await api.openWorktree({
+        params: { name: branch },
+        body: {
+          ...parsed.prompt ? { prompt: parsed.prompt } : {},
+          oneshot: oneshotConfig
+        }
+      });
+      if (parsed.prompt)
+        stdout(`[${timestamp()}] [event] sent prompt`);
+    } else {
+      stdout(`[${timestamp()}] [event] creating worktree${branch ? ` ${branch}` : ""}...`);
+      const result = await api.createWorktree({
+        body: { ...body, source: "oneshot", oneshot: oneshotConfig }
+      });
+      branch = result.primaryBranch;
+      stdout(`[${timestamp()}] [event] created ${branch}`);
+    }
+  } catch (error) {
+    stderr(`[${timestamp()}] [error] ${formatServerError(error, port)}`);
+    return 1;
+  }
+  if (!branch) {
+    stderr(`[${timestamp()}] [error] could not resolve branch`);
+    return 1;
+  }
+  const ready = await ensureWorktreeReady(branch, port, stderr);
+  if (!ready.ready)
+    return 1;
+  const conversationState = {
+    printedMessageIds: new Set,
+    streamingItemId: null,
+    streamingNeedsHeader: false
+  };
+  try {
+    const initial = await api.fetchAgentsWorktreeConversationHistory({ params: { name: branch } });
+    printConversationHistory(initial, conversationState);
+  } catch {}
+  let resolveExit;
+  const exitPromise = new Promise((resolve3) => {
+    resolveExit = resolve3;
+  });
+  let exiting = false;
+  let stream = null;
+  let historyPoller = null;
+  let poller = null;
+  const finalize = (code) => {
+    if (exiting)
+      return;
+    exiting = true;
+    stream?.close();
+    historyPoller?.stop();
+    poller?.stop();
+    flushStreamingLine(conversationState);
+    resolveExit(code);
+  };
+  stream = streamConversation(branch, port, conversationState, stderr, (reason) => {
+    stderr(`[${timestamp()}] [fatal] ${reason}`);
+    finalize(1);
+  });
+  if (ready.worktree.agentName === "claude") {
+    historyPoller = pollConversationHistory(branch, port, conversationState);
+  }
+  const pollState = {
+    seenPrUrls: new Set,
+    seenMergedUrls: new Set,
+    hadOpenSession: false,
+    consecutiveClosedReadings: 0,
+    idleSinceMs: null,
+    watcherWasArmed: false
+  };
+  poller = pollProjectState(branch, port, pollState, {
+    onSessionClosed: () => {
+      stdout(`[${timestamp()}] [event] session closed \u2014 exiting`);
+      finalize(0);
+    },
+    onWorktreeRemoved: () => {
+      stdout(`[${timestamp()}] [event] worktree removed \u2014 exiting`);
+      finalize(0);
     },
-    pullMain: {
-      method: "POST",
-      path: apiPaths.pullMain,
-      body: PullMainRequestSchema,
-      responses: {
-        200: PullMainResponseSchema,
-        ...commonErrorResponses
-      }
+    onPrEvent: (line) => {
+      flushStreamingLine(conversationState);
+      stdout(`[${timestamp()}] [event] ${line}`);
     },
-    fetchCiLogs: {
-      method: "GET",
-      path: apiPaths.fetchCiLogs,
-      pathParams: RunIdParamsSchema,
-      responses: {
-        200: CiLogsResponseSchema,
-        ...commonErrorResponses
-      }
+    onAgentDone: (reason) => {
+      flushStreamingLine(conversationState);
+      stdout(`[${timestamp()}] [event] ${reason} \u2014 exiting`);
+      finalize(0);
     },
-    dismissNotification: {
-      method: "POST",
-      path: apiPaths.dismissNotification,
-      pathParams: NotificationIdParamsSchema,
-      body: c.noBody(),
-      responses: {
-        200: OkResponseSchema,
-        400: ErrorResponseSchema,
-        404: ErrorResponseSchema
-      }
-    }
-  }, {
-    strictStatusCodes: true
-  });
+    onAgentStuck: (reason) => {
+      flushStreamingLine(conversationState);
+      stderr(`[${timestamp()}] [error] ${reason}`);
+      finalize(1);
+    },
+    onUserTookOver: () => {
+      flushStreamingLine(conversationState);
+      stdout(`[${timestamp()}] [event] user took over from the browser \u2014 exiting`);
+      finalize(0);
+    }
+  }, stderr);
+  const onSignal = () => {
+    stdout(`
+[${timestamp()}] [event] interrupted \u2014 worktree ${branch} keeps running`);
+    stdout(`[${timestamp()}] [event] resume with: webmux oneshot --resume ${branch}`);
+    finalize(130);
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  const finalExit = await exitPromise;
+  process.off("SIGINT", onSignal);
+  process.off("SIGTERM", onSignal);
+  return finalExit;
+}
+async function runOneshotCommand(args, port) {
+  let parsed;
+  try {
+    parsed = parseOneshotArgs(args);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    console.error(getOneshotUsage());
+    return 1;
+  }
+  if (!parsed) {
+    console.log(getOneshotUsage());
+    return 0;
+  }
+  return await runOneshot(parsed, port);
+}
+var TOOL_PRIMARY_KEY, MAX_CONSECUTIVE_RECONNECTS = 30, RECONNECT_WARN_AT, IDLE_GRACE_MS = 15000;
+var init_oneshot = __esm(() => {
+  init_src();
+  init_linear_service();
+  init_conversation_export_service();
+  init_shared();
+  TOOL_PRIMARY_KEY = {
+    bash: ["command"],
+    bashoutput: ["bash_id"],
+    killshell: ["shell_id"],
+    read: ["file_path"],
+    edit: ["file_path"],
+    multiedit: ["file_path"],
+    write: ["file_path"],
+    notebookedit: ["notebook_path"],
+    glob: ["pattern"],
+    grep: ["pattern"],
+    webfetch: ["url"],
+    websearch: ["query"],
+    task: ["description", "subagent_type"],
+    exitplanmode: ["plan"]
+  };
+  RECONNECT_WARN_AT = [3, 15];
 });
 
-// packages/api-contract/src/client.ts
-function createApiClient(baseUrl, options = {}) {
-  return initClient(apiContract, {
-    baseUrl,
-    throwOnUnknownStatus: true,
-    baseHeaders: {},
-    ...options
-  });
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null;
+// bin/src/linear-commands.ts
+var exports_linear_commands = {};
+__export(exports_linear_commands, {
+  runLinearCommand: () => runLinearCommand,
+  parseLinearTargetArg: () => parseLinearTargetArg,
+  parseLinearArgs: () => parseLinearArgs,
+  getLinearUsage: () => getLinearUsage
+});
+function getLinearUsage() {
+  return [
+    "Usage:",
+    "  webmux linear post <branch> <team-key> [--title <text>]",
+    "",
+    "Creates a new Linear issue in <team-key> and posts the worktree's conversation",
+    "as a JSON attachment + summary comment.",
+    "",
+    "  <team-key>       Linear team key (e.g. ENG). A new issue is created in that team.",
+    "  --title <text>   Override the auto-derived title for the new issue",
+    "",
+    "To post into an existing issue, start the session with `webmux oneshot --linear",
+    "<issue-id>` or `webmux add --from-linear <issue-id>` so the issue is the seed.",
+    "",
+    "Examples:",
+    "  webmux linear post feat/foo ENG",
+    '  webmux linear post feat/foo ENG --title "Investigate flaky test"'
+  ].join(`
+`);
 }
-function isRouteResponse(value) {
-  return isRecord2(value) && "status" in value && typeof value.status === "number" && "body" in value;
+function readOptionValue2(args, index, flag) {
+  const arg = args[index];
+  if (!arg)
+    throw new CommandUsageError(`${flag} requires a value`);
+  const prefix = `${flag}=`;
+  if (arg.startsWith(prefix))
+    return { value: arg.slice(prefix.length), nextIndex: index };
+  const value = args[index + 1];
+  if (value === undefined)
+    throw new CommandUsageError(`${flag} requires a value`);
+  return { value, nextIndex: index + 1 };
 }
-function unwrapResponse(response) {
-  if (!isRouteResponse(response)) {
-    throw new Error("Malformed API client response");
+function parseLinearTargetArg(raw) {
+  const target = parseLinearTarget(raw);
+  if (target.kind === "team") {
+    return { kind: "team", teamKey: target.teamKey };
   }
-  if (response.status < 200 || response.status >= 300) {
-    throw new Error(errorMessageFromResponse(response.body, response.status));
+  if (target.kind === "issue") {
+    throw new CommandUsageError(`Post target must be a team key (e.g. ENG). To post to issue ${target.issueId} as part of a session, use --linear ${target.issueId} on the oneshot/add command (loads issue context and posts back to it).`);
   }
-  return response.body;
+  throw new CommandUsageError(`Invalid Linear team key "${target.raw}". Use a team key like ENG.`);
 }
-function errorMessageFromResponse(body, status2) {
-  if (typeof body === "string") {
-    try {
-      const parsed = JSON.parse(body);
-      return errorMessageFromResponse(parsed, status2);
-    } catch {
-      return body.trim() || `HTTP ${status2}`;
-    }
-  }
-  if (body && typeof body === "object" && "error" in body && typeof body.error === "string") {
-    return body.error;
+function parseLinearArgs(args) {
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    return null;
   }
-  return `HTTP ${status2}`;
-}
-function withEncodedPathParams(args) {
-  const [first, ...rest] = args;
-  if (!first || typeof first !== "object" || !("params" in first) || !first.params || typeof first.params !== "object") {
-    return args;
+  const subcommand = args[0];
+  if (subcommand !== "post") {
+    throw new CommandUsageError(`Unknown linear subcommand: ${subcommand}`);
   }
-  const encodedParams = Object.fromEntries(Object.entries(first.params).map(([key, value]) => [key, encodeURIComponent(String(value))]));
-  return [
-    {
-      ...first,
-      params: encodedParams
-    },
-    ...rest
-  ];
-}
-function wrapRouteCall(routeCall) {
-  return async (...args) => unwrapResponse(await routeCall(...withEncodedPathParams(args)));
-}
-function wrapClient(client) {
-  return Object.fromEntries(Object.entries(client).map(([key, value]) => {
-    if (typeof value === "function") {
-      return [key, wrapRouteCall((...args) => Promise.resolve(Reflect.apply(value, undefined, args)))];
+  let branch = null;
+  let targetRaw = null;
+  let titleOverride = null;
+  for (let index = 1;index < args.length; index++) {
+    const arg = args[index];
+    if (!arg)
+      continue;
+    if (arg === "--help" || arg === "-h")
+      return null;
+    if (arg === "--title" || arg.startsWith("--title=")) {
+      const { value, nextIndex } = readOptionValue2(args, index, "--title");
+      titleOverride = value;
+      index = nextIndex;
+      continue;
     }
-    if (isRecord2(value)) {
-      return [key, wrapClient(value)];
+    if (arg.startsWith("-")) {
+      throw new CommandUsageError(`Unknown option: ${arg}`);
     }
-    return [key, value];
-  }));
+    if (!branch) {
+      branch = arg;
+      continue;
+    }
+    if (!targetRaw) {
+      targetRaw = arg;
+      continue;
+    }
+    throw new CommandUsageError(`Unexpected argument: ${arg}`);
+  }
+  if (!branch)
+    throw new CommandUsageError("linear post requires a <branch> argument");
+  if (!targetRaw)
+    throw new CommandUsageError("linear post requires a <team-key> argument");
+  const baseTarget = parseLinearTargetArg(targetRaw);
+  const target = baseTarget.kind === "team" && titleOverride ? { kind: "team", teamKey: baseTarget.teamKey, title: titleOverride } : baseTarget;
+  return {
+    subcommand: "post",
+    post: { branch, target, titleOverride }
+  };
 }
-function createApi(baseUrl, options = {}) {
-  return wrapClient(createApiClient(baseUrl, options));
+async function runLinearCommand(args, port) {
+  let parsed;
+  try {
+    parsed = parseLinearArgs(args);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    console.error(getLinearUsage());
+    return 1;
+  }
+  if (!parsed) {
+    console.log(getLinearUsage());
+    return 0;
+  }
+  const api = createApi(`http://localhost:${port}`);
+  try {
+    const response = await api.postWorktreeToLinear({
+      params: { name: parsed.post.branch },
+      body: { target: parsed.post.target }
+    });
+    console.log(`Posted to Linear issue: ${response.issueUrl}`);
+    if (response.commentUrl)
+      console.log(`Comment: ${response.commentUrl}`);
+    console.log(`Attachment: ${response.attachmentUrl}`);
+    return 0;
+  } catch (error) {
+    console.error(formatServerError(error, port));
+    return 1;
+  }
 }
-var init_client = __esm(() => {
-  init_index_esm();
-  init_contract();
-});
-
-// packages/api-contract/src/index.ts
-var init_src = __esm(() => {
-  init_contract();
-  init_client();
-  init_schemas();
+var init_linear_commands = __esm(() => {
+  init_src();
+  init_shared();
 });
 
 // backend/src/domain/model.ts
@@ -10140,7 +11589,7 @@ var require_merge = __commonJS((exports) => {
 
 // node_modules/.bun/yaml@2.9.0/node_modules/yaml/dist/nodes/addPairToJSMap.js
 var require_addPairToJSMap = __commonJS((exports) => {
-  var log = require_log();
+  var log2 = require_log();
   var merge = require_merge();
   var stringify = require_stringify();
   var identity = require_identity();
@@ -10189,7 +11638,7 @@ var require_addPairToJSMap = __commonJS((exports) => {
         let jsonStr = JSON.stringify(strKey);
         if (jsonStr.length > 40)
           jsonStr = jsonStr.substring(0, 36) + '..."';
-        log.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
+        log2.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
         ctx.mapKeyWarned = true;
       }
       return strKey;
@@ -11387,13 +12836,13 @@ var require_timestamp = __commonJS((exports) => {
     resolve: (str) => parseSexagesimal(str, false),
     stringify: stringifySexagesimal
   };
-  var timestamp = {
+  var timestamp2 = {
     identify: (value) => value instanceof Date,
     default: true,
     tag: "tag:yaml.org,2002:timestamp",
     test: RegExp("^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})" + "(?:" + "(?:t|T|[ \\t]+)" + "([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)" + "(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?" + ")?$"),
     resolve(str) {
-      const match = str.match(timestamp.test);
+      const match = str.match(timestamp2.test);
       if (!match)
         throw new Error("!!timestamp expects a date, starting with yyyy-mm-dd");
       const [, year, month, day, hour, minute, second] = match.map(Number);
@@ -11412,7 +12861,7 @@ var require_timestamp = __commonJS((exports) => {
   };
   exports.floatTime = floatTime;
   exports.intTime = intTime;
-  exports.timestamp = timestamp;
+  exports.timestamp = timestamp2;
 });
 
 // node_modules/.bun/yaml@2.9.0/node_modules/yaml/dist/schema/yaml-1.1/schema.js
@@ -11429,7 +12878,7 @@ var require_schema3 = __commonJS((exports) => {
   var omap = require_omap();
   var pairs = require_pairs();
   var set = require_set();
-  var timestamp = require_timestamp();
+  var timestamp2 = require_timestamp();
   var schema = [
     map.map,
     seq.seq,
@@ -11449,9 +12898,9 @@ var require_schema3 = __commonJS((exports) => {
     omap.omap,
     pairs.pairs,
     set.set,
-    timestamp.intTime,
-    timestamp.floatTime,
-    timestamp.timestamp
+    timestamp2.intTime,
+    timestamp2.floatTime,
+    timestamp2.timestamp
   ];
   exports.schema = schema;
 });
@@ -11473,7 +12922,7 @@ var require_tags = __commonJS((exports) => {
   var pairs = require_pairs();
   var schema$2 = require_schema3();
   var set = require_set();
-  var timestamp = require_timestamp();
+  var timestamp2 = require_timestamp();
   var schemas2 = new Map([
     ["core", schema.schema],
     ["failsafe", [map.map, seq.seq, string.string]],
@@ -11487,11 +12936,11 @@ var require_tags = __commonJS((exports) => {
     float: float.float,
     floatExp: float.floatExp,
     floatNaN: float.floatNaN,
-    floatTime: timestamp.floatTime,
+    floatTime: timestamp2.floatTime,
     int: int.int,
     intHex: int.intHex,
     intOct: int.intOct,
-    intTime: timestamp.intTime,
+    intTime: timestamp2.intTime,
     map: map.map,
     merge: merge.merge,
     null: _null.nullTag,
@@ -11499,7 +12948,7 @@ var require_tags = __commonJS((exports) => {
     pairs: pairs.pairs,
     seq: seq.seq,
     set: set.set,
-    timestamp: timestamp.timestamp
+    timestamp: timestamp2.timestamp
   };
   var coreKnownTags = {
     "tag:yaml.org,2002:binary": binary.binary,
@@ -11507,7 +12956,7 @@ var require_tags = __commonJS((exports) => {
     "tag:yaml.org,2002:omap": omap.omap,
     "tag:yaml.org,2002:pairs": pairs.pairs,
     "tag:yaml.org,2002:set": set.set,
-    "tag:yaml.org,2002:timestamp": timestamp.timestamp
+    "tag:yaml.org,2002:timestamp": timestamp2.timestamp
   };
   function getTags(customTags, schemaName, addMergeTag) {
     const schemaTags = schemas2.get(schemaName);
@@ -12775,9 +14224,9 @@ var require_resolve_block_scalar = __commonJS((exports) => {
         default: {
           const message = `Unexpected token in block scalar header: ${token.type}`;
           onError(token, "UNEXPECTED_TOKEN", message);
-          const ts = token.source;
-          if (ts && typeof ts === "string")
-            length += ts.length;
+          const ts2 = token.source;
+          if (ts2 && typeof ts2 === "string")
+            length += ts2.length;
         }
       }
     }
@@ -13080,9 +14529,9 @@ var require_compose_scalar = __commonJS((exports) => {
     if (schema.compat) {
       const compat = schema.compat.find((tag2) => tag2.default && tag2.test?.test(value)) ?? schema[identity.SCALAR];
       if (tag.tag !== compat.tag) {
-        const ts = directives.tagString(tag.tag);
+        const ts2 = directives.tagString(tag.tag);
         const cs = directives.tagString(compat.tag);
-        const msg = `Value may be parsed as either ${ts} or ${cs}`;
+        const msg = `Value may be parsed as either ${ts2} or ${cs}`;
         onError(token, "TAG_RESOLVE_FAILED", msg, true);
       }
     }
@@ -15346,7 +16795,7 @@ var require_public_api = __commonJS((exports) => {
   var composer = require_composer();
   var Document = require_Document();
   var errors2 = require_errors();
-  var log = require_log();
+  var log2 = require_log();
   var identity = require_identity();
   var lineCounter = require_line_counter();
   var parser = require_parser();
@@ -15398,7 +16847,7 @@ var require_public_api = __commonJS((exports) => {
     const doc = parseDocument(src, options);
     if (!doc)
       return null;
-    doc.warnings.forEach((warning) => log.warn(doc.options.logLevel, warning));
+    doc.warnings.forEach((warning) => log2.warn(doc.options.logLevel, warning));
     if (doc.errors.length > 0) {
       if (doc.options.logLevel !== "silent")
         throw doc.errors[0];
@@ -15487,6 +16936,15 @@ var init_dist5 = __esm(() => {
 // backend/src/adapters/config.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { dirname as dirname2, join as join7, resolve as resolve5 } from "path";
+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(" ");
+}
 function clonePanes(panes) {
   return panes.map((pane) => ({ ...pane }));
 }
@@ -15663,6 +17121,12 @@ function parseLifecycleHooks(raw) {
   }
   return hooks;
 }
+function parseOneshot(raw) {
+  if (!isRecord4(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 (!isRecord4(raw))
     return null;
@@ -15735,7 +17199,8 @@ function parseProjectConfig(parsed) {
       }
     },
     lifecycleHooks: parseLifecycleHooks(parsed.lifecycleHooks),
-    autoName: parseAutoName(parsed.auto_name)
+    autoName: parseAutoName(parsed.auto_name),
+    oneshot: parseOneshot(parsed.oneshot)
   };
 }
 function defaultConfig() {
@@ -15902,7 +17367,8 @@ var init_config = __esm(() => {
       linear: { enabled: true, autoCreateWorktrees: false, createTicketOption: false }
     },
     lifecycleHooks: {},
-    autoName: null
+    autoName: null,
+    oneshot: { systemPrompt: DEFAULT_ONESHOT_SYSTEM_PROMPT() }
   };
 });
 
@@ -15929,30 +17395,6 @@ var init_control_token = __esm(() => {
   CONTROL_TOKEN_PATH = `${Bun.env.HOME ?? "/root"}/.config/webmux/control-token`;
 });
 
-// backend/src/lib/log.ts
-function ts() {
-  return new Date().toISOString().slice(11, 23);
-}
-var DEBUG, log;
-var init_log = __esm(() => {
-  DEBUG = Bun.env.WEBMUX_DEBUG === "1";
-  log = {
-    info(msg) {
-      console.log(`[${ts()}] ${msg}`);
-    },
-    debug(msg) {
-      if (DEBUG)
-        console.log(`[${ts()}] ${msg}`);
-    },
-    warn(msg) {
-      console.warn(`[${ts()}] ${msg}`);
-    },
-    error(msg, err) {
-      err !== undefined ? console.error(`[${ts()}] ${msg}`, err) : console.error(`[${ts()}] ${msg}`);
-    }
-  };
-});
-
 // backend/src/adapters/docker.ts
 import { stat } from "fs/promises";
 async function pathExists(p2) {
@@ -17046,23 +18488,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}`;
   }
@@ -17380,7 +18821,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);
@@ -17433,7 +18876,9 @@ async function createManagedWorktree(opts, deps2 = {}) {
       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 (deps2.tmux) {
       sessionLayoutPlan = sessionLayoutPlan ?? opts.sessionLayoutPlanBuilder?.(initialized);
@@ -17573,10 +19018,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";
@@ -17591,7 +19041,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 {
@@ -17602,6 +19053,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);
@@ -17888,8 +19353,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: containerName2
       }));
       return;
@@ -17901,12 +19368,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 containerName2 = input.containerName;
     return planSessionLayout(this.deps.projectRoot, input.branch, input.profile.panes, {
       repoRoot: this.deps.projectRoot,
@@ -17921,7 +19395,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(containerName2, input.worktreePath, input.initialized.paths.runtimeEnvPath)
@@ -17935,7 +19409,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)
@@ -18059,12 +19533,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;
@@ -18089,7 +19565,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
       });
@@ -18127,8 +19605,9 @@ class LifecycleService {
         agent,
         initialized,
         worktreePath,
-        prompt: input.prompt,
-        launchMode: "fresh"
+        creationPrompt: input.prompt,
+        launchMode: "fresh",
+        source
       });
       await this.reportCreateProgress({
         ...createProgressBase,
@@ -18290,6 +19769,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,
@@ -18339,6 +19820,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);
@@ -18349,6 +19834,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)
@@ -18394,36 +19884,36 @@ class ProjectRuntime {
     if (event.branch !== state.branch) {
       this.applyBranchChange(state, event.branch);
     }
-    const timestamp = isoNow(now);
+    const timestamp2 = isoNow(now);
     switch (event.type) {
       case "agent_stopped":
         state.agent.lifecycle = "stopped";
-        state.agent.lastEventAt = timestamp;
+        state.agent.lastEventAt = timestamp2;
         break;
       case "agent_status_changed":
-        this.applyStatusChanged(state, event, timestamp);
+        this.applyStatusChanged(state, event, timestamp2);
         break;
       case "runtime_error":
-        this.applyRuntimeError(state, event, timestamp);
+        this.applyRuntimeError(state, event, timestamp2);
         break;
       case "pr_opened":
-        state.agent.lastEventAt = timestamp;
+        state.agent.lastEventAt = timestamp2;
         break;
     }
     return state;
   }
-  applyStatusChanged(state, event, timestamp) {
+  applyStatusChanged(state, event, timestamp2) {
     state.agent.lifecycle = event.lifecycle;
-    state.agent.lastEventAt = timestamp;
+    state.agent.lastEventAt = timestamp2;
     if (state.agent.lastStartedAt === null && event.lifecycle === "running") {
-      state.agent.lastStartedAt = timestamp;
+      state.agent.lastStartedAt = timestamp2;
     }
     state.agent.lastError = null;
   }
-  applyRuntimeError(state, event, timestamp) {
+  applyRuntimeError(state, event, timestamp2) {
     state.agent.lifecycle = "error";
     state.agent.lastError = event.message;
-    state.agent.lastEventAt = timestamp;
+    state.agent.lastEventAt = timestamp2;
   }
   applyBranchChange(state, branch) {
     this.reindexBranch(state.branch, branch, state.worktreeId);
@@ -18560,6 +20050,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,
@@ -18592,7 +20084,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,
@@ -18632,7 +20126,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);
   }
@@ -18738,7 +20233,7 @@ function getWorktreeCommandUsage(command) {
     case "add":
       return [
         "Usage:",
-        "  webmux add [branch] [--existing] [--base <branch>] [--profile <name>] [--agent <id>] [--prompt <text>] [--env KEY=VALUE] [--detach]",
+        "  webmux add [branch] [--existing] [--base <branch>] [--profile <name>] [--agent <id>] [--prompt <text>] [--env KEY=VALUE] [--detach] [--from-linear <issue-id>]",
         "",
         "Options:",
         "  --existing               Use an existing local or remote branch instead of creating a new one",
@@ -18748,6 +20243,8 @@ function getWorktreeCommandUsage(command) {
         "  --prompt <text>          Initial agent prompt",
         "  --env KEY=VALUE          Runtime env override (repeatable)",
         "  -d, --detach             Create worktree without switching to it",
+        "  --from-linear ID         Bootstrap from a Linear issue \u2014 loads the issue body as",
+        "                           context, plus any saved webmux session or linked PR",
         "  --help                   Show this help message"
       ].join(`
 `);
@@ -18809,7 +20306,7 @@ function getWorktreeCommandUsage(command) {
   webmux prune`;
   }
 }
-function readOptionValue(args, index, flag) {
+function readOptionValue3(args, index, flag) {
   const arg = args[index];
   if (!arg) {
     throw new CommandUsageError(`${flag} requires a value`);
@@ -18842,6 +20339,8 @@ function parseAddCommandArgs(args) {
   const envOverrides = {};
   const selectedAgents = [];
   let detach = false;
+  let fromLinearIssueId = null;
+  let branchExplicit = false;
   for (let index = 0;index < args.length; index++) {
     const arg = args[index];
     if (!arg)
@@ -18858,31 +20357,31 @@ function parseAddCommandArgs(args) {
       continue;
     }
     if (arg === "--profile" || arg.startsWith("--profile=")) {
-      const { value, nextIndex } = readOptionValue(args, index, "--profile");
+      const { value, nextIndex } = readOptionValue3(args, index, "--profile");
       input.profile = value;
       index = nextIndex;
       continue;
     }
     if (arg === "--base" || arg.startsWith("--base=")) {
-      const { value, nextIndex } = readOptionValue(args, index, "--base");
+      const { value, nextIndex } = readOptionValue3(args, index, "--base");
       input.baseBranch = value;
       index = nextIndex;
       continue;
     }
     if (arg === "--agent" || arg.startsWith("--agent=")) {
-      const { value, nextIndex } = readOptionValue(args, index, "--agent");
+      const { value, nextIndex } = readOptionValue3(args, index, "--agent");
       selectedAgents.push(parseAgent(value));
       index = nextIndex;
       continue;
     }
     if (arg === "--prompt" || arg.startsWith("--prompt=")) {
-      const { value, nextIndex } = readOptionValue(args, index, "--prompt");
+      const { value, nextIndex } = readOptionValue3(args, index, "--prompt");
       input.prompt = value;
       index = nextIndex;
       continue;
     }
     if (arg === "--env" || arg.startsWith("--env=")) {
-      const { value, nextIndex } = readOptionValue(args, index, "--env");
+      const { value, nextIndex } = readOptionValue3(args, index, "--env");
       const separatorIndex = value.indexOf("=");
       if (separatorIndex <= 0) {
         throw new CommandUsageError("--env must use KEY=VALUE");
@@ -18891,6 +20390,26 @@ function parseAddCommandArgs(args) {
       index = nextIndex;
       continue;
     }
+    if (arg === "--from-linear" || arg.startsWith("--from-linear=")) {
+      const { value, nextIndex } = readOptionValue3(args, index, "--from-linear");
+      const trimmed = value.trim();
+      if (!/^[A-Z]+-\d+$/.test(trimmed)) {
+        throw new CommandUsageError(`--from-linear expects an issue id like ENG-123 (got "${trimmed}")`);
+      }
+      fromLinearIssueId = trimmed;
+      index = nextIndex;
+      continue;
+    }
+    if (arg === "--branch" || arg.startsWith("--branch=")) {
+      const { value, nextIndex } = readOptionValue3(args, index, "--branch");
+      if (input.branch && input.branch !== value) {
+        throw new CommandUsageError(`Conflicting branch values: "${input.branch}" and "${value}"`);
+      }
+      input.branch = value.trim();
+      branchExplicit = true;
+      index = nextIndex;
+      continue;
+    }
     if (arg.startsWith("-")) {
       throw new CommandUsageError(`Unknown option: ${arg}`);
     }
@@ -18898,6 +20417,7 @@ function parseAddCommandArgs(args) {
       throw new CommandUsageError(`Unexpected argument: ${arg}`);
     }
     input.branch = arg;
+    branchExplicit = true;
   }
   if (selectedAgents.length > 0) {
     input.agents = selectedAgents;
@@ -18905,7 +20425,7 @@ function parseAddCommandArgs(args) {
   if (Object.keys(envOverrides).length > 0) {
     input.envOverrides = envOverrides;
   }
-  return { input, detach };
+  return { input, detach, fromLinearIssueId, branchExplicit };
 }
 function parseBranchCommandArgs(args) {
   let branch = null;
@@ -18949,7 +20469,7 @@ function parseLabelCommandArgs(args) {
       if (optionLabel !== null) {
         throw new CommandUsageError("Cannot use --label more than once");
       }
-      const { value, nextIndex } = readOptionValue(args, index, "--label");
+      const { value, nextIndex } = readOptionValue3(args, index, "--label");
       optionLabel = value;
       index = nextIndex;
       continue;
@@ -19001,13 +20521,13 @@ function parseSendCommandArgs(args) {
     if (arg === "--prompt" || arg.startsWith("--prompt=")) {
       if (text)
         throw new CommandUsageError("Cannot use --prompt with a positional prompt argument");
-      const { value, nextIndex } = readOptionValue(args, index, "--prompt");
+      const { value, nextIndex } = readOptionValue3(args, index, "--prompt");
       text = value;
       index = nextIndex;
       continue;
     }
     if (arg === "--preamble" || arg.startsWith("--preamble=")) {
-      const { value, nextIndex } = readOptionValue(args, index, "--preamble");
+      const { value, nextIndex } = readOptionValue3(args, index, "--preamble");
       preamble = value;
       index = nextIndex;
       continue;
@@ -19073,7 +20593,7 @@ function parseListCommandArgs(args) {
       continue;
     }
     if (arg === "--search" || arg.startsWith("--search=")) {
-      const { value, nextIndex } = readOptionValue(args, index, "--search");
+      const { value, nextIndex } = readOptionValue3(args, index, "--search");
       search = value;
       index = nextIndex;
       continue;
@@ -19217,6 +20737,31 @@ async function runWorktreeCommand(context, deps2 = {}) {
           stdout(PHASE_LABELS[progress.phase] ?? progress.phase);
         }
       });
+      if (parsed.fromLinearIssueId) {
+        stdout(`Resolving Linear issue ${parsed.fromLinearIssueId}...`);
+        const seed = await buildSeedFromLinear({ issueId: parsed.fromLinearIssueId }, defaultSeedFromLinearDeps);
+        if (!seed.ok) {
+          stderr(`Linear seed lookup failed: ${seed.error}`);
+          return 1;
+        }
+        stdout(`Linear seed source: ${seed.data.source}${seed.data.branch ? ` branch=${seed.data.branch}` : ""}${seed.data.prUrl ? ` pr=${seed.data.prUrl}` : ""}`);
+        if (!parsed.branchExplicit && seed.data.branch) {
+          parsed.input.branch = seed.data.branch;
+        }
+        if (!parsed.input.branch) {
+          stderr("Linear issue did not resolve to a branch; pass --branch to override.");
+          return 1;
+        }
+        if (seed.data.source !== "none")
+          parsed.input.mode = "existing";
+        if (seed.data.conversationMarkdown) {
+          parsed.input.prompt = parsed.input.prompt ? `${seed.data.conversationMarkdown}
+
+---
+
+${parsed.input.prompt}` : seed.data.conversationMarkdown;
+        }
+      }
       if (!parsed.input.branch && parsed.input.prompt && runtime2.config.autoName) {
         stdout("Generating branch name...");
       }
@@ -19275,23 +20820,13 @@ async function runWorktreeCommand(context, deps2 = {}) {
         return 0;
       }
       const api = createApi(`http://localhost:${context.port}`);
-      try {
-        await api.sendWorktreePrompt({
-          params: { name: parsed.branch },
-          body: {
-            text: parsed.text,
-            ...parsed.preamble ? { preamble: parsed.preamble } : {}
-          }
-        });
-      } catch (error) {
-        if (error instanceof Error && error.message.startsWith("HTTP")) {
-          throw error;
+      await withServerConnection(context.port, () => api.sendWorktreePrompt({
+        params: { name: parsed.branch },
+        body: {
+          text: parsed.text,
+          ...parsed.preamble ? { preamble: parsed.preamble } : {}
         }
-        if (error instanceof Error && !error.message.includes("fetch")) {
-          throw error;
-        }
-        throw new Error(`Could not connect to webmux server on port ${context.port}. Is it running?`);
-      }
+      }));
       stdout(`Sent prompt to ${parsed.branch}`);
       return 0;
     }
@@ -19351,10 +20886,12 @@ async function runWorktreeCommand(context, deps2 = {}) {
     return 1;
   }
 }
-var PHASE_LABELS, CommandUsageError;
+var PHASE_LABELS;
 var init_worktree_commands = __esm(() => {
   init_dist4();
   init_src();
+  init_conversation_export_service();
+  init_shared();
   init_fs();
   init_tmux();
   init_policies();
@@ -19367,18 +20904,16 @@ var init_worktree_commands = __esm(() => {
     starting_session: "Starting session",
     reconciling: "Reconciling"
   };
-  CommandUsageError = class CommandUsageError extends Error {
-  };
 });
 
 // bin/src/webmux.ts
-import { resolve as resolve11, dirname as dirname6, join as join11 } from "path";
+import { resolve as resolve11, dirname as dirname6, join as join10 } from "path";
 import { existsSync as existsSync5 } from "fs";
 import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "webmux",
-  version: "0.31.2",
+  version: "0.32.0",
   description: "Web dashboard for workmux \u2014 browser UI with embedded terminals, PR monitoring, and CI integration",
   type: "module",
   repository: {
@@ -19446,6 +20981,7 @@ Usage:
   webmux service      Manage webmux as a system service
   webmux update       Update webmux to the latest version
   webmux add          Create a worktree using the dashboard lifecycle
+  webmux oneshot      Run a worktree start-to-finish, streaming logs to stdout
   webmux list         List worktrees and their status
   webmux open         Open an existing worktree session
   webmux close        Close a worktree session without removing it
@@ -19456,6 +20992,7 @@ Usage:
   webmux merge        Merge a worktree into the main branch and remove it
   webmux send         Send a prompt to a running worktree agent
   webmux prune        Remove all worktrees in the current project
+  webmux linear       Post a worktree conversation to a Linear issue/team
   webmux completion   Generate shell completion script (bash, zsh)
 
 Options:
@@ -19470,7 +21007,7 @@ Environment:
 `);
 }
 function isRootCommand(value) {
-  return value === "serve" || value === "init" || value === "service" || value === "update" || value === "add" || value === "list" || value === "open" || value === "close" || value === "archive" || value === "unarchive" || value === "label" || value === "remove" || value === "merge" || value === "send" || value === "prune" || value === "completion";
+  return value === "serve" || value === "init" || value === "service" || value === "update" || value === "add" || value === "oneshot" || value === "list" || value === "open" || value === "close" || value === "archive" || value === "unarchive" || value === "label" || value === "remove" || value === "merge" || value === "send" || value === "prune" || value === "linear" || value === "completion";
 }
 function isServeRootOption(value) {
   return value === "--port" || value === "--app" || value === "--debug" || value === "--help" || value === "-h" || value === "--version" || value === "-V";
@@ -19653,6 +21190,16 @@ async function main(args = process.argv.slice(2)) {
   }
   await loadEnvFile(resolve11(process.cwd(), ".env.local"));
   await loadEnvFile(resolve11(process.cwd(), ".env"));
+  if (parsed.command === "oneshot") {
+    const { runOneshotCommand: runOneshotCommand2 } = await Promise.resolve().then(() => (init_oneshot(), exports_oneshot));
+    const exitCode2 = await runOneshotCommand2(parsed.commandArgs, parsed.port);
+    process.exit(exitCode2);
+  }
+  if (parsed.command === "linear") {
+    const { runLinearCommand: runLinearCommand2 } = await Promise.resolve().then(() => (init_linear_commands(), exports_linear_commands));
+    const exitCode2 = await runLinearCommand2(parsed.commandArgs, parsed.port);
+    process.exit(exitCode2);
+  }
   if (isWorktreeCommand(parsed.command)) {
     const { runWorktreeCommand: runWorktreeCommand2 } = await Promise.resolve().then(() => (init_worktree_commands(), exports_worktree_commands));
     const exitCode2 = await runWorktreeCommand2({
@@ -19701,8 +21248,8 @@ async function main(args = process.argv.slice(2)) {
   }
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
-  const backendEntry = join11(PKG_ROOT, "backend", "dist", "server.js");
-  const staticDir = join11(PKG_ROOT, "frontend", "dist");
+  const backendEntry = join10(PKG_ROOT, "backend", "dist", "server.js");
+  const staticDir = join10(PKG_ROOT, "frontend", "dist");
   if (!existsSync5(staticDir)) {
     console.error(`Error: frontend/dist/ not found. Run 'bun run build' first.`);
     process.exit(1);