vibeman 0.0.16 → 0.0.18

package/dist/api.js

@@ -54569,22 +54569,18 @@ async function getRepoDirtyBeforeWorktreeCreateMessage(repoRoot, worktreePath, g
   }
   const { branch, lines, suffix } = await readGitStatusDetails(gitService);
   return [
-    "Cannot create a new task worktree because the repository root has uncommitted changes.",
+    "Cannot create a new task worktree while the repository root has uncommitted changes.",
     "",
-    "Why this happens:",
-    "A new worktree starts from the latest committed state. Uncommitted changes in the main repository are not copied into the new worktree, so it would open with stale code.",
+    "A new worktree starts from the latest committed state. Any uncommitted repository root changes would be missing from the new task worktree.",
     "",
-    "How to fix:",
-    "- Commit the changes in the main repository, or",
-    "- Stash them if you are not ready to commit, or",
-    "- Discard them if they are no longer needed.",
+    "Use the header Commit Changes button to review and commit the repository root changes.",
+    "If you are not ready to commit, stash or discard the root changes first.",
+    "Retry creating the worktree after the repository root is clean.",
     "",
-    "Then try creating the worktree again.",
-    "",
-    `Planned worktree:
-${worktreePath}`,
     `Repository root:
 ${repoRoot}`,
+    `Planned worktree:
+${worktreePath}`,
     `Branch:
 ${branch}`,
     `Changes:
@@ -55694,6 +55690,7 @@ async function listLatestTaskWorkflowStatusByTaskId(db, taskIds) {
         taskId,
         workflowType,
         status,
+        updatedAt,
         ROW_NUMBER() OVER (
           PARTITION BY taskId, workflowType
           ORDER BY updatedAt DESC, createdAt DESC, runId DESC
@@ -55703,7 +55700,7 @@ async function listLatestTaskWorkflowStatusByTaskId(db, taskIds) {
         AND taskId <> ''
         ${taskFilterSql}
     )
-    SELECT taskId, workflowType, status
+    SELECT taskId, workflowType, status, updatedAt
     FROM ranked_runs
     WHERE rownum = 1
     ORDER BY taskId ASC, workflowType ASC
@@ -55723,7 +55720,8 @@ async function listLatestTaskWorkflowStatusByTaskId(db, taskIds) {
     }
     statusByTaskId[row.taskId]?.push({
       workflowType,
-      status
+      status,
+      updatedAt: row.updatedAt instanceof Date ? row.updatedAt.toISOString() : String(row.updatedAt)
     });
   }
   for (const taskId of Object.keys(statusByTaskId)) {
@@ -59532,9 +59530,10 @@ var init_model_aliases = __esm(() => {
 });
 
 // ../api/src/services/agents/runtime-backend.ts
-import { mkdir as mkdir2 } from "node:fs/promises";
+import { existsSync as existsSync13 } from "node:fs";
+import { mkdir as mkdir2, lstat, readdir as readdir2, readlink, rm, symlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join4 } from "node:path";
+import { dirname as dirname4, join as join4, resolve as resolvePath4 } from "node:path";
 function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -59793,6 +59792,45 @@ async function applyClaudeRuntimeIsolation(request, env) {
     XDG_DATA_HOME: xdgDataHome
   };
 }
+function resolveCodexHome(env) {
+  const configured = env.CODEX_HOME?.trim();
+  if (configured) {
+    return resolvePath4(configured);
+  }
+  const home = env.HOME?.trim();
+  if (!home) {
+    return;
+  }
+  return resolvePath4(home, ".codex");
+}
+async function ensureSymlinkTarget(targetPath, sourcePath) {
+  try {
+    const stats = await lstat(targetPath);
+    if (stats.isSymbolicLink()) {
+      const existingTarget = await readlink(targetPath);
+      if (resolvePath4(dirname4(targetPath), existingTarget) === resolvePath4(sourcePath)) {
+        return;
+      }
+    }
+    await rm(targetPath, { recursive: true, force: true });
+  } catch {}
+  await symlink(sourcePath, targetPath);
+}
+async function applyCodexRuntimeIsolation(request, env) {
+  const sourceCodexHome = resolveCodexHome(env);
+  if (!sourceCodexHome || !existsSync13(sourceCodexHome)) {
+    return env;
+  }
+  const runId = toSafePathSegment(request.runId);
+  const isolationRoot = join4(tmpdir(), "vibeman", "runtime", "runs", runId, "codex-home");
+  await mkdir2(isolationRoot, { recursive: true });
+  const entries = await readdir2(sourceCodexHome, { withFileTypes: true });
+  await Promise.all(entries.filter((entry) => entry.name !== "superpowers").map((entry) => ensureSymlinkTarget(join4(isolationRoot, entry.name), join4(sourceCodexHome, entry.name))));
+  return {
+    ...env,
+    CODEX_HOME: isolationRoot
+  };
+}
 function shouldIsolateClaudeRuntime(env) {
   const anthropicAuthToken = env.ANTHROPIC_AUTH_TOKEN?.trim();
   const anthropicApiKey = env.ANTHROPIC_API_KEY?.trim();
@@ -59865,6 +59903,9 @@ async function compileAgentExecutionPlan(db, request) {
     ...resolvedLegacyEnv,
     ...resolvedOverrideEnv
   };
+  if (provider === "codex-cli") {
+    env = await applyCodexRuntimeIsolation(request, env);
+  }
   if (provider === "claude-code" && shouldIsolateClaudeRuntime(env)) {
     env = await applyClaudeRuntimeIsolation(request, env);
   }
@@ -60082,22 +60123,22 @@ var init_agents = __esm(() => {
 
 // ../api/src/services/env-symlinks.ts
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync13 } from "node:fs";
-import { lstat, readlink, readdir as readdir2, symlink } from "node:fs/promises";
-import { dirname as dirname4, normalize as normalize5, resolve as resolve12 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
+import { lstat as lstat2, readlink as readlink2, readdir as readdir3, symlink as symlink2 } from "node:fs/promises";
+import { dirname as dirname5, normalize as normalize5, resolve as resolve12 } from "node:path";
 async function ensureEnvSymlinks(options2) {
   const log = logger.child({ module: "env-symlinks", ...options2.logContext });
-  if (!existsSync13(options2.repoRoot)) {
+  if (!existsSync14(options2.repoRoot)) {
     log.warn({ repoRoot: options2.repoRoot }, "Repo root does not exist; skipping env symlinks.");
     return;
   }
-  if (!existsSync13(options2.targetRoot)) {
+  if (!existsSync14(options2.targetRoot)) {
     log.warn({ targetRoot: options2.targetRoot }, "Target root does not exist; skipping env symlinks.");
     return;
   }
   let entries;
   try {
-    entries = await readdir2(options2.repoRoot);
+    entries = await readdir3(options2.repoRoot);
   } catch (error48) {
     log.warn({ error: error48 }, "Failed to read repo root for env symlinks.");
     return;
@@ -60116,7 +60157,7 @@ async function ensureEnvSymlinks(options2) {
     const sourcePath = resolve12(options2.repoRoot, name2);
     const targetPath = resolve12(options2.targetRoot, name2);
     try {
-      const sourceStat = await lstat(sourcePath);
+      const sourceStat = await lstat2(sourcePath);
       if (!sourceStat.isFile()) {
         log.info({ file: name2 }, "Skipping env entry that is not a regular file.");
         continue;
@@ -60140,10 +60181,10 @@ function isGitIgnored(repoRoot, relativePath, log) {
 }
 async function ensureSymlink(sourcePath, targetPath, log, filename) {
   try {
-    const existing = await lstat(targetPath);
+    const existing = await lstat2(targetPath);
     if (existing.isSymbolicLink()) {
-      const linkTarget = await readlink(targetPath);
-      const resolvedTarget = normalize5(resolve12(dirname4(targetPath), linkTarget));
+      const linkTarget = await readlink2(targetPath);
+      const resolvedTarget = normalize5(resolve12(dirname5(targetPath), linkTarget));
       const resolvedSource = normalize5(resolve12(sourcePath));
       if (resolvedTarget === resolvedSource) {
         return;
@@ -60160,7 +60201,7 @@ async function ensureSymlink(sourcePath, targetPath, log, filename) {
     }
   }
   try {
-    await symlink(sourcePath, targetPath, "file");
+    await symlink2(sourcePath, targetPath, "file");
   } catch (error48) {
     log.warn({ error: error48, file: filename, target: targetPath }, "Failed to create env symlink.");
   }
@@ -102232,7 +102273,7 @@ var init_prompt_builder = __esm(() => {
 // ../api/src/services/workflows/executor.ts
 import { spawn as spawn5 } from "node:child_process";
 import { readFileSync as readFileSync4 } from "node:fs";
-import { resolve as resolvePath4 } from "node:path";
+import { resolve as resolvePath5 } from "node:path";
 function createExecutorControl() {
   const abortController = new AbortController;
   let child = null;
@@ -103132,7 +103173,7 @@ function normalizeEnvPath(raw2) {
   const trimmed2 = raw2.trim();
   if (trimmed2.length === 0)
     return null;
-  return resolvePath4(trimmed2);
+  return resolvePath5(trimmed2);
 }
 function summarizeShellFailure(command, result) {
   const SNIPPET_LINES = 30;
@@ -105316,7 +105357,7 @@ var init_workflows = __esm(() => {
 
 // ../api/src/server/routes/tasks.ts
 import { normalize as normalize9, resolve as resolve16, join as join5, relative as relative5, sep as sep2 } from "node:path";
-import { writeFile as writeFile3, mkdir as mkdir3 } from "node:fs/promises";
+import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir3, rm as rm2 } from "node:fs/promises";
 function normalizeFrontmatterTags(value) {
   if (Array.isArray(value)) {
     return value.map((tag) => String(tag).trim()).filter(Boolean);
@@ -105363,6 +105404,117 @@ function runBelongsToTask(payload, plan, explicitTaskId) {
     return true;
   return false;
 }
+function buildTaskDeleteCommitMessage(taskId, taskTitle) {
+  const normalizedId = taskId.trim();
+  const normalizedTitle = taskTitle?.trim() ?? "";
+  const raw2 = `task: ${normalizedId} ${normalizedTitle} deleted`.replace(/\s+/g, " ").trim();
+  return raw2 || `task: ${normalizedId} deleted`;
+}
+async function deleteTaskFileWithCommit(args) {
+  for (const file2 of args.deletedFiles) {
+    await rm2(resolve16(args.rootPath, file2.path), { force: true });
+  }
+  if (!args.commitDirect) {
+    return { commit: null };
+  }
+  try {
+    const commit = await args.git.commit(args.commitMessage, {
+      paths: args.deletedFiles.map((file2) => file2.path)
+    });
+    return { commit };
+  } catch (error48) {
+    try {
+      await Promise.all(args.deletedFiles.map((file2) => writeFile3(resolve16(args.rootPath, file2.path), file2.content)));
+    } catch (restoreError) {
+      const restoreMessage = restoreError instanceof Error ? restoreError.message : "Unknown restore error";
+      const originalMessage = error48 instanceof Error ? error48.message : "Unknown commit error";
+      throw new Error(`Unable to commit task delete (${originalMessage}). The task file could not be restored (${restoreMessage}).`);
+    }
+    throw error48;
+  }
+}
+async function collectRestorableTaskDeleteFiles(args) {
+  const deletedFiles = [
+    { path: args.taskPath, content: args.taskContent }
+  ];
+  const assetPaths = collectTaskAssetPaths(args.taskContent);
+  for (const assetPath of assetPaths) {
+    try {
+      deletedFiles.push({
+        path: assetPath,
+        content: await readFile5(resolve16(args.rootPath, assetPath))
+      });
+    } catch (error48) {
+      if (error48 instanceof Error && error48.code === "ENOENT") {
+        continue;
+      }
+      throw error48;
+    }
+  }
+  return deletedFiles;
+}
+async function cleanupTaskGitArtifacts(rootPath, plan) {
+  const git = createGitService(rootPath);
+  const worktrees = await git.listWorktrees();
+  const normalizedTarget = normalize9(plan.worktreePath);
+  const rootPathNormalized = normalize9(resolve16(rootPath));
+  const matchingWorktrees = worktrees.filter((worktree) => {
+    const resolvedPath = normalize9(resolve16(rootPath, worktree.path));
+    return resolvedPath === normalizedTarget || worktree.branch === plan.branchName;
+  });
+  for (const worktree of matchingWorktrees) {
+    const resolvedPath = normalize9(resolve16(rootPath, worktree.path));
+    const relativePath = relative5(rootPathNormalized, resolvedPath);
+    const isWithinRoot2 = relativePath === "" || !relativePath.startsWith("..") && !relativePath.startsWith(`..${sep2}`);
+    if (isWithinRoot2) {
+      continue;
+    }
+    await git.removeWorktree(worktree.path, { force: true });
+  }
+  await git.pruneWorktrees();
+  const hasBranch = await git.branchExists(plan.branchName);
+  if (!hasBranch) {
+    return;
+  }
+  const currentBranch = await git.getCurrentBranch();
+  if (currentBranch === plan.branchName) {
+    const localBranches = await git.listLocalBranches();
+    const fallbackCandidates = [await git.getDefaultBranch(), "main", "master", ...localBranches];
+    const fallbackBranch = fallbackCandidates.find((branch) => branch && branch !== plan.branchName && localBranches.includes(branch)) ?? "";
+    if (!fallbackBranch) {
+      throw new Error(`Cannot delete branch "${plan.branchName}" because it is currently checked out.`);
+    }
+    await git.checkoutBranch(fallbackBranch);
+  }
+  await git.removeBranch(plan.branchName, { force: true });
+}
+async function cleanupTaskWorkflowRuns(args) {
+  let deletedRuns = 0;
+  let cancelledRuns = 0;
+  const runs = await args.db.workflowRun.findMany({
+    where: { deletedAt: null },
+    select: { id: true, status: true, runPayload: true }
+  });
+  const relatedRuns = runs.filter((run2) => runBelongsToTask(run2.runPayload ?? null, args.plan, args.explicitTaskId));
+  const workflowService = createWorkflowService({ db: args.db, root: args.rootPath });
+  const cancellableRuns = relatedRuns.filter((run2) => {
+    const status = String(run2.status).toLowerCase();
+    return status === "running" || status === "pending" || status === "paused";
+  });
+  for (const run2 of cancellableRuns) {
+    await workflowService.cancelRun(run2.id, args.cancelReason);
+    cancelledRuns += 1;
+  }
+  const runIds = relatedRuns.map((run2) => run2.id);
+  if (runIds.length > 0) {
+    const result = await args.db.workflowRun.updateMany({
+      where: { id: { in: runIds } },
+      data: { deletedAt: new Date }
+    });
+    deletedRuns = result.count;
+  }
+  return { deletedRuns, cancelledRuns };
+}
 function parseTaskFile(filename, content) {
   const parsed = import_gray_matter2.default(content);
   const frontmatter = { ...parsed.data };
@@ -105408,6 +105560,7 @@ var init_tasks2 = __esm(() => {
   init_log();
   init_task_markdown();
   init_task_id();
+  init_task_commit_paths();
   init_tasks();
   init_workflows();
   init_trpc();
@@ -105763,44 +105916,8 @@ var init_tasks2 = __esm(() => {
           cause: error48 instanceof Error ? error48 : undefined
         });
       }
-      const git = createGitService(ctx.root);
       try {
-        const worktrees = await git.listWorktrees();
-        const normalizedTarget = normalize9(plan.worktreePath);
-        const rootPath = normalize9(resolve16(ctx.root));
-        const matchingWorktrees = worktrees.filter((worktree) => {
-          const resolvedPath = normalize9(resolve16(ctx.root, worktree.path));
-          return resolvedPath === normalizedTarget || worktree.branch === plan.branchName;
-        });
-        for (const worktree of matchingWorktrees) {
-          const resolvedPath = normalize9(resolve16(ctx.root, worktree.path));
-          const relativePath = relative5(rootPath, resolvedPath);
-          const isWithinRoot2 = relativePath === "" || !relativePath.startsWith("..") && !relativePath.startsWith(`..${sep2}`);
-          if (isWithinRoot2) {
-            continue;
-          }
-          await git.removeWorktree(worktree.path, { force: true });
-        }
-        await git.pruneWorktrees();
-        const hasBranch = await git.branchExists(plan.branchName);
-        if (hasBranch) {
-          const currentBranch = await git.getCurrentBranch();
-          if (currentBranch === plan.branchName) {
-            const localBranches = await git.listLocalBranches();
-            const fallbackCandidates = [
-              await git.getDefaultBranch(),
-              "main",
-              "master",
-              ...localBranches
-            ];
-            const fallbackBranch = fallbackCandidates.find((branch) => branch && branch !== plan.branchName && localBranches.includes(branch)) ?? "";
-            if (!fallbackBranch) {
-              throw new Error(`Cannot delete branch "${plan.branchName}" because it is currently checked out.`);
-            }
-            await git.checkoutBranch(fallbackBranch);
-          }
-          await git.removeBranch(plan.branchName, { force: true });
-        }
+        await cleanupTaskGitArtifacts(ctx.root, plan);
       } catch (error48) {
         const message = error48 instanceof Error ? error48.message : "Unable to reset git worktree and branch";
         throw new TRPCError({
@@ -105812,28 +105929,13 @@ var init_tasks2 = __esm(() => {
       let deletedRuns = 0;
       let cancelledRuns = 0;
       try {
-        const runs = await ctx.db.workflowRun.findMany({
-          where: { deletedAt: null },
-          select: { id: true, status: true, runPayload: true }
-        });
-        const relatedRuns = runs.filter((run2) => runBelongsToTask(run2.runPayload ?? null, plan, input.taskId));
-        const workflowService = createWorkflowService({ db: ctx.db, root: ctx.root });
-        const cancellableRuns = relatedRuns.filter((run2) => {
-          const status = String(run2.status).toLowerCase();
-          return status === "running" || status === "pending" || status === "paused";
-        });
-        for (const run2 of cancellableRuns) {
-          await workflowService.cancelRun(run2.id, "Cancelled by task reset");
-          cancelledRuns += 1;
-        }
-        const runIds = relatedRuns.map((run2) => run2.id);
-        if (runIds.length > 0) {
-          const result = await ctx.db.workflowRun.updateMany({
-            where: { id: { in: runIds } },
-            data: { deletedAt: new Date }
-          });
-          deletedRuns = result.count;
-        }
+        ({ deletedRuns, cancelledRuns } = await cleanupTaskWorkflowRuns({
+          db: ctx.db,
+          rootPath: ctx.root,
+          plan,
+          explicitTaskId: input.taskId,
+          cancelReason: "Cancelled by task reset"
+        }));
       } catch (error48) {
         const message = error48 instanceof Error ? error48.message : "Unable to reset workflow runs and states for task";
         throw new TRPCError({
@@ -105851,6 +105953,112 @@ var init_tasks2 = __esm(() => {
         deletedRuns
       });
     }),
+    delete: dbProcedure.input(exports_external.object({
+      filename: exports_external.string().min(1),
+      taskId: exports_external.string().min(1).optional(),
+      commitDirect: exports_external.boolean().optional(),
+      commitMessage: exports_external.string().min(1).optional()
+    })).mutation(async ({ ctx, input }) => {
+      const taskPath = join5(".vibeman/tasks", input.filename);
+      let plan;
+      let taskTitle;
+      let existingContent = "";
+      try {
+        plan = buildTaskExecutionPlan(ctx.root, taskPath);
+        existingContent = await readFileContent(ctx.root, taskPath);
+        const parsed = import_gray_matter2.default(existingContent);
+        taskTitle = typeof parsed.data.title === "string" ? parsed.data.title : undefined;
+      } catch (error48) {
+        const message = error48 instanceof Error ? error48.message : "Unable to prepare task delete plan";
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message,
+          cause: error48 instanceof Error ? error48 : undefined
+        });
+      }
+      let deletedFiles;
+      try {
+        deletedFiles = await collectRestorableTaskDeleteFiles({
+          rootPath: ctx.root,
+          taskPath,
+          taskContent: existingContent
+        });
+      } catch (error48) {
+        const message = error48 instanceof Error ? error48.message : "Unable to prepare task attachments for delete";
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message,
+          cause: error48 instanceof Error ? error48 : undefined
+        });
+      }
+      const commitDirect = input.commitDirect ?? true;
+      let commitResult = null;
+      const git = createGitService(ctx.root);
+      if (commitDirect) {
+        try {
+          ({ commit: commitResult } = await deleteTaskFileWithCommit({
+            rootPath: ctx.root,
+            deletedFiles,
+            commitDirect,
+            commitMessage: input.commitMessage?.trim() || buildTaskDeleteCommitMessage(plan.taskId, taskTitle),
+            git
+          }));
+        } catch (error48) {
+          const message = error48 instanceof Error ? error48.message : "Unable to commit task delete";
+          throw new TRPCError({
+            code: "BAD_REQUEST",
+            message,
+            cause: error48 instanceof Error ? error48 : undefined
+          });
+        }
+      } else {
+        try {
+          ({ commit: commitResult } = await deleteTaskFileWithCommit({
+            rootPath: ctx.root,
+            deletedFiles,
+            commitDirect,
+            commitMessage: "",
+            git
+          }));
+        } catch (error48) {
+          const message = error48 instanceof Error ? error48.message : "Unable to delete task file";
+          throw new TRPCError({
+            code: "INTERNAL_SERVER_ERROR",
+            message,
+            cause: error48 instanceof Error ? error48 : undefined
+          });
+        }
+      }
+      let deletedRuns = 0;
+      let cancelledRuns = 0;
+      const cleanupWarnings = [];
+      try {
+        await cleanupTaskGitArtifacts(ctx.root, plan);
+      } catch (error48) {
+        cleanupWarnings.push(error48 instanceof Error ? error48.message : "Unable to delete task worktree and branch");
+      }
+      try {
+        ({ deletedRuns, cancelledRuns } = await cleanupTaskWorkflowRuns({
+          db: ctx.db,
+          rootPath: ctx.root,
+          plan,
+          explicitTaskId: input.taskId,
+          cancelReason: "Cancelled by task delete"
+        }));
+      } catch (error48) {
+        cleanupWarnings.push(error48 instanceof Error ? error48.message : "Unable to delete workflow runs and states for task");
+      }
+      return createResponse(ctx, {
+        taskPath: plan.taskPath,
+        taskName: plan.taskName,
+        branch: plan.branchName,
+        worktree: plan.worktreePath,
+        cancelledRuns,
+        deletedRuns,
+        commit: commitResult,
+        cleanupWarnings
+      });
+    }),
     setup: dbProcedure.input(exports_external.object({ filename: exports_external.string().min(1) })).mutation(async ({ ctx, input }) => {
       const taskPath = join5(".vibeman/tasks", input.filename);
       let plan;
@@ -105928,7 +106136,7 @@ function classifyMergeReadiness(input) {
 
 // ../api/src/server/routes/workflows.ts
 import { normalize as normalize10, relative as relative6, resolve as resolve17 } from "node:path";
-import { readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
+import { readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
 import { execFile as execFile4 } from "node:child_process";
 import { promisify } from "node:util";
 function workflowRecency(workflow) {
@@ -106354,7 +106562,7 @@ function resolvePathWithinRoot(rootPath, pathInput) {
 }
 async function markTaskFrontmatterDone(rootPath, taskPath) {
   const filePath = resolvePathWithinRoot(rootPath, taskPath);
-  const raw2 = await readFile5(filePath, "utf8");
+  const raw2 = await readFile6(filePath, "utf8");
   const match = raw2.match(/^---\n([\s\S]*?)\n---\n?/);
   if (!match) {
     return false;
@@ -107968,10 +108176,11 @@ var init_remote_access = __esm(() => {
 });
 
 // ../api/src/server/routes/system.ts
-import { spawn as spawn7 } from "node:child_process";
-import { resolve as resolve18, relative as relative7, sep as sep3 } from "node:path";
-import { access as access3 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
+import { execFile as execFile5, spawn as spawn7 } from "node:child_process";
+import { resolve as resolve18, relative as relative7, sep as sep3, join as join6, extname } from "node:path";
+import { access as access3, mkdtemp, readFile as readFile7, rm as rm3 } from "node:fs/promises";
+import { homedir as homedir2, tmpdir as tmpdir2 } from "node:os";
+import { promisify as promisify2 } from "node:util";
 function isWithin2(rootPath, targetPath) {
   const relativePath = relative7(rootPath, targetPath);
   return relativePath === "" || !relativePath.startsWith("..") && !relativePath.startsWith(`..${sep3}`);
@@ -108003,11 +108212,108 @@ async function isAnyDetectionPathAccessible(paths) {
   }
   return false;
 }
+async function resolveAccessibleDetectionPath(paths) {
+  for (const rawPath of paths) {
+    const candidate = resolveDetectionPath(rawPath);
+    try {
+      await access3(candidate);
+      return candidate;
+    } catch {}
+  }
+  return null;
+}
+function normalizeIconFileName(value) {
+  if (typeof value !== "string" || value.trim().length === 0)
+    return null;
+  const trimmed2 = value.trim();
+  return extname(trimmed2) ? trimmed2 : `${trimmed2}.icns`;
+}
+function extractIconFileName(plist) {
+  const directCandidates = [
+    plist.CFBundleIconFile,
+    plist.CFBundleIconName,
+    plist.CFBundlePrimaryIcon?.CFBundleIconFile
+  ];
+  for (const candidate of directCandidates) {
+    const normalized = normalizeIconFileName(candidate);
+    if (normalized)
+      return normalized;
+  }
+  const bundleIcons = plist.CFBundleIcons;
+  if (bundleIcons && typeof bundleIcons === "object") {
+    const primaryIcon = bundleIcons.CFBundlePrimaryIcon;
+    if (primaryIcon && typeof primaryIcon === "object") {
+      const iconFiles = primaryIcon.CFBundleIconFiles;
+      if (Array.isArray(iconFiles)) {
+        for (const candidate of [...iconFiles].reverse()) {
+          const normalized = normalizeIconFileName(candidate);
+          if (normalized)
+            return normalized;
+        }
+      }
+    }
+  }
+  return null;
+}
+function toDataUrl(buffer, extension) {
+  const normalized = extension.toLowerCase();
+  if (normalized === ".svg") {
+    return `data:image/svg+xml;base64,${buffer.toString("base64")}`;
+  }
+  if (normalized === ".jpg" || normalized === ".jpeg") {
+    return `data:image/jpeg;base64,${buffer.toString("base64")}`;
+  }
+  return `data:image/png;base64,${buffer.toString("base64")}`;
+}
+async function convertIcnsToPngDataUrl(iconPath) {
+  const tempDir = await mkdtemp(join6(tmpdir2(), "vibeman-app-icon-"));
+  const pngPath = join6(tempDir, "icon.png");
+  try {
+    await execFileAsync2("sips", ["-s", "format", "png", iconPath, "--out", pngPath]);
+    const pngBuffer = await readFile7(pngPath);
+    return toDataUrl(pngBuffer, ".png");
+  } finally {
+    await rm3(tempDir, { recursive: true, force: true });
+  }
+}
+async function readAppIconDataUrl(appPath) {
+  const cached2 = appIconCache.get(appPath);
+  if (cached2 !== undefined)
+    return cached2;
+  const infoPlistPath = join6(appPath, "Contents", "Info.plist");
+  try {
+    const { stdout } = await execFileAsync2("plutil", [
+      "-convert",
+      "json",
+      "-o",
+      "-",
+      infoPlistPath
+    ]);
+    const plist = JSON.parse(stdout);
+    const iconFileName = extractIconFileName(plist);
+    if (!iconFileName) {
+      appIconCache.set(appPath, null);
+      return null;
+    }
+    const iconPath = join6(appPath, "Contents", "Resources", iconFileName);
+    await access3(iconPath);
+    const extension = extname(iconPath).toLowerCase();
+    const dataUrl = extension === ".icns" ? await convertIcnsToPngDataUrl(iconPath) : toDataUrl(await readFile7(iconPath), extension);
+    appIconCache.set(appPath, dataUrl);
+    return dataUrl;
+  } catch {
+    appIconCache.set(appPath, null);
+    return null;
+  }
+}
 async function listAvailableApps(category) {
   const defs = appCatalog.filter((app) => app.category === category);
   const results = await Promise.all(defs.map(async (app) => {
-    const installed = await isAnyDetectionPathAccessible(app.detectionPaths);
-    return installed ? { id: app.id, label: app.label } : null;
+    const installedPath = await resolveAccessibleDetectionPath(app.detectionPaths);
+    if (!installedPath)
+      return null;
+    const iconDataUrl = await readAppIconDataUrl(installedPath);
+    return { id: app.id, label: app.label, iconDataUrl };
   }));
   return results.filter(Boolean);
 }
@@ -108059,7 +108365,7 @@ async function openInApp(appName, targetPath) {
     });
   });
 }
-var appCategories, appCatalog, systemRouter;
+var appCategories, execFileAsync2, appIconCache, appCatalog, systemRouter;
 var init_system2 = __esm(() => {
   init_dist4();
   init_zod();
@@ -108067,6 +108373,8 @@ var init_system2 = __esm(() => {
   init_env_policy();
   init_remote_access();
   appCategories = ["terminal", "editor"];
+  execFileAsync2 = promisify2(execFile5);
+  appIconCache = new Map;
   appCatalog = [
     {
       id: "warp",
@@ -108113,6 +108421,13 @@ var init_system2 = __esm(() => {
       openAppName: "Antigravity",
       detectionPaths: ["/Applications/Antigravity.app", "~/Applications/Antigravity.app"]
     },
+    {
+      id: "zed",
+      category: "editor",
+      label: "Zed",
+      openAppName: "Zed",
+      detectionPaths: ["/Applications/Zed.app", "~/Applications/Zed.app"]
+    },
     {
       id: "vscode",
       category: "editor",
@@ -108310,7 +108625,7 @@ var init_system2 = __esm(() => {
 
 // ../api/src/services/assets.ts
 import { mkdir as mkdir4, writeFile as writeFile5 } from "node:fs/promises";
-import { extname, resolve as resolve19, sep as sep4 } from "node:path";
+import { extname as extname2, resolve as resolve19, sep as sep4 } from "node:path";
 import { randomUUID } from "node:crypto";
 function getImagesDir(rootPath) {
   return resolve19(rootPath, ".vibeman/assets/images");
@@ -108322,7 +108637,7 @@ async function writeImageAsset(options2) {
   const imagesDir = getImagesDir(options2.rootPath);
   await mkdir4(imagesDir, { recursive: true });
   const extFromMime = imageMimeToExt[options2.mimeType] ?? null;
-  const extFromNameRaw = options2.originalName ? sanitizeExt(extname(options2.originalName)) : null;
+  const extFromNameRaw = options2.originalName ? sanitizeExt(extname2(options2.originalName)) : null;
   const extFromName = extFromNameRaw ? imageExtAliases[extFromNameRaw] ?? null : null;
   const ext = extFromMime ?? extFromName ?? null;
   if (!ext) {
@@ -108647,12 +108962,12 @@ var init_model_catalog = __esm(() => {
 });
 
 // ../api/src/server/routes/cli-settings.ts
-import { delimiter as delimiter4, dirname as dirname5 } from "node:path";
+import { delimiter as delimiter4, dirname as dirname6 } from "node:path";
 function withExecutableOnPath(env, executable) {
   if (!executable) {
     return env;
   }
-  const dir = dirname5(executable);
+  const dir = dirname6(executable);
   const basePath = env.PATH ?? process.env.PATH ?? "";
   const combined = [dir, basePath].filter(Boolean).join(delimiter4);
   return { ...env, PATH: combined };
@@ -112852,7 +113167,7 @@ var init_github = __esm(() => {
 });
 
 // ../api/src/services/integrations/github-sync.ts
-import { join as join6, resolve as resolve20 } from "node:path";
+import { join as join7, resolve as resolve20 } from "node:path";
 import { mkdir as mkdir5, writeFile as writeFile6 } from "node:fs/promises";
 function mapIssueStateToTaskStatus(state2) {
   return state2 === "open" ? "backlog" : "done";
@@ -112873,7 +113188,7 @@ async function findTaskForIssue(rootPath, owner, repo, issueNumber) {
         continue;
       }
       try {
-        const content = await readFileContent(rootPath, join6(tasksPath, file2.name));
+        const content = await readFileContent(rootPath, join7(tasksPath, file2.name));
         const parsed = import_gray_matter3.default(content);
         if (isTaskLinkedToIssue(parsed.data, owner, repo, issueNumber)) {
           return {
@@ -112923,7 +113238,7 @@ async function syncIssueToTask(rootPath, owner, repo, issue2, options2) {
     };
     const content = import_gray_matter3.default.stringify(taskBody, updatedFrontmatter, frontmatterYamlOptions2);
     const tasksDir = resolve20(rootPath, ".vibeman/tasks");
-    await writeFile6(join6(tasksDir, existingTask.filename), content);
+    await writeFile6(join7(tasksDir, existingTask.filename), content);
     return { action: "updated", filename: existingTask.filename };
   } else {
     const taskId = generateTaskIdFromIssue(issue2);
@@ -112943,7 +113258,7 @@ async function syncIssueToTask(rootPath, owner, repo, issue2, options2) {
     const content = import_gray_matter3.default.stringify(taskBody, frontmatter, frontmatterYamlOptions2);
     const tasksDir = resolve20(rootPath, ".vibeman/tasks");
     await mkdir5(tasksDir, { recursive: true });
-    await writeFile6(join6(tasksDir, filename), content);
+    await writeFile6(join7(tasksDir, filename), content);
     return { action: "created", filename };
   }
 }
@@ -113008,7 +113323,7 @@ async function syncTaskToGitHub(db, rootPath, taskFilename) {
     throw new Error("GitHub integration is not configured");
   }
   const tasksPath = ".vibeman/tasks";
-  const content = await readFileContent(rootPath, join6(tasksPath, taskFilename));
+  const content = await readFileContent(rootPath, join7(tasksPath, taskFilename));
   const parsed = import_gray_matter3.default(content);
   const githubRepo = parsed.data.github_repo;
   const githubIssueNumberRaw = parsed.data.github_issue_number;
@@ -113037,7 +113352,7 @@ async function syncTaskToGitHub(db, rootPath, taskFilename) {
   };
   const updatedContent = import_gray_matter3.default.stringify(parsed.content, updatedFrontmatter, stringifyOptions);
   const tasksDir = resolve20(rootPath, ".vibeman/tasks");
-  await writeFile6(join6(tasksDir, taskFilename), updatedContent);
+  await writeFile6(join7(tasksDir, taskFilename), updatedContent);
 }
 async function syncIssueToTaskFromGitHub(db, rootPath, taskFilename) {
   const config2 = await getGitHubConfig(db);
@@ -113045,7 +113360,7 @@ async function syncIssueToTaskFromGitHub(db, rootPath, taskFilename) {
     throw new Error("GitHub integration is not configured");
   }
   const tasksPath = ".vibeman/tasks";
-  const content = await readFileContent(rootPath, join6(tasksPath, taskFilename));
+  const content = await readFileContent(rootPath, join7(tasksPath, taskFilename));
   const parsed = import_gray_matter3.default(content);
   const githubRepo = parsed.data.github_repo;
   const githubIssueNumberRaw = parsed.data.github_issue_number;
@@ -113065,7 +113380,7 @@ async function syncIssueToTaskFromGitHub(db, rootPath, taskFilename) {
 }
 async function linkTaskToGitHubIssue(rootPath, taskFilename, owner, repo, issueNumber, issueUrl) {
   const tasksPath = ".vibeman/tasks";
-  const content = await readFileContent(rootPath, join6(tasksPath, taskFilename));
+  const content = await readFileContent(rootPath, join7(tasksPath, taskFilename));
   const parsed = import_gray_matter3.default(content);
   const repoIdentifier = `${owner}/${repo}`;
   const githubMetadata = {
@@ -113081,11 +113396,11 @@ async function linkTaskToGitHubIssue(rootPath, taskFilename, owner, repo, issueN
   };
   const updatedContent = import_gray_matter3.default.stringify(parsed.content, updatedFrontmatter, stringifyOptions);
   const tasksDir = resolve20(rootPath, ".vibeman/tasks");
-  await writeFile6(join6(tasksDir, taskFilename), updatedContent);
+  await writeFile6(join7(tasksDir, taskFilename), updatedContent);
 }
 async function unlinkTaskFromGitHubIssue(rootPath, taskFilename) {
   const tasksPath = ".vibeman/tasks";
-  const content = await readFileContent(rootPath, join6(tasksPath, taskFilename));
+  const content = await readFileContent(rootPath, join7(tasksPath, taskFilename));
   const parsed = import_gray_matter3.default(content);
   const updatedFrontmatter = { ...parsed.data };
   delete updatedFrontmatter.github_repo;
@@ -113095,7 +113410,7 @@ async function unlinkTaskFromGitHubIssue(rootPath, taskFilename) {
   updatedFrontmatter.updated_at = new Date().toISOString();
   const updatedContent = import_gray_matter3.default.stringify(parsed.content, updatedFrontmatter, stringifyOptions);
   const tasksDir = resolve20(rootPath, ".vibeman/tasks");
-  await writeFile6(join6(tasksDir, taskFilename), updatedContent);
+  await writeFile6(join7(tasksDir, taskFilename), updatedContent);
 }
 var import_gray_matter3, stringifyOptions, parseTimestamp = (value) => {
   if (typeof value !== "string")
@@ -113127,7 +113442,7 @@ var import_gray_matter3, stringifyOptions, parseTimestamp = (value) => {
         continue;
       }
       try {
-        const content = await readFileContent(rootPath, join6(tasksPath, file2.name));
+        const content = await readFileContent(rootPath, join7(tasksPath, file2.name));
         const parsed = import_gray_matter3.default(content);
         if (!shouldPushTaskToGitHub(parsed.data, owner, repo))
           continue;
@@ -113358,9 +113673,283 @@ var init_github3 = __esm(() => {
   });
 });
 
+// ../api/src/services/feedback.ts
+function shouldRedactUnixPath(path3) {
+  if (path3 === "~")
+    return false;
+  return path3.startsWith("~/") || path3.startsWith("/");
+}
+function isSensitiveEnvKey(key) {
+  return /(token|secret|password|passwd|auth|session|cookie|api_?key)/i.test(key);
+}
+function sanitizeText(value) {
+  return value.replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, "[REDACTED_EMAIL]").replace(/\b(Bearer\s+)[A-Za-z0-9._\-]+/gi, "$1[REDACTED_TOKEN]").replace(/\b(sk-[A-Za-z0-9]{12,})\b/g, "[REDACTED_TOKEN]").replace(/\b(gh[pousr]_[A-Za-z0-9]{12,})\b/g, "[REDACTED_TOKEN]").replace(/\b(github_pat_[A-Za-z0-9_]{20,})\b/g, "[REDACTED_TOKEN]").replace(/\b(xox[baprs]-[A-Za-z0-9-]{10,})\b/g, "[REDACTED_TOKEN]").replace(ABSOLUTE_WINDOWS_PATH_PATTERN, (_, prefix, path3) => {
+    return `${prefix}[REDACTED_PATH]`;
+  }).replace(ABSOLUTE_UNIX_PATH_PATTERN, (_, prefix, path3) => {
+    return shouldRedactUnixPath(path3) ? `${prefix}[REDACTED_PATH]` : `${prefix}${path3}`;
+  }).replace(ENV_ASSIGNMENT_PATTERN, (match, key) => {
+    return isSensitiveEnvKey(key) ? `${key}=[REDACTED_TOKEN]` : match;
+  });
+}
+function collapseBlankLines(value) {
+  return value.replace(/\n{3,}/g, `
+
+`).trim();
+}
+function sanitizeFeedbackText(value) {
+  return collapseBlankLines(sanitizeText(value.trim()));
+}
+function sanitizeBrowserFeedbackContext(input) {
+  if (!input)
+    return;
+  const entries = Object.entries(input).flatMap(([key, value]) => {
+    if (typeof value !== "string")
+      return [];
+    const sanitized = sanitizeFeedbackText(value);
+    return sanitized ? [[key, sanitized]] : [];
+  });
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function fallbackTitleFromBody(body) {
+  const line = body.split(`
+`).map((entry) => entry.trim()).find((entry) => entry.length > 0 && !entry.startsWith("#") && !entry.startsWith("- "));
+  if (!line)
+    return "Feedback";
+  return line.slice(0, FEEDBACK_TITLE_MAX_LENGTH);
+}
+function normalizeFeedbackIssueDraft(input) {
+  const title = sanitizeFeedbackText(input.title ?? "").replace(/\s+/g, " ").trim();
+  const body = sanitizeFeedbackText(input.body ?? "");
+  return {
+    title: (title || fallbackTitleFromBody(body) || "Feedback").slice(0, FEEDBACK_TITLE_MAX_LENGTH),
+    body: body.slice(0, FEEDBACK_BODY_MAX_LENGTH) || "No additional details provided."
+  };
+}
+function sanitizeFeedbackIssueDraft(input) {
+  return normalizeFeedbackIssueDraft(input);
+}
+function parsePolishedFeedbackOutput(output) {
+  const trimmed2 = output.trim();
+  if (!trimmed2)
+    return null;
+  const fencedJsonMatch = trimmed2.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const jsonCandidate = fencedJsonMatch?.[1] ?? trimmed2;
+  const jsonMatch = jsonCandidate.match(/\{[\s\S]*\}/);
+  if (jsonMatch) {
+    try {
+      return feedbackIssueDraftSchema.parse(JSON.parse(jsonMatch[0]));
+    } catch {}
+  }
+  const titleMatch = trimmed2.match(/(?:^|\n)TITLE:\s*(.+?)(?:\n|$)/i);
+  const bodyMatch = trimmed2.match(/(?:^|\n)BODY:\s*([\s\S]+)/i);
+  if (titleMatch && bodyMatch) {
+    return normalizeFeedbackIssueDraft({
+      title: titleMatch[1],
+      body: bodyMatch[1]
+    });
+  }
+  return null;
+}
+function buildBrowserContextSection(browserContext) {
+  const entries = [
+    browserContext?.platform ? `- Platform: ${browserContext.platform}` : null,
+    browserContext?.operatingSystem ? `- OS: ${browserContext.operatingSystem}` : null,
+    browserContext?.browser ? `- Browser: ${browserContext.browser}` : null,
+    browserContext?.viewport ? `- Viewport: ${browserContext.viewport}` : null,
+    browserContext?.devicePixelRatio ? `- Device Pixel Ratio: ${browserContext.devicePixelRatio}` : null,
+    browserContext?.language ? `- Language: ${browserContext.language}` : null,
+    browserContext?.touchSupport ? `- Touch Support: ${browserContext.touchSupport}` : null,
+    browserContext?.walletContext ? `- Wallet/Web3 Context: ${browserContext.walletContext}` : null,
+    browserContext?.appVersion ? `- App Version: ${browserContext.appVersion}` : null
+  ].filter(Boolean);
+  if (entries.length === 0)
+    return "Not provided.";
+  return ["Browser context captured from the web app:", ...entries].join(`
+`);
+}
+function buildReproductionContextTemplate() {
+  return [
+    "- Platform: Not provided.",
+    "- OS: Not provided.",
+    "- Browser: Not provided.",
+    "- Viewport: Not provided.",
+    "- Wallet/Web3 Context: Not provided.",
+    "- App Version: Not provided."
+  ].join(`
+`);
+}
+function buildFeedbackPolishPrompt(input, browserContext) {
+  return [
+    "Rewrite this user feedback into a GitHub issue draft.",
+    "Return ONLY valid JSON with this shape:",
+    '{"title":"string","body":"string"}',
+    "",
+    "Rules:",
+    "- Keep the result deterministic and concise.",
+    "- Do not include private information, secrets, local paths, or email addresses.",
+    "- Use this exact markdown template for body sections and preserve the headings/order:",
+    "## Summary",
+    "## Problem",
+    "## Reproduction Context",
+    "## Desired Outcome",
+    '- Use bullet points under "## Reproduction Context", with one context field per line prefixed by "-".',
+    "- Prefer these reproduction context fields when relevant: Platform, OS, Browser, Viewport, Wallet/Web3 Context, App Version.",
+    "- Use the browser context below when it helps reproducibility, but keep it compact and non-sensitive.",
+    '- If a section has no useful details, write "Not provided."',
+    "",
+    `Current title: ${input.title}`,
+    "Current details:",
+    input.body,
+    "",
+    "Available reproduction context:",
+    buildBrowserContextSection(browserContext)
+  ].join(`
+`);
+}
+function buildFeedbackDraftFromInput(input) {
+  const normalized = normalizeFeedbackIssueDraft({
+    title: input.title,
+    body: input.body
+  });
+  return {
+    title: normalized.title,
+    body: [
+      "## Summary",
+      normalized.title,
+      "",
+      "## Problem",
+      normalized.body || "Not provided.",
+      "",
+      "## Reproduction Context",
+      buildReproductionContextTemplate(),
+      "",
+      "## Desired Outcome",
+      "Not provided."
+    ].join(`
+`)
+  };
+}
+function buildGitHubIssueCreateUrl(input) {
+  const params = new URLSearchParams({
+    title: input.draft.title,
+    body: input.draft.body,
+    labels: "feedback"
+  });
+  return `https://github.com/${input.owner}/${input.repo}/issues/new?${params.toString()}`;
+}
+var FEEDBACK_SANITIZED_FIELDS, feedbackIssueDraftSchema, FEEDBACK_TITLE_MAX_LENGTH = 120, FEEDBACK_BODY_MAX_LENGTH = 8000, ENV_ASSIGNMENT_PATTERN, ABSOLUTE_UNIX_PATH_PATTERN, ABSOLUTE_WINDOWS_PATH_PATTERN;
+var init_feedback = __esm(() => {
+  init_zod();
+  FEEDBACK_SANITIZED_FIELDS = [
+    "Email addresses",
+    "Bearer/API/GitHub-style tokens",
+    "Absolute local filesystem paths",
+    "Sensitive env assignments such as TOKEN=..."
+  ];
+  feedbackIssueDraftSchema = exports_external.object({
+    title: exports_external.string().trim().min(1),
+    body: exports_external.string().trim().min(1)
+  });
+  ENV_ASSIGNMENT_PATTERN = /\b([A-Za-z_][A-Za-z0-9_]*)=([^\s]+)/g;
+  ABSOLUTE_UNIX_PATH_PATTERN = /(^|[\s([{'"`])((?:~|\/)[^\s)\]}'"`]+)(?=$|[\s)\]},'"`.!?;:])/gm;
+  ABSOLUTE_WINDOWS_PATH_PATTERN = /(^|[\s([{'"`])([A-Za-z]:\\[^\s)\]}'"`]+)(?=$|[\s)\]},'"`.!?;:])/gm;
+});
+
+// ../api/src/server/routes/feedback.ts
+function getFeedbackPolishFailureMessage(result) {
+  if (result.aborted)
+    return FEEDBACK_POLISH_TIMEOUT_MESSAGE;
+  return result.error ?? "Failed to polish feedback draft.";
+}
+var feedbackDraftSchema, browserFeedbackContextSchema, feedbackPolishInputSchema, FEEDBACK_POLISH_TIMEOUT_MS = 30000, FEEDBACK_POLISH_TIMEOUT_MESSAGE = "Polish timed out after 30 seconds. Try again with a shorter draft or verify the default coding agent is available.", FEEDBACK_REPOSITORY, feedbackRouter;
+var init_feedback2 = __esm(() => {
+  init_dist4();
+  init_zod();
+  init_trpc();
+  init_agents();
+  init_feedback();
+  feedbackDraftSchema = exports_external.object({
+    title: exports_external.string().trim().max(200).optional(),
+    body: exports_external.string().trim().max(12000)
+  });
+  browserFeedbackContextSchema = exports_external.object({
+    platform: exports_external.string().trim().max(40).optional(),
+    operatingSystem: exports_external.string().trim().max(80).optional(),
+    browser: exports_external.string().trim().max(80).optional(),
+    viewport: exports_external.string().trim().max(40).optional(),
+    devicePixelRatio: exports_external.string().trim().max(20).optional(),
+    language: exports_external.string().trim().max(40).optional(),
+    touchSupport: exports_external.string().trim().max(20).optional(),
+    walletContext: exports_external.string().trim().max(240).optional(),
+    appVersion: exports_external.string().trim().max(80).optional()
+  });
+  feedbackPolishInputSchema = feedbackDraftSchema.extend({
+    browserContext: browserFeedbackContextSchema.optional()
+  });
+  FEEDBACK_REPOSITORY = {
+    owner: "brucexu-eth",
+    repo: "vibeman"
+  };
+  feedbackRouter = t.router({
+    polishDraft: dbProcedure.input(feedbackPolishInputSchema).mutation(async ({ ctx, input }) => {
+      const sanitizedInput = normalizeFeedbackIssueDraft(input);
+      const browserContext = sanitizeBrowserFeedbackContext(input.browserContext);
+      const fallbackDraft = buildFeedbackDraftFromInput(sanitizedInput);
+      const timeoutController = new AbortController;
+      const timeoutId = setTimeout(() => {
+        timeoutController.abort();
+      }, FEEDBACK_POLISH_TIMEOUT_MS);
+      const result = await executeAgentExecutionRequest(ctx.db, {
+        source: "task",
+        runId: `feedback-polish-${Date.now()}`,
+        nodeKey: "feedback-polish",
+        root: ctx.root,
+        prompt: buildFeedbackPolishPrompt(sanitizedInput, browserContext),
+        resumeThread: false,
+        executorConfig: {
+          permissionMode: "read-only"
+        },
+        signal: timeoutController.signal,
+        logContext: { module: "feedback" }
+      }).finally(() => {
+        clearTimeout(timeoutId);
+      });
+      if (!result.success) {
+        throw new TRPCError({
+          code: "INTERNAL_SERVER_ERROR",
+          message: getFeedbackPolishFailureMessage(result)
+        });
+      }
+      const polished = parsePolishedFeedbackOutput(result.output ?? "");
+      const draft = sanitizeFeedbackIssueDraft(polished ?? fallbackDraft);
+      return createResponse(ctx, {
+        draft,
+        provider: result.provider,
+        model: result.model,
+        sanitizedFields: FEEDBACK_SANITIZED_FIELDS
+      });
+    }),
+    prepareSubmission: dbProcedure.input(feedbackDraftSchema).mutation(async ({ ctx, input }) => {
+      const draft = sanitizeFeedbackIssueDraft(input);
+      const url2 = buildGitHubIssueCreateUrl({
+        owner: FEEDBACK_REPOSITORY.owner,
+        repo: FEEDBACK_REPOSITORY.repo,
+        draft
+      });
+      return createResponse(ctx, {
+        draft,
+        url: url2,
+        owner: FEEDBACK_REPOSITORY.owner,
+        repo: FEEDBACK_REPOSITORY.repo,
+        sanitizedFields: FEEDBACK_SANITIZED_FIELDS
+      });
+    })
+  });
+});
+
 // ../api/src/server/routes/onboarding.ts
-import { readFile as readFile6, readdir as readdir3, rename as rename2, rm, mkdir as mkdir6, writeFile as writeFile7 } from "node:fs/promises";
-import { basename as basename2, join as join7, resolve as resolve21 } from "node:path";
+import { readFile as readFile8, readdir as readdir4, rename as rename2, rm as rm4, mkdir as mkdir6, writeFile as writeFile7 } from "node:fs/promises";
+import { basename as basename2, join as join8, resolve as resolve21 } from "node:path";
 import { spawn as spawn8 } from "node:child_process";
 function buildInitialOnboardingState(nowIso) {
   return {
@@ -113413,10 +114002,10 @@ ${err instanceof Error ? err.message : String(err)}`,
   });
 }
 async function moveDirectoryContents(srcDir, destDir) {
-  const entries = await readdir3(srcDir);
+  const entries = await readdir4(srcDir);
   const moved = [];
   for (const entry of entries) {
-    await rename2(join7(srcDir, entry), join7(destDir, entry));
+    await rename2(join8(srcDir, entry), join8(destDir, entry));
     moved.push(entry);
   }
   return moved;
@@ -113491,7 +114080,7 @@ function buildTemplateWorkspace(root) {
 async function patchGeneratedPackageName(root, desiredName) {
   const packageJsonPath = resolve21(root, "package.json");
   try {
-    const raw2 = await readFile6(packageJsonPath, "utf8");
+    const raw2 = await readFile8(packageJsonPath, "utf8");
     const pkg = JSON.parse(raw2);
     const currentName = typeof pkg.name === "string" ? pkg.name.trim() : "";
     if (currentName.length === 0 || currentName.includes("vibeman-init-tmp")) {
@@ -113510,7 +114099,7 @@ async function patchGeneratedT3ImportAlias(root, desiredAlias) {
   }
   const tsconfigPath = resolve21(root, "tsconfig.json");
   try {
-    const raw2 = await readFile6(tsconfigPath, "utf8");
+    const raw2 = await readFile8(tsconfigPath, "utf8");
     const config2 = JSON.parse(raw2);
     const paths = config2.compilerOptions?.paths;
     const current = paths?.["~/*"];
@@ -113712,7 +114301,7 @@ var init_onboarding = __esm(() => {
       let packageName = null;
       let packageDescription = null;
       try {
-        const raw2 = await readFile6(resolve21(ctx.root, "package.json"), "utf8");
+        const raw2 = await readFile8(resolve21(ctx.root, "package.json"), "utf8");
         const pkg = JSON.parse(raw2);
         if (typeof pkg.name === "string" && pkg.name.trim()) {
           packageName = pkg.name.trim();
@@ -113729,7 +114318,7 @@ var init_onboarding = __esm(() => {
       let hasPackageJson = false;
       let detectedFramework = null;
       try {
-        const entries = await readdir3(ctx.root, { withFileTypes: true });
+        const entries = await readdir4(ctx.root, { withFileTypes: true });
         for (const entry of entries) {
           if (IGNORED.has(entry.name))
             continue;
@@ -113742,7 +114331,7 @@ var init_onboarding = __esm(() => {
       } catch {}
       if (hasPackageJson) {
         try {
-          const raw2 = await readFile6(resolve21(ctx.root, "package.json"), "utf8");
+          const raw2 = await readFile8(resolve21(ctx.root, "package.json"), "utf8");
           const pkg = JSON.parse(raw2);
           const all = { ...pkg.dependencies, ...pkg.devDependencies };
           if (all["next"] && all["@trpc/server"])
@@ -113782,13 +114371,13 @@ var init_onboarding = __esm(() => {
       const scaffoldPath = shouldRunInTmpDir ? resolve21(tmpPath, workspace.projectDirName) : resolve21(ctx.root, workspace.scaffoldDir);
       const command = buildTemplateInitCommand(input, commandTargetDir);
       try {
-        await rm(tmpPath, { recursive: true, force: true });
+        await rm4(tmpPath, { recursive: true, force: true });
       } catch {}
       await mkdir6(tmpPath, { recursive: true });
       const result = await runShellCommand(command, commandCwd);
       if (!result.success) {
         try {
-          await rm(tmpPath, { recursive: true, force: true });
+          await rm4(tmpPath, { recursive: true, force: true });
         } catch {}
         const detail = (result.stderr || result.stdout).trim().slice(-2000);
         throw new TRPCError({
@@ -113819,7 +114408,7 @@ ${detail}`
         throw new TRPCError({ code: "INTERNAL_SERVER_ERROR", message: msg });
       } finally {
         try {
-          await rm(tmpPath, { recursive: true, force: true });
+          await rm4(tmpPath, { recursive: true, force: true });
         } catch {}
       }
       return createResponse(ctx, {
@@ -113990,7 +114579,7 @@ Rules:
         };
         const body = task2.body.trim() || task2.title;
         const content = stringifyTaskMarkdown(body, frontmatter);
-        await writeFile7(join7(tasksDir, filename), content);
+        await writeFile7(join8(tasksDir, filename), content);
         created.push(filename);
       }
       return createResponse(ctx, { created });
@@ -114013,6 +114602,7 @@ var init_router2 = __esm(() => {
   init_settings2();
   init_cli_settings();
   init_github3();
+  init_feedback2();
   init_onboarding();
   init_trpc();
   appRouter = t.router({
@@ -114028,6 +114618,7 @@ var init_router2 = __esm(() => {
     settings: settingsRouter,
     cliSettings: cliSettingsRouter,
     github: githubRouter,
+    feedback: feedbackRouter,
     onboarding: onboardingRouter
   });
 });
@@ -122216,7 +122807,7 @@ var require_mime_types = __commonJS((exports) => {
    * MIT Licensed
    */
   var db = require_mime_db();
-  var extname2 = __require("path").extname;
+  var extname3 = __require("path").extname;
   var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
   var TEXT_TYPE_REGEXP = /^text\//i;
   exports.charset = charset;
@@ -122271,7 +122862,7 @@ var require_mime_types = __commonJS((exports) => {
     if (!path3 || typeof path3 !== "string") {
       return false;
     }
-    var extension2 = extname2("x." + path3).toLowerCase().substr(1);
+    var extension2 = extname3("x." + path3).toLowerCase().substr(1);
     if (!extension2) {
       return false;
     }
@@ -122735,10 +123326,10 @@ var require_error = __commonJS((exports, module) => {
 
 // ../../node_modules/serve-handler/src/index.js
 var require_src3 = __commonJS((exports, module) => {
-  var { promisify: promisify2 } = __require("util");
+  var { promisify: promisify3 } = __require("util");
   var path3 = __require("path");
   var { createHash: createHash2 } = __require("crypto");
-  var { realpath, lstat: lstat2, createReadStream, readdir: readdir4 } = __require("fs");
+  var { realpath, lstat: lstat3, createReadStream, readdir: readdir5 } = __require("fs");
   var url2 = __require("url");
   var slasher = require_glob_slash();
   var minimatch = require_minimatch();
@@ -123126,10 +123717,10 @@ var require_src3 = __commonJS((exports, module) => {
     return sendError(...args);
   };
   var getHandlers = (methods) => Object.assign({
-    lstat: promisify2(lstat2),
-    realpath: promisify2(realpath),
+    lstat: promisify3(lstat3),
+    realpath: promisify3(realpath),
     createReadStream,
-    readdir: promisify2(readdir4),
+    readdir: promisify3(readdir5),
     sendError
   }, methods);
   module.exports = async (request2, response, config2 = {}, methods = {}) => {
@@ -123490,7 +124081,7 @@ var init_port_utils = () => {};
 // ../api/src/services/pty-session.ts
 import { chmodSync, statSync as statSync3 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname6, join as join8 } from "node:path";
+import { dirname as dirname7, join as join9 } from "node:path";
 import * as pty from "node-pty";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
@@ -123522,9 +124113,9 @@ function ensureNodePtySpawnHelperExecutable() {
   const helperCandidates = new Set;
   try {
     const packageJsonPath = require2.resolve("node-pty/package.json");
-    helperCandidates.add(join8(dirname6(packageJsonPath), "prebuilds", `darwin-${process.arch}`, "spawn-helper"));
+    helperCandidates.add(join9(dirname7(packageJsonPath), "prebuilds", `darwin-${process.arch}`, "spawn-helper"));
   } catch {}
-  const bundledDistHelperPath = join8(dirname6(fileURLToPath4(import.meta.url)), "prebuilds", `darwin-${process.arch}`, "spawn-helper");
+  const bundledDistHelperPath = join9(dirname7(fileURLToPath4(import.meta.url)), "prebuilds", `darwin-${process.arch}`, "spawn-helper");
   helperCandidates.add(bundledDistHelperPath);
   for (const helperPath of helperCandidates) {
     try {
@@ -123727,19 +124318,19 @@ var init_pty_session = __esm(() => {
 });
 
 // ../api/src/server/terminal-ws.ts
-import { dirname as dirname7, resolve as resolve23, sep as sep6 } from "node:path";
-import { existsSync as existsSync14, statSync as statSync4 } from "node:fs";
+import { dirname as dirname8, resolve as resolve23, sep as sep6 } from "node:path";
+import { existsSync as existsSync15, statSync as statSync4 } from "node:fs";
 function validateCwd(cwd2, root) {
   if (!cwd2 || typeof cwd2 !== "string")
     return null;
   const resolved = resolve23(cwd2);
   const resolvedRoot = resolve23(root);
-  const parentDir = dirname7(resolvedRoot) + sep6;
+  const parentDir = dirname8(resolvedRoot) + sep6;
   const isWithinRoot2 = resolved === resolvedRoot || resolved.startsWith(resolvedRoot + sep6);
   const isSibling = resolved.startsWith(parentDir);
   if (!isWithinRoot2 && !isSibling)
     return null;
-  if (!existsSync14(resolved))
+  if (!existsSync15(resolved))
     return null;
   try {
     if (!statSync4(resolved).isDirectory())
@@ -123940,10 +124531,10 @@ __export(exports_http, {
   startServer: () => startServer
 });
 import { createServer as createServer2 } from "node:http";
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync16 } from "node:fs";
 import { createReadStream } from "node:fs";
 import { stat as stat2 } from "node:fs/promises";
-import { extname as extname2, resolve as resolve24, sep as sep7 } from "node:path";
+import { extname as extname3, resolve as resolve24, sep as sep7 } from "node:path";
 async function startServer(options2) {
   const startedAt = Date.now();
   const taskFileWatch = createTaskFileWatchService(options2.root);
@@ -123965,7 +124556,7 @@ async function startServer(options2) {
       logger.error(`tRPC request failed ${JSON.stringify(details, (_key, value) => value === undefined ? "[undefined]" : value)}`);
     }
   });
-  const hasUi = Boolean(options2.uiRoot && existsSync15(options2.uiRoot));
+  const hasUi = Boolean(options2.uiRoot && existsSync16(options2.uiRoot));
   const server = createServer2(async (req, res) => {
     const url2 = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
     if (url2.pathname === "/api/health/live") {
@@ -124187,7 +124778,7 @@ function safeDecode3(value) {
   }
 }
 function guessContentType(absolutePath) {
-  const ext = extname2(absolutePath).toLowerCase();
+  const ext = extname3(absolutePath).toLowerCase();
   switch (ext) {
     case ".png":
       return "image/png";