diff --git a/apps/desktop/src/main/renderer-recovery.test.ts b/apps/desktop/src/main/renderer-recovery.test.ts
index afacaaeb4d..9704b163a9 100644
--- a/apps/desktop/src/main/renderer-recovery.test.ts
+++ b/apps/desktop/src/main/renderer-recovery.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import { installRendererRecoveryHandlers } from "./renderer-recovery";
+import { createElectronReloadPrompt, installRendererRecoveryHandlers } from "./renderer-recovery";
 
 type Handler = (...args: unknown[]) => void;
 
@@ -109,4 +109,30 @@ describe("installRendererRecoveryHandlers", () => {
     expect(showReloadPrompt).not.toHaveBeenCalled();
     expect(fixture.reload).not.toHaveBeenCalled();
   });
+
+  it("shows actionable recovery guidance before diagnostic details", async () => {
+    let detail = "";
+    const showMessageBox = vi.fn(
+      async (options: { title: string; message: string; detail: string }) => {
+        detail = options.detail;
+        return { response: 1 };
+      },
+    );
+    const showReloadPrompt = createElectronReloadPrompt(showMessageBox);
+
+    await showReloadPrompt({ kind: "unresponsive", context: {} });
+
+    expect(showMessageBox).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "Multica needs to reload",
+        message: "The desktop window has been stuck for a few seconds.",
+        detail: expect.stringContaining(
+          "Click Reload to refresh this window and keep using Multica.",
+        ),
+      }),
+    );
+    expect(detail).toContain("what you were doing right before this message appeared");
+    expect(detail).toContain("Activity Monitor sample");
+    expect(detail).toContain("Diagnostic details:\nkind: unresponsive\ncontext: {}");
+  });
 });
diff --git a/apps/desktop/src/main/renderer-recovery.ts b/apps/desktop/src/main/renderer-recovery.ts
index e6df0cfb0f..4e26d052e4 100644
--- a/apps/desktop/src/main/renderer-recovery.ts
+++ b/apps/desktop/src/main/renderer-recovery.ts
@@ -109,18 +109,30 @@ function isRecoverableRendererExit(details: unknown) {
 function rendererRecoveryMessage(kind: ReloadPromptPayload["kind"]) {
   switch (kind) {
     case "render-process-gone":
-      return "The desktop renderer process stopped responding or crashed.";
+      return "The desktop window stopped unexpectedly.";
     case "preload-error":
-      return "The desktop preload script failed before the app could start.";
+      return "The desktop window could not finish starting.";
     case "unresponsive":
-      return "The desktop window is not responding.";
+      return "The desktop window has been stuck for a few seconds.";
   }
 }
 
 function rendererRecoveryDetail(payload: ReloadPromptPayload) {
+  const guidance = [
+    "Click Reload to refresh this window and keep using Multica.",
+    "If this keeps happening, please tell us what you were doing right before this message appeared and whether Reload recovered the window.",
+  ];
+
+  if (payload.kind === "unresponsive") {
+    guidance.push(
+      "For macOS reports, an Activity Monitor sample of the Multica Helper (Renderer) process helps us find what blocked the app.",
+    );
+  }
+
   return [
-    "Reloading is the safest recovery path for this window.",
+    ...guidance,
     "",
+    "Diagnostic details:",
     `kind: ${payload.kind}`,
     `context: ${JSON.stringify(payload.context)}`,
   ].join("\n");
@@ -132,4 +144,4 @@ function defaultDevLog(tag: string, ...args: unknown[]) {
 
 function formatError(error: unknown) {
   return error instanceof Error ? (error.stack ?? error.message) : String(error);
-}
\ No newline at end of file
+}
diff --git a/apps/docs/content/docs/cli.ja.mdx b/apps/docs/content/docs/cli.ja.mdx
index 83f35fdf30..0e753e96fe 100644
--- a/apps/docs/content/docs/cli.ja.mdx
+++ b/apps/docs/content/docs/cli.ja.mdx
@@ -79,6 +79,19 @@ CI やヘッドレス環境では、ブラウザフローをスキップでき
 | `multica skill import ...` | GitHub、ClawHub、またはローカルマシンからスキルをインポート |
 | `multica skill files ...` | ネスト: スキルのファイルを管理 |
 
+### スキルインポートの競合
+
+`multica skill import --url <url>` の既定値は `--on-conflict fail` です。同じ名前のスキルがすでに存在する場合、コマンドは構造化された `conflict` 結果で終了し、ワークスペースは変更されません。
+
+既存スキルの作成者で、スキル ID とエージェントの紐付けを維持したまま内容を置き換える場合は `--on-conflict overwrite` を使います。既存スキルを残してコピーを取り込む場合は `--on-conflict rename` を使うと、`-2` のような接尾辞が自動で付きます。同名の項目を単に飛ばす場合は `--on-conflict skip` を使います。
+
+```bash
+multica skill import --url https://skills.sh/acme/repo/review-helper
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict overwrite
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict rename
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict skip
+```
+
 ## スクワッド
 
 | コマンド | 用途 |
diff --git a/apps/docs/content/docs/cli.ko.mdx b/apps/docs/content/docs/cli.ko.mdx
index 6f32b59887..24b255f5a6 100644
--- a/apps/docs/content/docs/cli.ko.mdx
+++ b/apps/docs/content/docs/cli.ko.mdx
@@ -79,6 +79,19 @@ CI나 headless 환경에서는 브라우저 플로우를 건너뛰세요. 웹 
 | `multica skill import ...` | GitHub, ClawHub, 또는 로컬 기기에서 스킬 가져오기 |
 | `multica skill files ...` | 중첩: 스킬의 파일 관리 |
 
+### 스킬 가져오기 충돌
+
+`multica skill import --url <url>`의 기본값은 `--on-conflict fail`입니다. 같은 이름의 스킬이 이미 있으면 명령은 구조화된 `conflict` 결과로 종료되며 워크스페이스를 변경하지 않습니다.
+
+기존 스킬을 만든 사용자이고, 스킬 ID와 에이전트 연결은 유지한 채 내용을 바꾸려면 `--on-conflict overwrite`를 사용하세요. 기존 스킬을 그대로 두고 복사본을 가져오려면 `--on-conflict rename`을 사용하면 `-2` 같은 접미사가 자동으로 붙습니다. 같은 이름의 항목을 그냥 건너뛰려면 `--on-conflict skip`을 사용하세요.
+
+```bash
+multica skill import --url https://skills.sh/acme/repo/review-helper
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict overwrite
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict rename
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict skip
+```
+
 ## 스쿼드
 
 | 명령어 | 용도 |
diff --git a/apps/docs/content/docs/cli.mdx b/apps/docs/content/docs/cli.mdx
index 2536fb7773..f51db7ddf2 100644
--- a/apps/docs/content/docs/cli.mdx
+++ b/apps/docs/content/docs/cli.mdx
@@ -79,6 +79,25 @@ For the difference between token types, see [Authentication and tokens](/auth-to
 | `multica skill import ...` | Import a skill from GitHub, ClawHub, or the local machine |
 | `multica skill files ...` | Nested: manage a skill's files |
 
+### Skill import conflicts
+
+`multica skill import --url <url>` defaults to `--on-conflict fail`. If a skill
+with the same name already exists, the command exits with a structured
+`conflict` result and does not change the workspace.
+
+Use `--on-conflict overwrite` when you created the existing skill and want to
+replace its content while preserving its ID and agent bindings. Use
+`--on-conflict rename` to import a copy with an automatic suffix such as `-2`.
+Use `--on-conflict skip` to leave the existing skill untouched and report
+`skipped`.
+
+```bash
+multica skill import --url https://skills.sh/acme/repo/review-helper
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict overwrite
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict rename
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict skip
+```
+
 ## Squads
 
 | Command | Purpose |
diff --git a/apps/docs/content/docs/cli.zh.mdx b/apps/docs/content/docs/cli.zh.mdx
index 1f8b0e6607..0b5555057c 100644
--- a/apps/docs/content/docs/cli.zh.mdx
+++ b/apps/docs/content/docs/cli.zh.mdx
@@ -79,6 +79,19 @@ Token 类型的详细区分见 [认证与令牌](/auth-tokens)。
 | `multica skill import ...` | 从 GitHub / ClawHub / 本机导入 Skill |
 | `multica skill files ...` | 嵌套：管理 Skill 的文件 |
 
+### Skill 导入冲突
+
+`multica skill import --url <url>` 默认等同于 `--on-conflict fail`。如果工作区里已经有同名 Skill，命令会返回结构化 `conflict` 结果并退出，不会修改工作区。
+
+如果你是已有 Skill 的 creator，并且想用新导入内容覆盖它，同时保留原 Skill 的 ID 和 agent 绑定，用 `--on-conflict overwrite`。如果想保留已有 Skill、另存一份，用 `--on-conflict rename`，系统会自动加 `-2` 这类后缀。如果只是批量导入时遇到同名项就跳过，用 `--on-conflict skip`。
+
+```bash
+multica skill import --url https://skills.sh/acme/repo/review-helper
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict overwrite
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict rename
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict skip
+```
+
 ## 小队
 
 | 命令 | 用途 |
diff --git a/apps/mobile/app/(app)/[workspace]/issue/[id]/runs.tsx b/apps/mobile/app/(app)/[workspace]/issue/[id]/runs.tsx
index e6e6d4251a..5cbcd58aa5 100644
--- a/apps/mobile/app/(app)/[workspace]/issue/[id]/runs.tsx
+++ b/apps/mobile/app/(app)/[workspace]/issue/[id]/runs.tsx
@@ -1,7 +1,7 @@
 /**
  * Agent Runs sheet — presented as a formSheet by the parent Stack. Two
  * sections: Active (queued/dispatched/running, created_at desc) and Past
- * (failed → cancelled → completed, completed_at desc within each). Empty
+ * (completed_at desc, status rank as tiebreaker). Empty
  * sections hide entirely.
  *
  * Both entry points (the in-card AgentActivityRow and the Stack-header
@@ -58,9 +58,9 @@ export default function IssueRunsRoute() {
         t.status === "cancelled",
     );
     return filtered.sort((a, b) => {
-      const ord = PAST_STATUS_ORDER[a.status] - PAST_STATUS_ORDER[b.status];
-      if (ord !== 0) return ord;
-      return (b.completed_at ?? "").localeCompare(a.completed_at ?? "");
+      const timeDiff = (b.completed_at ?? "").localeCompare(a.completed_at ?? "");
+      if (timeDiff !== 0) return timeDiff;
+      return PAST_STATUS_ORDER[a.status] - PAST_STATUS_ORDER[b.status];
     });
   }, [allTasks]);
 
diff --git a/apps/web/features/landing/i18n/en.ts b/apps/web/features/landing/i18n/en.ts
index 541b3f8e0f..8e2695ee2b 100644
--- a/apps/web/features/landing/i18n/en.ts
+++ b/apps/web/features/landing/i18n/en.ts
@@ -292,45 +292,72 @@ export function createEnDict(allowSignup: boolean): LandingDict {
       fixes: "Bug Fixes",
     },
     entries: [
+      {
+        version: "0.3.21",
+        date: "2026-06-12",
+        title: "CodeBuddy Runtime",
+        changes: [],
+        features: [
+          "CodeBuddy can now run local Multica agents, with its available model and effort choices shown automatically",
+          "Quick-created Issues now keep uploaded files attached from the first draft through the final Issue",
+        ],
+        improvements: [
+          "Skill import conflicts are clearer: locked skills show a person's name instead of an internal ID, and a single overwrite now completes in one click",
+          "Desktop recovery prompts now explain what happened first and give clearer details to include when reporting a stuck window",
+          "Views that sort or filter people by signup time can now load faster",
+        ],
+        fixes: [
+          "Chat now keeps messages and drafts in sync when sending, stopping, or recovering from a failed send",
+          "Lark account binding now works reliably for users who are already signed in, and sign-in returns to the binding page",
+          "Local agent runs no longer announce that work has started before the task folder is ready",
+        ],
+      },
       {
         version: "0.3.20",
-        date: "2026-06-10",
-        title: "Safer Comment Triggers and More Reliable Attachments",
+        date: "2026-06-11",
+        title: "Skill Imports, Cleaner Run History, and Resilient Agents",
         changes: [],
         features: [
-          "Comment boxes now show which agents or squads will start work before you send, with controls to avoid accidental runs",
-          "Run transcripts now include timestamps, making agent progress and handoffs easier to review",
-          "Autopilot detail pages now show who created each autopilot",
-          "Claude Fable 5 is now available in Multica's supported model and pricing list",
+          "Skill imports now let you choose what happens when a skill already exists: stop, replace it, save a renamed copy, or skip it",
+          "Import results now clearly show which skills were added, updated, skipped, blocked by a conflict, or could not be imported",
         ],
         improvements: [
-          "Comment trigger indicators are quieter, clearer, and less likely to crowd long agent names",
-          "Desktop now disables daemon start and stop controls when the daemon is managed outside Multica, such as in WSL2",
+          "Execution logs now show the newest past runs first on web and mobile, so recent progress is easier to scan",
+          "Changelog content was cleaned up so the latest release notes stay grouped under the right release",
         ],
         fixes: [
-          "Inline images and files in Issue descriptions now stay visible across web and desktop after reloads",
-          "Each Issue discussion thread now keeps only one resolved answer at a time, so replacing the conclusion is consistent for everyone",
-          "Issue pages refresh their data after realtime reconnects, avoiding stale timelines after a connection drop",
-          "Agent task initiator history now works more reliably for older task records",
-          "Sticky Issue comments keep a cleaner visual edge while scrolling",
+          "Issue thread replies now stay in the order they arrived, even when a slower agent reply lands later",
+          "Agents can recover when a saved session disappears, starting fresh instead of failing again on every mention",
+          "Reviving an Issue from a new workspace folder now starts a fresh session instead of retrying one that only existed in the old folder",
         ],
       },
       {
         version: "0.3.19",
-        date: "2026-06-09",
-        title: "More Reliable Agents, Attachments, and Issue Threads",
+        date: "2026-06-10",
+        title: "Safer Comment Triggers, Reliable Agents, and Attachments",
         changes: [],
         features: [
+          "Comment boxes now show which agents or squads will start work before you send, with controls to avoid accidental runs",
+          "Run transcripts now include timestamps, making agent progress and handoffs easier to review",
+          "Autopilot detail pages now show who created each autopilot",
+          "Claude Fable 5 is now available in Multica's supported model and pricing list",
           "Issue conversations can now resolve a specific reply, making long threads easier to close while keeping the final answer visible",
           "Lark and Feishu conversations now show a typing reaction while Multica is preparing a reply, then clear it before the answer is sent",
           "Agent runs now know who started each task, making handoffs, audit trails, and privacy-aware behavior more accurate",
           "OpenClaw users can point Multica at a custom app location and data folder from their local configuration",
         ],
         improvements: [
+          "Comment trigger indicators are quieter, clearer, and less likely to crowd long agent names",
+          "Desktop now disables daemon start and stop controls when the daemon is managed outside Multica, such as in WSL2",
           "The active agent indicator in an Issue header is easier to read, with motion only while work is running and clearer queued wording otherwise",
           "The CLI now gives clearer guidance around common errors, sign-in problems, and project setup values",
         ],
         fixes: [
+          "Inline images and files in Issue descriptions now stay visible across web and desktop after reloads",
+          "Each Issue discussion thread now keeps only one resolved answer at a time, so replacing the conclusion is consistent for everyone",
+          "Issue pages refresh their data after realtime reconnects, avoiding stale timelines after a connection drop",
+          "Agent task initiator history now works more reliably for older task records",
+          "Sticky Issue comments keep a cleaner visual edge while scrolling",
           "Newly posted attachments now use stable private download links, so images and files stay visible after temporary upload links expire",
           "Autopilot runs started from newly created Issues now fail cleanly when the assigned task cannot complete, instead of staying stuck",
           "Inbox deep links now scroll inside the Issue timeline without pushing the desktop window out of place",
diff --git a/apps/web/features/landing/i18n/ja.ts b/apps/web/features/landing/i18n/ja.ts
index 4eab8b9c9e..8e01dbee64 100644
--- a/apps/web/features/landing/i18n/ja.ts
+++ b/apps/web/features/landing/i18n/ja.ts
@@ -268,45 +268,72 @@ export function createJaDict(allowSignup: boolean): LandingDict {
         fixes: "バグ修正",
       },
       entries: [
+        {
+          version: "0.3.21",
+          date: "2026-06-12",
+          title: "CodeBuddy Runtime",
+          changes: [],
+          features: [
+            "CodeBuddy でローカルの Multica エージェントを動かせるようになり、利用できるモデルと実行の強さが自動で表示されます。",
+            "クイック作成した Issue では、下書きでアップロードしたファイルが最終的な Issue まで保持されます。",
+          ],
+          improvements: [
+            "スキル取り込みの競合が分かりやすくなり、ロックされたスキルには内部 ID ではなくメンバー名が表示され、単体の上書きも 1 クリックで完了します。",
+            "デスクトップの復旧案内は、まず何が起きたかを説明し、固まったウィンドウを報告するときに含める情報も分かりやすくなりました。",
+            "登録日時でメンバーを並べ替えたり絞り込んだりする画面が、より速く読み込まれるようになりました。",
+          ],
+          fixes: [
+            "チャットの送信、停止、送信失敗からの復旧時に、メッセージと下書きがより安定して同期されます。",
+            "Lark アカウント連携は、すでにサインイン済みのユーザーでも安定して完了し、サインイン後も連携ページに戻ります。",
+            "ローカルエージェントの実行は、タスクフォルダの準備が終わる前に開始済みとして表示されなくなりました。",
+          ],
+        },
         {
           version: "0.3.20",
-          date: "2026-06-10",
-          title: "より安全なコメントトリガーと安定した添付ファイル",
+          date: "2026-06-11",
+          title: "スキルのインポート、実行履歴、より安定したエージェント",
           changes: [],
           features: [
-            "コメント入力欄では、送信前にどのエージェントやスクワッドが動き始めるかを確認でき、誤って実行することを避けられます。",
-            "実行記録に時刻が表示されるようになり、エージェントの進捗や引き継ぎを振り返りやすくなりました。",
-            "オートパイロット詳細ページで、誰が作成したかを確認できるようになりました。",
-            "Claude Fable 5 が Multica の対応モデルと料金一覧に加わりました。",
+            "スキルのインポート時に同じスキルがすでにある場合、停止、置き換え、別名で保存、スキップを選べるようになりました。",
+            "インポート結果では、追加、更新、スキップ、競合、失敗したスキルがわかりやすく表示されます。",
           ],
           improvements: [
-            "コメントトリガーの表示はより控えめで読みやすく、長いエージェント名でも混み合いにくくなりました。",
-            "WSL2 など Multica の外でデーモンが管理されている場合、デスクトップは開始と停止の操作を無効にします。",
+            "Web とモバイルの実行履歴は新しい過去実行を先に表示するため、最近の進捗を追いやすくなりました。",
+            "変更履歴の内容を整理し、最新のリリースノートが正しいバージョンにまとまるようにしました。",
           ],
           fixes: [
-            "イシュー説明内の画像とファイルは、Web とデスクトップのどちらでも再読み込み後に表示され続けます。",
-            "各イシュー会話スレッドは解決済みの回答を 1 つだけ保持するため、結論を置き換えたときの表示が全員でそろいます。",
-            "リアルタイム接続が復帰したあと、イシュー画面はデータを更新し、古いタイムラインが残りにくくなりました。",
-            "エージェントタスクの開始者履歴が、古いタスク記録でもより信頼できるようになりました。",
-            "スクロール中の固定イシューコメントの境界がよりきれいに表示されます。",
+            "イシューの返信は到着した順番のまま表示され、遅れて届いたエージェント返信が途中に割り込まなくなりました。",
+            "保存済みセッションが失われた場合でも、エージェントは新しく開始して復旧でき、以後のメンションで失敗し続けません。",
+            "新しい作業フォルダーからイシューを再開すると、古いフォルダーにだけ存在したセッションではなく新しいセッションで始まります。",
           ],
         },
         {
           version: "0.3.19",
-          date: "2026-06-09",
-          title: "より安定したエージェント、添付ファイル、イシューの会話",
+          date: "2026-06-10",
+          title: "より安全なコメントトリガー、安定したエージェントと添付ファイル",
           changes: [],
           features: [
+            "コメント入力欄では、送信前にどのエージェントやスクワッドが動き始めるかを確認でき、誤って実行することを避けられます。",
+            "実行記録に時刻が表示されるようになり、エージェントの進捗や引き継ぎを振り返りやすくなりました。",
+            "オートパイロット詳細ページで、誰が作成したかを確認できるようになりました。",
+            "Claude Fable 5 が Multica の対応モデルと料金一覧に加わりました。",
             "イシューの会話で特定の返信を解決として残せるようになり、長いスレッドを閉じても結論を確認しやすくなりました。",
             "Lark と Feishu の会話では、Multica が返信を準備している間に入力中のリアクションを表示し、返信前に自動で消します。",
             "エージェント実行は、誰がそのタスクを始めたかを把握できるようになり、引き継ぎ、監査、プライバシーに配慮した動作がより正確になります。",
             "OpenClaw ユーザーは、ローカル設定から独自のアプリ場所とデータフォルダーを指定できます。",
           ],
           improvements: [
+            "コメントトリガーの表示はより控えめで読みやすく、長いエージェント名でも混み合いにくくなりました。",
+            "WSL2 など Multica の外でデーモンが管理されている場合、デスクトップは開始と停止の操作を無効にします。",
             "イシュー上部のアクティブなエージェント表示は、実行中だけ動き、待機中は待機状態を明確に示すため、読み取りやすくなりました。",
             "CLI は、よくあるエラー、サインインの問題、プロジェクト設定の値について、よりわかりやすく案内します。",
           ],
           fixes: [
+            "イシュー説明内の画像とファイルは、Web とデスクトップのどちらでも再読み込み後に表示され続けます。",
+            "各イシュー会話スレッドは解決済みの回答を 1 つだけ保持するため、結論を置き換えたときの表示が全員でそろいます。",
+            "リアルタイム接続が復帰したあと、イシュー画面はデータを更新し、古いタイムラインが残りにくくなりました。",
+            "エージェントタスクの開始者履歴が、古いタスク記録でもより信頼できるようになりました。",
+            "スクロール中の固定イシューコメントの境界がよりきれいに表示されます。",
             "新しく投稿された添付ファイルは安定した非公開ダウンロードリンクを使うため、一時的なアップロードリンクが期限切れになっても画像やファイルを表示できます。",
             "新規イシューから始まったオートパイロット実行は、割り当てられたタスクが完了できない場合に正しく失敗し、進行中のまま残りません。",
             "受信箱からコメントリンクを開いたとき、デスクトップ画面全体ではなくイシューのタイムラインだけがスクロールします。",
diff --git a/apps/web/features/landing/i18n/ko.ts b/apps/web/features/landing/i18n/ko.ts
index ec6bb1e7eb..e417d0a531 100644
--- a/apps/web/features/landing/i18n/ko.ts
+++ b/apps/web/features/landing/i18n/ko.ts
@@ -267,45 +267,72 @@ export function createKoDict(allowSignup: boolean): LandingDict {
         fixes: "버그 수정",
       },
       entries: [
+        {
+          version: "0.3.21",
+          date: "2026-06-12",
+          title: "CodeBuddy Runtime",
+          changes: [],
+          features: [
+            "CodeBuddy로 로컬 Multica 에이전트를 실행할 수 있으며, 사용할 수 있는 모델과 실행 강도 선택지가 자동으로 표시됩니다.",
+            "빠르게 만든 Issue에서도 초안에서 올린 파일이 최종 Issue까지 함께 유지됩니다.",
+          ],
+          improvements: [
+            "스킬 가져오기 충돌이 더 이해하기 쉬워졌습니다. 잠긴 스킬은 내부 ID 대신 멤버 이름을 보여주고, 단일 덮어쓰기도 한 번의 클릭으로 끝납니다.",
+            "데스크톱 복구 안내가 먼저 무슨 일이 있었는지 설명하고, 멈춘 창을 신고할 때 포함할 정보를 더 명확하게 보여줍니다.",
+            "가입 시간으로 멤버를 정렬하거나 필터링하는 화면이 더 빠르게 로드될 수 있습니다.",
+          ],
+          fixes: [
+            "채팅을 보내거나 중지하거나 전송 실패에서 복구할 때 메시지와 초안이 더 안정적으로 동기화됩니다.",
+            "Lark 계정 연결은 이미 로그인한 사용자에게도 안정적으로 완료되며, 로그인 후에도 연결 페이지로 돌아옵니다.",
+            "로컬 에이전트 실행은 작업 폴더가 준비되기 전에 시작된 것으로 표시되지 않습니다.",
+          ],
+        },
         {
           version: "0.3.20",
-          date: "2026-06-10",
-          title: "더 안전한 댓글 트리거와 더 안정적인 첨부 파일",
+          date: "2026-06-11",
+          title: "스킬 가져오기, 실행 기록, 더 안정적인 에이전트",
           changes: [],
           features: [
-            "댓글 입력창에서 보내기 전에 어떤 에이전트나 스쿼드가 작업을 시작할지 확인하고, 실수로 실행되는 일을 줄일 수 있습니다.",
-            "실행 기록에 시간이 표시되어 에이전트 진행 상황과 인계를 더 쉽게 검토할 수 있습니다.",
-            "오토파일럿 상세 페이지에서 누가 만들었는지 확인할 수 있습니다.",
-            "Claude Fable 5가 Multica의 지원 모델과 가격 목록에 추가되었습니다.",
+            "스킬을 가져올 때 같은 스킬이 이미 있으면 중단, 교체, 이름을 바꿔 저장, 건너뛰기 중에서 선택할 수 있습니다.",
+            "가져오기 결과에서 추가, 업데이트, 건너뜀, 충돌, 실패한 스킬을 더 명확하게 확인할 수 있습니다.",
           ],
           improvements: [
-            "댓글 트리거 표시가 더 조용하고 명확해졌으며, 긴 에이전트 이름도 덜 비좁게 보입니다.",
-            "WSL2처럼 Multica 밖에서 데몬을 관리하는 경우 데스크톱은 시작과 중지 조작을 비활성화합니다.",
+            "웹과 모바일 실행 기록은 최신 과거 실행을 먼저 보여 주어 최근 진행 상황을 더 쉽게 확인할 수 있습니다.",
+            "변경 로그 콘텐츠를 정리해 최신 릴리스 노트가 올바른 버전에 묶이도록 했습니다.",
           ],
           fixes: [
-            "이슈 설명의 이미지와 파일은 웹과 데스크톱에서 다시 열어도 계속 표시됩니다.",
-            "각 이슈 대화 스레드는 해결 답변을 하나만 유지해 결론을 바꿀 때 모두에게 일관되게 보입니다.",
-            "실시간 연결이 복구된 뒤 이슈 화면이 데이터를 새로고침해 오래된 타임라인이 남지 않습니다.",
-            "에이전트 작업을 시작한 사람의 기록이 오래된 작업에서도 더 안정적으로 유지됩니다.",
-            "스크롤 중 고정된 이슈 댓글의 가장자리가 더 깔끔하게 보입니다.",
+            "이슈 스레드 답글은 도착한 순서대로 표시되어, 늦게 도착한 에이전트 답글이 중간에 끼어들지 않습니다.",
+            "저장된 세션이 사라져도 에이전트가 새로 시작해 복구할 수 있어, 이후 멘션마다 계속 실패하지 않습니다.",
+            "새 작업 폴더에서 이슈를 다시 시작할 때 이전 폴더에만 있던 세션을 재시도하지 않고 새 세션으로 시작합니다.",
           ],
         },
         {
           version: "0.3.19",
-          date: "2026-06-09",
-          title: "더 안정적인 에이전트, 첨부 파일, 이슈 대화",
+          date: "2026-06-10",
+          title: "더 안전한 댓글 트리거, 안정적인 에이전트와 첨부 파일",
           changes: [],
           features: [
+            "댓글 입력창에서 보내기 전에 어떤 에이전트나 스쿼드가 작업을 시작할지 확인하고, 실수로 실행되는 일을 줄일 수 있습니다.",
+            "실행 기록에 시간이 표시되어 에이전트 진행 상황과 인계를 더 쉽게 검토할 수 있습니다.",
+            "오토파일럿 상세 페이지에서 누가 만들었는지 확인할 수 있습니다.",
+            "Claude Fable 5가 Multica의 지원 모델과 가격 목록에 추가되었습니다.",
             "이슈 대화에서 특정 답글을 해결 답변으로 남길 수 있어, 긴 스레드를 접어도 결론을 더 쉽게 확인할 수 있습니다.",
             "Lark와 Feishu 대화는 Multica가 답변을 준비하는 동안 입력 중 반응을 표시하고, 답변을 보내기 전에 자동으로 지웁니다.",
             "에이전트 실행은 각 작업을 누가 시작했는지 알 수 있어 인계, 감사, 개인정보를 고려한 동작이 더 정확해집니다.",
             "OpenClaw 사용자는 로컬 설정에서 사용자 지정 앱 위치와 데이터 폴더를 지정할 수 있습니다.",
           ],
           improvements: [
+            "댓글 트리거 표시가 더 조용하고 명확해졌으며, 긴 에이전트 이름도 덜 비좁게 보입니다.",
+            "WSL2처럼 Multica 밖에서 데몬을 관리하는 경우 데스크톱은 시작과 중지 조작을 비활성화합니다.",
             "이슈 헤더의 활성 에이전트 표시가 더 읽기 쉬워졌으며, 실제 실행 중일 때만 움직이고 대기 중일 때는 대기 상태를 명확히 보여 줍니다.",
             "CLI는 흔한 오류, 로그인 문제, 프로젝트 설정 값에 대해 더 명확하게 안내합니다.",
           ],
           fixes: [
+            "이슈 설명의 이미지와 파일은 웹과 데스크톱에서 다시 열어도 계속 표시됩니다.",
+            "각 이슈 대화 스레드는 해결 답변을 하나만 유지해 결론을 바꿀 때 모두에게 일관되게 보입니다.",
+            "실시간 연결이 복구된 뒤 이슈 화면이 데이터를 새로고침해 오래된 타임라인이 남지 않습니다.",
+            "에이전트 작업을 시작한 사람의 기록이 오래된 작업에서도 더 안정적으로 유지됩니다.",
+            "스크롤 중 고정된 이슈 댓글의 가장자리가 더 깔끔하게 보입니다.",
             "새로 올린 첨부 파일은 안정적인 비공개 다운로드 링크를 사용해 임시 업로드 링크가 만료된 뒤에도 이미지와 파일이 계속 표시됩니다.",
             "새 이슈에서 시작된 오토파일럿 실행은 배정된 작업이 완료되지 못하면 올바르게 실패 처리되어 진행 중에 멈춰 있지 않습니다.",
             "받은함에서 댓글 링크를 열 때 데스크톱 화면 전체가 밀리지 않고 이슈 타임라인 안에서만 스크롤됩니다.",
diff --git a/apps/web/features/landing/i18n/zh.ts b/apps/web/features/landing/i18n/zh.ts
index 70975423bf..c54c03ed38 100644
--- a/apps/web/features/landing/i18n/zh.ts
+++ b/apps/web/features/landing/i18n/zh.ts
@@ -292,45 +292,72 @@ export function createZhDict(allowSignup: boolean): LandingDict {
       fixes: "问题修复",
     },
     entries: [
+      {
+        version: "0.3.21",
+        date: "2026-06-12",
+        title: "CodeBuddy Runtime",
+        changes: [],
+        features: [
+          "CodeBuddy 现在可以驱动本地 Multica 智能体，并会自动显示可用的模型和投入强度选项",
+          "快速创建 Issue 时上传的文件现在会从草稿一直带到最终创建的 Issue 里",
+        ],
+        improvements: [
+          "技能导入冲突更容易理解：锁定的技能会显示成员名称，不再显示内部 ID；单个覆盖也可以一键完成",
+          "桌面端恢复提示会先说明发生了什么，并给出更清楚的窗口卡住反馈信息",
+          "按注册时间排序或筛选成员的页面现在加载更快",
+        ],
+        fixes: [
+          "聊天在发送、停止或发送失败恢复时，会更稳定地同步消息和草稿",
+          "Lark 账号绑定现在对已登录用户也能稳定完成，登录后也会回到绑定页面",
+          "本地智能体运行不会再在任务文件夹准备好之前就显示已经开始",
+        ],
+      },
       {
         version: "0.3.20",
-        date: "2026-06-10",
-        title: "更安全的评论触发和更稳定的附件",
+        date: "2026-06-11",
+        title: "技能导入、运行记录和更稳定的智能体",
         changes: [],
         features: [
-          "评论输入框现在会在发送前显示哪些智能体或小队会开始工作，也可以避免误触发运行",
-          "智能体运行记录现在会显示时间点，回看进度和交接信息更清楚",
-          "自动任务详情页现在会显示创建人",
-          "Claude Fable 5 现在已加入 Multica 支持的模型和价格列表",
+          "导入技能时，如果同名技能已存在，现在可以选择停止、替换、另存为新名称或跳过",
+          "导入结果会清楚显示哪些技能已新增、已更新、已跳过、发生冲突或导入失败",
         ],
         improvements: [
-          "评论触发提示更安静、更清楚，遇到较长的智能体名称时也不容易拥挤",
-          "桌面端在守护进程由 Multica 之外的环境管理时，会禁用启动和停止控制，例如 WSL2 场景",
+          "网页端和移动端的执行记录现在会优先显示最新的历史运行，更容易看清最近进展",
+          "更新日志内容已整理，最新发布内容会归在正确的版本下",
         ],
         fixes: [
-          "Issue 描述里的图片和文件在网页端和桌面端重新打开后都会保持可见",
-          "每个 Issue 讨论线程现在只会保留一个解决结论，替换结论时所有人看到的状态更一致",
-          "实时连接断开并恢复后，Issue 页面会刷新数据，避免时间线停留在旧状态",
-          "智能体任务的发起人历史在较早任务记录上也会更可靠",
-          "滚动时置顶的 Issue 评论边缘显示更干净",
+          "Issue 讨论里的回复现在会按到达顺序显示，即使较慢的智能体回复稍后才出现，也不会插到前面",
+          "当已保存的会话失效时，智能体可以自动重新开始，不会在后续每次提及时反复失败",
+          "从新的工作目录重新唤起 Issue 时，现在会开始新会话，不会继续尝试只存在于旧目录里的会话",
         ],
       },
       {
         version: "0.3.19",
-        date: "2026-06-09",
-        title: "身份上下文优化、附件稳定性和 Issue 讨论升级",
+        date: "2026-06-10",
+        title: "更安全的评论触发、更稳定的智能体和附件",
         changes: [],
         features: [
+          "评论输入框现在会在发送前显示哪些智能体或小队会开始工作，也可以避免误触发运行",
+          "智能体运行记录现在会显示时间点，回看进度和交接信息更清楚",
+          "自动任务详情页现在会显示创建人",
+          "Claude Fable 5 现在已加入 Multica 支持的模型和价格列表",
           "Issue 讨论可以把某一条回复设为解决结论，长讨论收起后也能直接看到最终答案",
           "在 Lark 和飞书里和 Multica 对话时，会显示等待中的输入状态，回复发出后自动清除",
           "每次智能体任务都会带上真实发起人信息，交接、审计和权限判断更准确",
           "OpenClaw 可以从本地配置中读取自定义程序位置和数据目录",
         ],
         improvements: [
+          "评论触发提示更安静、更清楚，遇到较长的智能体名称时也不容易拥挤",
+          "桌面端在守护进程由 Multica 之外的环境管理时，会禁用启动和停止控制，例如 WSL2 场景",
           "Issue 顶部的智能体状态更容易区分：运行中才显示动效，等待中会明确显示排队状态",
           "命令行会直接说明常见错误、登录问题和项目配置问题的处理方式",
         ],
         fixes: [
+          "Issue 描述里的图片和文件在网页端和桌面端重新打开后都会保持可见",
+          "每个 Issue 讨论线程现在只会保留一个解决结论，替换结论时所有人看到的状态更一致",
+          "实时连接断开并恢复后，Issue 页面会刷新数据，避免时间线停留在旧状态",
+          "智能体任务的发起人历史在较早任务记录上也会更可靠",
+          "滚动时置顶的 Issue 评论边缘显示更干净",
           "新上传的附件会使用稳定的私有下载链接，临时上传链接过期后图片和文件仍能正常显示",
           "自动任务通过新建 Issue 启动后，如果对应的智能体任务失败，会同步标记为失败，不会一直卡在进行中",
           "从收件箱打开评论链接时，只会滚动 Issue 时间线，不会把桌面窗口内容顶出可见区域",
diff --git a/packages/core/api/client.test.ts b/packages/core/api/client.test.ts
index 563653a61a..f5cfd0a899 100644
--- a/packages/core/api/client.test.ts
+++ b/packages/core/api/client.test.ts
@@ -487,6 +487,109 @@ describe("ApiClient", () => {
     });
   });
 
+  describe("cancelTaskById response parsing", () => {
+    const taskResponse = {
+      id: "task-1",
+      agent_id: "agent-1",
+      runtime_id: "runtime-1",
+      issue_id: "",
+      status: "cancelled",
+      priority: 0,
+      dispatched_at: null,
+      started_at: null,
+      completed_at: "2026-06-12T06:40:00Z",
+      result: null,
+      error: null,
+      created_at: "2026-06-12T06:39:00Z",
+    };
+
+    it("parses the cancelled chat message payload", async () => {
+      const fetchMock = vi.fn().mockResolvedValue(
+        new Response(JSON.stringify({
+          ...taskResponse,
+          cancelled_chat_message: {
+            chat_session_id: "session-1",
+            message_id: "message-1",
+            content: "restore me",
+            restore_to_input: true,
+          },
+        }), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        }),
+      );
+      vi.stubGlobal("fetch", fetchMock);
+
+      const client = new ApiClient("https://api.example.test");
+      const result = await client.cancelTaskById("task-1");
+
+      expect(fetchMock.mock.calls[0]).toMatchObject([
+        "https://api.example.test/api/tasks/task-1/cancel",
+        { method: "POST" },
+      ]);
+      expect(result.cancelled_chat_message).toEqual({
+        chat_session_id: "session-1",
+        message_id: "message-1",
+        content: "restore me",
+        restore_to_input: true,
+      });
+    });
+
+    it("treats a null cancelled chat message as absent", async () => {
+      vi.stubGlobal(
+        "fetch",
+        vi.fn().mockResolvedValue(
+          new Response(JSON.stringify({
+            ...taskResponse,
+            cancelled_chat_message: null,
+          }), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          }),
+        ),
+      );
+
+      const client = new ApiClient("https://api.example.test");
+      const result = await client.cancelTaskById("task-1");
+
+      expect(result.id).toBe("task-1");
+      expect(result.cancelled_chat_message).toBeUndefined();
+    });
+
+    it.each([
+      ["a missing task id", { ...taskResponse, id: undefined }],
+      [
+        "a malformed cancelled chat message",
+        {
+          ...taskResponse,
+          cancelled_chat_message: {
+            chat_session_id: "session-1",
+            message_id: "message-1",
+            content: "restore me",
+            restore_to_input: "true",
+          },
+        },
+      ],
+      ["a null body", null],
+    ])("falls back for %s", async (_label, body) => {
+      vi.stubGlobal(
+        "fetch",
+        vi.fn().mockResolvedValue(
+          new Response(JSON.stringify(body), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          }),
+        ),
+      );
+
+      const client = new ApiClient("https://api.example.test");
+      const result = await client.cancelTaskById("task-1");
+
+      expect(result.id).toBe("");
+      expect(result.cancelled_chat_message).toBeUndefined();
+    });
+  });
+
   describe("chat attachment wiring", () => {
     it("uploadFile includes chat_session_id in the FormData body", async () => {
       const fetchMock = vi.fn().mockResolvedValue(
diff --git a/packages/core/api/client.ts b/packages/core/api/client.ts
index 0d4885c523..7be5696a04 100644
--- a/packages/core/api/client.ts
+++ b/packages/core/api/client.ts
@@ -66,6 +66,7 @@ import type {
   ChatPendingTask,
   PendingChatTasksResponse,
   SendChatMessageResponse,
+  CancelTaskResponse,
   Project,
   CreateProjectRequest,
   UpdateProjectRequest,
@@ -135,6 +136,7 @@ import {
   AgentTemplateSchema,
   AgentTemplateSummaryListSchema,
   AttachmentResponseSchema,
+  CancelTaskResponseSchema,
   ChildIssuesResponseSchema,
   CommentsListSchema,
   CommentTriggerPreviewSchema,
@@ -193,6 +195,7 @@ import {
   EMPTY_CREATE_BILLING_CHECKOUT_SESSION_RESPONSE,
   EMPTY_BILLING_CHECKOUT_SESSION_STATUS,
   EMPTY_CREATE_BILLING_PORTAL_SESSION_RESPONSE,
+  EMPTY_CANCEL_TASK_RESPONSE,
   OctoInstallationSchema,
   EMPTY_OCTO_INSTALLATION,
   ListOctoInstallationsResponseSchema,
@@ -571,6 +574,7 @@ export class ApiClient {
     prompt: string;
     project_id?: string | null;
     parent_issue_id?: string | null;
+    attachment_ids?: string[];
   }): Promise<{ task_id: string }> {
     return this.fetch("/api/issues/quick-create", {
       method: "POST",
@@ -1692,8 +1696,11 @@ export class ApiClient {
     await this.fetch(`/api/chat/sessions/${sessionId}/read`, { method: "POST" });
   }
 
-  async cancelTaskById(taskId: string): Promise<void> {
-    await this.fetch(`/api/tasks/${taskId}/cancel`, { method: "POST" });
+  async cancelTaskById(taskId: string): Promise<CancelTaskResponse> {
+    const raw = await this.fetch<unknown>(`/api/tasks/${taskId}/cancel`, { method: "POST" });
+    return parseWithFallback(raw, CancelTaskResponseSchema, EMPTY_CANCEL_TASK_RESPONSE, {
+      endpoint: "POST /api/tasks/{taskId}/cancel",
+    });
   }
 
   async listAttachments(issueId: string): Promise<Attachment[]> {
diff --git a/packages/core/api/schemas.ts b/packages/core/api/schemas.ts
index 9568cac02a..3f4acad17c 100644
--- a/packages/core/api/schemas.ts
+++ b/packages/core/api/schemas.ts
@@ -10,6 +10,7 @@ import type {
   BillingPriceTier,
   BillingTopupsPage,
   BillingTransactionsPage,
+  CancelTaskResponse,
   CreateAgentFromTemplateResponse,
   CreateBillingCheckoutSessionResponse,
   CreateBillingPortalSessionResponse,
@@ -423,6 +424,67 @@ const RuntimeUsageByHourSchema = z.object({
 
 export const RuntimeUsageByHourListSchema = z.array(RuntimeUsageByHourSchema);
 
+// ---------------------------------------------------------------------------
+// Task cancellation (`POST /api/tasks/:id/cancel`)
+//
+// This response is consumed directly by chat recovery. The embedded task
+// object stays loose so daemon/runtime fields can drift, but the optional
+// `cancelled_chat_message` payload must be well-formed before the UI deletes
+// a message from cache or restores text into the input.
+// ---------------------------------------------------------------------------
+
+const AgentTaskResponseSchema = z.object({
+  id: z.string(),
+  agent_id: z.string().default(""),
+  runtime_id: z.string().default(""),
+  issue_id: z.string().default(""),
+  status: z.string().default("cancelled"),
+  priority: z.number().default(0),
+  dispatched_at: z.string().nullable().default(null),
+  started_at: z.string().nullable().default(null),
+  completed_at: z.string().nullable().default(null),
+  result: z.unknown().default(null),
+  error: z.string().nullable().default(null),
+  failure_reason: z.string().optional(),
+  created_at: z.string().default(""),
+  chat_session_id: z.string().optional(),
+  autopilot_run_id: z.string().optional(),
+  parent_task_id: z.string().optional(),
+  attempt: z.number().optional(),
+  trigger_comment_id: z.string().optional(),
+  trigger_summary: z.string().optional(),
+  kind: z.string().optional(),
+  work_dir: z.string().optional(),
+  relative_work_dir: z.string().optional(),
+}).loose();
+
+const CancelledChatMessageSchema = z.object({
+  chat_session_id: z.string(),
+  message_id: z.string(),
+  content: z.string(),
+  restore_to_input: z.boolean().default(false),
+}).loose();
+
+export const CancelTaskResponseSchema = AgentTaskResponseSchema.extend({
+  cancelled_chat_message: CancelledChatMessageSchema.nullish()
+    .transform((value) => value ?? undefined),
+}).loose();
+
+export const EMPTY_CANCEL_TASK_RESPONSE: CancelTaskResponse = {
+  id: "",
+  agent_id: "",
+  runtime_id: "",
+  issue_id: "",
+  status: "cancelled",
+  priority: 0,
+  dispatched_at: null,
+  started_at: null,
+  completed_at: null,
+  result: null,
+  error: null,
+  created_at: "",
+};
+
 // ---------------------------------------------------------------------------
 // Agent template catalog — `/api/agent-templates*` and the
 // create-from-template response. The desktop app's create-agent picker
diff --git a/packages/core/realtime/use-realtime-sync.test.ts b/packages/core/realtime/use-realtime-sync.test.ts
index a1ede2d4ef..94e118972c 100644
--- a/packages/core/realtime/use-realtime-sync.test.ts
+++ b/packages/core/realtime/use-realtime-sync.test.ts
@@ -19,6 +19,7 @@ import {
   applyChatDoneToCache,
   applyWorkspaceUpdatedToCache,
   handleInboxNew,
+  invalidateChatMessageQueries,
   resolveInboxSourceSlug,
 } from "./use-realtime-sync";
 
@@ -134,6 +135,18 @@ describe("applyChatDoneToCache", () => {
   });
 });
 
+describe("invalidateChatMessageQueries", () => {
+  it("invalidates both legacy and paged chat message caches", () => {
+    const qc = createQueryClient();
+    const invalidate = vi.spyOn(qc, "invalidateQueries");
+
+    invalidateChatMessageQueries(qc, sessionId);
+
+    expect(invalidate).toHaveBeenCalledWith({ queryKey: chatKeys.messages(sessionId) });
+    expect(invalidate).toHaveBeenCalledWith({ queryKey: chatKeys.messagesPage(sessionId) });
+  });
+});
+
 describe("applyWorkspaceUpdatedToCache", () => {
   const wsId = "ws-1";
 
diff --git a/packages/core/realtime/use-realtime-sync.ts b/packages/core/realtime/use-realtime-sync.ts
index aa0c2b0378..68e678964d 100644
--- a/packages/core/realtime/use-realtime-sync.ts
+++ b/packages/core/realtime/use-realtime-sync.ts
@@ -90,6 +90,14 @@ const chatWsLogger = createLogger("chat.ws");
 
 const logger = createLogger("realtime-sync");
 
+export function invalidateChatMessageQueries(
+  qc: QueryClient,
+  sessionId: string,
+) {
+  qc.invalidateQueries({ queryKey: chatKeys.messages(sessionId) });
+  qc.invalidateQueries({ queryKey: chatKeys.messagesPage(sessionId) });
+}
+
 export function applyChatDoneToCache(
   qc: QueryClient,
   payload: ChatDonePayload,
@@ -126,8 +134,7 @@ export function applyChatDoneToCache(
   qc.setQueryData(chatKeys.pendingTask(sessionId), {});
   // Authoritative refetch reconciles redaction / migrations / clients
   // that took the fallback branch above.
-  qc.invalidateQueries({ queryKey: chatKeys.messages(sessionId) });
-  qc.invalidateQueries({ queryKey: chatKeys.messagesPage(sessionId) });
+  invalidateChatMessageQueries(qc, sessionId);
   qc.invalidateQueries({ queryKey: chatKeys.pendingTask(sessionId) });
 }
 
@@ -840,7 +847,7 @@ export function useRealtimeSync(
     const unsubChatMessage = ws.on("chat:message", (p) => {
       const payload = p as { chat_session_id: string };
       chatWsLogger.info("chat:message (global)", { chat_session_id: payload.chat_session_id });
-      qc.invalidateQueries({ queryKey: chatKeys.messages(payload.chat_session_id) });
+      invalidateChatMessageQueries(qc, payload.chat_session_id);
       qc.invalidateQueries({ queryKey: chatKeys.pendingTask(payload.chat_session_id) });
       invalidatePendingAggregate();
     });
@@ -954,6 +961,9 @@ export function useRealtimeSync(
     //   2. another tab / admin / system cancels — this is the only path that
     //      drops the pending pill in those cases. Without it the pill spins
     //      forever in the second-tab scenario.
+    // CancelTask also persists a best-effort assistant snapshot when the
+    // stopped chat task had already streamed transcript rows, so refresh the
+    // message page along with clearing pending.
     const unsubTaskCancelled = ws.on("task:cancelled", (p) => {
       const payload = p as TaskCancelledPayload;
       if (!payload.chat_session_id) return;
@@ -962,6 +972,7 @@ export function useRealtimeSync(
         chat_session_id: payload.chat_session_id,
       });
       qc.setQueryData(chatKeys.pendingTask(payload.chat_session_id), {});
+      invalidateChatMessageQueries(qc, payload.chat_session_id);
       invalidatePendingAggregate();
     });
 
@@ -995,7 +1006,7 @@ export function useRealtimeSync(
       // this branch only flipped pending — the comment "No new message"
       // was true then, but FailTask now persists a row.
       qc.setQueryData(chatKeys.pendingTask(payload.chat_session_id), {});
-      qc.invalidateQueries({ queryKey: chatKeys.messages(payload.chat_session_id) });
+      invalidateChatMessageQueries(qc, payload.chat_session_id);
       qc.invalidateQueries({ queryKey: chatKeys.pendingTask(payload.chat_session_id) });
       invalidatePendingAggregate();
     });
diff --git a/packages/core/runtimes/cli-version.test.ts b/packages/core/runtimes/cli-version.test.ts
index ea05fba86f..08e7eb4678 100644
--- a/packages/core/runtimes/cli-version.test.ts
+++ b/packages/core/runtimes/cli-version.test.ts
@@ -3,11 +3,12 @@ import { checkQuickCreateCliVersion } from "./cli-version";
 
 describe("checkQuickCreateCliVersion", () => {
   it("returns ok for a tagged release at or above the minimum", () => {
-    expect(checkQuickCreateCliVersion("v0.2.20").state).toBe("ok");
+    expect(checkQuickCreateCliVersion("v0.2.21").state).toBe("ok");
     expect(checkQuickCreateCliVersion("0.3.1").state).toBe("ok");
   });
 
   it("returns too_old for a tagged release below the minimum", () => {
+    expect(checkQuickCreateCliVersion("v0.2.20").state).toBe("too_old");
     expect(checkQuickCreateCliVersion("v0.2.15").state).toBe("too_old");
   });
 
diff --git a/packages/core/runtimes/cli-version.ts b/packages/core/runtimes/cli-version.ts
index e7c8e0891e..6bce638406 100644
--- a/packages/core/runtimes/cli-version.ts
+++ b/packages/core/runtimes/cli-version.ts
@@ -2,15 +2,15 @@
  * Frontend mirror of the server's MinQuickCreateCLIVersion gate. The
  * agent-create flow (Quick Create modal) requires the daemon's bundled
  * multica CLI to be at least this version — older daemons either
- * double-create issues on partial CLI failures or mishandle pasted
- * screenshot URLs (see PR #1851 / MUL-1496).
+ * double-create issues on partial CLI failures, drop quick-create attachment
+ * bindings, or mishandle pasted screenshot URLs (see PR #1851 / MUL-1496).
  *
  * Both the frontend pre-validation in the modal and the server's
  * `/api/issues/quick-create` handler enforce this; the server is the
  * authoritative trust boundary, the frontend just lets us tell the user
  * "your daemon needs an upgrade" before they hit submit.
  */
-export const MIN_QUICK_CREATE_CLI_VERSION = "0.2.20";
+export const MIN_QUICK_CREATE_CLI_VERSION = "0.2.21";
 
 export type CliVersionState = "ok" | "too_old" | "missing";
 
diff --git a/packages/core/runtimes/local-skills.ts b/packages/core/runtimes/local-skills.ts
index 20f7fe0b36..f0c711f842 100644
--- a/packages/core/runtimes/local-skills.ts
+++ b/packages/core/runtimes/local-skills.ts
@@ -67,6 +67,16 @@ export async function resolveRuntimeLocalSkillImport(
     current = await api.getImportLocalSkillResult(runtimeId, initial.id);
   }
 
+  if (current.status === "conflict") {
+    if (!current.conflict) {
+      throw new Error("runtime local skill import conflict missing details");
+    }
+    return {
+      status: "conflict",
+      conflict: current.conflict,
+    };
+  }
+
   if (current.status === "failed" || current.status === "timeout") {
     throw new Error(current.error || "runtime local skill import failed");
   }
@@ -74,7 +84,10 @@ export async function resolveRuntimeLocalSkillImport(
     throw new Error("runtime local skill import did not return a skill");
   }
 
-  return { skill: current.skill };
+  return {
+    status: current.action === "overwrite" ? "updated" : "created",
+    skill: current.skill,
+  };
 }
 
 export function runtimeLocalSkillsOptions(runtimeId: string | null | undefined) {
diff --git a/packages/core/types/agent.ts b/packages/core/types/agent.ts
index c015b46854..8e43d60237 100644
--- a/packages/core/types/agent.ts
+++ b/packages/core/types/agent.ts
@@ -617,9 +617,18 @@ export type RuntimeLocalSkillStatus =
   | "pending"
   | "running"
   | "completed"
+  | "conflict"
   | "failed"
   | "timeout";
 
+export type RuntimeLocalSkillImportAction = "overwrite";
+
+export interface RuntimeLocalSkillImportConflict {
+  existing_skill_id: string;
+  existing_created_by?: string;
+  can_overwrite: boolean;
+}
+
 export interface RuntimeLocalSkillSummary {
   key: string;
   name: string;
@@ -644,6 +653,9 @@ export interface CreateRuntimeLocalSkillImportRequest {
   skill_key: string;
   name?: string;
   description?: string;
+  action?: RuntimeLocalSkillImportAction;
+  target_skill_id?: string;
+  supports_conflict?: boolean;
 }
 
 export interface RuntimeLocalSkillImportRequest {
@@ -652,8 +664,12 @@ export interface RuntimeLocalSkillImportRequest {
   skill_key: string;
   name?: string;
   description?: string;
+  action?: RuntimeLocalSkillImportAction;
+  target_skill_id?: string;
+  supports_conflict?: boolean;
   status: RuntimeLocalSkillStatus;
   skill?: Skill;
+  conflict?: RuntimeLocalSkillImportConflict;
   error?: string;
   created_at: string;
   updated_at: string;
@@ -665,5 +681,7 @@ export interface RuntimeLocalSkillsResult {
 }
 
 export interface RuntimeLocalSkillImportResult {
-  skill: Skill;
+  status: "created" | "updated" | "conflict";
+  skill?: Skill;
+  conflict?: RuntimeLocalSkillImportConflict;
 }
diff --git a/packages/core/types/chat.ts b/packages/core/types/chat.ts
index 762b01a6ab..7b19710c1e 100644
--- a/packages/core/types/chat.ts
+++ b/packages/core/types/chat.ts
@@ -1,3 +1,5 @@
+import type { AgentTask } from "./agent";
+
 export interface ChatSession {
   id: string;
   workspace_id: string;
@@ -79,6 +81,17 @@ export interface SendChatMessageResponse {
   created_at: string;
 }
 
+export interface CancelledChatMessage {
+  chat_session_id: string;
+  message_id: string;
+  content: string;
+  restore_to_input: boolean;
+}
+
+export interface CancelTaskResponse extends AgentTask {
+  cancelled_chat_message?: CancelledChatMessage;
+}
+
 /**
  * Response from GET /api/chat/sessions/{id}/pending-task.
  * All fields are absent when the session has no in-flight task.
diff --git a/packages/core/types/index.ts b/packages/core/types/index.ts
index aa726264e8..0dd45db84a 100644
--- a/packages/core/types/index.ts
+++ b/packages/core/types/index.ts
@@ -44,6 +44,8 @@ export type {
   RuntimeModelListStatus,
   RuntimeModelsResult,
   RuntimeLocalSkillStatus,
+  RuntimeLocalSkillImportAction,
+  RuntimeLocalSkillImportConflict,
   RuntimeLocalSkillSummary,
   RuntimeLocalSkillListRequest,
   CreateRuntimeLocalSkillImportRequest,
@@ -66,7 +68,17 @@ export type * from "./events";
 export type * from "./api";
 export type { Attachment } from "./attachment";
 export { attachmentDownloadPath, attachmentIdFromDownloadURL, contentReferencesAttachment } from "./attachment-url";
-export type { ChatSession, ChatMessage, ChatMessagesPage, ChatPendingTask, PendingChatTaskItem, PendingChatTasksResponse, SendChatMessageResponse } from "./chat";
+export type {
+  ChatSession,
+  ChatMessage,
+  ChatMessagesPage,
+  ChatPendingTask,
+  PendingChatTaskItem,
+  PendingChatTasksResponse,
+  SendChatMessageResponse,
+  CancelledChatMessage,
+  CancelTaskResponse,
+} from "./chat";
 export type { StorageAdapter } from "./storage";
 export type {
   Project,
diff --git a/packages/ui/components/common/reaction-bar.tsx b/packages/ui/components/common/reaction-bar.tsx
index 12a05c852a..1b57305c67 100644
--- a/packages/ui/components/common/reaction-bar.tsx
+++ b/packages/ui/components/common/reaction-bar.tsx
@@ -40,7 +40,6 @@ interface ReactionBarProps {
   onToggle: (emoji: string) => void;
   getActorName: (type: string, id: string) => string;
   className?: string;
-  hideAddButton?: boolean;
 }
 
 function ReactionBar({
@@ -49,7 +48,6 @@ function ReactionBar({
   onToggle,
   getActorName,
   className,
-  hideAddButton,
 }: ReactionBarProps) {
   const grouped = groupReactions(reactions, currentUserId);
 
@@ -78,7 +76,7 @@ function ReactionBar({
           </TooltipContent>
         </Tooltip>
       ))}
-      {!hideAddButton && <QuickEmojiPicker onSelect={onToggle} />}
+      <QuickEmojiPicker onSelect={onToggle} />
     </div>
   );
 }
diff --git a/packages/views/chat/components/chat-input.test.tsx b/packages/views/chat/components/chat-input.test.tsx
index 8a0ed33c12..ee123e815e 100644
--- a/packages/views/chat/components/chat-input.test.tsx
+++ b/packages/views/chat/components/chat-input.test.tsx
@@ -1,5 +1,5 @@
 import { forwardRef, useRef, useImperativeHandle } from "react";
-import { describe, it, expect, vi } from "vitest";
+import { beforeEach, describe, it, expect, vi } from "vitest";
 import { act, render, screen, fireEvent, waitFor } from "@testing-library/react";
 import { I18nProvider } from "@multica/core/i18n/react";
 import type { UploadResult } from "@multica/core/hooks/use-file-upload";
@@ -130,6 +130,24 @@ vi.mock("@multica/core/chat", () => {
 });
 
 import { ChatInput } from "./chat-input";
+import { useChatStore } from "@multica/core/chat";
+
+beforeEach(() => {
+  dropHandlers.onDrop = null;
+  editorProps.last = null;
+  const state = useChatStore.getState() as unknown as {
+    activeSessionId: string | null;
+    selectedAgentId: string;
+    inputDrafts: Record<string, string>;
+    setInputDraft: ReturnType<typeof vi.fn>;
+    clearInputDraft: ReturnType<typeof vi.fn>;
+  };
+  state.activeSessionId = null;
+  state.selectedAgentId = "agent-1";
+  state.inputDrafts = {};
+  state.setInputDraft.mockClear();
+  state.clearInputDraft.mockClear();
+});
 
 function renderInput(props: Partial<React.ComponentProps<typeof ChatInput>> = {}) {
   const onSend = props.onSend ?? vi.fn();
@@ -313,3 +331,105 @@ describe("ChatInput attachment wiring", () => {
     expect(buttons.length).toBe(1);
   });
 });
+
+describe("ChatInput async send", () => {
+  it("restores a cancelled empty run draft into the editor", async () => {
+    const onRestoreDraftConsumed = vi.fn();
+    renderInput({
+      restoreDraftRequest: {
+        id: "msg-restored",
+        content: "bring this back",
+      },
+      onRestoreDraftConsumed,
+    });
+
+    await waitFor(() => {
+      expect(useChatStore.getState().setInputDraft).toHaveBeenCalledWith(
+        "__draft_new__:agent-1",
+        "bring this back",
+      );
+      expect(editorProps.last?.defaultValue).toBe("bring this back");
+      expect(onRestoreDraftConsumed).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  it("consumes a restore request even when an existing draft blocks restore", async () => {
+    const state = useChatStore.getState() as unknown as {
+      inputDrafts: Record<string, string>;
+      setInputDraft: ReturnType<typeof vi.fn>;
+    };
+    state.inputDrafts["__draft_new__:agent-1"] = "already typing";
+    const onRestoreDraftConsumed = vi.fn();
+
+    renderInput({
+      restoreDraftRequest: {
+        id: "msg-restored",
+        content: "bring this back",
+      },
+      onRestoreDraftConsumed,
+    });
+
+    await waitFor(() => {
+      expect(onRestoreDraftConsumed).toHaveBeenCalledTimes(1);
+    });
+    expect(state.setInputDraft).not.toHaveBeenCalledWith(
+      "__draft_new__:agent-1",
+      "bring this back",
+    );
+  });
+
+  it("keeps the draft while send is pending and clears after acceptance", async () => {
+    let resolveSend: (accepted: boolean) => void;
+    const sendPromise = new Promise<boolean>((res) => {
+      resolveSend = res;
+    });
+    const onSend = vi.fn(() => sendPromise);
+    renderInput({ onSend });
+
+    fireEvent.change(screen.getByTestId("editor"), { target: { value: "slow network" } });
+
+    let sendButton: HTMLElement;
+    await waitFor(() => {
+      const buttons = screen.getAllByRole("button");
+      sendButton = buttons[buttons.length - 1]!;
+      expect(sendButton).not.toBeDisabled();
+    });
+
+    fireEvent.click(sendButton!);
+
+    expect(onSend).toHaveBeenCalledWith("slow network", undefined);
+    expect(useChatStore.getState().clearInputDraft).not.toHaveBeenCalled();
+    await waitFor(() => expect(sendButton!).toBeDisabled());
+
+    await act(async () => {
+      resolveSend!(true);
+      await sendPromise;
+    });
+
+    await waitFor(() => {
+      expect(useChatStore.getState().clearInputDraft).toHaveBeenCalledWith("__draft_new__:agent-1");
+    });
+  });
+
+  it("keeps the draft when send is rejected by the owner", async () => {
+    const onSend = vi.fn(async () => false);
+    renderInput({ onSend });
+
+    fireEvent.change(screen.getByTestId("editor"), { target: { value: "retry me" } });
+
+    let sendButton: HTMLElement;
+    await waitFor(() => {
+      const buttons = screen.getAllByRole("button");
+      sendButton = buttons[buttons.length - 1]!;
+      expect(sendButton).not.toBeDisabled();
+    });
+
+    await act(async () => {
+      fireEvent.click(sendButton!);
+      await Promise.resolve();
+    });
+
+    expect(onSend).toHaveBeenCalledWith("retry me", undefined);
+    expect(useChatStore.getState().clearInputDraft).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/views/chat/components/chat-input.tsx b/packages/views/chat/components/chat-input.tsx
index 38d2e7efb1..6c8ebd4a46 100644
--- a/packages/views/chat/components/chat-input.tsx
+++ b/packages/views/chat/components/chat-input.tsx
@@ -1,7 +1,7 @@
 "use client";
 
 import type { ReactNode } from "react";
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { cn } from "@multica/ui/lib/utils";
 import {
   ContentEditor,
@@ -21,7 +21,9 @@ import { useT } from "../../i18n";
 const logger = createLogger("chat.ui");
 
 interface ChatInputProps {
-  onSend: (content: string, attachmentIds?: string[]) => void;
+  onSend: (content: string, attachmentIds?: string[]) => void | boolean | Promise<void | boolean>;
+  restoreDraftRequest?: { id: string; content: string } | null;
+  onRestoreDraftConsumed?: () => void;
   /** Receives a File and returns the attachment row (with id + CDN link).
    *  The wrapper owner (ChatWindow) lazy-creates a chat_session if needed
    *  and forwards `chatSessionId` to the upload — chat-input only cares
@@ -46,6 +48,8 @@ interface ChatInputProps {
 
 export function ChatInput({
   onSend,
+  restoreDraftRequest,
+  onRestoreDraftConsumed,
   onUploadFile,
   onStop,
   isRunning,
@@ -67,9 +71,10 @@ export function ChatInput({
   // mid-compose gives each agent its own draft. This is a STORAGE key, not
   // a React identity.
   //
-  // `editorKey` — React `key` on the ContentEditor. Used ONLY to force a
+  // `editorKey` — React `key` on the ContentEditor. Used to force a
   // remount when the user explicitly switches agent (so Tiptap's
-  // Placeholder, which only reads on mount, refreshes to "Tell {agent}…").
+  // Placeholder, which only reads on mount, refreshes to "Tell {agent}…")
+  // or when a cancelled empty run restores a draft from the server.
   // Crucially this does NOT include `activeSessionId`: when the user
   // uploads a file in a brand-new chat, `handleUploadFile` first awaits
   // `ensureSession` which lazily creates the session and flips
@@ -82,12 +87,19 @@ export function ChatInput({
   // first-upload-creates-session work the same as second-upload.
   const draftKey =
     activeSessionId ?? `${DRAFT_NEW_SESSION}:${selectedAgentId ?? ""}`;
-  const editorKey = selectedAgentId ?? "no-agent";
   // Select a primitive — empty-string fallback keeps referential stability.
   const inputDraft = useChatStore((s) => s.inputDrafts[draftKey] ?? "");
   const setInputDraft = useChatStore((s) => s.setInputDraft);
   const clearInputDraft = useChatStore((s) => s.clearInputDraft);
   const [isEmpty, setIsEmpty] = useState(!inputDraft.trim());
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [editorRestore, setEditorRestore] = useState<{
+    id: string;
+    content: string;
+    draftKey: string;
+  } | null>(null);
+  const activeRestore = editorRestore?.draftKey === draftKey ? editorRestore : null;
+  const editorKey = `${selectedAgentId ?? "no-agent"}:${activeRestore?.id ?? "base"}`;
   // Number of in-flight uploads. We track this explicitly (rather than
   // peeking at the editor on every render) so the SubmitButton visibly
   // disables the instant an upload starts and re-enables the instant it
@@ -110,6 +122,26 @@ export function ChatInput({
   // attachment never binds to the chat message.
   const uploadMapRef = useRef<Map<string, string>>(new Map());
 
+  useEffect(() => {
+    if (!restoreDraftRequest) return;
+    if (inputDraft.trim()) {
+      logger.info("input.restore skipped: draft already has content", {
+        draftKey,
+        restoreId: restoreDraftRequest.id,
+      });
+      onRestoreDraftConsumed?.();
+      return;
+    }
+    setInputDraft(draftKey, restoreDraftRequest.content);
+    setIsEmpty(!restoreDraftRequest.content.trim());
+    setEditorRestore({
+      id: restoreDraftRequest.id,
+      content: restoreDraftRequest.content,
+      draftKey,
+    });
+    onRestoreDraftConsumed?.();
+  }, [draftKey, inputDraft, onRestoreDraftConsumed, restoreDraftRequest, setInputDraft]);
+
   const handleUpload = useCallback(
     async (file: File): Promise<UploadResult | null> => {
       if (!onUploadFile) return null;
@@ -135,12 +167,13 @@ export function ChatInput({
     onDrop: (files) => files.forEach((f) => editorRef.current?.uploadFile(f)),
   });
 
-  const handleSend = () => {
+  const handleSend = async () => {
     const content = editorRef.current?.getMarkdown()?.replace(/(\n\s*)+$/, "").trim();
-    if (!content || isRunning || disabled || noAgent) {
+    if (!content || isRunning || isSubmitting || disabled || noAgent) {
       logger.debug("input.send skipped", {
         emptyContent: !content,
         isRunning,
+        isSubmitting,
         disabled,
         noAgent,
       });
@@ -172,7 +205,17 @@ export function ChatInput({
       draftKey: keyAtSend,
       attachmentCount: activeIds.length,
     });
-    onSend(content, activeIds.length > 0 ? activeIds : undefined);
+    setIsSubmitting(true);
+    let accepted: void | boolean;
+    try {
+      accepted = await onSend(content, activeIds.length > 0 ? activeIds : undefined);
+    } catch (err) {
+      logger.warn("input.send failed", err);
+      setIsSubmitting(false);
+      return;
+    }
+    setIsSubmitting(false);
+    if (accepted === false) return;
     editorRef.current?.clearContent();
     // Drop focus so the caret doesn't keep blinking under the StatusPill /
     // streaming reply that's about to take over the user's attention. The
@@ -228,7 +271,7 @@ export function ChatInput({
             // intentionally does not depend on activeSessionId.
             key={editorKey}
             ref={editorRef}
-            defaultValue={inputDraft}
+            defaultValue={activeRestore?.content ?? inputDraft}
             placeholder={placeholder}
             onUpdate={(md) => {
               setIsEmpty(!md.trim());
@@ -264,7 +307,7 @@ export function ChatInput({
           )}
           <SubmitButton
             onClick={handleSend}
-            disabled={isEmpty || !!disabled || !!noAgent || pendingUploads > 0}
+            disabled={isEmpty || isSubmitting || !!disabled || !!noAgent || pendingUploads > 0}
             running={isRunning}
             onStop={onStop}
             tooltip={`${t(($) => $.input.send_tooltip)} · ${formatShortcut(modKey, enterKey)}`}
diff --git a/packages/views/chat/components/chat-window.tsx b/packages/views/chat/components/chat-window.tsx
index 764f88c9e9..703c8d0acc 100644
--- a/packages/views/chat/components/chat-window.tsx
+++ b/packages/views/chat/components/chat-window.tsx
@@ -12,6 +12,7 @@ import {
   PopoverContent,
   PopoverTrigger,
 } from "@multica/ui/components/ui/popover";
+import { toast } from "sonner";
 import { useWorkspaceId } from "@multica/core/hooks";
 import { useAuthStore } from "@multica/core/auth";
 import { agentListOptions, memberListOptions } from "@multica/core/workspace/queries";
@@ -35,6 +36,7 @@ import {
   pendingChatTaskOptions,
   pendingChatTasksOptions,
   chatKeys,
+  isTaskMessageTaskId,
 } from "@multica/core/chat/queries";
 import {
   useCreateChatSession,
@@ -75,6 +77,106 @@ function seedChatMessagesPageCache(
   );
 }
 
+function appendChatMessageToLatestPageCache(
+  qc: ReturnType<typeof useQueryClient>,
+  sessionId: string,
+  message: ChatMessage,
+) {
+  qc.setQueryData<InfiniteData<ChatMessagesPage>>(
+    chatKeys.messagesPage(sessionId),
+    (old) => {
+      if (!old) {
+        return {
+          pages: [{
+            messages: [message],
+            limit: 50,
+            has_more: false,
+            next_cursor: null,
+          }],
+          pageParams: [null],
+        };
+      }
+      if (old.pages.some((page) => page.messages.some((m) => m.id === message.id))) {
+        return old;
+      }
+      return {
+        ...old,
+        pages: old.pages.map((page, index) =>
+          index === 0 ? { ...page, messages: [...page.messages, message] } : page,
+        ),
+      };
+    },
+  );
+}
+
+function removeChatMessageFromPageCache(
+  qc: ReturnType<typeof useQueryClient>,
+  sessionId: string,
+  messageId: string,
+) {
+  qc.setQueryData<InfiniteData<ChatMessagesPage> | undefined>(
+    chatKeys.messagesPage(sessionId),
+    (old) => {
+      if (!old) return old;
+      return {
+        ...old,
+        pages: old.pages.map((page) => ({
+          ...page,
+          messages: page.messages.filter((m) => m.id !== messageId),
+        })),
+      };
+    },
+  );
+}
+
+function removeChatMessageFromCaches(
+  qc: ReturnType<typeof useQueryClient>,
+  sessionId: string,
+  messageId: string,
+) {
+  qc.setQueryData<ChatMessage[]>(
+    chatKeys.messages(sessionId),
+    (old) => old?.filter((m) => m.id !== messageId) ?? old,
+  );
+  removeChatMessageFromPageCache(qc, sessionId, messageId);
+}
+
+function replaceOptimisticChatMessageId(
+  qc: ReturnType<typeof useQueryClient>,
+  sessionId: string,
+  optimisticId: string,
+  messageId: string,
+  taskId: string,
+) {
+  const replace = (messages: ChatMessage[] | undefined) => {
+    if (!messages) return messages;
+    if (messages.some((m) => m.id === messageId)) {
+      return messages.filter((m) => m.id !== optimisticId);
+    }
+    return messages.map((m) =>
+      m.id === optimisticId ? { ...m, id: messageId, task_id: taskId } : m,
+    );
+  };
+
+  qc.setQueryData<ChatMessage[]>(
+    chatKeys.messages(sessionId),
+    replace,
+  );
+  qc.setQueryData<InfiniteData<ChatMessagesPage> | undefined>(
+    chatKeys.messagesPage(sessionId),
+    (old) => {
+      if (!old) return old;
+      return {
+        ...old,
+        pages: old.pages.map((page) => ({
+          ...page,
+          messages: replace(page.messages) ?? page.messages,
+        })),
+      };
+    },
+  );
+}
+
 export function ChatWindow() {
   const { t } = useT("chat");
   const wsId = useWorkspaceId();
@@ -123,6 +225,14 @@ export function ChatWindow() {
     pendingChatTaskOptions(activeSessionId ?? ""),
   );
   const pendingTaskId = pendingTask?.task_id ?? null;
+  const stopRequestedBeforeTaskRef = useRef(false);
+  const [restoreDraftRequest, setRestoreDraftRequest] = useState<{
+    id: string;
+    content: string;
+  } | null>(null);
+  const handleRestoreDraftConsumed = useCallback(() => {
+    setRestoreDraftRequest(null);
+  }, []);
 
   // Legacy archived sessions (the old soft-archive feature was removed but
   // pre-existing rows with status='archived' may still exist) are excluded
@@ -277,11 +387,58 @@ export function ChatWindow() {
     [ensureSession, uploadWithToast, qc, setActiveSession],
   );
 
+  const cancelChatTask = useCallback(
+    async (
+      taskId: string,
+      sessionId: string,
+      options: { restoreDraftToInput: boolean; source: string },
+    ) => {
+      apiLogger.info("cancelTask.start", {
+        taskId,
+        sessionId,
+        source: options.source,
+      });
+      qc.setQueryData(chatKeys.pendingTask(sessionId), {});
+
+      try {
+        const result = await api.cancelTaskById(taskId);
+        const restored = result.cancelled_chat_message;
+        if (restored?.restore_to_input) {
+          removeChatMessageFromCaches(qc, restored.chat_session_id, restored.message_id);
+          if (options.restoreDraftToInput && restored.chat_session_id === sessionId) {
+            setRestoreDraftRequest({
+              id: restored.message_id,
+              content: restored.content,
+            });
+          }
+        }
+        qc.invalidateQueries({ queryKey: chatKeys.messages(sessionId) });
+        qc.invalidateQueries({ queryKey: chatKeys.messagesPage(sessionId) });
+        apiLogger.info("cancelTask.success", {
+          taskId,
+          sessionId,
+          restoredToInput: !!restored?.restore_to_input && options.restoreDraftToInput,
+        });
+        return result;
+      } catch (err) {
+        apiLogger.warn("cancelTask.error (task may have already finished)", {
+          taskId,
+          sessionId,
+          err,
+        });
+        qc.invalidateQueries({ queryKey: chatKeys.messages(sessionId) });
+        qc.invalidateQueries({ queryKey: chatKeys.messagesPage(sessionId) });
+        return null;
+      }
+    },
+    [qc],
+  );
+
   const handleSend = useCallback(
-    async (content: string, attachmentIds?: string[]) => {
+    async (content: string, attachmentIds?: string[]): Promise<boolean> => {
       if (!activeAgent) {
         apiLogger.warn("sendChatMessage skipped: no active agent");
-        return;
+        return false;
       }
 
       const finalContent = content;
@@ -296,10 +453,17 @@ export function ChatWindow() {
         attachmentCount: attachmentIds?.length ?? 0,
       });
 
-      const sessionId = await ensureSession(finalContent);
+      let sessionId: string | null = null;
+      try {
+        sessionId = await ensureSession(finalContent);
+      } catch (err) {
+        apiLogger.error("sendChatMessage.ensureSession.error", err);
+        toast.error(t(($) => $.input.send_failed_toast));
+        return false;
+      }
       if (!sessionId) {
         apiLogger.warn("sendChatMessage aborted: ensureSession returned null");
-        return;
+        return false;
       }
 
       // Optimistic burst — everything that gives the user "I sent a message
@@ -322,7 +486,7 @@ export function ChatWindow() {
       // "new-chat first-message" white flash. Priming the cache first means
       // the very first read after activeSessionId flips hits data
       // synchronously and ChatMessageList mounts directly.
-      seedChatMessagesPageCache(qc, sessionId, [optimistic]);
+      appendChatMessageToLatestPageCache(qc, sessionId, optimistic);
       qc.setQueryData<ChatMessage[]>(
         chatKeys.messages(sessionId),
         (old) => (old ? [...old, optimistic] : [optimistic]),
@@ -342,12 +506,23 @@ export function ChatWindow() {
       setActiveSession(sessionId);
       apiLogger.debug("sendChatMessage.optimistic", { sessionId, optimisticId: optimistic.id });
 
-      const result = await api.sendChatMessage(sessionId, finalContent, attachmentIds);
+      let result;
+      try {
+        result = await api.sendChatMessage(sessionId, finalContent, attachmentIds);
+      } catch (err) {
+        apiLogger.error("sendChatMessage.error.rollback", { sessionId, optimisticId: optimistic.id, err });
+        stopRequestedBeforeTaskRef.current = false;
+        removeChatMessageFromCaches(qc, sessionId, optimistic.id);
+        qc.setQueryData(chatKeys.pendingTask(sessionId), {});
+        toast.error(t(($) => $.input.send_failed_toast));
+        return false;
+      }
       apiLogger.info("sendChatMessage.success", {
         sessionId,
         messageId: result.message_id,
         taskId: result.task_id,
       });
+      replaceOptimisticChatMessageId(qc, sessionId, optimistic.id, result.message_id, result.task_id);
       // Replace the temporary task_id with the server's real one (so the WS
       // task: handlers can match against it) and snap the anchor to the
       // server's created_at — keeping the elapsed-seconds reading stable.
@@ -356,15 +531,26 @@ export function ChatWindow() {
         status: "queued",
         created_at: result.created_at,
       });
+      if (stopRequestedBeforeTaskRef.current) {
+        stopRequestedBeforeTaskRef.current = false;
+        await cancelChatTask(result.task_id, sessionId, {
+          restoreDraftToInput: true,
+          source: "deferred-send",
+        });
+        return false;
+      }
       qc.invalidateQueries({ queryKey: chatKeys.messages(sessionId) });
       qc.invalidateQueries({ queryKey: chatKeys.messagesPage(sessionId) });
+      return true;
     },
     [
       activeSessionId,
       activeAgent,
       ensureSession,
+      cancelChatTask,
       qc,
       setActiveSession,
+      t,
     ],
   );
 
@@ -373,27 +559,19 @@ export function ChatWindow() {
       apiLogger.debug("cancelTask skipped: no pending task");
       return;
     }
-    // Optimistic clear — pill disappears + input unlocks the moment the
-    // user clicks Stop, instead of after the HTTP roundtrip. WS
-    // task:cancelled will confirm later (no-op if cache is already empty);
-    // if the cancel POST fails because the task already finished, the
-    // assistant message arrives via task:completed → chat:done and renders
-    // normally. Either way the UI is in sync with reality without latency.
-    apiLogger.info("cancelTask.start", { taskId: pendingTaskId, sessionId: activeSessionId });
-    qc.setQueryData(chatKeys.pendingTask(activeSessionId), {});
-    qc.invalidateQueries({ queryKey: chatKeys.messages(activeSessionId) });
-    qc.invalidateQueries({ queryKey: chatKeys.messagesPage(activeSessionId) });
-    // Fire-and-forget — UI is already in its post-cancel state. We log the
-    // outcome but never block on it.
-    api.cancelTaskById(pendingTaskId).then(
-      () => apiLogger.info("cancelTask.success", { taskId: pendingTaskId }),
-      (err) =>
-        apiLogger.warn("cancelTask.error (task may have already finished)", {
-          taskId: pendingTaskId,
-          err,
-        }),
-    );
-  }, [pendingTaskId, activeSessionId, qc]);
+    if (!isTaskMessageTaskId(pendingTaskId)) {
+      stopRequestedBeforeTaskRef.current = true;
+      apiLogger.info("cancelTask.deferred until server task id", {
+        taskId: pendingTaskId,
+        sessionId: activeSessionId,
+      });
+      return;
+    }
+    void cancelChatTask(pendingTaskId, activeSessionId, {
+      restoreDraftToInput: true,
+      source: "active-input",
+    });
+  }, [pendingTaskId, activeSessionId, cancelChatTask]);
 
   const handleSelectAgent = useCallback(
     (agent: Agent) => {
@@ -590,6 +768,8 @@ export function ChatWindow() {
        *  when there's no agent (the EmptyState above carries the CTA). */}
       <ChatInput
         onSend={handleSend}
+        restoreDraftRequest={restoreDraftRequest}
+        onRestoreDraftConsumed={handleRestoreDraftConsumed}
         onUploadFile={handleUploadFile}
         onStop={handleStop}
         isRunning={!!pendingTaskId}
@@ -914,7 +1094,13 @@ function SessionDropdown({
     queryClient.invalidateQueries({ queryKey: chatKeys.messagesPage(session.id) });
 
     api.cancelTaskById(task.task_id).then(
-      () => apiLogger.info("cancelTask.success (history row)", { taskId: task.task_id, sessionId: session.id }),
+      (result) => {
+        const restored = result.cancelled_chat_message;
+        if (restored?.restore_to_input) {
+          removeChatMessageFromCaches(queryClient, restored.chat_session_id, restored.message_id);
+        }
+        apiLogger.info("cancelTask.success (history row)", { taskId: task.task_id, sessionId: session.id });
+      },
       (err) =>
         apiLogger.warn("cancelTask.error (history row; task may have already finished)", {
           taskId: task.task_id,
diff --git a/packages/views/issues/components/comment-card.tsx b/packages/views/issues/components/comment-card.tsx
index 8ddbea5783..b7f36b8639 100644
--- a/packages/views/issues/components/comment-card.tsx
+++ b/packages/views/issues/components/comment-card.tsx
@@ -26,7 +26,6 @@ import {
 import { Collapsible, CollapsibleTrigger, CollapsibleContent } from "@multica/ui/components/ui/collapsible";
 import { ActorAvatar } from "../../common/actor-avatar";
 import { ReactionBar } from "@multica/ui/components/common/reaction-bar";
-import { QuickEmojiPicker } from "@multica/ui/components/common/quick-emoji-picker";
 import { cn } from "@multica/ui/lib/utils";
 import { copyText } from "@multica/ui/lib/clipboard";
 import { useActorName } from "@multica/core/workspace/hooks";
@@ -400,8 +399,6 @@ function CommentRow({
   const [confirmDelete, setConfirmDelete] = useState(false);
 
   const reactions = entry.reactions ?? [];
-  const contentText = entry.content ?? "";
-  const isLongContent = contentText.length > 500 || contentText.split("\n").length > 8;
 
   return (
     <div className="py-1.5">
@@ -437,10 +434,6 @@ function CommentRow({
         )}
 
         <div className="ml-auto flex items-center gap-0.5">
-          <QuickEmojiPicker
-            onSelect={(emoji) => onToggleReaction(entry.id, emoji)}
-            align="end"
-          />
           <DropdownMenu>
             <DropdownMenuTrigger
               render={
@@ -563,7 +556,6 @@ function CommentRow({
             currentUserId={currentUserId}
             onToggle={(emoji) => onToggleReaction(entry.id, emoji)}
             getActorName={getActorName}
-            hideAddButton={!isLongContent}
             className="mt-1.5 pl-12 pr-4"
           />
         </>
@@ -612,8 +604,6 @@ function CommentCardImpl({
   const replyCount = allNestedReplies.length;
   const contentPreview = (entry.content ?? "").replace(/\n/g, " ").slice(0, 80);
   const reactions = entry.reactions ?? [];
-  const contentText = entry.content ?? "";
-  const isLongContent = contentText.length > 500 || contentText.split("\n").length > 8;
 
   const isHighlighted = highlightedCommentId === entry.id;
 
@@ -709,10 +699,6 @@ function CommentCardImpl({
 
             {open && (
               <div className="ml-auto flex items-center gap-0.5">
-                <QuickEmojiPicker
-                  onSelect={(emoji) => onToggleReaction(entry.id, emoji)}
-                  align="end"
-                />
               <DropdownMenu>
                 <DropdownMenuTrigger
                   render={
@@ -844,7 +830,6 @@ function CommentCardImpl({
                   currentUserId={currentUserId}
                   onToggle={(emoji) => onToggleReaction(entry.id, emoji)}
                   getActorName={getActorName}
-                  hideAddButton={!isLongContent}
                   className="mt-1.5 pl-10"
                 />
               </>
diff --git a/packages/views/issues/components/execution-log-section.tsx b/packages/views/issues/components/execution-log-section.tsx
index 91f21e5541..513c1770bf 100644
--- a/packages/views/issues/components/execution-log-section.tsx
+++ b/packages/views/issues/components/execution-log-section.tsx
@@ -48,9 +48,9 @@ interface ExecutionLogSectionProps {
   issueId: string;
 }
 
-// Past-runs sort priority: failed first (needs attention), then
-// cancelled (procedural noise), then completed (the boring 'done'
-// case sinks to the bottom). Within each group, newest first.
+// Past-runs sort priority: newest first by timestamp. When two runs
+// share the same timestamp, failed ranks above cancelled, which ranks
+// above completed.
 const PAST_STATUS_RANK: Record<string, number> = {
   failed: 0,
   cancelled: 1,
@@ -96,17 +96,15 @@ export function ExecutionLogSection({ issueId }: ExecutionLogSectionProps) {
         t.status === "failed" ||
         t.status === "cancelled",
     );
-    // Stable sort: failed first, cancelled second, completed last.
-    // Within group: newest completed_at first (fall back to created_at
-    // for malformed rows missing completed_at).
     return past.toSorted((a, b) => {
-      const rankDiff =
-        (PAST_STATUS_RANK[a.status] ?? 99) -
-        (PAST_STATUS_RANK[b.status] ?? 99);
-      if (rankDiff !== 0) return rankDiff;
       const at = a.completed_at ?? a.created_at;
       const bt = b.completed_at ?? b.created_at;
-      return new Date(bt).getTime() - new Date(at).getTime();
+      const timeDiff = new Date(bt).getTime() - new Date(at).getTime();
+      if (timeDiff !== 0) return timeDiff;
+      return (
+        (PAST_STATUS_RANK[a.status] ?? 99) -
+        (PAST_STATUS_RANK[b.status] ?? 99)
+      );
     });
   }, [tasks]);
 
diff --git a/packages/views/issues/components/thread-utils.test.ts b/packages/views/issues/components/thread-utils.test.ts
new file mode 100644
index 0000000000..2c1f9c76ce
--- /dev/null
+++ b/packages/views/issues/components/thread-utils.test.ts
@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import type { TimelineEntry } from "@multica/core/types";
+import { collectThreadReplies } from "./thread-utils";
+
+function comment(id: string, createdAt: string, parentId: string | null): TimelineEntry {
+  return {
+    type: "comment",
+    id,
+    actor_type: "member",
+    actor_id: "user-1",
+    content: id,
+    parent_id: parentId,
+    created_at: createdAt,
+    updated_at: createdAt,
+    comment_type: "comment",
+  } as TimelineEntry;
+}
+
+function bucketByParent(entries: TimelineEntry[]): Map<string, TimelineEntry[]> {
+  const map = new Map<string, TimelineEntry[]>();
+  for (const e of entries) {
+    if (!e.parent_id) continue;
+    const list = map.get(e.parent_id) ?? [];
+    list.push(e);
+    map.set(e.parent_id, list);
+  }
+  return map;
+}
+
+describe("collectThreadReplies", () => {
+  it("orders a late nested reply after earlier sibling replies (#3691)", () => {
+    // R1 (50m ago) triggered a slow agent; R2 (30m) and R3 (10m) arrived while
+    // it ran; D (3m ago) is the agent's reply, forced to nest under R1. A
+    // depth-first walk yields R1-D-R2-R3; the thread must read R1-R2-R3-D.
+    const r1 = comment("r1", "2026-06-11T10:00:00Z", "root");
+    const r2 = comment("r2", "2026-06-11T10:20:00Z", "root");
+    const r3 = comment("r3", "2026-06-11T10:40:00Z", "root");
+    const d = comment("d", "2026-06-11T10:47:00Z", "r1");
+
+    const out = collectThreadReplies("root", bucketByParent([r1, r2, r3, d]));
+
+    expect(out.map((e) => e.id)).toEqual(["r1", "r2", "r3", "d"]);
+  });
+
+  it("still returns every descendant across nesting levels", () => {
+    const r1 = comment("r1", "2026-06-11T10:00:00Z", "root");
+    const d1 = comment("d1", "2026-06-11T10:05:00Z", "r1");
+    const d2 = comment("d2", "2026-06-11T10:10:00Z", "d1");
+
+    const out = collectThreadReplies("root", bucketByParent([r1, d1, d2]));
+
+    expect(out.map((e) => e.id)).toEqual(["r1", "d1", "d2"]);
+  });
+
+  it("breaks created_at ties by id so the order is deterministic", () => {
+    const b = comment("b", "2026-06-11T10:00:00Z", "root");
+    const a = comment("a", "2026-06-11T10:00:00Z", "b");
+
+    const out = collectThreadReplies("root", bucketByParent([b, a]));
+
+    expect(out.map((e) => e.id)).toEqual(["a", "b"]);
+  });
+});
diff --git a/packages/views/issues/components/thread-utils.ts b/packages/views/issues/components/thread-utils.ts
index ab821e8b81..a47074fb91 100644
--- a/packages/views/issues/components/thread-utils.ts
+++ b/packages/views/issues/components/thread-utils.ts
@@ -1,11 +1,19 @@
 import type { TimelineEntry } from "@multica/core/types";
+import { sortTimelineEntriesAsc } from "@multica/core/issues/timeline-sort";
 
 /**
  * Walks the parent_id graph rooted at `rootId` and returns every descendant in
- * traversal order. Shared between CommentCard (which renders the expanded
- * thread) and ResolvedThreadBar (which displays the collapsed count + author
- * list) so the two views stay in sync — direct-children-only counts diverge
- * once nested replies exist (see Emacs review on PR #2300).
+ * CHRONOLOGICAL order (created_at ASC, id tie-break). Shared between
+ * CommentCard (which renders the expanded thread) and ResolvedThreadBar
+ * (which displays the collapsed count + author list) so the two views stay in
+ * sync — direct-children-only counts diverge once nested replies exist (see
+ * Emacs review on PR #2300).
+ *
+ * Chronological, not depth-first: agent replies are forced to nest under the
+ * comment that triggered them, so a depth-first walk lets a slow agent's late
+ * reply render BEFORE earlier sibling replies (#3691). The server's --thread
+ * output the agent reads is already chronological (ListThreadCommentsForIssue
+ * in comment.sql); this keeps the UI on the same order.
  */
 export function collectThreadReplies(
   rootId: string,
@@ -20,7 +28,7 @@ export function collectThreadReplies(
     }
   };
   walk(rootId);
-  return out;
+  return sortTimelineEntriesAsc(out);
 }
 
 /**
diff --git a/packages/views/lark/bind-page.test.tsx b/packages/views/lark/bind-page.test.tsx
new file mode 100644
index 0000000000..7352d00f03
--- /dev/null
+++ b/packages/views/lark/bind-page.test.tsx
@@ -0,0 +1,120 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, waitFor, fireEvent } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { I18nProvider } from "@multica/core/i18n/react";
+import enCommon from "../locales/en/common.json";
+
+const TEST_RESOURCES = { en: { common: enCommon } };
+
+// ---------------------------------------------------------------------------
+// Hoisted mutable auth state — lets individual tests set different scenarios
+// ---------------------------------------------------------------------------
+const mockAuthState = vi.hoisted(() => ({
+  user: null as { id: string; email: string } | null,
+  isLoading: false,
+}));
+
+const mockNavigatePush = vi.hoisted(() => vi.fn());
+const mockRedeemToken = vi.hoisted(() => vi.fn());
+
+vi.mock("@multica/core/auth", () => {
+  const useAuthStore = Object.assign(
+    (sel?: (s: typeof mockAuthState) => unknown) =>
+      sel ? sel(mockAuthState) : mockAuthState,
+    { getState: () => mockAuthState },
+  );
+  return { useAuthStore };
+});
+
+vi.mock("../navigation", () => ({
+  useNavigation: () => ({ push: mockNavigatePush }),
+}));
+
+vi.mock("@multica/core/api", () => ({
+  api: { redeemLarkBindingToken: mockRedeemToken },
+}));
+
+import { LarkBindPage } from "./bind-page";
+
+function I18nWrapper({ children }: { children: ReactNode }) {
+  return (
+    <I18nProvider locale="en" resources={TEST_RESOURCES}>
+      {children}
+    </I18nProvider>
+  );
+}
+
+function renderPage(token: string | null) {
+  return render(<LarkBindPage token={token} />, { wrapper: I18nWrapper });
+}
+
+describe("LarkBindPage", () => {
+  beforeEach(() => {
+    mockAuthState.user = null;
+    mockAuthState.isLoading = false;
+    mockNavigatePush.mockReset();
+    mockRedeemToken.mockReset();
+  });
+
+  it("shows redeeming text while auth is still loading (not needs-auth)", () => {
+    mockAuthState.isLoading = true;
+    mockAuthState.user = null;
+    renderPage("tok123");
+    expect(screen.getByText(/redeeming binding token/i)).toBeInTheDocument();
+    expect(screen.queryByRole("button", { name: /sign in/i })).toBeNull();
+  });
+
+  it("shows needs-auth UI when auth finishes loading and user is null", () => {
+    mockAuthState.isLoading = false;
+    mockAuthState.user = null;
+    renderPage("tok123");
+    expect(
+      screen.getByRole("button", { name: /sign in/i }),
+    ).toBeInTheDocument();
+  });
+
+  it("starts redemption immediately when user is already logged in", async () => {
+    mockAuthState.isLoading = false;
+    mockAuthState.user = { id: "u1", email: "u@example.com" };
+    mockRedeemToken.mockResolvedValue({
+      workspace_id: "ws1",
+      installation_id: "inst1",
+    });
+    renderPage("tok123");
+    await waitFor(() => {
+      expect(mockRedeemToken).toHaveBeenCalledWith("tok123");
+    });
+  });
+
+  it("shows success state after successful redemption", async () => {
+    mockAuthState.isLoading = false;
+    mockAuthState.user = { id: "u1", email: "u@example.com" };
+    mockRedeemToken.mockResolvedValue({
+      workspace_id: "ws1",
+      installation_id: "inst1",
+    });
+    renderPage("tok123");
+    await waitFor(() => {
+      expect(screen.getByText(/you're bound/i)).toBeInTheDocument();
+    });
+  });
+
+  it("sign-in button navigates with ?next= parameter (not ?redirect=)", () => {
+    mockAuthState.isLoading = false;
+    mockAuthState.user = null;
+    renderPage("mytoken");
+    fireEvent.click(screen.getByRole("button", { name: /sign in/i }));
+    expect(mockNavigatePush).toHaveBeenCalledTimes(1);
+    const url: string = mockNavigatePush.mock.calls[0]?.[0] as string;
+    expect(url).toContain("?next=");
+    expect(url).not.toContain("?redirect=");
+    expect(url).toContain(encodeURIComponent("mytoken"));
+  });
+
+  it("shows missing token error when token is null", () => {
+    renderPage(null);
+    expect(
+      screen.getByText(/missing its binding token/i),
+    ).toBeInTheDocument();
+  });
+});
diff --git a/packages/views/lark/bind-page.tsx b/packages/views/lark/bind-page.tsx
index d1e9e4973e..8c13223618 100644
--- a/packages/views/lark/bind-page.tsx
+++ b/packages/views/lark/bind-page.tsx
@@ -29,6 +29,7 @@ type RedeemState =
 export function LarkBindPage({ token }: { token: string | null }) {
   const { t } = useT("common");
   const user = useAuthStore((s) => s.user);
+  const isAuthLoading = useAuthStore((s) => s.isLoading);
   const navigation = useNavigation();
   const [state, setState] = useState<RedeemState>({ kind: "idle" });
 
@@ -37,11 +38,12 @@ export function LarkBindPage({ token }: { token: string | null }) {
       setState({ kind: "error", reason: "missing_token" });
       return;
     }
+    if (isAuthLoading) return;
     if (!user) {
       setState({ kind: "needs-auth" });
       return;
     }
-    if (state.kind !== "idle") return;
+    if (state.kind !== "idle" && state.kind !== "needs-auth") return;
     setState({ kind: "redeeming" });
     (async () => {
       try {
@@ -58,7 +60,7 @@ export function LarkBindPage({ token }: { token: string | null }) {
         });
       }
     })();
-  }, [token, user, state.kind]);
+  }, [token, user, isAuthLoading, state.kind]);
 
   return (
     <div className="mx-auto flex min-h-screen max-w-md flex-col items-center justify-center p-6">
@@ -76,7 +78,7 @@ export function LarkBindPage({ token }: { token: string | null }) {
                 size="sm"
                 onClick={() =>
                   navigation.push(
-                    `/login?redirect=${encodeURIComponent(
+                    `/login?next=${encodeURIComponent(
                       `/lark/bind?token=${encodeURIComponent(token ?? "")}`,
                     )}`,
                   )
diff --git a/packages/views/locales/en/chat.json b/packages/views/locales/en/chat.json
index 77ec1da7da..d5aa77689c 100644
--- a/packages/views/locales/en/chat.json
+++ b/packages/views/locales/en/chat.json
@@ -11,7 +11,8 @@
     "placeholder_named": "Message {{name}}…",
     "placeholder_default": "Start a message…",
     "send_tooltip": "Send",
-    "stop_tooltip": "Stop"
+    "stop_tooltip": "Stop",
+    "send_failed_toast": "Failed to send message"
   },
   "message_list": {
     "show_details": "Show details",
diff --git a/packages/views/locales/en/skills.json b/packages/views/locales/en/skills.json
index de6a32b0b2..6287901417 100644
--- a/packages/views/locales/en/skills.json
+++ b/packages/views/locales/en/skills.json
@@ -231,9 +231,27 @@
     "bulk_complete_hint": "Import complete.",
     "bulk_cancelled_hint": "Import cancelled.",
     "bulk_done_button": "Done",
-    "bulk_summary_imported": "Imported",
+    "bulk_summary_created": "Created",
+    "bulk_summary_updated": "Updated",
+    "bulk_summary_conflicts": "Conflicts",
     "bulk_summary_skipped": "Skipped",
-    "bulk_summary_failed": "Failed"
+    "bulk_summary_failed": "Failed",
+    "conflict_single_title": "A skill with this name already exists",
+    "conflict_bulk_title": "{{count}} skills need a decision",
+    "conflict_hint": "Choose whether to overwrite the existing workspace skill, import with a new name, or skip it.",
+    "conflict_locked_creator": "This skill was created by {{creator}}. Only the creator can overwrite it from local import; edit it from the Skill detail page if you need to change it.",
+    "conflict_locked": "Only the creator can overwrite this skill from local import; edit it from the Skill detail page if you need to change it.",
+    "conflict_overwrite": "Overwrite",
+    "conflict_rename": "Rename",
+    "conflict_skip": "Skip",
+    "conflict_cancel": "Cancel",
+    "conflict_overwrite_all": "Overwrite all",
+    "conflict_skip_all": "Skip all",
+    "conflict_rename_label": "New skill name",
+    "conflict_footer": "{{count}} conflict decisions pending.",
+    "conflict_apply_button": "Apply decisions",
+    "conflict_missing_resolution": "Choose how to resolve this conflict.",
+    "conflict_name_still_exists": "That name already exists. Choose another name or skip."
   },
   "file_tree": {
     "no_files": "No files"
diff --git a/packages/views/locales/ja/chat.json b/packages/views/locales/ja/chat.json
index b297912c76..2a8319be4d 100644
--- a/packages/views/locales/ja/chat.json
+++ b/packages/views/locales/ja/chat.json
@@ -10,7 +10,8 @@
     "placeholder_named": "{{name}} にメッセージ…",
     "placeholder_default": "メッセージを入力…",
     "send_tooltip": "送信",
-    "stop_tooltip": "停止"
+    "stop_tooltip": "停止",
+    "send_failed_toast": "メッセージを送信できませんでした"
   },
   "message_list": {
     "show_details": "詳細を表示",
diff --git a/packages/views/locales/ja/skills.json b/packages/views/locales/ja/skills.json
index 8ac5001276..ae72a940a7 100644
--- a/packages/views/locales/ja/skills.json
+++ b/packages/views/locales/ja/skills.json
@@ -228,9 +228,27 @@
     "bulk_complete_hint": "インポートが完了しました。",
     "bulk_cancelled_hint": "インポートをキャンセルしました。",
     "bulk_done_button": "完了",
-    "bulk_summary_imported": "インポート済み",
+    "bulk_summary_created": "作成済み",
+    "bulk_summary_updated": "更新済み",
+    "bulk_summary_conflicts": "競合",
     "bulk_summary_skipped": "スキップ",
-    "bulk_summary_failed": "失敗"
+    "bulk_summary_failed": "失敗",
+    "conflict_single_title": "同じ名前のスキルがすでに存在します",
+    "conflict_bulk_title": "{{count}} 個のスキルに判断が必要です",
+    "conflict_hint": "既存のワークスペーススキルを上書きするか、新しい名前でインポートするか、スキップするかを選択してください。",
+    "conflict_locked_creator": "このスキルは {{creator}} が作成しました。ローカルインポートで上書きできるのは作成者だけです。変更が必要な場合は、スキル詳細ページで編集してください。",
+    "conflict_locked": "ローカルインポートでこのスキルを上書きできるのは作成者だけです。変更が必要な場合は、スキル詳細ページで編集してください。",
+    "conflict_overwrite": "上書き",
+    "conflict_rename": "名前を変更",
+    "conflict_skip": "スキップ",
+    "conflict_cancel": "キャンセル",
+    "conflict_overwrite_all": "すべて上書き",
+    "conflict_skip_all": "すべてスキップ",
+    "conflict_rename_label": "新しいスキル名",
+    "conflict_footer": "{{count}} 件の競合判断が残っています。",
+    "conflict_apply_button": "決定を適用",
+    "conflict_missing_resolution": "この競合の処理方法を選択してください。",
+    "conflict_name_still_exists": "その名前はすでに存在します。別の名前を選択するか、スキップしてください。"
   },
   "file_tree": {
     "no_files": "ファイルなし"
diff --git a/packages/views/locales/ko/chat.json b/packages/views/locales/ko/chat.json
index f84be61209..3a8bde7c96 100644
--- a/packages/views/locales/ko/chat.json
+++ b/packages/views/locales/ko/chat.json
@@ -11,7 +11,8 @@
     "placeholder_named": "{{name}}에게 메시지 보내기…",
     "placeholder_default": "메시지 입력…",
     "send_tooltip": "보내기",
-    "stop_tooltip": "중지"
+    "stop_tooltip": "중지",
+    "send_failed_toast": "메시지를 보내지 못했습니다"
   },
   "message_list": {
     "show_details": "세부 정보 보기",
diff --git a/packages/views/locales/ko/skills.json b/packages/views/locales/ko/skills.json
index dce5b2cf56..562bcdf6f1 100644
--- a/packages/views/locales/ko/skills.json
+++ b/packages/views/locales/ko/skills.json
@@ -231,9 +231,27 @@
     "bulk_complete_hint": "가져오기가 완료되었습니다.",
     "bulk_cancelled_hint": "가져오기가 취소되었습니다.",
     "bulk_done_button": "완료",
-    "bulk_summary_imported": "가져옴",
+    "bulk_summary_created": "생성됨",
+    "bulk_summary_updated": "업데이트됨",
+    "bulk_summary_conflicts": "충돌",
     "bulk_summary_skipped": "건너뜀",
-    "bulk_summary_failed": "실패"
+    "bulk_summary_failed": "실패",
+    "conflict_single_title": "이 이름의 스킬이 이미 있습니다",
+    "conflict_bulk_title": "{{count}}개의 스킬에 결정이 필요합니다",
+    "conflict_hint": "기존 워크스페이스 스킬을 덮어쓸지, 새 이름으로 가져올지, 건너뛸지 선택하세요.",
+    "conflict_locked_creator": "이 스킬은 {{creator}}님이 만들었습니다. 로컬 가져오기에서 덮어쓰기는 생성자만 할 수 있습니다. 변경이 필요하면 스킬 상세 페이지에서 편집하세요.",
+    "conflict_locked": "로컬 가져오기에서 이 스킬은 생성자만 덮어쓸 수 있습니다. 변경이 필요하면 스킬 상세 페이지에서 편집하세요.",
+    "conflict_overwrite": "덮어쓰기",
+    "conflict_rename": "이름 변경",
+    "conflict_skip": "건너뛰기",
+    "conflict_cancel": "취소",
+    "conflict_overwrite_all": "모두 덮어쓰기",
+    "conflict_skip_all": "모두 건너뛰기",
+    "conflict_rename_label": "새 스킬 이름",
+    "conflict_footer": "{{count}}개의 충돌 결정이 남아 있습니다.",
+    "conflict_apply_button": "결정 적용",
+    "conflict_missing_resolution": "이 충돌을 처리할 방법을 선택하세요.",
+    "conflict_name_still_exists": "해당 이름이 이미 있습니다. 다른 이름을 선택하거나 건너뛰세요."
   },
   "file_tree": {
     "no_files": "파일 없음"
diff --git a/packages/views/locales/zh-Hans/chat.json b/packages/views/locales/zh-Hans/chat.json
index 0abfbf3d46..5eb786ff76 100644
--- a/packages/views/locales/zh-Hans/chat.json
+++ b/packages/views/locales/zh-Hans/chat.json
@@ -10,7 +10,8 @@
     "placeholder_named": "给 {{name}} 发消息…",
     "placeholder_default": "输入消息…",
     "send_tooltip": "发送",
-    "stop_tooltip": "停止"
+    "stop_tooltip": "停止",
+    "send_failed_toast": "发送消息失败"
   },
   "message_list": {
     "show_details": "查看详情",
diff --git a/packages/views/locales/zh-Hans/skills.json b/packages/views/locales/zh-Hans/skills.json
index 7beacc57be..484cb4be64 100644
--- a/packages/views/locales/zh-Hans/skills.json
+++ b/packages/views/locales/zh-Hans/skills.json
@@ -243,9 +243,27 @@
     "bulk_complete_hint": "导入完成。",
     "bulk_cancelled_hint": "导入已取消。",
     "bulk_done_button": "完成",
-    "bulk_summary_imported": "已导入",
+    "bulk_summary_created": "已创建",
+    "bulk_summary_updated": "已更新",
+    "bulk_summary_conflicts": "冲突",
     "bulk_summary_skipped": "已跳过",
-    "bulk_summary_failed": "失败"
+    "bulk_summary_failed": "失败",
+    "conflict_single_title": "工作区里已存在同名 skill",
+    "conflict_bulk_title": "{{count}} 个 skill 需要处理冲突",
+    "conflict_hint": "选择覆盖现有工作区 skill、改名导入，或跳过。",
+    "conflict_locked_creator": "该 skill 由 {{creator}} 创建，只能由创建者通过本地导入覆盖；如需修改请到 Skill 详情页编辑。",
+    "conflict_locked": "该 skill 只能由创建者通过本地导入覆盖；如需修改请到 Skill 详情页编辑。",
+    "conflict_overwrite": "覆盖",
+    "conflict_rename": "改名",
+    "conflict_skip": "跳过",
+    "conflict_cancel": "取消",
+    "conflict_overwrite_all": "全部覆盖",
+    "conflict_skip_all": "全部跳过",
+    "conflict_rename_label": "新的 skill 名称",
+    "conflict_footer": "还有 {{count}} 个冲突决策待处理。",
+    "conflict_apply_button": "应用决策",
+    "conflict_missing_resolution": "请选择如何处理这个冲突。",
+    "conflict_name_still_exists": "这个名称仍然已存在。请换一个名称或跳过。"
   },
   "file_tree": {
     "no_files": "无文件"
diff --git a/packages/views/modals/quick-create-issue.test.tsx b/packages/views/modals/quick-create-issue.test.tsx
index ba2c70b58c..1ab7e2d770 100644
--- a/packages/views/modals/quick-create-issue.test.tsx
+++ b/packages/views/modals/quick-create-issue.test.tsx
@@ -1,6 +1,6 @@
 import { forwardRef, useImperativeHandle, useRef, useState, type ReactNode } from "react";
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { render, screen, waitFor } from "@testing-library/react";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 
 const mockQuickCreateIssue = vi.hoisted(() => vi.fn());
@@ -11,6 +11,7 @@ const mockClearPrompt = vi.hoisted(() => vi.fn());
 const mockSetKeepOpen = vi.hoisted(() => vi.fn());
 const mockSetLastMode = vi.hoisted(() => vi.fn());
 const mockToastSuccess = vi.hoisted(() => vi.fn());
+const mockUploadWithToast = vi.hoisted(() => vi.fn());
 
 const mockQuickCreateStore = {
   lastActorType: null as "agent" | "squad" | null,
@@ -116,7 +117,7 @@ vi.mock("@multica/core/runtimes", () => ({
 }));
 
 vi.mock("@multica/core/hooks/use-file-upload", () => ({
-  useFileUpload: () => ({ uploadWithToast: vi.fn(), uploading: false }),
+  useFileUpload: () => ({ uploadWithToast: mockUploadWithToast, uploading: false }),
 }));
 
 vi.mock("../issues/components/pickers/assignee-picker", () => ({
@@ -141,7 +142,7 @@ vi.mock("../common/pill-button", () => ({
 }));
 
 vi.mock("../editor", () => {
-  const ContentEditor = forwardRef(({ defaultValue, onUpdate, onSubmit, placeholder }: any, ref: any) => {
+  const ContentEditor = forwardRef(({ defaultValue, onUpdate, onSubmit, onUploadFile, placeholder }: any, ref: any) => {
     const valueRef = useRef(defaultValue || "");
     const [value, setValue] = useState(defaultValue || "");
 
@@ -156,20 +157,28 @@ vi.mock("../editor", () => {
     }));
 
     return (
-      <textarea
-        value={value}
-        placeholder={placeholder}
-        onChange={(e) => {
-          valueRef.current = e.target.value;
-          setValue(e.target.value);
-          onUpdate?.(e.target.value);
-        }}
-        onKeyDown={(e) => {
-          if ((e.metaKey || e.ctrlKey) && e.key === "Enter") {
-            onSubmit?.();
-          }
-        }}
-      />
+      <>
+        <textarea
+          value={value}
+          placeholder={placeholder}
+          onChange={(e) => {
+            valueRef.current = e.target.value;
+            setValue(e.target.value);
+            onUpdate?.(e.target.value);
+          }}
+          onKeyDown={(e) => {
+            if ((e.metaKey || e.ctrlKey) && e.key === "Enter") {
+              onSubmit?.();
+            }
+          }}
+        />
+        <button
+          type="button"
+          onClick={() => onUploadFile?.(new File(["image"], "shot.png", { type: "image/png" }))}
+        >
+          Mock editor upload
+        </button>
+      </>
     );
   });
   ContentEditor.displayName = "ContentEditor";
@@ -287,6 +296,23 @@ describe("AgentCreatePanel", () => {
     mockProjectsQuery.isSuccess = true;
     mockSquadsData.list = [];
     mockQuickCreateIssue.mockResolvedValue(undefined);
+    mockUploadWithToast.mockResolvedValue({
+      id: "019ec09d-6222-722b-bdfa-427b105d80be",
+      workspace_id: "ws-test",
+      issue_id: null,
+      comment_id: null,
+      chat_session_id: null,
+      chat_message_id: null,
+      uploader_type: "member",
+      uploader_id: "user-1",
+      filename: "shot.png",
+      url: "/uploads/shot.png",
+      download_url: "/api/attachments/019ec09d-6222-722b-bdfa-427b105d80be/download",
+      markdown_url: "/api/attachments/019ec09d-6222-722b-bdfa-427b105d80be/download",
+      content_type: "image/png",
+      size_bytes: 5,
+      created_at: "2026-06-12T00:00:00Z",
+    });
     mockSetKeepOpen.mockImplementation((value: boolean) => {
       mockQuickCreateStore.keepOpen = value;
     });
@@ -335,6 +361,38 @@ describe("AgentCreatePanel", () => {
     expect(onClose).toHaveBeenCalled();
   });
 
+  it("passes referenced upload attachment ids to quick-create", async () => {
+    const user = userEvent.setup();
+    const onClose = vi.fn();
+
+    renderPanel({ onClose, isExpanded: false, setIsExpanded: vi.fn() });
+
+    await user.click(screen.getByRole("button", { name: "Mock editor upload" }));
+    await waitFor(() => expect(mockUploadWithToast).toHaveBeenCalled());
+
+    const editor = screen.getByPlaceholderText(
+      'Tell the agent what to do, e.g. "let Bohan fix the inbox loading slowness in the Web project"',
+    );
+    await user.clear(editor);
+    fireEvent.change(editor, {
+      target: {
+        value: "Create issue with ![image](/api/attachments/019ec09d-6222-722b-bdfa-427b105d80be/download)",
+      },
+    });
+
+    await user.click(screen.getByRole("button", { name: /^Create \(/i }));
+
+    await waitFor(() => {
+      expect(mockQuickCreateIssue).toHaveBeenCalledWith({
+        agent_id: "agent-1",
+        prompt: "Create issue with ![image](/api/attachments/019ec09d-6222-722b-bdfa-427b105d80be/download)",
+        project_id: undefined,
+        parent_issue_id: undefined,
+        attachment_ids: ["019ec09d-6222-722b-bdfa-427b105d80be"],
+      });
+    });
+  });
+
   // Picking a squad routes the submission through `squad_id` (not
   // `agent_id`) so the backend can resolve the squad's leader agent and
   // inject the squad-leader briefing on dispatch. The persisted preference
diff --git a/packages/views/modals/quick-create-issue.tsx b/packages/views/modals/quick-create-issue.tsx
index 783fa3a024..feb9496536 100644
--- a/packages/views/modals/quick-create-issue.tsx
+++ b/packages/views/modals/quick-create-issue.tsx
@@ -26,7 +26,7 @@ import {
 } from "@multica/core/runtimes";
 import { useFileUpload } from "@multica/core/hooks/use-file-upload";
 import { formatShortcut, modKey, enterKey } from "@multica/core/platform";
-import type { Agent, Squad } from "@multica/core/types";
+import { contentReferencesAttachment, type Agent, type Attachment, type Squad } from "@multica/core/types";
 import { ActorAvatar } from "../common/actor-avatar";
 import { PillButton } from "../common/pill-button";
 import { ProjectPicker } from "../projects/components/project-picker";
@@ -257,15 +257,21 @@ export function AgentCreatePanel({
   const [justSent, setJustSent] = useState(false);
   const [sentCount, setSentCount] = useState(0);
   const [error, setError] = useState<string | null>(null);
+  const [pendingAttachments, setPendingAttachments] = useState<Attachment[]>([]);
 
   // Image paste/drop support: route uploads through the same helper Advanced
   // uses, so users can paste screenshots straight into the prompt and the
   // agent receives them as embedded markdown image URLs in the prompt.
   const { uploadWithToast, uploading } = useFileUpload(api);
-  const handleUploadFile = useCallback(
-    (file: File) => uploadWithToast(file),
-    [uploadWithToast],
-  );
+  const handleUploadFile = useCallback(async (file: File) => {
+    const result = await uploadWithToast(file);
+    if (result) {
+      setPendingAttachments((prev) =>
+        prev.some((a) => a.id === result.id) ? prev : [...prev, result],
+      );
+    }
+    return result;
+  }, [uploadWithToast]);
   const { isDragOver, dropZoneProps } = useFileDropZone({
     onDrop: (files) => files.forEach((f) => editorRef.current?.uploadFile(f)),
   });
@@ -281,6 +287,9 @@ export function AgentCreatePanel({
   const submit = async () => {
     const md = editorRef.current?.getMarkdown()?.trim() ?? "";
     if (!md || !actor || submitting || versionBlocked || uploading) return;
+    const activeAttachmentIds = pendingAttachments
+      .filter((a) => contentReferencesAttachment(md, a))
+      .map((a) => a.id);
     setSubmitting(true);
     setError(null);
     try {
@@ -291,6 +300,7 @@ export function AgentCreatePanel({
         prompt: md,
         project_id: projectId ?? undefined,
         parent_issue_id: parentIssueId,
+        ...(activeAttachmentIds.length > 0 ? { attachment_ids: activeAttachmentIds } : {}),
       });
       setLastActor(actor.type, actor.id);
       setLastProjectId(projectId);
@@ -303,6 +313,7 @@ export function AgentCreatePanel({
         // Stay open for continuous creation — clear the editor so the
         // user can immediately type the next prompt.
         editorRef.current?.clearContent();
+        setPendingAttachments([]);
         setHasContent(false);
         setSentCount((c) => c + 1);
         setJustSent(true);
@@ -469,6 +480,7 @@ export function AgentCreatePanel({
               setPrompt(md);
             }}
             onUploadFile={handleUploadFile}
+            attachments={pendingAttachments}
             onSubmit={submit}
             debounceMs={150}
           />
diff --git a/packages/views/runtimes/components/provider-logo.tsx b/packages/views/runtimes/components/provider-logo.tsx
index 4b1224533e..2af22ddee2 100644
--- a/packages/views/runtimes/components/provider-logo.tsx
+++ b/packages/views/runtimes/components/provider-logo.tsx
@@ -202,6 +202,8 @@ export function ProviderLogo({
   switch (provider) {
     case "claude":
       return <ClaudeLogo className={className} />;
+    case "codebuddy":
+      return <ClaudeLogo className={className} />;
     case "codex":
       return <CodexLogo className={className} />;
     case "opencode":
diff --git a/packages/views/skills/components/runtime-local-skill-import-panel.test.tsx b/packages/views/skills/components/runtime-local-skill-import-panel.test.tsx
index bff9953fef..5c13d0818c 100644
--- a/packages/views/skills/components/runtime-local-skill-import-panel.test.tsx
+++ b/packages/views/skills/components/runtime-local-skill-import-panel.test.tsx
@@ -15,6 +15,13 @@ const TEST_RESOURCES = {
 const mockResolveRuntimeLocalSkillImport = vi.hoisted(() => vi.fn());
 const mockRuntimeListOptions = vi.hoisted(() => vi.fn());
 const mockRuntimeLocalSkillsOptions = vi.hoisted(() => vi.fn());
+const mockListMembers = vi.hoisted(() => vi.fn());
+
+vi.mock("@multica/core/api", () => ({
+  api: {
+    listMembers: (...args: unknown[]) => mockListMembers(...args),
+  },
+}));
 
 vi.mock("@multica/core/hooks", () => ({
   useWorkspaceId: () => "ws-1",
@@ -148,8 +155,13 @@ describe("RuntimeLocalSkillImportPanel", () => {
         }),
     });
     mockResolveRuntimeLocalSkillImport.mockResolvedValue({
+      status: "created",
       skill: MOCK_IMPORTED_SKILL_A,
     });
+    mockListMembers.mockResolvedValue([
+      { user_id: "user-1", name: "Alice", email: "alice@example.com" },
+      { user_id: "user-2", name: "Bob", email: "bob@example.com" },
+    ]);
   });
 
   it("imports a single skill when selected via checkbox", async () => {
@@ -183,6 +195,7 @@ describe("RuntimeLocalSkillImportPanel", () => {
             skill_key: "review-helper",
             name: "Review Helper",
             description: "Review pull requests",
+            supports_conflict: true,
           },
         );
       },
@@ -200,8 +213,8 @@ describe("RuntimeLocalSkillImportPanel", () => {
         }),
     });
     mockResolveRuntimeLocalSkillImport
-      .mockResolvedValueOnce({ skill: MOCK_IMPORTED_SKILL_A })
-      .mockResolvedValueOnce({ skill: MOCK_IMPORTED_SKILL_B });
+      .mockResolvedValueOnce({ status: "created", skill: MOCK_IMPORTED_SKILL_A })
+      .mockResolvedValueOnce({ status: "created", skill: MOCK_IMPORTED_SKILL_B });
 
     renderPanel();
 
@@ -240,8 +253,8 @@ describe("RuntimeLocalSkillImportPanel", () => {
 
     expect(mockResolveRuntimeLocalSkillImport).toHaveBeenCalledTimes(2);
 
-    // Verify summary shows both as imported
-    expect(screen.getByText("Imported")).toBeInTheDocument();
+    // Verify summary shows both as created
+    expect(screen.getByText("Created")).toBeInTheDocument();
   });
 
   it("handles partial failures gracefully", async () => {
@@ -254,7 +267,7 @@ describe("RuntimeLocalSkillImportPanel", () => {
         }),
     });
     mockResolveRuntimeLocalSkillImport
-      .mockResolvedValueOnce({ skill: MOCK_IMPORTED_SKILL_A })
+      .mockResolvedValueOnce({ status: "created", skill: MOCK_IMPORTED_SKILL_A })
       .mockRejectedValueOnce(new Error("409 conflict: already exists"));
 
     renderPanel();
@@ -291,8 +304,8 @@ describe("RuntimeLocalSkillImportPanel", () => {
       { timeout: 10000 },
     );
 
-    // Summary should show imported and skipped
-    expect(screen.getByText("Imported")).toBeInTheDocument();
+    // Summary should show created and skipped
+    expect(screen.getByText("Created")).toBeInTheDocument();
     expect(screen.getByText("Skipped")).toBeInTheDocument();
   });
 
@@ -344,8 +357,8 @@ describe("RuntimeLocalSkillImportPanel", () => {
         }),
     });
     mockResolveRuntimeLocalSkillImport
-      .mockResolvedValueOnce({ skill: MOCK_IMPORTED_SKILL_A })
-      .mockResolvedValueOnce({ skill: MOCK_IMPORTED_SKILL_B });
+      .mockResolvedValueOnce({ status: "created", skill: MOCK_IMPORTED_SKILL_A })
+      .mockResolvedValueOnce({ status: "created", skill: MOCK_IMPORTED_SKILL_B });
 
     const onImported = vi.fn();
     const onBulkDone = vi.fn();
@@ -385,4 +398,275 @@ describe("RuntimeLocalSkillImportPanel", () => {
     expect(onBulkDone).toHaveBeenCalledTimes(1);
     expect(onImported).not.toHaveBeenCalled();
   });
+
+  it("resolves a creator conflict by overwriting the existing skill", async () => {
+    mockResolveRuntimeLocalSkillImport
+      .mockResolvedValueOnce({
+        status: "conflict",
+        conflict: {
+          existing_skill_id: "existing-skill-1",
+          existing_created_by: "user-1",
+          can_overwrite: true,
+        },
+      })
+      .mockResolvedValueOnce({
+        status: "updated",
+        skill: {
+          ...MOCK_IMPORTED_SKILL_A,
+          id: "existing-skill-1",
+        },
+      });
+
+    renderPanel();
+
+    expect(
+      await screen.findByText("Review Helper", {}, { timeout: 5000 }),
+    ).toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole("button", { name: /Review Helper/i }));
+
+    const importButton = screen.getByRole("button", {
+      name: /Import to Workspace/i,
+    });
+    await waitFor(() => expect(importButton).not.toBeDisabled(), {
+      timeout: 5000,
+    });
+    fireEvent.click(importButton);
+
+    expect(
+      await screen.findByText(/A skill with this name already exists/i),
+    ).toBeInTheDocument();
+
+    const applyButton = screen.getByRole("button", {
+      name: /Apply decisions/i,
+    });
+    await waitFor(() => expect(applyButton).not.toBeDisabled(), {
+      timeout: 5000,
+    });
+    fireEvent.click(applyButton);
+
+    await waitFor(
+      () => {
+        expect(mockResolveRuntimeLocalSkillImport).toHaveBeenLastCalledWith(
+          "runtime-1",
+          {
+            skill_key: "review-helper",
+            name: "Review Helper",
+            description: "Review pull requests",
+            supports_conflict: true,
+            action: "overwrite",
+            target_skill_id: "existing-skill-1",
+          },
+        );
+      },
+      { timeout: 5000 },
+    );
+
+    expect(await screen.findByText("Updated")).toBeInTheDocument();
+  });
+
+  it("applies a single creator conflict when clicking overwrite", async () => {
+    mockResolveRuntimeLocalSkillImport
+      .mockResolvedValueOnce({
+        status: "conflict",
+        conflict: {
+          existing_skill_id: "existing-skill-1",
+          existing_created_by: "user-1",
+          can_overwrite: true,
+        },
+      })
+      .mockResolvedValueOnce({
+        status: "updated",
+        skill: {
+          ...MOCK_IMPORTED_SKILL_A,
+          id: "existing-skill-1",
+        },
+      });
+
+    renderPanel();
+
+    expect(
+      await screen.findByText("Review Helper", {}, { timeout: 5000 }),
+    ).toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole("button", { name: /Review Helper/i }));
+
+    const importButton = screen.getByRole("button", {
+      name: /Import to Workspace/i,
+    });
+    await waitFor(() => expect(importButton).not.toBeDisabled(), {
+      timeout: 5000,
+    });
+    fireEvent.click(importButton);
+
+    expect(
+      await screen.findByText(/A skill with this name already exists/i),
+    ).toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole("button", { name: /^Overwrite$/i }));
+
+    await waitFor(
+      () => {
+        expect(mockResolveRuntimeLocalSkillImport).toHaveBeenLastCalledWith(
+          "runtime-1",
+          {
+            skill_key: "review-helper",
+            name: "Review Helper",
+            description: "Review pull requests",
+            supports_conflict: true,
+            action: "overwrite",
+            target_skill_id: "existing-skill-1",
+          },
+        );
+      },
+      { timeout: 5000 },
+    );
+
+    expect(await screen.findByText("Updated")).toBeInTheDocument();
+  });
+
+  it("keeps bulk completion behavior when conflict resolution leaves one success", async () => {
+    mockRuntimeLocalSkillsOptions.mockReturnValue({
+      queryKey: ["runtimes", "local-skills", "runtime-1"],
+      queryFn: () =>
+        Promise.resolve({
+          supported: true,
+          skills: [MOCK_SKILL_A, MOCK_SKILL_B],
+        }),
+    });
+    mockResolveRuntimeLocalSkillImport
+      .mockResolvedValueOnce({
+        status: "conflict",
+        conflict: {
+          existing_skill_id: "existing-skill-1",
+          existing_created_by: "user-1",
+          can_overwrite: true,
+        },
+      })
+      .mockRejectedValueOnce(new Error("daemon failed"))
+      .mockResolvedValueOnce({
+        status: "updated",
+        skill: {
+          ...MOCK_IMPORTED_SKILL_A,
+          id: "existing-skill-1",
+        },
+      });
+
+    const onImported = vi.fn();
+    const onBulkDone = vi.fn();
+    renderPanel({ onImported, onBulkDone });
+
+    expect(
+      await screen.findByText("Review Helper", {}, { timeout: 5000 }),
+    ).toBeInTheDocument();
+
+    const selectAllLabel = screen.getByText(/Select all/i);
+    const selectAllCheckbox = selectAllLabel
+      .closest("label")!
+      .querySelector("input[type='checkbox']")!;
+    fireEvent.click(selectAllCheckbox);
+
+    const importButton = screen.getByRole("button", {
+      name: /Import 2 Skills/i,
+    });
+    await waitFor(() => expect(importButton).not.toBeDisabled(), {
+      timeout: 5000,
+    });
+    fireEvent.click(importButton);
+
+    expect(
+      await screen.findByText(/A skill with this name already exists/i),
+    ).toBeInTheDocument();
+
+    const applyButton = screen.getByRole("button", {
+      name: /Apply decisions/i,
+    });
+    await waitFor(() => expect(applyButton).not.toBeDisabled(), {
+      timeout: 5000,
+    });
+    fireEvent.click(applyButton);
+
+    await waitFor(
+      () => {
+        expect(
+          screen.getByRole("button", { name: /Done/i }),
+        ).toBeInTheDocument();
+      },
+      { timeout: 10000 },
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: /Done/i }));
+    expect(onBulkDone).toHaveBeenCalledTimes(1);
+    expect(onImported).not.toHaveBeenCalled();
+  });
+
+  it("renders the creator's display name for non-overwritable conflicts", async () => {
+    mockResolveRuntimeLocalSkillImport.mockResolvedValueOnce({
+      status: "conflict",
+      conflict: {
+        existing_skill_id: "existing-skill-1",
+        existing_created_by: "user-2",
+        can_overwrite: false,
+      },
+    });
+
+    renderPanel();
+
+    expect(
+      await screen.findByText("Review Helper", {}, { timeout: 5000 }),
+    ).toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole("button", { name: /Review Helper/i }));
+    const importButton = screen.getByRole("button", {
+      name: /Import to Workspace/i,
+    });
+    await waitFor(() => expect(importButton).not.toBeDisabled(), {
+      timeout: 5000,
+    });
+    fireEvent.click(importButton);
+
+    // Bob is user-2 in the mocked member list. The locked message must show
+    // the resolved name, never the raw UUID.
+    expect(
+      await screen.findByText(/created by Bob/i, {}, { timeout: 5000 }),
+    ).toBeInTheDocument();
+    expect(screen.queryByText(/user-2/)).not.toBeInTheDocument();
+  });
+
+  it("falls back to the unbranded locked message when the creator left the workspace", async () => {
+    mockResolveRuntimeLocalSkillImport.mockResolvedValueOnce({
+      status: "conflict",
+      conflict: {
+        existing_skill_id: "existing-skill-1",
+        existing_created_by: "user-gone",
+        can_overwrite: false,
+      },
+    });
+
+    renderPanel();
+
+    expect(
+      await screen.findByText("Review Helper", {}, { timeout: 5000 }),
+    ).toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole("button", { name: /Review Helper/i }));
+    const importButton = screen.getByRole("button", {
+      name: /Import to Workspace/i,
+    });
+    await waitFor(() => expect(importButton).not.toBeDisabled(), {
+      timeout: 5000,
+    });
+    fireEvent.click(importButton);
+
+    // user-gone is not in the workspace; the UI must not leak the UUID and
+    // should render the no-creator variant of the message.
+    expect(
+      await screen.findByText(
+        /Only the creator can overwrite this skill/i,
+        {},
+        { timeout: 5000 },
+      ),
+    ).toBeInTheDocument();
+    expect(screen.queryByText(/user-gone/)).not.toBeInTheDocument();
+  });
 });
diff --git a/packages/views/skills/components/runtime-local-skill-import-panel.tsx b/packages/views/skills/components/runtime-local-skill-import-panel.tsx
index 88ea8bca12..9e2deb5d9b 100644
--- a/packages/views/skills/components/runtime-local-skill-import-panel.tsx
+++ b/packages/views/skills/components/runtime-local-skill-import-panel.tsx
@@ -4,14 +4,18 @@ import { useEffect, useMemo, useRef, useState } from "react";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import {
   AlertCircle,
+  AlertTriangle,
   CheckCircle2,
   Download,
   HardDrive,
   Loader2,
+  RefreshCw,
   SkipForward,
+  XCircle,
 } from "lucide-react";
 import type {
   AgentRuntime,
+  RuntimeLocalSkillImportConflict,
   RuntimeLocalSkillSummary,
   Skill,
 } from "@multica/core/types";
@@ -24,6 +28,7 @@ import {
   resolveRuntimeLocalSkillImport,
 } from "@multica/core/runtimes";
 import {
+  memberListOptions,
   skillDetailOptions,
   workspaceKeys,
 } from "@multica/core/workspace/queries";
@@ -53,22 +58,33 @@ import { isNameConflictError } from "../lib/utils";
 type BulkImportResult = {
   key: string;
   name: string;
-  status: "success" | "skipped" | "failed";
+  description?: string;
+  status: "created" | "updated" | "conflict" | "skipped" | "failed";
+  conflict?: RuntimeLocalSkillImportConflict;
   error?: string;
   skill?: Skill;
 };
 
 type BulkImportState = {
-  phase: "idle" | "importing" | "done" | "cancelled";
+  phase: "idle" | "importing" | "resolving" | "done" | "cancelled";
   total: number;
   completed: number;
+  selectedCount: number;
   results: BulkImportResult[];
 };
 
+type ConflictResolutionAction = "overwrite" | "rename" | "skip";
+
+type ConflictResolutionState = {
+  action: ConflictResolutionAction;
+  renameName: string;
+};
+
 const INITIAL_BULK_STATE: BulkImportState = {
   phase: "idle",
   total: 0,
   completed: 0,
+  selectedCount: 0,
   results: [],
 };
 
@@ -90,6 +106,25 @@ function runtimeLabel(runtime: AgentRuntime): string {
   return `${runtime.name} (${runtime.provider})`;
 }
 
+function defaultRenameName(name: string): string {
+  return `${name} copy`;
+}
+
+function ResultIcon({ status }: { status: BulkImportResult["status"] }) {
+  switch (status) {
+    case "created":
+      return <CheckCircle2 className="h-3.5 w-3.5 shrink-0 text-green-600" />;
+    case "updated":
+      return <RefreshCw className="h-3.5 w-3.5 shrink-0 text-blue-600" />;
+    case "conflict":
+      return <AlertTriangle className="h-3.5 w-3.5 shrink-0 text-amber-600" />;
+    case "skipped":
+      return <SkipForward className="h-3.5 w-3.5 shrink-0 text-yellow-600" />;
+    case "failed":
+      return <AlertCircle className="h-3.5 w-3.5 shrink-0 text-destructive" />;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Skill row with checkbox
 // ---------------------------------------------------------------------------
@@ -195,20 +230,38 @@ function SkillItem({
 
 function BulkImportSummary({ results }: { results: BulkImportResult[] }) {
   const { t } = useT("skills");
-  const succeeded = results.filter((r) => r.status === "success");
+  const created = results.filter((r) => r.status === "created");
+  const updated = results.filter((r) => r.status === "updated");
+  const conflicts = results.filter((r) => r.status === "conflict");
   const skipped = results.filter((r) => r.status === "skipped");
   const failed = results.filter((r) => r.status === "failed");
 
   return (
     <div className="space-y-4 py-2">
       {/* Summary counts */}
-      <div className="grid grid-cols-3 gap-2 text-center">
+      <div className="grid grid-cols-2 gap-2 text-center sm:grid-cols-5">
         <div className="rounded-md bg-green-50 px-3 py-2 dark:bg-green-950/30">
           <div className="text-lg font-semibold text-green-700 dark:text-green-400">
-            {succeeded.length}
+            {created.length}
           </div>
           <div className="text-xs text-muted-foreground">
-            {t(($) => $.runtime_import.bulk_summary_imported)}
+            {t(($) => $.runtime_import.bulk_summary_created)}
+          </div>
+        </div>
+        <div className="rounded-md bg-blue-50 px-3 py-2 dark:bg-blue-950/30">
+          <div className="text-lg font-semibold text-blue-700 dark:text-blue-400">
+            {updated.length}
+          </div>
+          <div className="text-xs text-muted-foreground">
+            {t(($) => $.runtime_import.bulk_summary_updated)}
+          </div>
+        </div>
+        <div className="rounded-md bg-amber-50 px-3 py-2 dark:bg-amber-950/30">
+          <div className="text-lg font-semibold text-amber-700 dark:text-amber-400">
+            {conflicts.length}
+          </div>
+          <div className="text-xs text-muted-foreground">
+            {t(($) => $.runtime_import.bulk_summary_conflicts)}
           </div>
         </div>
         <div className="rounded-md bg-yellow-50 px-3 py-2 dark:bg-yellow-950/30">
@@ -236,15 +289,7 @@ function BulkImportSummary({ results }: { results: BulkImportResult[] }) {
             key={r.key}
             className="flex items-center gap-2 rounded px-2 py-1.5 text-xs"
           >
-            {r.status === "success" && (
-              <CheckCircle2 className="h-3.5 w-3.5 shrink-0 text-green-600" />
-            )}
-            {r.status === "skipped" && (
-              <SkipForward className="h-3.5 w-3.5 shrink-0 text-yellow-600" />
-            )}
-            {r.status === "failed" && (
-              <AlertCircle className="h-3.5 w-3.5 shrink-0 text-destructive" />
-            )}
+            <ResultIcon status={r.status} />
             <span className="min-w-0 flex-1 truncate">{r.name}</span>
             {r.error && (
               <span className="max-w-[200px] shrink-0 truncate text-muted-foreground">
@@ -258,6 +303,178 @@ function BulkImportSummary({ results }: { results: BulkImportResult[] }) {
   );
 }
 
+function ConflictResolutionPanel({
+  conflicts,
+  resolutions,
+  onChange,
+  onResolveNow,
+  onOverwriteAll,
+  onSkipAll,
+}: {
+  conflicts: BulkImportResult[];
+  resolutions: Record<string, ConflictResolutionState>;
+  onChange: (key: string, next: ConflictResolutionState) => void;
+  onResolveNow?: (key: string, next: ConflictResolutionState) => void;
+  onOverwriteAll: () => void;
+  onSkipAll: () => void;
+}) {
+  const { t } = useT("skills");
+  const wsId = useWorkspaceId();
+  const { data: members = [] } = useQuery(memberListOptions(wsId));
+  const single = conflicts.length === 1;
+  const canOverwriteAny = conflicts.some((r) => r.conflict?.can_overwrite);
+
+  return (
+    <div className="space-y-4 py-2">
+      <div className="rounded-md border border-amber-200 bg-amber-50 px-3 py-2 text-sm text-amber-950 dark:border-amber-900/60 dark:bg-amber-950/30 dark:text-amber-100">
+        <div className="flex items-start gap-2">
+          <AlertTriangle className="mt-0.5 h-4 w-4 shrink-0" />
+          <div className="min-w-0">
+            <p className="font-medium">
+              {single
+                ? t(($) => $.runtime_import.conflict_single_title)
+                : t(($) => $.runtime_import.conflict_bulk_title, {
+                    count: conflicts.length,
+                  })}
+            </p>
+            <p className="mt-1 text-xs opacity-85">
+              {t(($) => $.runtime_import.conflict_hint)}
+            </p>
+          </div>
+        </div>
+      </div>
+
+      {!single && (
+        <div className="flex flex-wrap gap-2">
+          <Button
+            type="button"
+            size="sm"
+            variant="outline"
+            onClick={onOverwriteAll}
+            disabled={!canOverwriteAny}
+          >
+            <RefreshCw className="h-3 w-3" />
+            {t(($) => $.runtime_import.conflict_overwrite_all)}
+          </Button>
+          <Button type="button" size="sm" variant="outline" onClick={onSkipAll}>
+            <SkipForward className="h-3 w-3" />
+            {t(($) => $.runtime_import.conflict_skip_all)}
+          </Button>
+        </div>
+      )}
+
+      <div className="space-y-2">
+        {conflicts.map((r) => {
+          const resolution =
+            resolutions[r.key] ??
+            ({
+              action: r.conflict?.can_overwrite ? "overwrite" : "rename",
+              renameName: defaultRenameName(r.name),
+            } satisfies ConflictResolutionState);
+          const creatorId = r.conflict?.existing_created_by;
+          const creatorName = creatorId
+            ? members.find((m) => m.user_id === creatorId)?.name
+            : undefined;
+          return (
+            <div key={r.key} className="rounded-lg border bg-card p-3">
+              <div className="flex items-start gap-2">
+                <AlertTriangle className="mt-0.5 h-4 w-4 shrink-0 text-amber-600" />
+                <div className="min-w-0 flex-1">
+                  <div className="truncate text-sm font-medium">{r.name}</div>
+                  {r.error && (
+                    <p className="mt-1 text-xs text-destructive">{r.error}</p>
+                  )}
+                  {!r.conflict?.can_overwrite && (
+                    <p className="mt-1 text-xs text-muted-foreground">
+                      {creatorName
+                        ? t(($) => $.runtime_import.conflict_locked_creator, {
+                            creator: creatorName,
+                          })
+                        : t(($) => $.runtime_import.conflict_locked)}
+                    </p>
+                  )}
+                </div>
+              </div>
+
+              <div className="mt-3 flex flex-wrap gap-2">
+                <Button
+                  type="button"
+                  size="sm"
+                  variant={
+                    resolution.action === "overwrite" ? "default" : "outline"
+                  }
+                  onClick={() => {
+                    const next = {
+                      action: "overwrite",
+                      renameName: resolution.renameName,
+                    } satisfies ConflictResolutionState;
+                    if (single && r.conflict?.can_overwrite && onResolveNow) {
+                      onResolveNow(r.key, next);
+                    } else {
+                      onChange(r.key, next);
+                    }
+                  }}
+                  disabled={!r.conflict?.can_overwrite}
+                >
+                  <RefreshCw className="h-3 w-3" />
+                  {t(($) => $.runtime_import.conflict_overwrite)}
+                </Button>
+                <Button
+                  type="button"
+                  size="sm"
+                  variant={resolution.action === "rename" ? "default" : "outline"}
+                  onClick={() =>
+                    onChange(r.key, {
+                      action: "rename",
+                      renameName: resolution.renameName,
+                    })
+                  }
+                >
+                  {t(($) => $.runtime_import.conflict_rename)}
+                </Button>
+                <Button
+                  type="button"
+                  size="sm"
+                  variant={resolution.action === "skip" ? "default" : "outline"}
+                  onClick={() =>
+                    onChange(r.key, {
+                      action: "skip",
+                      renameName: resolution.renameName,
+                    })
+                  }
+                >
+                  <XCircle className="h-3 w-3" />
+                  {single
+                    ? t(($) => $.runtime_import.conflict_cancel)
+                    : t(($) => $.runtime_import.conflict_skip)}
+                </Button>
+              </div>
+
+              {resolution.action === "rename" && (
+                <div className="mt-3 space-y-1">
+                  <Label className="text-xs text-muted-foreground">
+                    {t(($) => $.runtime_import.conflict_rename_label)}
+                  </Label>
+                  <Input
+                    value={resolution.renameName}
+                    onChange={(e) =>
+                      onChange(r.key, {
+                        action: "rename",
+                        renameName: e.target.value,
+                      })
+                    }
+                    className="h-8 text-sm"
+                  />
+                </div>
+              )}
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Panel
 // ---------------------------------------------------------------------------
@@ -288,12 +505,17 @@ export function RuntimeLocalSkillImportPanel({
   const [selectedRuntimeId, setSelectedRuntimeId] = useState<string>("");
   const [selectedKeys, setSelectedKeys] = useState<Set<string>>(new Set());
   const [bulkState, setBulkState] = useState<BulkImportState>(INITIAL_BULK_STATE);
+  const [conflictResolutions, setConflictResolutions] = useState<
+    Record<string, ConflictResolutionState>
+  >({});
   const cancelRef = useRef(false);
   // Single-select inline edit fields (shown when exactly 1 skill is checked)
   const [editName, setEditName] = useState("");
   const [editDescription, setEditDescription] = useState("");
 
   const importing = bulkState.phase === "importing";
+  const resolvingConflicts = bulkState.phase === "resolving";
+  const busy = importing || resolvingConflicts;
 
   useEffect(() => {
     setSelectedRuntimeId((prev) => prev || localRuntimes[0]?.id || "");
@@ -302,6 +524,7 @@ export function RuntimeLocalSkillImportPanel({
   useEffect(() => {
     setSelectedKeys(new Set());
     setBulkState(INITIAL_BULK_STATE);
+    setConflictResolutions({});
     setEditName("");
     setEditDescription("");
   }, [selectedRuntimeId]);
@@ -354,6 +577,56 @@ export function RuntimeLocalSkillImportPanel({
   const allSelected =
     runtimeSkills.length > 0 && selectedKeys.size === runtimeSkills.length;
   const someSelected = selectedKeys.size > 0 && !allSelected;
+  const pendingConflicts = bulkState.results.filter(
+    (r) => r.status === "conflict" && r.conflict,
+  );
+  const canApplyConflictResolutions =
+    pendingConflicts.length > 0 &&
+    pendingConflicts.every((r) => {
+      const resolution = conflictResolutions[r.key];
+      if (!resolution) return false;
+      if (resolution.action === "overwrite") return !!r.conflict?.can_overwrite;
+      if (resolution.action === "rename") return !!resolution.renameName.trim();
+      return true;
+    });
+
+  const setConflictResolution = (
+    key: string,
+    next: ConflictResolutionState,
+  ) => {
+    setConflictResolutions((prev) => ({ ...prev, [key]: next }));
+  };
+
+  const seedConflictResolutions = (results: BulkImportResult[]) => {
+    const next: Record<string, ConflictResolutionState> = {};
+    for (const r of results) {
+      if (r.status !== "conflict" || !r.conflict) continue;
+      next[r.key] = {
+        action: r.conflict.can_overwrite ? "overwrite" : "rename",
+        renameName: defaultRenameName(r.name),
+      };
+    }
+    setConflictResolutions(next);
+  };
+
+  const refreshImportedSkills = async (results: BulkImportResult[]) => {
+    await Promise.all([
+      qc.invalidateQueries({
+        queryKey: runtimeLocalSkillsKeys.forRuntime(selectedRuntimeId),
+      }),
+      qc.invalidateQueries({ queryKey: workspaceKeys.skills(wsId) }),
+      qc.invalidateQueries({ queryKey: workspaceKeys.agents(wsId) }),
+    ]);
+
+    for (const r of results) {
+      if ((r.status === "created" || r.status === "updated") && r.skill) {
+        qc.setQueryData(
+          skillDetailOptions(wsId, r.skill.id).queryKey,
+          r.skill,
+        );
+      }
+    }
+  };
 
   // -- Bulk import handler --
 
@@ -364,7 +637,13 @@ export function RuntimeLocalSkillImportPanel({
     const total = skillsToImport.length;
 
     cancelRef.current = false;
-    setBulkState({ phase: "importing", total, completed: 0, results: [] });
+    setBulkState({
+      phase: "importing",
+      total,
+      completed: 0,
+      selectedCount: total,
+      results: [],
+    });
 
     const results: BulkImportResult[] = [];
 
@@ -381,19 +660,32 @@ export function RuntimeLocalSkillImportPanel({
           skill_key: skill.key,
           name: importName,
           description: importDescription,
+          supports_conflict: true,
         });
-        results.push({
-          key: skill.key,
-          name: importName,
-          status: "success",
-          skill: result.skill,
-        });
+        if (result.status === "conflict") {
+          results.push({
+            key: skill.key,
+            name: importName,
+            description: importDescription,
+            status: "conflict",
+            conflict: result.conflict,
+          });
+        } else {
+          results.push({
+            key: skill.key,
+            name: result.skill?.name ?? importName,
+            description: importDescription,
+            status: result.status,
+            skill: result.skill,
+          });
+        }
       } catch (error) {
         const msg = error instanceof Error ? error.message : "";
         const isSkipped = isNameConflictError(msg);
         results.push({
           key: skill.key,
           name: skill.name,
+          description: importDescription,
           status: isSkipped ? "skipped" : "failed",
           error: msg || t(($) => $.runtime_import.toast_import_failed),
         });
@@ -420,23 +712,16 @@ export function RuntimeLocalSkillImportPanel({
     }
     await Promise.all(executing);
 
-    // Invalidate queries ONCE at the end
-    await Promise.all([
-      qc.invalidateQueries({
-        queryKey: runtimeLocalSkillsKeys.forRuntime(selectedRuntimeId),
-      }),
-      qc.invalidateQueries({ queryKey: workspaceKeys.skills(wsId) }),
-      qc.invalidateQueries({ queryKey: workspaceKeys.agents(wsId) }),
-    ]);
+    await refreshImportedSkills(results);
 
-    // Seed query cache for each successfully imported skill
-    for (const r of results) {
-      if (r.status === "success" && r.skill) {
-        qc.setQueryData(
-          skillDetailOptions(wsId, r.skill.id).queryKey,
-          r.skill,
-        );
-      }
+    const conflicts = results.filter((r) => r.status === "conflict");
+    if (!cancelRef.current && conflicts.length > 0) {
+      seedConflictResolutions(results);
+      setBulkState((prev) => ({
+        ...prev,
+        phase: "resolving",
+      }));
+      return;
     }
 
     setBulkState((prev) => ({
@@ -445,13 +730,123 @@ export function RuntimeLocalSkillImportPanel({
     }));
   };
 
+  const handleApplyConflictResolutions = async (
+    resolutionOverrides: Record<string, ConflictResolutionState> = {},
+  ) => {
+    if (!selectedRuntimeId || pendingConflicts.length === 0) return;
+
+    const conflicts = [...pendingConflicts];
+    let nextResults = bulkState.results;
+    const applyResult = (key: string, next: Partial<BulkImportResult>) => {
+      nextResults = nextResults.map((r) =>
+        r.key === key ? { ...r, ...next } : r,
+      );
+      setBulkState((prev) => ({
+        ...prev,
+        results: prev.results.map((r) =>
+          r.key === key ? { ...r, ...next } : r,
+        ),
+      }));
+    };
+
+    setBulkState((prev) => ({
+      ...prev,
+      phase: "importing",
+      total: conflicts.length,
+      completed: 0,
+    }));
+
+    for (const r of conflicts) {
+      const resolution =
+        resolutionOverrides[r.key] ?? conflictResolutions[r.key];
+      if (!resolution) {
+        applyResult(r.key, {
+          status: "failed",
+          error: t(($) => $.runtime_import.conflict_missing_resolution),
+        });
+        setBulkState((prev) => ({ ...prev, completed: prev.completed + 1 }));
+        continue;
+      }
+
+      if (resolution.action === "skip") {
+        applyResult(r.key, { status: "skipped", error: undefined });
+        setBulkState((prev) => ({ ...prev, completed: prev.completed + 1 }));
+        continue;
+      }
+
+      try {
+        const result = await resolveRuntimeLocalSkillImport(selectedRuntimeId, {
+          skill_key: r.key,
+          name:
+            resolution.action === "rename"
+              ? resolution.renameName.trim()
+              : r.name,
+          description: r.description,
+          supports_conflict: true,
+          ...(resolution.action === "overwrite" && r.conflict
+            ? {
+                action: "overwrite" as const,
+                target_skill_id: r.conflict.existing_skill_id,
+              }
+            : {}),
+        });
+
+        if (result.status === "conflict") {
+          applyResult(r.key, {
+            name:
+              resolution.action === "rename"
+                ? resolution.renameName.trim()
+                : r.name,
+            status: "conflict",
+            conflict: result.conflict,
+            error: t(($) => $.runtime_import.conflict_name_still_exists),
+          });
+          if (result.conflict) {
+            setConflictResolution(r.key, {
+              action: result.conflict.can_overwrite ? "overwrite" : "rename",
+              renameName: defaultRenameName(
+                resolution.action === "rename"
+                  ? resolution.renameName.trim()
+                  : r.name,
+              ),
+            });
+          }
+        } else {
+          applyResult(r.key, {
+            name: result.skill?.name ?? r.name,
+            status: result.status,
+            skill: result.skill,
+            conflict: undefined,
+            error: undefined,
+          });
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : "";
+        applyResult(r.key, {
+          status: "failed",
+          error: msg || t(($) => $.runtime_import.toast_import_failed),
+        });
+      }
+
+      setBulkState((prev) => ({ ...prev, completed: prev.completed + 1 }));
+    }
+
+    await refreshImportedSkills(nextResults);
+    const unresolved = nextResults.some((r) => r.status === "conflict");
+    setBulkState((prev) => ({
+      ...prev,
+      results: nextResults,
+      phase: unresolved ? "resolving" : "done",
+    }));
+  };
+
   const canImport =
     !!selectedRuntime &&
     selectedRuntime.status === "online" &&
     selectedKeys.size > 0 &&
     // Single-select requires a non-empty name (user may be renaming)
     (selectedKeys.size > 1 || !!editName.trim()) &&
-    !importing;
+    !busy;
 
   const handleCancel = () => {
     cancelRef.current = true;
@@ -488,15 +883,7 @@ export function RuntimeLocalSkillImportPanel({
                 key={r.key}
                 className="flex items-center gap-2 rounded px-2 py-1 text-xs"
               >
-                {r.status === "success" && (
-                  <CheckCircle2 className="h-3.5 w-3.5 shrink-0 text-green-600" />
-                )}
-                {r.status === "skipped" && (
-                  <SkipForward className="h-3.5 w-3.5 shrink-0 text-yellow-600" />
-                )}
-                {r.status === "failed" && (
-                  <AlertCircle className="h-3.5 w-3.5 shrink-0 text-destructive" />
-                )}
+                <ResultIcon status={r.status} />
                 <span className="truncate">{r.name}</span>
               </div>
             ))}
@@ -510,6 +897,45 @@ export function RuntimeLocalSkillImportPanel({
       return <BulkImportSummary results={bulkState.results} />;
     }
 
+    if (bulkState.phase === "resolving") {
+      return (
+        <ConflictResolutionPanel
+          conflicts={pendingConflicts}
+          resolutions={conflictResolutions}
+          onChange={setConflictResolution}
+          onResolveNow={(key, next) => {
+            setConflictResolution(key, next);
+            void handleApplyConflictResolutions({ [key]: next });
+          }}
+          onOverwriteAll={() => {
+            setConflictResolutions((prev) => {
+              const next = { ...prev };
+              for (const r of pendingConflicts) {
+                if (!r.conflict?.can_overwrite) continue;
+                next[r.key] = {
+                  action: "overwrite",
+                  renameName: prev[r.key]?.renameName ?? defaultRenameName(r.name),
+                };
+              }
+              return next;
+            });
+          }}
+          onSkipAll={() => {
+            setConflictResolutions((prev) => {
+              const next = { ...prev };
+              for (const r of pendingConflicts) {
+                next[r.key] = {
+                  action: "skip",
+                  renameName: prev[r.key]?.renameName ?? defaultRenameName(r.name),
+                };
+              }
+              return next;
+            });
+          }}
+        />
+      );
+    }
+
     // --- Idle phase: skill selection list ---
 
     if (localRuntimes.length === 0) {
@@ -626,10 +1052,16 @@ export function RuntimeLocalSkillImportPanel({
   // -- Handle "Done" button after import --
 
   const handleDone = () => {
-    const succeeded = bulkState.results.filter((r) => r.status === "success");
+    const succeeded = bulkState.results.filter(
+      (r) => r.status === "created" || r.status === "updated",
+    );
     // Single-import flow: navigate to the imported skill detail page.
     // Multi-import flow: close the dialog even if only one succeeded.
-    if (bulkState.total === 1 && succeeded.length === 1 && succeeded[0]!.skill) {
+    if (
+      bulkState.selectedCount === 1 &&
+      succeeded.length === 1 &&
+      succeeded[0]!.skill
+    ) {
       onImported?.(succeeded[0]!.skill);
     } else {
       onBulkDone?.();
@@ -640,9 +1072,9 @@ export function RuntimeLocalSkillImportPanel({
     <div className="flex min-h-0 flex-1 flex-col">
       {/* Sticky top: runtime picker + status */}
       <div
-        aria-disabled={importing || undefined}
+        aria-disabled={busy || undefined}
         className={`shrink-0 space-y-2 border-b px-5 py-3 ${
-          importing ? "pointer-events-none opacity-60" : ""
+          busy ? "pointer-events-none opacity-60" : ""
         }`}
       >
         <div className="space-y-1.5">
@@ -691,9 +1123,7 @@ export function RuntimeLocalSkillImportPanel({
         style={fadeStyle}
         aria-disabled={importing || undefined}
         className={`min-h-0 flex-1 overflow-y-auto px-5 py-3 ${
-          importing && bulkState.phase !== "importing"
-            ? "pointer-events-none opacity-60"
-            : ""
+          importing && bulkState.phase !== "importing" ? "pointer-events-none opacity-60" : ""
         }`}
       >
         {middle}
@@ -717,6 +1147,22 @@ export function RuntimeLocalSkillImportPanel({
               {t(($) => $.runtime_import.bulk_done_button)}
             </Button>
           </>
+        ) : resolvingConflicts ? (
+          <>
+            <div className="min-w-0 flex-1 text-xs text-muted-foreground">
+              {t(($) => $.runtime_import.conflict_footer, {
+                count: pendingConflicts.length,
+              })}
+            </div>
+            <Button
+              type="button"
+              size="sm"
+              onClick={() => void handleApplyConflictResolutions()}
+              disabled={!canApplyConflictResolutions}
+            >
+              {t(($) => $.runtime_import.conflict_apply_button)}
+            </Button>
+          </>
         ) : importing ? (
           <>
             <div className="min-w-0 flex-1 text-xs text-muted-foreground">
diff --git a/server/cmd/multica/cmd_daemon.go b/server/cmd/multica/cmd_daemon.go
index 8d46aca0ee..15498ea4a1 100644
--- a/server/cmd/multica/cmd_daemon.go
+++ b/server/cmd/multica/cmd_daemon.go
@@ -10,6 +10,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -735,9 +736,11 @@ func runDaemonDiskUsage(cmd *cobra.Command, _ []string) error {
 
 	if byWorkspace {
 		printDiskUsageWorkspaceTable(os.Stdout, report)
+		printDiskUsageEmptyHint(os.Stdout, report, profile, rootOverride)
 		return nil
 	}
 	printDiskUsageTaskTable(os.Stdout, report)
+	printDiskUsageEmptyHint(os.Stdout, report, profile, rootOverride)
 	return nil
 }
 
@@ -814,6 +817,153 @@ func printDiskUsageWorkspaceTable(w io.Writer, report daemon.DiskUsageReport) {
 		formatBytes(report.TotalArtifactSizeBytes), report.TotalArtifactRatio*100)
 }
 
+func printDiskUsageEmptyHint(w io.Writer, report daemon.DiskUsageReport, profile, rootOverride string) {
+	if report.TotalTaskCount != 0 || rootOverride != "" {
+		return
+	}
+	suggestions := diskUsageProfileSuggestions(profile, report.WorkspacesRoot)
+	if len(suggestions) == 0 {
+		return
+	}
+	fmt.Fprintln(w)
+	fmt.Fprintln(w, "Other workspace roots contain task directories:")
+	for _, s := range suggestions {
+		fmt.Fprintf(w, "  %s  # %s (%d task%s)\n",
+			s.Command, s.Root, s.TaskCount, pluralS(s.TaskCount))
+	}
+}
+
+type diskUsageProfileSuggestion struct {
+	Profile   string
+	Command   string
+	Root      string
+	TaskCount int
+}
+
+func diskUsageProfileSuggestions(currentProfile, currentRoot string) []diskUsageProfileSuggestion {
+	out := make([]diskUsageProfileSuggestion, 0)
+	if currentProfile != "" {
+		if root, err := daemon.ResolveWorkspacesRoot("", ""); err == nil && !samePath(root, currentRoot) {
+			if taskCount := countDiskUsageTaskDirs(root); taskCount > 0 {
+				out = append(out, diskUsageProfileSuggestion{
+					Profile:   "",
+					Command:   "multica daemon disk-usage",
+					Root:      root,
+					TaskCount: taskCount,
+				})
+			}
+		}
+	}
+
+	profilesRoot, err := profilesRootDir()
+	if err != nil {
+		return out
+	}
+	entries, err := os.ReadDir(profilesRoot)
+	if err != nil {
+		return out
+	}
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		profile := entry.Name()
+		if profile == currentProfile {
+			continue
+		}
+		root, err := daemon.ResolveWorkspacesRoot(profile, "")
+		if err != nil || samePath(root, currentRoot) {
+			continue
+		}
+		taskCount := countDiskUsageTaskDirs(root)
+		if taskCount == 0 {
+			continue
+		}
+		out = append(out, diskUsageProfileSuggestion{
+			Profile:   profile,
+			Command:   "multica --profile " + shellQuoteArg(profile) + " daemon disk-usage",
+			Root:      root,
+			TaskCount: taskCount,
+		})
+	}
+	sort.Slice(out, func(i, j int) bool {
+		if out[i].TaskCount == out[j].TaskCount {
+			return out[i].Profile < out[j].Profile
+		}
+		return out[i].TaskCount > out[j].TaskCount
+	})
+	const maxSuggestions = 5
+	if len(out) > maxSuggestions {
+		out = out[:maxSuggestions]
+	}
+	return out
+}
+
+func shellQuoteArg(s string) string {
+	if s == "" {
+		return "''"
+	}
+	if strings.IndexFunc(s, func(r rune) bool {
+		return !(r == '-' || r == '_' || r == '.' || r == '/' ||
+			r >= '0' && r <= '9' ||
+			r >= 'A' && r <= 'Z' ||
+			r >= 'a' && r <= 'z')
+	}) == -1 {
+		return s
+	}
+	return "'" + strings.ReplaceAll(s, "'", "'\\''") + "'"
+}
+
+func countDiskUsageTaskDirs(root string) int {
+	wsEntries, err := os.ReadDir(root)
+	if err != nil {
+		return 0
+	}
+	count := 0
+	for _, wsEntry := range wsEntries {
+		if !wsEntry.IsDir() || wsEntry.Name() == ".repos" {
+			continue
+		}
+		taskEntries, err := os.ReadDir(filepath.Join(root, wsEntry.Name()))
+		if err != nil {
+			continue
+		}
+		for _, taskEntry := range taskEntries {
+			if taskEntry.IsDir() {
+				count++
+			}
+		}
+	}
+	return count
+}
+
+func profilesRootDir() (string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(home, ".multica", "profiles"), nil
+}
+
+func samePath(a, b string) bool {
+	if a == "" || b == "" {
+		return false
+	}
+	aa, errA := filepath.Abs(a)
+	bb, errB := filepath.Abs(b)
+	if errA != nil || errB != nil {
+		return a == b
+	}
+	return aa == bb
+}
+
+func pluralS(n int) string {
+	if n == 1 {
+		return ""
+	}
+	return "s"
+}
+
 // formatRatio renders a 0..1 fraction as a percentage to one decimal. A
 // non-finite or negative input collapses to "0.0%" — total=0 workspaces
 // shouldn't surface "NaN%".
diff --git a/server/cmd/multica/cmd_daemon_test.go b/server/cmd/multica/cmd_daemon_test.go
index 5db31fd8ae..4e412e3440 100644
--- a/server/cmd/multica/cmd_daemon_test.go
+++ b/server/cmd/multica/cmd_daemon_test.go
@@ -2,8 +2,12 @@ package main
 
 import (
 	"bytes"
+	"os"
+	"path/filepath"
 	"strings"
 	"testing"
+
+	"github.com/multica-ai/multica/server/internal/daemon"
 )
 
 // TestDaemonAlive locks in the liveness predicate the lifecycle commands rely
@@ -127,6 +131,86 @@ func TestPrintDaemonStatusAlignsValuesWithProfileLabel(t *testing.T) {
 	}
 }
 
+func TestPrintDiskUsageEmptyHintSuggestsProfilesWithTasks(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("MULTICA_WORKSPACES_ROOT", "")
+
+	mkdirProfile(t, home, "empty")
+	mkdirProfile(t, home, "one-task")
+	mkdirProfile(t, home, "space profile")
+	mkdirProfile(t, home, "two-tasks")
+
+	writeDiskUsageTaskFile(t, home, "one-task", "ws1", "task1", "workdir/main.go")
+	writeDiskUsageTaskFile(t, home, "space profile", "ws3", "task1", "workdir/main.go")
+	writeDiskUsageTaskFile(t, home, "two-tasks", "ws2", "task1", "workdir/main.go")
+	writeDiskUsageTaskFile(t, home, "two-tasks", "ws2", "task2", "workdir/main.go")
+
+	var out bytes.Buffer
+	printDiskUsageEmptyHint(&out, daemon.DiskUsageReport{
+		WorkspacesRoot: filepath.Join(home, "multica_workspaces"),
+	}, "", "")
+
+	got := out.String()
+	if !strings.Contains(got, "Other workspace roots contain task directories:") {
+		t.Fatalf("hint output = %q, want profile suggestion header", got)
+	}
+	if !strings.Contains(got, "multica --profile two-tasks daemon disk-usage") {
+		t.Fatalf("hint output = %q, want two-tasks profile command", got)
+	}
+	if !strings.Contains(got, "multica --profile one-task daemon disk-usage") {
+		t.Fatalf("hint output = %q, want one-task profile command", got)
+	}
+	if !strings.Contains(got, "multica --profile 'space profile' daemon disk-usage") {
+		t.Fatalf("hint output = %q, want shell-quoted profile command", got)
+	}
+	if strings.Contains(got, "empty") {
+		t.Fatalf("hint output = %q, want empty profile omitted", got)
+	}
+	if strings.Index(got, "two-tasks") > strings.Index(got, "one-task") {
+		t.Fatalf("hint output = %q, want larger profile first", got)
+	}
+}
+
+func TestPrintDiskUsageEmptyHintSuggestsDefaultFromNamedProfile(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("MULTICA_WORKSPACES_ROOT", "")
+
+	writeDefaultDiskUsageTaskFile(t, home, "ws0", "task0", "workdir/main.go")
+
+	var out bytes.Buffer
+	printDiskUsageEmptyHint(&out, daemon.DiskUsageReport{
+		WorkspacesRoot: filepath.Join(home, "multica_workspaces_named"),
+	}, "named", "")
+
+	got := out.String()
+	if !strings.Contains(got, "multica daemon disk-usage") {
+		t.Fatalf("hint output = %q, want default profile command", got)
+	}
+	if strings.Contains(got, "--profile") {
+		t.Fatalf("hint output = %q, want default profile command without --profile", got)
+	}
+}
+
+func TestPrintDiskUsageEmptyHintSkipsExplicitRootOverride(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+	t.Setenv("MULTICA_WORKSPACES_ROOT", "")
+
+	mkdirProfile(t, home, "has-task")
+	writeDiskUsageTaskFile(t, home, "has-task", "ws1", "task1", "workdir/main.go")
+
+	var out bytes.Buffer
+	printDiskUsageEmptyHint(&out, daemon.DiskUsageReport{
+		WorkspacesRoot: filepath.Join(home, "custom-root"),
+	}, "", filepath.Join(home, "custom-root"))
+
+	if got := out.String(); got != "" {
+		t.Fatalf("hint output = %q, want no hint for explicit root override", got)
+	}
+}
+
 func valueColumn(t *testing.T, line string) int {
 	t.Helper()
 	colon := strings.Index(line, ":")
@@ -141,3 +225,32 @@ func valueColumn(t *testing.T, line string) int {
 	t.Fatalf("line missing value: %q", line)
 	return 0
 }
+
+func mkdirProfile(t *testing.T, home, profile string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Join(home, ".multica", "profiles", profile), 0o755); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func writeDiskUsageTaskFile(t *testing.T, home, profile, workspaceID, taskID, rel string) {
+	t.Helper()
+	path := filepath.Join(home, "multica_workspaces_"+profile, workspaceID, taskID, rel)
+	writeDiskUsageFile(t, path)
+}
+
+func writeDefaultDiskUsageTaskFile(t *testing.T, home, workspaceID, taskID, rel string) {
+	t.Helper()
+	path := filepath.Join(home, "multica_workspaces", workspaceID, taskID, rel)
+	writeDiskUsageFile(t, path)
+}
+
+func writeDiskUsageFile(t *testing.T, path string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, []byte("x"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/server/cmd/multica/cmd_issue.go b/server/cmd/multica/cmd_issue.go
index 5062e54079..7e6ed1421d 100644
--- a/server/cmd/multica/cmd_issue.go
+++ b/server/cmd/multica/cmd_issue.go
@@ -296,6 +296,7 @@ func init() {
 	issueCreateCmd.Flags().Bool("allow-duplicate", false, "Allow creating an issue even when an active duplicate exists")
 	issueCreateCmd.Flags().String("output", "json", "Output format: table or json")
 	issueCreateCmd.Flags().StringSlice("attachment", nil, "File path(s) to attach (can be specified multiple times)")
+	issueCreateCmd.Flags().StringSlice("attachment-id", nil, "Existing attachment UUID(s) to bind to the created issue (can be specified multiple times)")
 
 	// issue update
 	issueUpdateCmd.Flags().String("title", "", "New title")
@@ -624,6 +625,35 @@ func isHTTPURL(path string) bool {
 	return strings.HasPrefix(p, "http://") || strings.HasPrefix(p, "https://")
 }
 
+func appendUniqueStrings(dst []string, values ...string) []string {
+	seen := make(map[string]struct{}, len(dst)+len(values))
+	out := make([]string, 0, len(dst)+len(values))
+	for _, v := range append(dst, values...) {
+		v = strings.TrimSpace(v)
+		if v == "" {
+			continue
+		}
+		if _, ok := seen[v]; ok {
+			continue
+		}
+		seen[v] = struct{}{}
+		out = append(out, v)
+	}
+	return out
+}
+
+func quickCreateAttachmentIDsFromEnv() ([]string, error) {
+	raw := strings.TrimSpace(os.Getenv("MULTICA_QUICK_CREATE_ATTACHMENT_IDS"))
+	if raw == "" {
+		return nil, nil
+	}
+	var ids []string
+	if err := json.Unmarshal([]byte(raw), &ids); err != nil {
+		return nil, fmt.Errorf("parse MULTICA_QUICK_CREATE_ATTACHMENT_IDS: %w", err)
+	}
+	return appendUniqueStrings(nil, ids...), nil
+}
+
 func runIssueCreate(cmd *cobra.Command, _ []string) error {
 	title, _ := cmd.Flags().GetString("title")
 	if title == "" {
@@ -701,6 +731,15 @@ func runIssueCreate(cmd *cobra.Command, _ []string) error {
 		body["origin_type"] = "quick_create"
 		body["origin_id"] = taskID
 	}
+	attachmentIDs, _ := cmd.Flags().GetStringSlice("attachment-id")
+	envAttachmentIDs, err := quickCreateAttachmentIDsFromEnv()
+	if err != nil {
+		return err
+	}
+	attachmentIDs = appendUniqueStrings(attachmentIDs, envAttachmentIDs...)
+	if len(attachmentIDs) > 0 {
+		body["attachment_ids"] = attachmentIDs
+	}
 
 	// Pre-validate attachments BEFORE creating the issue so a bad path
 	// can never produce a half-created issue (which would otherwise
diff --git a/server/cmd/multica/cmd_issue_test.go b/server/cmd/multica/cmd_issue_test.go
index f22fa38be3..a2e200aaa7 100644
--- a/server/cmd/multica/cmd_issue_test.go
+++ b/server/cmd/multica/cmd_issue_test.go
@@ -242,6 +242,7 @@ func newIssueCreateTestCmd() *cobra.Command {
 	cmd.Flags().Bool("allow-duplicate", false, "")
 	cmd.Flags().String("output", "json", "")
 	cmd.Flags().StringSlice("attachment", nil, "")
+	cmd.Flags().StringSlice("attachment-id", nil, "")
 	return cmd
 }
 
@@ -283,6 +284,54 @@ func TestRunIssueCreateSendsAllowDuplicate(t *testing.T) {
 	}
 }
 
+func TestRunIssueCreateSendsExistingAttachmentIDs(t *testing.T) {
+	var body map[string]any
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/api/issues" {
+			http.NotFound(w, r)
+			return
+		}
+		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+			t.Errorf("decode body: %v", err)
+		}
+		json.NewEncoder(w).Encode(map[string]any{
+			"id":         "issue-1",
+			"identifier": "MUL-1",
+			"title":      "With attachments",
+			"status":     "todo",
+			"priority":   "none",
+		})
+	}))
+	defer srv.Close()
+
+	t.Setenv("MULTICA_SERVER_URL", srv.URL)
+	t.Setenv("MULTICA_WORKSPACE_ID", "ws-1")
+	t.Setenv("MULTICA_TOKEN", "test-token")
+	t.Setenv("MULTICA_QUICK_CREATE_ATTACHMENT_IDS", `["att-env","att-shared"]`)
+
+	cmd := newIssueCreateTestCmd()
+	_ = cmd.Flags().Set("title", "With attachments")
+	_ = cmd.Flags().Set("attachment-id", "att-flag")
+	_ = cmd.Flags().Set("attachment-id", "att-shared")
+	if err := runIssueCreate(cmd, nil); err != nil {
+		t.Fatalf("runIssueCreate: %v", err)
+	}
+
+	got, ok := body["attachment_ids"].([]any)
+	if !ok {
+		t.Fatalf("attachment_ids = %#v, want JSON array", body["attachment_ids"])
+	}
+	want := []string{"att-flag", "att-shared", "att-env"}
+	if len(got) != len(want) {
+		t.Fatalf("attachment_ids length = %d, want %d (%#v)", len(got), len(want), got)
+	}
+	for i, w := range want {
+		if got[i] != w {
+			t.Fatalf("attachment_ids[%d] = %#v, want %q (all=%#v)", i, got[i], w, got)
+		}
+	}
+}
+
 func TestRunIssueCreateShowsDuplicateMessage(t *testing.T) {
 	want := "Active duplicate issue exists: YUA-36 SH-PM-SYNTH-01 Synthesize recommendation-to-shortlist planning outputs (status: in_progress). Set allow_duplicate=true or use --allow-duplicate to create another."
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
diff --git a/server/cmd/multica/cmd_skill.go b/server/cmd/multica/cmd_skill.go
index c6b08fcf50..23da0a03e4 100644
--- a/server/cmd/multica/cmd_skill.go
+++ b/server/cmd/multica/cmd_skill.go
@@ -7,7 +7,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"net/http"
 	"net/url"
 	"os"
 	"strings"
@@ -141,6 +140,7 @@ func init() {
 
 	// skill import
 	skillImportCmd.Flags().String("url", "", "URL to import from (required)")
+	skillImportCmd.Flags().String("on-conflict", "fail", "Conflict strategy when a skill with the same name exists: fail, overwrite, rename, or skip")
 	skillImportCmd.Flags().String("output", "json", "Output format: table or json")
 
 	// skill search
@@ -419,9 +419,14 @@ func runSkillImport(cmd *cobra.Command, _ []string) error {
 	if importURL == "" {
 		return fmt.Errorf("--url is required")
 	}
+	onConflict, _ := cmd.Flags().GetString("on-conflict")
+	if !validSkillImportConflictStrategy(onConflict) {
+		return fmt.Errorf("--on-conflict must be one of: fail, overwrite, rename, skip")
+	}
 
 	body := map[string]any{
-		"url": importURL,
+		"url":         importURL,
+		"on_conflict": onConflict,
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), cli.AtLeastAPITimeout(60*time.Second))
@@ -429,44 +434,107 @@ func runSkillImport(cmd *cobra.Command, _ []string) error {
 
 	var result map[string]any
 	if err := client.PostJSON(ctx, "/api/skills/import", body, &result); err != nil {
-		if handleSkillImportConflict(cmd, err) {
-			return nil
+		if handledErr := handleSkillImportError(cmd, err); handledErr != nil {
+			return handledErr
 		}
 		return fmt.Errorf("import skill: %w", err)
 	}
 
-	output, _ := cmd.Flags().GetString("output")
-	if output == "json" {
-		return cli.PrintJSON(os.Stdout, result)
-	}
+	return printSkillImportResult(cmd, result)
+}
 
-	fmt.Printf("Skill imported: %s (%s)\n", strVal(result, "name"), strVal(result, "id"))
-	return nil
+func validSkillImportConflictStrategy(strategy string) bool {
+	switch strategy {
+	case "fail", "overwrite", "rename", "skip":
+		return true
+	}
+	return false
 }
 
-func handleSkillImportConflict(cmd *cobra.Command, err error) bool {
+func handleSkillImportError(cmd *cobra.Command, err error) error {
 	var httpErr *cli.HTTPError
-	if !errors.As(err, &httpErr) || httpErr.StatusCode != http.StatusConflict || strings.TrimSpace(httpErr.Body) == "" {
-		return false
+	if !errors.As(err, &httpErr) || strings.TrimSpace(httpErr.Body) == "" {
+		return nil
 	}
 
 	var body map[string]any
 	if json.Unmarshal([]byte(httpErr.Body), &body) != nil {
-		return false
+		return nil
 	}
-	if _, ok := body["existing_skill"]; !ok {
-		return false
+	if _, ok := body["status"]; !ok {
+		if _, hasExisting := body["existing_skill"]; !hasExisting {
+			return nil
+		}
+		body = normalizeLegacySkillImportConflict(body)
 	}
 
+	if err := printSkillImportResult(cmd, body); err != nil {
+		return err
+	}
+	reason := strVal(body, "reason")
+	if reason == "" {
+		reason = strVal(body, "error")
+	}
+	if reason == "" {
+		reason = "skill import conflict"
+	}
+	return errors.New(reason)
+}
+
+func normalizeLegacySkillImportConflict(body map[string]any) map[string]any {
+	reason := strVal(body, "error")
+	if reason == "" {
+		reason = "a skill with this name already exists"
+	}
+	reason += "; use --on-conflict overwrite to replace it or --on-conflict rename to import a copy"
+	return map[string]any{
+		"status":         "conflict",
+		"reason":         reason,
+		"existing_skill": body["existing_skill"],
+	}
+}
+
+func printSkillImportResult(cmd *cobra.Command, result map[string]any) error {
 	output, _ := cmd.Flags().GetString("output")
 	if output == "json" {
-		_ = cli.PrintJSON(os.Stdout, body)
-		return true
+		return cli.PrintJSON(os.Stdout, result)
 	}
 
-	existing, _ := body["existing_skill"].(map[string]any)
-	fmt.Printf("Skill already exists: %s (%s)\n", strVal(existing, "name"), strVal(existing, "id"))
-	return true
+	status := strVal(result, "status")
+	if status == "" {
+		fmt.Printf("Skill imported: %s (%s)\n", strVal(result, "name"), strVal(result, "id"))
+		return nil
+	}
+
+	skill := nestedMap(result, "skill")
+	existing := nestedMap(result, "existing_skill")
+	reason := strVal(result, "reason")
+	switch status {
+	case "created":
+		fmt.Printf("Skill imported: %s (%s)\n", strVal(skill, "name"), strVal(skill, "id"))
+	case "updated":
+		fmt.Printf("Skill updated: %s (%s)\n", strVal(skill, "name"), strVal(skill, "id"))
+	case "skipped":
+		fmt.Printf("Skill skipped: %s (%s)\n", strVal(existing, "name"), strVal(existing, "id"))
+	case "conflict":
+		fmt.Printf("Skill import conflict: %s (%s)\n", strVal(existing, "name"), strVal(existing, "id"))
+	case "failed":
+		fmt.Printf("Skill import failed: %s\n", reason)
+	default:
+		fmt.Printf("Skill import %s\n", status)
+	}
+	if reason != "" && status != "failed" {
+		fmt.Printf("Reason: %s\n", reason)
+	}
+	return nil
+}
+
+func nestedMap(m map[string]any, key string) map[string]any {
+	nested, _ := m[key].(map[string]any)
+	if nested == nil {
+		return map[string]any{}
+	}
+	return nested
 }
 
 func runSkillSearch(cmd *cobra.Command, args []string) error {
diff --git a/server/cmd/multica/cmd_skill_test.go b/server/cmd/multica/cmd_skill_test.go
index 1efbb41521..aedd39a74a 100644
--- a/server/cmd/multica/cmd_skill_test.go
+++ b/server/cmd/multica/cmd_skill_test.go
@@ -18,6 +18,7 @@ func newSkillImportTestCmd() *cobra.Command {
 	cmd.Flags().String("workspace-id", "", "")
 	cmd.Flags().String("profile", "", "")
 	cmd.Flags().String("url", "", "")
+	cmd.Flags().String("on-conflict", "fail", "")
 	cmd.Flags().String("output", "json", "")
 	return cmd
 }
@@ -43,7 +44,7 @@ func captureStdout(t *testing.T, fn func() error) (string, error) {
 	return string(out), runErr
 }
 
-func TestRunSkillImportJsonTreatsDuplicateAsStructuredResult(t *testing.T) {
+func TestRunSkillImportJsonTreatsDuplicateAsConflictResult(t *testing.T) {
 	t.Setenv("HOME", t.TempDir())
 	t.Setenv("MULTICA_TOKEN", "test-token")
 	t.Setenv("MULTICA_WORKSPACE_ID", "workspace-123")
@@ -58,10 +59,21 @@ func TestRunSkillImportJsonTreatsDuplicateAsStructuredResult(t *testing.T) {
 		if r.Header.Get("X-Workspace-ID") != "workspace-123" {
 			t.Fatalf("X-Workspace-ID = %q, want workspace-123", r.Header.Get("X-Workspace-ID"))
 		}
+		var body map[string]any
+		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+			t.Fatalf("decode request body: %v", err)
+		}
+		if body["url"] != "https://skills.sh/acme/review-helper" {
+			t.Fatalf("url = %v", body["url"])
+		}
+		if body["on_conflict"] != "fail" {
+			t.Fatalf("on_conflict = %v, want fail", body["on_conflict"])
+		}
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusConflict)
 		_ = json.NewEncoder(w).Encode(map[string]any{
-			"error": "a skill with this name already exists",
+			"status": "conflict",
+			"reason": "a skill with this name already exists; use --on-conflict overwrite to replace it or --on-conflict rename to import a copy",
 			"existing_skill": map[string]any{
 				"id":   "skill-123",
 				"name": "review-helper",
@@ -78,16 +90,19 @@ func TestRunSkillImportJsonTreatsDuplicateAsStructuredResult(t *testing.T) {
 	out, err := captureStdout(t, func() error {
 		return runSkillImport(cmd, nil)
 	})
-	if err != nil {
-		t.Fatalf("runSkillImport returned error for duplicate import: %v", err)
+	if err == nil {
+		t.Fatal("expected duplicate import to return an error")
 	}
 
 	var got map[string]any
 	if err := json.Unmarshal([]byte(out), &got); err != nil {
 		t.Fatalf("decode stdout JSON %q: %v", out, err)
 	}
-	if got["error"] != "a skill with this name already exists" {
-		t.Fatalf("error = %v", got["error"])
+	if got["status"] != "conflict" {
+		t.Fatalf("status = %v", got["status"])
+	}
+	if !strings.Contains(strVal(got, "reason"), "--on-conflict overwrite") {
+		t.Fatalf("reason = %v", got["reason"])
 	}
 	existing, ok := got["existing_skill"].(map[string]any)
 	if !ok {
@@ -98,6 +113,52 @@ func TestRunSkillImportJsonTreatsDuplicateAsStructuredResult(t *testing.T) {
 	}
 }
 
+func TestRunSkillImportSendsOnConflictAndPrintsStructuredResult(t *testing.T) {
+	t.Setenv("HOME", t.TempDir())
+	t.Setenv("MULTICA_TOKEN", "test-token")
+	t.Setenv("MULTICA_WORKSPACE_ID", "workspace-123")
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var body map[string]any
+		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+			t.Fatalf("decode request body: %v", err)
+		}
+		if body["on_conflict"] != "overwrite" {
+			t.Fatalf("on_conflict = %v, want overwrite", body["on_conflict"])
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"status": "updated",
+			"skill": map[string]any{
+				"id":   "skill-123",
+				"name": "review-helper",
+			},
+		})
+	}))
+	defer srv.Close()
+	t.Setenv("MULTICA_SERVER_URL", srv.URL)
+
+	cmd := newSkillImportTestCmd()
+	_ = cmd.Flags().Set("url", "https://skills.sh/acme/review-helper")
+	_ = cmd.Flags().Set("on-conflict", "overwrite")
+	_ = cmd.Flags().Set("output", "json")
+
+	out, err := captureStdout(t, func() error {
+		return runSkillImport(cmd, nil)
+	})
+	if err != nil {
+		t.Fatalf("runSkillImport returned error: %v", err)
+	}
+	var got map[string]any
+	if err := json.Unmarshal([]byte(out), &got); err != nil {
+		t.Fatalf("decode stdout JSON %q: %v", out, err)
+	}
+	if got["status"] != "updated" {
+		t.Fatalf("status = %v", got["status"])
+	}
+}
+
 func TestRunSkillSearchRequestsSearchEndpoint(t *testing.T) {
 	var gotPath string
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
diff --git a/server/cmd/server/quick_create_subscriber_test.go b/server/cmd/server/quick_create_subscriber_test.go
index b694cc2591..14e638a1fe 100644
--- a/server/cmd/server/quick_create_subscriber_test.go
+++ b/server/cmd/server/quick_create_subscriber_test.go
@@ -38,6 +38,7 @@ func TestQuickCreateCompletion_SubscribesRequester(t *testing.T) {
 		"please file a bug",
 		pgtype.UUID{},
 		pgtype.UUID{},
+		nil,
 	)
 	if err != nil {
 		t.Fatalf("EnqueueQuickCreateTask: %v", err)
@@ -112,6 +113,7 @@ func TestQuickCreateFailure_DoesNotSubscribeRequester(t *testing.T) {
 		"another bug",
 		pgtype.UUID{},
 		pgtype.UUID{},
+		nil,
 	)
 	if err != nil {
 		t.Fatalf("EnqueueQuickCreateTask: %v", err)
diff --git a/server/internal/daemon/config.go b/server/internal/daemon/config.go
index de6160980c..70fb75340e 100644
--- a/server/internal/daemon/config.go
+++ b/server/internal/daemon/config.go
@@ -80,7 +80,7 @@ type Config struct {
 	CLIVersion                     string                // multica CLI version (e.g. "0.1.13")
 	LaunchedBy                     string                // "desktop" when spawned by the Electron app, empty for standalone
 	Profile                        string                // profile name (empty = default)
-	Agents                         map[string]AgentEntry // keyed by provider: claude, codex, copilot, opencode, openclaw, hermes, gemini, pi, cursor, kimi, kiro, antigravity
+	Agents                         map[string]AgentEntry // keyed by provider: claude, codebuddy, codex, copilot, opencode, openclaw, hermes, gemini, pi, cursor, kimi, kiro, antigravity
 	WorkspacesRoot                 string                // base path for execution envs (default: ~/multica_workspaces)
 	KeepEnvAfterTask               bool                  // preserve env after task for debugging
 	HealthPort                     int                   // local HTTP port for health checks (default: 19514)
@@ -101,6 +101,7 @@ type Config struct {
 	AgentToolWatchdog              time.Duration // force-stop a run when a single tool call stays in flight (silent) this long (0 = disabled); backstop for hung tools now that there is no wall-clock cap
 	ClaudeArgs                     []string
 	CodexArgs                      []string
+	CodebuddyArgs                  []string
 }
 
 // Overrides allows CLI flags to override environment variables and defaults.
@@ -266,6 +267,9 @@ func LoadConfig(overrides Overrides) (Config, error) {
 	if e, ok := probe("MULTICA_KIRO_PATH", "kiro-cli", "MULTICA_KIRO_MODEL"); ok {
 		agents["kiro"] = e
 	}
+	if e, ok := probe("MULTICA_CODEBUDDY_PATH", "codebuddy", "MULTICA_CODEBUDDY_MODEL"); ok {
+		agents["codebuddy"] = e
+	}
 	// agy 1.0.6 added a `--model` flag (MUL-3125), so Antigravity now takes a
 	// model env like every other backend. MULTICA_ANTIGRAVITY_MODEL seeds the
 	// daemon-wide default; its value is the exact `agy models` display string
@@ -274,7 +278,7 @@ func LoadConfig(overrides Overrides) (Config, error) {
 		agents["antigravity"] = e
 	}
 	if len(agents) == 0 {
-		return Config{}, fmt.Errorf("no agent CLI found: install claude, codex, copilot, opencode, openclaw, hermes, gemini, pi, cursor-agent, kimi, kiro-cli, or agy and ensure it is on PATH")
+		return Config{}, fmt.Errorf("no agent CLI found: install claude, codebuddy, codex, copilot, opencode, openclaw, hermes, gemini, pi, cursor-agent, kimi, kiro-cli, or agy and ensure it is on PATH")
 	}
 
 	claudeArgs, err := shellArgsFromEnv("MULTICA_CLAUDE_ARGS")
@@ -285,6 +289,10 @@ func LoadConfig(overrides Overrides) (Config, error) {
 	if err != nil {
 		return Config{}, err
 	}
+	codebuddyArgs, err := shellArgsFromEnv("MULTICA_CODEBUDDY_ARGS")
+	if err != nil {
+		return Config{}, err
+	}
 
 	// Host info
 	host, err := os.Hostname()
@@ -491,6 +499,7 @@ func LoadConfig(overrides Overrides) (Config, error) {
 		AgentToolWatchdog:              agentToolWatchdog,
 		ClaudeArgs:                     claudeArgs,
 		CodexArgs:                      codexArgs,
+		CodebuddyArgs:                  codebuddyArgs,
 	}, nil
 }
 
@@ -617,7 +626,7 @@ func shellArgsFromEnv(name string) ([]string, error) {
 // invocation, instead of paying the cost-per-miss.
 var defaultAgentCommandNames = []string{
 	"claude", "codex", "opencode", "openclaw", "hermes",
-	"gemini", "pi", "cursor-agent", "copilot", "kimi", "kiro-cli", "agy",
+	"gemini", "pi", "cursor-agent", "copilot", "kimi", "kiro-cli", "codebuddy", "agy",
 }
 
 var codexDesktopAppBundlePaths = func() []string {
diff --git a/server/internal/daemon/daemon.go b/server/internal/daemon/daemon.go
index af87269c0f..3c29ed7b2d 100644
--- a/server/internal/daemon/daemon.go
+++ b/server/internal/daemon/daemon.go
@@ -2224,11 +2224,16 @@ func (d *Daemon) handleTask(ctx context.Context, task Task, slot int) {
 	)
 
 	// If the task targets a project_resource of type local_directory that
-	// is pinned to this daemon, acquire the path mutex BEFORE StartTask so
-	// the server-side state machine is dispatched → waiting_local_directory
-	// → running rather than backwards-transitioning from running into the
-	// wait state. The release is deferred so a panic or early return
-	// always frees the lock for the next waiter.
+	// is pinned to this daemon, acquire the path mutex before runner.run
+	// so the server-side state machine is dispatched →
+	// waiting_local_directory → running rather than backwards-transitioning
+	// from running into the wait state. The release is deferred so a panic
+	// or early return always frees the lock for the next waiter.
+	//
+	// StartTask itself now lives in runTask (see issue #3999 race A) and
+	// fires only after execenv.Prepare/Reuse has put env.WorkDir on disk,
+	// so consumers that read status==running can resolve the workdir path
+	// without racing the daemon's os.MkdirAll.
 	localRelease, abort := d.acquireLocalDirectoryLockIfNeeded(ctx, task, taskLog)
 	if abort {
 		return
@@ -2237,24 +2242,27 @@ func (d *Daemon) handleTask(ctx context.Context, task Task, slot int) {
 		defer localRelease()
 	}
 
-	if err := d.client.StartTask(ctx, task.ID); err != nil {
-		taskLog.Error("start task failed", "error", err)
-		startErrMsg := fmt.Sprintf("start task failed: %s", err.Error())
-		// MUL-2946: classify the wrapper error so the failure_reason
-		// column lands in the canonical refined taxonomy rather than
-		// the legacy coarse "agent_error" bucket. A start-task failure
-		// most commonly surfaces as ReasonAgentUnknown (no rule
-		// matches "start task failed: <…>"), but a future provider /
-		// network blip in the wrapper layer would still classify
-		// correctly without us touching this site.
-		if failErr := d.client.FailTask(ctx, task.ID, startErrMsg, "", "", taskfailure.Classify(startErrMsg).String()); failErr != nil {
-			taskLog.Error("fail task after start error", "error", failErr)
+	// Hold a process-wide active-root guard for the rest of this task so
+	// the GC loop never sees a window where the env root has neither the
+	// in-process guard nor .gc_meta.json (issue #3999 race B). runTask
+	// installs its own ref-counted mark/unmark internally; without this
+	// outer guard the inner unmark fires when runTask returns, leaving
+	// the directory protected only by the 72h orphan TTL through
+	// reportTaskResult and execenv.WriteGCMeta below. markActiveEnvRoot
+	// is reference-counted, so the duplicate marks runTask installs are
+	// correctly nested within these.
+	predictedEnvRoot := execenv.PredictRootDir(d.cfg.WorkspacesRoot, task.WorkspaceID, task.ID)
+	if predictedEnvRoot != "" {
+		d.markActiveEnvRoot(predictedEnvRoot)
+		defer d.unmarkActiveEnvRoot(predictedEnvRoot)
+	}
+	if task.PriorWorkDir != "" {
+		if priorRoot := filepath.Dir(task.PriorWorkDir); priorRoot != "" && priorRoot != predictedEnvRoot {
+			d.markActiveEnvRoot(priorRoot)
+			defer d.unmarkActiveEnvRoot(priorRoot)
 		}
-		return
 	}
 
-	_ = d.client.ReportProgress(ctx, task.ID, fmt.Sprintf("Launching %s", provider), 1, 2)
-
 	// Create a cancellable context so we can interrupt the running agent
 	// when the server signals the task should stop — either the task reached
 	// a terminal state (completed/failed/cancelled) or the task row is
@@ -2392,10 +2400,10 @@ func (d *Daemon) acquireLocalDirectoryLockIfNeeded(ctx context.Context, task Tas
 
 	// While the lock is contended the daemon would otherwise sit blocked on
 	// the path mutex with no signal back from the server — the main
-	// per-task watcher only starts after StartTask. If the user cancels
-	// the issue or it gets reassigned during the wait, we need to notice
-	// promptly so the daemon slot isn't pinned by a phantom waiter. We
-	// spin up the cancellation watcher lazily inside onWait so the
+	// per-task watcher only starts after the lock is acquired. If the user
+	// cancels the issue or it gets reassigned during the wait, we need to
+	// notice promptly so the daemon slot isn't pinned by a phantom waiter.
+	// We spin up the cancellation watcher lazily inside onWait so the
 	// no-contention fast path still costs nothing.
 	waitCtx, waitCancel := context.WithCancel(ctx)
 	defer waitCancel()
@@ -2579,6 +2587,30 @@ func providerNeedsInlineSystemPrompt(provider string) bool {
 	}
 }
 
+// gateResumeToReusedWorkdir clears the task's prior session unless the task
+// runs in the exact workdir the session was recorded against, and reports
+// whether that workdir was reused. CLI backends key their session stores to
+// the cwd (Claude Code looks sessions up under ~/.claude/projects/<encoded-cwd>/),
+// so a session id from a different workdir can never resolve: the CLI exits
+// within a second and the run fails before doing any work — permanently,
+// because the failed run records no session and the next claim serves the
+// same stale pointer again. This fires whenever the prior workdir no longer
+// exists (GC'd after the issue went done, daemon reinstall, manual cleanup)
+// and execenv.Reuse fell back to a fresh Prepare (GitHub #3854).
+func gateResumeToReusedWorkdir(task *Task, taskCtx *execenv.TaskContextForEnv, envWorkDir string, taskLog *slog.Logger) bool {
+	reused := task.PriorWorkDir != "" && envWorkDir == task.PriorWorkDir
+	if !reused && task.PriorSessionID != "" {
+		taskLog.Info("dropping prior session: workdir not reused, per-cwd session cannot resolve",
+			"session_id", task.PriorSessionID,
+			"prior_workdir", task.PriorWorkDir,
+			"workdir", envWorkDir,
+		)
+		task.PriorSessionID = ""
+		taskCtx.PriorSessionResumed = false
+	}
+	return reused
+}
+
 func (d *Daemon) runTask(ctx context.Context, task Task, provider string, slot int, taskLog *slog.Logger) (TaskResult, error) {
 	// Refuse to spawn an agent without a workspace. An empty workspace_id
 	// here would make MULTICA_WORKSPACE_ID empty in the agent env, and the
@@ -2721,6 +2753,24 @@ func (d *Daemon) runTask(ctx context.Context, task Task, provider string, slot i
 		defer d.unmarkActiveEnvRoot(env.RootDir)
 	}
 
+	// Issue #3999 race A: now that env.WorkDir is on disk, transition the
+	// server-side state machine dispatched (or waiting_local_directory) →
+	// running. Calling StartTask before Prepare/Reuse let any consumer
+	// that read status==running and resolved
+	// /multica_workspaces/{ws}/{short-id}/workdir hit FileNotFoundError in
+	// the microsecond window before os.MkdirAll ran.
+	//
+	// On error we return early so handleTask's existing FailTask +
+	// taskfailure.Classify path records the failure with the same
+	// "start task failed: <…>" string and the same failure_reason
+	// taxonomy as before — see MUL-2946 for the classifier contract.
+	if err := d.client.StartTask(ctx, task.ID); err != nil {
+		return TaskResult{}, fmt.Errorf("start task failed: %w", err)
+	}
+	_ = d.client.ReportProgress(ctx, task.ID, fmt.Sprintf("Launching %s", provider), 1, 2)
+
+	reused := gateResumeToReusedWorkdir(&task, &taskCtx, env.WorkDir, taskLog)
+
 	// Inject runtime-specific config (meta skill) so the agent discovers .agent_context/.
 	runtimeBrief, err := execenv.InjectRuntimeConfig(env.WorkDir, provider, taskCtx)
 	if err != nil {
@@ -2800,6 +2850,13 @@ func (d *Daemon) runTask(ctx context.Context, task Task, provider string, slot i
 	// deterministically (see GetIssueByOrigin).
 	if task.QuickCreatePrompt != "" {
 		agentEnv["MULTICA_QUICK_CREATE_TASK_ID"] = task.ID
+		if len(task.QuickCreateAttachmentIDs) > 0 {
+			if raw, err := json.Marshal(task.QuickCreateAttachmentIDs); err == nil {
+				agentEnv["MULTICA_QUICK_CREATE_ATTACHMENT_IDS"] = string(raw)
+			} else {
+				taskLog.Warn("quick-create attachment ids: marshal failed; skipping env injection", "error", err)
+			}
+		}
 	}
 	// Ensure the multica CLI is on PATH inside the agent's environment.
 	// Some runtimes (e.g. Codex) run in an isolated sandbox that may not
@@ -2853,7 +2910,6 @@ func (d *Daemon) runTask(ctx context.Context, task Task, provider string, slot i
 		return TaskResult{}, fmt.Errorf("create agent backend: %w", err)
 	}
 
-	reused := task.PriorWorkDir != "" && env.WorkDir == task.PriorWorkDir
 	taskLog.Info("starting agent",
 		"provider", provider,
 		"workdir", env.WorkDir,
@@ -3718,6 +3774,8 @@ func defaultArgsForProvider(cfg Config, provider string) []string {
 		args = cfg.ClaudeArgs
 	case "codex":
 		args = cfg.CodexArgs
+	case "codebuddy":
+		args = cfg.CodebuddyArgs
 	default:
 		return nil
 	}
diff --git a/server/internal/daemon/daemon_test.go b/server/internal/daemon/daemon_test.go
index de1d462dea..fa748e5f9c 100644
--- a/server/internal/daemon/daemon_test.go
+++ b/server/internal/daemon/daemon_test.go
@@ -18,6 +18,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/multica-ai/multica/server/internal/daemon/execenv"
 	"github.com/multica-ai/multica/server/internal/daemon/repocache"
 	"github.com/multica-ai/multica/server/pkg/agent"
 )
@@ -896,6 +897,71 @@ func newRepoReadyTestDaemon(t *testing.T, handler http.HandlerFunc) *Daemon {
 	return d
 }
 
+func TestGateResumeToReusedWorkdir(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name        string
+		sessionID   string
+		priorDir    string
+		envDir      string
+		wantSession string
+		wantReused  bool
+	}{
+		{
+			name:        "same workdir keeps session",
+			sessionID:   "sess-1",
+			priorDir:    "/ws/task-a/workdir",
+			envDir:      "/ws/task-a/workdir",
+			wantSession: "sess-1",
+			wantReused:  true,
+		},
+		{
+			name:        "fresh workdir drops session",
+			sessionID:   "sess-1",
+			priorDir:    "/ws/task-a/workdir",
+			envDir:      "/ws/task-b/workdir",
+			wantSession: "",
+			wantReused:  false,
+		},
+		{
+			name:        "session without recorded workdir drops session",
+			sessionID:   "sess-1",
+			priorDir:    "",
+			envDir:      "/ws/task-b/workdir",
+			wantSession: "",
+			wantReused:  false,
+		},
+		{
+			name:        "no prior session is a no-op",
+			sessionID:   "",
+			priorDir:    "/ws/task-a/workdir",
+			envDir:      "/ws/task-b/workdir",
+			wantSession: "",
+			wantReused:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			task := Task{PriorSessionID: tt.sessionID, PriorWorkDir: tt.priorDir}
+			taskCtx := execenv.TaskContextForEnv{PriorSessionResumed: tt.sessionID != ""}
+
+			reused := gateResumeToReusedWorkdir(&task, &taskCtx, tt.envDir, slog.Default())
+
+			if reused != tt.wantReused {
+				t.Fatalf("reused = %v, want %v", reused, tt.wantReused)
+			}
+			if task.PriorSessionID != tt.wantSession {
+				t.Fatalf("PriorSessionID = %q, want %q", task.PriorSessionID, tt.wantSession)
+			}
+			if taskCtx.PriorSessionResumed != (tt.wantSession != "") {
+				t.Fatalf("PriorSessionResumed = %v, want %v", taskCtx.PriorSessionResumed, tt.wantSession != "")
+			}
+		})
+	}
+}
+
 func TestExecuteAndDrain_ResumeFailureFallback(t *testing.T) {
 	t.Parallel()
 
diff --git a/server/internal/daemon/execenv/context.go b/server/internal/daemon/execenv/context.go
index eb00573bc0..af9fc6e580 100644
--- a/server/internal/daemon/execenv/context.go
+++ b/server/internal/daemon/execenv/context.go
@@ -171,7 +171,7 @@ func resolveSkillsDir(workDir, provider string, manifest *sidecarManifest) (stri
 // it can match the managed skill roots the prior manifest recorded.
 func skillsDirPath(workDir, provider string) string {
 	switch provider {
-	case "claude":
+	case "claude", "codebuddy":
 		// Claude Code natively discovers skills from .claude/skills/ in the workdir.
 		return filepath.Join(workDir, ".claude", "skills")
 	case "copilot":
diff --git a/server/internal/daemon/execenv/runtime_config.go b/server/internal/daemon/execenv/runtime_config.go
index 02ec6f14b7..4c64ff2549 100644
--- a/server/internal/daemon/execenv/runtime_config.go
+++ b/server/internal/daemon/execenv/runtime_config.go
@@ -177,7 +177,7 @@ func InjectRuntimeConfig(workDir, provider string, ctx TaskContextForEnv) (strin
 // added to one side cannot drift past the other.
 func runtimeConfigPath(workDir, provider string) string {
 	switch provider {
-	case "claude":
+	case "claude", "codebuddy":
 		return filepath.Join(workDir, "CLAUDE.md")
 	case "codex", "copilot", "opencode", "openclaw", "hermes", "pi", "cursor", "kimi", "kiro", "antigravity":
 		return filepath.Join(workDir, "AGENTS.md")
@@ -690,8 +690,8 @@ func buildMetaSkillContent(provider string, ctx TaskContextForEnv) string {
 	if len(ctx.AgentSkills) > 0 {
 		b.WriteString("## Skills\n\n")
 		switch provider {
-		case "claude":
-			// Claude discovers skills natively from .claude/skills/ — just list names.
+		case "claude", "codebuddy":
+			// Claude/CodeBuddy discovers skills natively from .claude/skills/ — just list names.
 			b.WriteString("You have the following skills installed (discovered automatically):\n\n")
 		case "codex", "copilot", "opencode", "openclaw", "pi", "cursor", "kimi", "kiro", "antigravity":
 			// Codex, Copilot, OpenCode, OpenClaw, Pi, Cursor, Kimi, Kiro, and
diff --git a/server/internal/daemon/local_skills.go b/server/internal/daemon/local_skills.go
index 0ee0fa3ec3..dfb12d2ae1 100644
--- a/server/internal/daemon/local_skills.go
+++ b/server/internal/daemon/local_skills.go
@@ -62,7 +62,7 @@ func localSkillRootForProvider(provider string) (string, bool, error) {
 	}
 
 	switch provider {
-	case "claude":
+	case "claude", "codebuddy":
 		return filepath.Join(home, ".claude", "skills"), true, nil
 	case "codex":
 		codexHome := strings.TrimSpace(os.Getenv("CODEX_HOME"))
diff --git a/server/internal/daemon/prompt.go b/server/internal/daemon/prompt.go
index 6b7e448087..69a322ddc6 100644
--- a/server/internal/daemon/prompt.go
+++ b/server/internal/daemon/prompt.go
@@ -231,6 +231,7 @@ func buildChatPrompt(task Task) string {
 			}
 		}
 		b.WriteString("Use `multica attachment download <id>` to fetch each file locally before referring to it.\n")
+		b.WriteString("When creating an issue that should preserve one of these attachments, pass `--attachment-id <id>` to `multica issue create` in addition to keeping the attachment markdown inline.\n")
 	}
 	return b.String()
 }
diff --git a/server/internal/daemon/prompt_test.go b/server/internal/daemon/prompt_test.go
index 069a51ca65..010d26ced5 100644
--- a/server/internal/daemon/prompt_test.go
+++ b/server/internal/daemon/prompt_test.go
@@ -249,6 +249,27 @@ func TestBuildPromptSquadLeaderNoActionForAgentTrigger(t *testing.T) {
 	}
 }
 
+func TestBuildChatPromptAttachmentIDsCanBeBoundToCreatedIssues(t *testing.T) {
+	task := Task{
+		ChatSessionID: "sess-1",
+		ChatMessage:   "please create an issue with this screenshot",
+		ChatMessageAttachments: []ChatAttachmentMeta{
+			{ID: "019ec09d-6222-722b-bdfa-427b105d80be", Filename: "shot.png", ContentType: "image/png"},
+		},
+	}
+	out := BuildPrompt(task, "claude")
+	for _, want := range []string{
+		"Attachments on this message:",
+		"id=019ec09d-6222-722b-bdfa-427b105d80be",
+		"multica attachment download <id>",
+		"--attachment-id <id>",
+	} {
+		if !strings.Contains(out, want) {
+			t.Errorf("chat prompt missing %q\n--- output ---\n%s", want, out)
+		}
+	}
+}
+
 func TestBuildChatPromptSlashSkills(t *testing.T) {
 	t.Run("injects selected skills block", func(t *testing.T) {
 		task := Task{
diff --git a/server/internal/daemon/types.go b/server/internal/daemon/types.go
index 16c83e3189..28d4ee74e1 100644
--- a/server/internal/daemon/types.go
+++ b/server/internal/daemon/types.go
@@ -43,36 +43,37 @@ type Task struct {
 	// prompt set in Settings → General). Server populates this on every claim
 	// regardless of task kind so the daemon can inject `## Workspace Context`
 	// into the brief. Empty when the owner hasn't set one.
-	WorkspaceContext        string                `json:"workspace_context,omitempty"`
-	ThreadName              string                `json:"thread_name,omitempty"` // semantic title for provider-native session/thread history
-	Agent                   *AgentData            `json:"agent,omitempty"`
-	Repos                   []RepoData            `json:"repos,omitempty"`
-	ProjectID               string                `json:"project_id,omitempty"`                // issue's project, when present
-	ProjectTitle            string                `json:"project_title,omitempty"`             // human-readable project title for context injection
-	ProjectResources        []ProjectResourceData `json:"project_resources,omitempty"`         // project-scoped resources to expose to the agent
-	PriorSessionID          string                `json:"prior_session_id,omitempty"`          // Claude session ID from a previous task on this issue
-	PriorWorkDir            string                `json:"prior_work_dir,omitempty"`            // work_dir from a previous task on this issue
-	TriggerCommentID        string                `json:"trigger_comment_id,omitempty"`        // comment that triggered this task
-	TriggerThreadID         string                `json:"trigger_thread_id,omitempty"`         // root comment ID for the triggering thread; falls back to trigger_comment_id on old servers
-	TriggerCommentContent   string                `json:"trigger_comment_content,omitempty"`   // content of the triggering comment
-	TriggerAuthorType       string                `json:"trigger_author_type,omitempty"`       // "agent" or "member" — author kind for the triggering comment
-	TriggerAuthorName       string                `json:"trigger_author_name,omitempty"`       // display name of the triggering comment author
-	NewCommentCount         int                   `json:"new_comment_count,omitempty"`         // issue-wide comments since this agent's last run (excludes its own and the injected trigger); 0/omitted for old daemons or cold start
-	NewCommentsSince        string                `json:"new_comments_since,omitempty"`        // RFC3339 anchor (last run's started_at) the count is measured from; empty on cold start
-	ChatSessionID           string                `json:"chat_session_id,omitempty"`           // non-empty for chat tasks
-	ChatMessage             string                `json:"chat_message,omitempty"`              // user message content for chat tasks
-	ChatMessageAttachments  []ChatAttachmentMeta  `json:"chat_message_attachments,omitempty"`  // attachments linked to the chat message; agent uses these to `multica attachment download <id>`
-	AutopilotRunID          string                `json:"autopilot_run_id,omitempty"`          // non-empty for autopilot run_only tasks
-	AutopilotID             string                `json:"autopilot_id,omitempty"`              // autopilot that spawned this run
-	AutopilotTitle          string                `json:"autopilot_title,omitempty"`           // autopilot title used as task context
-	AutopilotDescription    string                `json:"autopilot_description,omitempty"`     // autopilot description used as task prompt
-	AutopilotSource         string                `json:"autopilot_source,omitempty"`          // manual, schedule, webhook, or api
-	AutopilotTriggerPayload json.RawMessage       `json:"autopilot_trigger_payload,omitempty"` // optional trigger payload for webhook/api runs
-	QuickCreatePrompt       string                `json:"quick_create_prompt,omitempty"`       // user's natural-language input for quick-create tasks
-	SquadID                 string                `json:"squad_id,omitempty"`                  // when the picker was a squad, the squad's UUID; Agent is still the resolved leader
-	SquadName               string                `json:"squad_name,omitempty"`                // display name for the picker squad, used in prompt text
-	ParentIssueID           string                `json:"parent_issue_id,omitempty"`           // for quick-create tasks opened from "Add sub issue" — UUID of the parent issue the new issue should be filed under
-	ParentIssueIdentifier   string                `json:"parent_issue_identifier,omitempty"`   // human-readable identifier (e.g. MUL-123) of the quick-create parent issue, used in prompt context
+	WorkspaceContext         string                `json:"workspace_context,omitempty"`
+	ThreadName               string                `json:"thread_name,omitempty"` // semantic title for provider-native session/thread history
+	Agent                    *AgentData            `json:"agent,omitempty"`
+	Repos                    []RepoData            `json:"repos,omitempty"`
+	ProjectID                string                `json:"project_id,omitempty"`                  // issue's project, when present
+	ProjectTitle             string                `json:"project_title,omitempty"`               // human-readable project title for context injection
+	ProjectResources         []ProjectResourceData `json:"project_resources,omitempty"`           // project-scoped resources to expose to the agent
+	PriorSessionID           string                `json:"prior_session_id,omitempty"`            // Claude session ID from a previous task on this issue
+	PriorWorkDir             string                `json:"prior_work_dir,omitempty"`              // work_dir from a previous task on this issue
+	TriggerCommentID         string                `json:"trigger_comment_id,omitempty"`          // comment that triggered this task
+	TriggerThreadID          string                `json:"trigger_thread_id,omitempty"`           // root comment ID for the triggering thread; falls back to trigger_comment_id on old servers
+	TriggerCommentContent    string                `json:"trigger_comment_content,omitempty"`     // content of the triggering comment
+	TriggerAuthorType        string                `json:"trigger_author_type,omitempty"`         // "agent" or "member" — author kind for the triggering comment
+	TriggerAuthorName        string                `json:"trigger_author_name,omitempty"`         // display name of the triggering comment author
+	NewCommentCount          int                   `json:"new_comment_count,omitempty"`           // issue-wide comments since this agent's last run (excludes its own and the injected trigger); 0/omitted for old daemons or cold start
+	NewCommentsSince         string                `json:"new_comments_since,omitempty"`          // RFC3339 anchor (last run's started_at) the count is measured from; empty on cold start
+	ChatSessionID            string                `json:"chat_session_id,omitempty"`             // non-empty for chat tasks
+	ChatMessage              string                `json:"chat_message,omitempty"`                // user message content for chat tasks
+	ChatMessageAttachments   []ChatAttachmentMeta  `json:"chat_message_attachments,omitempty"`    // attachments linked to the chat message; agent uses these to `multica attachment download <id>`
+	AutopilotRunID           string                `json:"autopilot_run_id,omitempty"`            // non-empty for autopilot run_only tasks
+	AutopilotID              string                `json:"autopilot_id,omitempty"`                // autopilot that spawned this run
+	AutopilotTitle           string                `json:"autopilot_title,omitempty"`             // autopilot title used as task context
+	AutopilotDescription     string                `json:"autopilot_description,omitempty"`       // autopilot description used as task prompt
+	AutopilotSource          string                `json:"autopilot_source,omitempty"`            // manual, schedule, webhook, or api
+	AutopilotTriggerPayload  json.RawMessage       `json:"autopilot_trigger_payload,omitempty"`   // optional trigger payload for webhook/api runs
+	QuickCreatePrompt        string                `json:"quick_create_prompt,omitempty"`         // user's natural-language input for quick-create tasks
+	QuickCreateAttachmentIDs []string              `json:"quick_create_attachment_ids,omitempty"` // attachments uploaded in the quick-create prompt and bound by issue create
+	SquadID                  string                `json:"squad_id,omitempty"`                    // when the picker was a squad, the squad's UUID; Agent is still the resolved leader
+	SquadName                string                `json:"squad_name,omitempty"`                  // display name for the picker squad, used in prompt text
+	ParentIssueID            string                `json:"parent_issue_id,omitempty"`             // for quick-create tasks opened from "Add sub issue" — UUID of the parent issue the new issue should be filed under
+	ParentIssueIdentifier    string                `json:"parent_issue_identifier,omitempty"`     // human-readable identifier (e.g. MUL-123) of the quick-create parent issue, used in prompt context
 	// RequestingUserName + RequestingUserProfileDescription describe the human
 	// the agent is working on behalf of. v1 sources them from the runtime
 	// owner (the user who registered the daemon). Empty when the runtime has
diff --git a/server/internal/daemon/workdir_race_test.go b/server/internal/daemon/workdir_race_test.go
new file mode 100644
index 0000000000..ee79031b2e
--- /dev/null
+++ b/server/internal/daemon/workdir_race_test.go
@@ -0,0 +1,244 @@
+package daemon
+
+import (
+	"context"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/multica-ai/multica/server/internal/daemon/execenv"
+)
+
+// TestHandleTask_DoesNotCallStartTaskItself is the regression guard for
+// issue #3999 race A. handleTask must not call /tasks/{id}/start before
+// runner.run — the runner is now responsible for calling StartTask only
+// after execenv.Prepare/Reuse has put env.WorkDir on disk, so consumers
+// that read status==running can resolve the workdir path without racing
+// the daemon's os.MkdirAll.
+//
+// Before the fix: handleTask called StartTask before invoking the runner,
+// flipping the server-side state to "running" while the per-task workdir
+// still didn't exist on disk. Hermes/OpenClaw agents that resolved
+// /multica_workspaces/{ws}/{short-id}/workdir from the running signal
+// would then hit FileNotFoundError.
+func TestHandleTask_DoesNotCallStartTaskItself(t *testing.T) {
+	t.Parallel()
+
+	var (
+		startCalls   atomic.Int64
+		runnerCalled atomic.Bool
+	)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasSuffix(r.URL.Path, "/start"):
+			startCalls.Add(1)
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(srv.Close)
+
+	d := &Daemon{
+		client:             NewClient(srv.URL),
+		logger:             slog.New(slog.NewTextHandler(io.Discard, nil)),
+		workspaces:         make(map[string]*workspaceState),
+		runtimeIndex:       map[string]Runtime{"rt-1": {ID: "rt-1", Provider: "claude"}},
+		activeEnvRoots:     make(map[string]int),
+		cancelPollInterval: time.Hour, // disable poll-cancel path; we only care about the entry-side ordering
+	}
+
+	// Fake runner that does NOT call StartTask — production runTask does
+	// the call itself, after Prepare/Reuse confirms env.WorkDir on disk.
+	d.runner = taskRunnerFunc(func(_ context.Context, _ Task, _ string, _ int, _ *slog.Logger) (TaskResult, error) {
+		runnerCalled.Store(true)
+		return TaskResult{Status: "completed"}, nil
+	})
+
+	task := Task{
+		ID:          "task-no-start",
+		WorkspaceID: "ws-no-start",
+		RuntimeID:   "rt-1",
+		IssueID:     "issue-no-start",
+		Agent:       &AgentData{Name: "test-agent"},
+	}
+
+	d.handleTask(context.Background(), task, 0)
+
+	if !runnerCalled.Load() {
+		t.Fatal("fake runner was never invoked — handleTask aborted before runner.run, can't assert ordering")
+	}
+	if got := startCalls.Load(); got != 0 {
+		t.Fatalf("handleTask called /start %d time(s); StartTask must be runTask's responsibility now (issue #3999 race A)", got)
+	}
+}
+
+// TestRunTask_StartTaskCalledAfterWorkdirOnDisk is the behavioral regression
+// guard for issue #3999 race A. Calls runTask directly with a missing agent
+// binary so the run aborts at exec time — but only AFTER reaching the
+// post-Prepare StartTask call. The fake server records whether the per-task
+// workdir already exists on disk at the moment /start is hit; before the
+// fix it did not.
+func TestRunTask_StartTaskCalledAfterWorkdirOnDisk(t *testing.T) {
+	t.Parallel()
+
+	workspacesRoot := t.TempDir()
+	workspaceID := "ws-runtask"
+	taskID := "task-runtask-after-mkdir"
+	expectedEnvRoot := execenv.PredictRootDir(workspacesRoot, workspaceID, taskID)
+	expectedWorkDir := filepath.Join(expectedEnvRoot, "workdir")
+
+	var (
+		startCalled    atomic.Bool
+		workdirOnDisk  atomic.Bool
+		envRootOnDisk  atomic.Bool
+	)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if strings.HasSuffix(r.URL.Path, "/start") {
+			startCalled.Store(true)
+			if info, err := os.Stat(expectedWorkDir); err == nil && info.IsDir() {
+				workdirOnDisk.Store(true)
+			}
+			if info, err := os.Stat(expectedEnvRoot); err == nil && info.IsDir() {
+				envRootOnDisk.Store(true)
+			}
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(srv.Close)
+
+	// Provider entry intentionally points at a non-existent binary: runTask
+	// reaches Prepare → StartTask → ReportProgress before agent.Backend.Run
+	// fails at exec time. We don't care about the eventual error; the
+	// regression guard is the order of /start vs. os.MkdirAll(envRoot).
+	missingBin := filepath.Join(t.TempDir(), "definitely-not-claude")
+	d := &Daemon{
+		client:         NewClient(srv.URL),
+		logger:         slog.New(slog.NewTextHandler(io.Discard, nil)),
+		workspaces:     make(map[string]*workspaceState),
+		runtimeIndex:   map[string]Runtime{"rt-1": {ID: "rt-1", Provider: "claude"}},
+		activeEnvRoots: make(map[string]int),
+		cfg: Config{
+			WorkspacesRoot: workspacesRoot,
+			Agents: map[string]AgentEntry{
+				"claude": {Path: missingBin, Model: ""},
+			},
+		},
+	}
+
+	task := Task{
+		ID:          taskID,
+		WorkspaceID: workspaceID,
+		RuntimeID:   "rt-1",
+		IssueID:     "issue-runtask",
+		Agent:       &AgentData{Name: "test-agent"},
+	}
+
+	taskLog := slog.New(slog.NewTextHandler(io.Discard, nil))
+	// The Run() failure is expected; we only assert the pre-Run ordering.
+	_, _ = d.runTask(context.Background(), task, "claude", 0, taskLog)
+
+	if !startCalled.Load() {
+		t.Fatal("runTask did not call /start — Fix A's StartTask placement is missing")
+	}
+	if !envRootOnDisk.Load() {
+		t.Fatal("envRoot did not exist on disk when /start was called — Prepare must run before StartTask (issue #3999 race A)")
+	}
+	if !workdirOnDisk.Load() {
+		t.Fatal("envRoot/workdir did not exist on disk when /start was called — os.MkdirAll must complete before StartTask (issue #3999 race A)")
+	}
+}
+
+// TestHandleTask_KeepsEnvRootActiveAcrossCompletion is the regression guard
+// for issue #3999 race B. After runner.run returns, the in-process active
+// guard installed inside runTask (defer unmarkActiveEnvRoot at the
+// goroutine's exit) has already fired by the time handleTask calls
+// reportTaskResult and execenv.WriteGCMeta. Without an outer guard at the
+// handleTask level, the GC loop sees a window where the directory has
+// neither isActiveEnvRoot nor a .gc_meta.json file — falling through to
+// orphanByMTime, gated only by the 72h GCOrphanTTL.
+//
+// This test fakes the inner guard's lifecycle (mark + deferred unmark),
+// then asserts that at the moment /complete is hit (i.e. between runner.run
+// returning and WriteGCMeta running), isActiveEnvRoot(envRoot) is still
+// true thanks to the outer guard handleTask installs.
+func TestHandleTask_KeepsEnvRootActiveAcrossCompletion(t *testing.T) {
+	t.Parallel()
+
+	workspacesRoot := t.TempDir()
+	workspaceID := "ws-active-during-complete"
+	taskID := "task-active-during-complete"
+	expectedEnvRoot := execenv.PredictRootDir(workspacesRoot, workspaceID, taskID)
+
+	var (
+		completeCalled atomic.Bool
+		activeAtComplete atomic.Bool
+	)
+
+	d := &Daemon{
+		logger:             slog.New(slog.NewTextHandler(io.Discard, nil)),
+		workspaces:         make(map[string]*workspaceState),
+		runtimeIndex:       map[string]Runtime{"rt-1": {ID: "rt-1", Provider: "claude"}},
+		activeEnvRoots:     make(map[string]int),
+		cancelPollInterval: time.Hour,
+		cfg:                Config{WorkspacesRoot: workspacesRoot},
+	}
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if strings.HasSuffix(r.URL.Path, "/complete") {
+			completeCalled.Store(true)
+			// This is the exact window race B exposed: the inner deferred
+			// unmark has already fired (see fake runner below); only the
+			// outer guard installed by handleTask keeps the env root in the
+			// active set at this moment.
+			if d.isActiveEnvRoot(expectedEnvRoot) {
+				activeAtComplete.Store(true)
+			}
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(srv.Close)
+	d.client = NewClient(srv.URL)
+
+	// Fake runner mimics the real runTask's mark/defer-unmark pair. Without
+	// the outer guard added in handleTask, the deferred unmark would bring
+	// isActiveEnvRoot back to false before reportTaskResult fires.
+	d.runner = taskRunnerFunc(func(_ context.Context, tk Task, _ string, _ int, _ *slog.Logger) (TaskResult, error) {
+		predicted := execenv.PredictRootDir(d.cfg.WorkspacesRoot, tk.WorkspaceID, tk.ID)
+		d.markActiveEnvRoot(predicted)
+		defer d.unmarkActiveEnvRoot(predicted)
+		return TaskResult{
+			Status:  "completed",
+			EnvRoot: predicted,
+		}, nil
+	})
+
+	task := Task{
+		ID:          taskID,
+		WorkspaceID: workspaceID,
+		RuntimeID:   "rt-1",
+		IssueID:     "issue-active-during-complete",
+		Agent:       &AgentData{Name: "test-agent"},
+	}
+
+	d.handleTask(context.Background(), task, 0)
+
+	if !completeCalled.Load() {
+		t.Fatal("/complete was never hit — handleTask did not reach reportTaskResult")
+	}
+	if !activeAtComplete.Load() {
+		t.Fatal("env root was NOT in the active set at /complete time — issue #3999 race B regression: GC could reclaim the directory between runner.run returning and WriteGCMeta landing on disk")
+	}
+	// And the outer guard must have been released by the time handleTask
+	// returned, otherwise we'd be leaking active marks across tasks.
+	if d.isActiveEnvRoot(expectedEnvRoot) {
+		t.Fatal("env root remained active after handleTask returned — outer guard's deferred unmark did not fire")
+	}
+}
diff --git a/server/internal/handler/agent.go b/server/internal/handler/agent.go
index 41275771c8..0994592895 100644
--- a/server/internal/handler/agent.go
+++ b/server/internal/handler/agent.go
@@ -199,29 +199,30 @@ type AgentTaskResponse struct {
 	// when WorkDir is empty, or when stripping leaves nothing. See
 	// relativeWorkDir() for the full rules. Older clients can still read
 	// WorkDir directly; newer UIs should prefer RelativeWorkDir.
-	RelativeWorkDir         string               `json:"relative_work_dir,omitempty"`
-	TriggerCommentID        *string              `json:"trigger_comment_id,omitempty"`        // comment that triggered this task
-	TriggerThreadID         string               `json:"trigger_thread_id,omitempty"`         // root comment ID for the triggering thread
-	TriggerCommentContent   string               `json:"trigger_comment_content,omitempty"`   // content of the triggering comment
-	TriggerSummary          *string              `json:"trigger_summary,omitempty"`           // canonical short description snapshot — comment text / autopilot title — taken at task creation; survives source edits/deletes
-	TriggerAuthorType       string               `json:"trigger_author_type,omitempty"`       // "agent" or "member" — author kind of the triggering comment
-	TriggerAuthorName       string               `json:"trigger_author_name,omitempty"`       // display name of the triggering comment author
-	NewCommentCount         int                  `json:"new_comment_count,omitempty"`         // trigger-thread comments since last run; excludes injected trigger + own comments; omitempty so old daemons ignore it
-	NewCommentsSince        string               `json:"new_comments_since,omitempty"`        // RFC3339 anchor (last run's started_at) the count is measured from; omitempty so old daemons ignore it
-	ChatSessionID           string               `json:"chat_session_id,omitempty"`           // non-empty for chat tasks
-	ChatMessage             string               `json:"chat_message,omitempty"`              // user message for chat tasks
-	ChatMessageAttachments  []ChatAttachmentMeta `json:"chat_message_attachments,omitempty"`  // attachments on the user message — agent calls `multica attachment download <id>` per entry
-	AutopilotRunID          string               `json:"autopilot_run_id,omitempty"`          // non-empty for autopilot-spawned tasks
-	AutopilotID             string               `json:"autopilot_id,omitempty"`              // autopilot that spawned this task
-	AutopilotTitle          string               `json:"autopilot_title,omitempty"`           // autopilot title used as task context
-	AutopilotDescription    string               `json:"autopilot_description,omitempty"`     // autopilot description used as task prompt
-	AutopilotSource         string               `json:"autopilot_source,omitempty"`          // manual, schedule, webhook, or api
-	AutopilotTriggerPayload json.RawMessage      `json:"autopilot_trigger_payload,omitempty"` // optional trigger payload for webhook/api runs
-	QuickCreatePrompt       string               `json:"quick_create_prompt,omitempty"`       // user's natural-language input for quick-create tasks
-	SquadID                 string               `json:"squad_id,omitempty"`                  // for quick-create tasks where the picker was a squad; Agent is still the resolved leader
-	SquadName               string               `json:"squad_name,omitempty"`                // display name for the picker squad
-	ParentIssueID           string               `json:"parent_issue_id,omitempty"`           // for quick-create tasks opened from "Add sub issue" — UUID of the parent issue the new issue should be filed under
-	ParentIssueIdentifier   string               `json:"parent_issue_identifier,omitempty"`   // human-readable identifier (e.g. MUL-123) of the quick-create parent issue, resolved on claim for prompt context
+	RelativeWorkDir          string               `json:"relative_work_dir,omitempty"`
+	TriggerCommentID         *string              `json:"trigger_comment_id,omitempty"`          // comment that triggered this task
+	TriggerThreadID          string               `json:"trigger_thread_id,omitempty"`           // root comment ID for the triggering thread
+	TriggerCommentContent    string               `json:"trigger_comment_content,omitempty"`     // content of the triggering comment
+	TriggerSummary           *string              `json:"trigger_summary,omitempty"`             // canonical short description snapshot — comment text / autopilot title — taken at task creation; survives source edits/deletes
+	TriggerAuthorType        string               `json:"trigger_author_type,omitempty"`         // "agent" or "member" — author kind of the triggering comment
+	TriggerAuthorName        string               `json:"trigger_author_name,omitempty"`         // display name of the triggering comment author
+	NewCommentCount          int                  `json:"new_comment_count,omitempty"`           // trigger-thread comments since last run; excludes injected trigger + own comments; omitempty so old daemons ignore it
+	NewCommentsSince         string               `json:"new_comments_since,omitempty"`          // RFC3339 anchor (last run's started_at) the count is measured from; omitempty so old daemons ignore it
+	ChatSessionID            string               `json:"chat_session_id,omitempty"`             // non-empty for chat tasks
+	ChatMessage              string               `json:"chat_message,omitempty"`                // user message for chat tasks
+	ChatMessageAttachments   []ChatAttachmentMeta `json:"chat_message_attachments,omitempty"`    // attachments on the user message — agent calls `multica attachment download <id>` per entry
+	AutopilotRunID           string               `json:"autopilot_run_id,omitempty"`            // non-empty for autopilot-spawned tasks
+	AutopilotID              string               `json:"autopilot_id,omitempty"`                // autopilot that spawned this task
+	AutopilotTitle           string               `json:"autopilot_title,omitempty"`             // autopilot title used as task context
+	AutopilotDescription     string               `json:"autopilot_description,omitempty"`       // autopilot description used as task prompt
+	AutopilotSource          string               `json:"autopilot_source,omitempty"`            // manual, schedule, webhook, or api
+	AutopilotTriggerPayload  json.RawMessage      `json:"autopilot_trigger_payload,omitempty"`   // optional trigger payload for webhook/api runs
+	QuickCreatePrompt        string               `json:"quick_create_prompt,omitempty"`         // user's natural-language input for quick-create tasks
+	QuickCreateAttachmentIDs []string             `json:"quick_create_attachment_ids,omitempty"` // attachment ids uploaded in the quick-create prompt and bound on issue create
+	SquadID                  string               `json:"squad_id,omitempty"`                    // for quick-create tasks where the picker was a squad; Agent is still the resolved leader
+	SquadName                string               `json:"squad_name,omitempty"`                  // display name for the picker squad
+	ParentIssueID            string               `json:"parent_issue_id,omitempty"`             // for quick-create tasks opened from "Add sub issue" — UUID of the parent issue the new issue should be filed under
+	ParentIssueIdentifier    string               `json:"parent_issue_identifier,omitempty"`     // human-readable identifier (e.g. MUL-123) of the quick-create parent issue, resolved on claim for prompt context
 	// RequestingUserName + RequestingUserProfileDescription mirror the user
 	// the agent is acting on behalf of (see daemon/types.go). v1 sources them
 	// from the runtime owner so they're populated for daemon runtimes and
diff --git a/server/internal/handler/cancel_task_by_user_test.go b/server/internal/handler/cancel_task_by_user_test.go
index 7097c70e05..513f7c38c5 100644
--- a/server/internal/handler/cancel_task_by_user_test.go
+++ b/server/internal/handler/cancel_task_by_user_test.go
@@ -2,6 +2,7 @@ package handler
 
 import (
 	"context"
+	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -313,6 +314,133 @@ func TestCancelTaskByUser_ChatTask_NonCreator_Returns403(t *testing.T) {
 	}
 }
 
+func TestCancelTaskByUser_ChatTaskWithTranscript_PersistsAssistantSnapshot(t *testing.T) {
+	if testHandler == nil {
+		t.Skip("database not available")
+	}
+
+	agentID := createHandlerTestAgent(t, "CancelChatTranscriptAgent", []byte("[]"))
+	sessionID := createHandlerTestChatSession(t, agentID)
+
+	var taskID string
+	if err := testPool.QueryRow(context.Background(), `
+		INSERT INTO agent_task_queue (agent_id, runtime_id, status, priority, issue_id, chat_session_id, created_at)
+		VALUES ($1, (SELECT runtime_id FROM agent WHERE id = $1), 'running', 0, NULL, $2, now() - interval '5 seconds')
+		RETURNING id
+	`, agentID, sessionID).Scan(&taskID); err != nil {
+		t.Fatalf("create chat task: %v", err)
+	}
+	t.Cleanup(func() { testPool.Exec(context.Background(), `DELETE FROM agent_task_queue WHERE id = $1`, taskID) })
+
+	if _, err := testPool.Exec(context.Background(), `
+		INSERT INTO chat_message (chat_session_id, role, content, task_id)
+		VALUES ($1, 'user', 'please answer', $2)
+	`, sessionID, taskID); err != nil {
+		t.Fatalf("create linked user chat message: %v", err)
+	}
+	if _, err := testPool.Exec(context.Background(), `
+		INSERT INTO task_message (task_id, seq, type, content)
+		VALUES ($1, 1, 'text', 'partial answer')
+	`, taskID); err != nil {
+		t.Fatalf("create task message: %v", err)
+	}
+
+	w := httptest.NewRecorder()
+	testHandler.CancelTaskByUser(w, cancelTaskByUserRequest(t, testUserID, taskID))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var resp CancelTaskByUserResponse
+	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("decode cancel response: %v", err)
+	}
+	if resp.CancelledChatMessage != nil {
+		t.Fatalf("expected no restore payload when transcript exists, got %#v", resp.CancelledChatMessage)
+	}
+	if got := taskStatus(t, taskID); got != "cancelled" {
+		t.Fatalf("task not cancelled: status = %q", got)
+	}
+
+	var role, content, messageTaskID string
+	if err := testPool.QueryRow(context.Background(), `
+		SELECT role, content, COALESCE(task_id::text, '')
+		FROM chat_message
+		WHERE chat_session_id = $1 AND role = 'assistant'
+	`, sessionID).Scan(&role, &content, &messageTaskID); err != nil {
+		t.Fatalf("read cancelled assistant chat message: %v", err)
+	}
+	if role != "assistant" || content != "Stopped." || messageTaskID != taskID {
+		t.Fatalf("assistant snapshot mismatch: role=%q content=%q task_id=%q", role, content, messageTaskID)
+	}
+}
+
+func TestCancelTaskByUser_ChatTaskWithoutTranscript_RestoresUserDraft(t *testing.T) {
+	if testHandler == nil {
+		t.Skip("database not available")
+	}
+
+	agentID := createHandlerTestAgent(t, "CancelChatNoTranscriptAgent", []byte("[]"))
+	sessionID := createHandlerTestChatSession(t, agentID)
+
+	var taskID string
+	if err := testPool.QueryRow(context.Background(), `
+		INSERT INTO agent_task_queue (agent_id, runtime_id, status, priority, issue_id, chat_session_id)
+		VALUES ($1, (SELECT runtime_id FROM agent WHERE id = $1), 'running', 0, NULL, $2)
+		RETURNING id
+	`, agentID, sessionID).Scan(&taskID); err != nil {
+		t.Fatalf("create chat task: %v", err)
+	}
+	t.Cleanup(func() { testPool.Exec(context.Background(), `DELETE FROM agent_task_queue WHERE id = $1`, taskID) })
+
+	var userMessageID string
+	const userContent = "keep this prompt"
+	if err := testPool.QueryRow(context.Background(), `
+		INSERT INTO chat_message (chat_session_id, role, content, task_id)
+		VALUES ($1, 'user', $2, $3)
+		RETURNING id
+	`, sessionID, userContent, taskID).Scan(&userMessageID); err != nil {
+		t.Fatalf("create linked user chat message: %v", err)
+	}
+
+	w := httptest.NewRecorder()
+	testHandler.CancelTaskByUser(w, cancelTaskByUserRequest(t, testUserID, taskID))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var resp CancelTaskByUserResponse
+	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("decode cancel response: %v", err)
+	}
+	if resp.CancelledChatMessage == nil {
+		t.Fatal("expected restore payload for empty transcript cancel")
+	}
+	if resp.CancelledChatMessage.MessageID != userMessageID ||
+		resp.CancelledChatMessage.Content != userContent ||
+		!resp.CancelledChatMessage.RestoreToInput {
+		t.Fatalf("restore payload mismatch: %#v", resp.CancelledChatMessage)
+	}
+
+	var count int
+	if err := testPool.QueryRow(context.Background(), `
+		SELECT count(*) FROM chat_message
+		WHERE chat_session_id = $1 AND role = 'assistant'
+	`, sessionID).Scan(&count); err != nil {
+		t.Fatalf("count assistant chat messages: %v", err)
+	}
+	if count != 0 {
+		t.Fatalf("expected no assistant snapshot for empty transcript, got %d", count)
+	}
+	if err := testPool.QueryRow(context.Background(), `
+		SELECT count(*) FROM chat_message
+		WHERE id = $1
+	`, userMessageID).Scan(&count); err != nil {
+		t.Fatalf("count deleted user chat message: %v", err)
+	}
+	if count != 0 {
+		t.Fatalf("expected linked user message to be deleted, got %d", count)
+	}
+}
+
 // TestCancelTaskByUser_PrivateAgent_PlainMember_Returns403 verifies the cancel
 // endpoint mirrors the agent Activity / snapshot visibility gate: a plain
 // member who cannot see a private agent's tasks cannot cancel them either.
diff --git a/server/internal/handler/chat.go b/server/internal/handler/chat.go
index 0188f91369..f7f7801df7 100644
--- a/server/internal/handler/chat.go
+++ b/server/internal/handler/chat.go
@@ -473,6 +473,19 @@ func (h *Handler) SendChatMessage(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusInternalServerError, "failed to enqueue chat task: "+err.Error())
 		return
 	}
+	if err := h.Queries.LinkChatMessageToTask(r.Context(), db.LinkChatMessageToTaskParams{
+		ID:     msg.ID,
+		TaskID: task.ID,
+	}); err != nil {
+		// Don't fail the send: the task already exists and the user message
+		// is persisted. The link is only needed for precise empty-cancel
+		// cleanup; older/unlinked rows simply keep the historical behavior.
+		slog.Warn("link user chat message to task failed",
+			"message_id", uuidToString(msg.ID),
+			"task_id", uuidToString(task.ID),
+			"error", err,
+		)
+	}
 
 	// Touch session updated_at.
 	if err := h.Queries.TouchChatSession(r.Context(), session.ID); err != nil {
@@ -700,6 +713,18 @@ type PendingChatTaskItem struct {
 	ChatSessionID string `json:"chat_session_id"`
 }
 
+type CancelledChatMessageResponse struct {
+	ChatSessionID  string `json:"chat_session_id"`
+	MessageID      string `json:"message_id"`
+	Content        string `json:"content"`
+	RestoreToInput bool   `json:"restore_to_input"`
+}
+
+type CancelTaskByUserResponse struct {
+	AgentTaskResponse
+	CancelledChatMessage *CancelledChatMessageResponse `json:"cancelled_chat_message,omitempty"`
+}
+
 // ListPendingChatTasks returns every in-flight chat task owned by the current
 // user in this workspace. Drives the FAB's "running" indicator when the chat
 // window is closed (no per-session query is subscribed). Tasks belonging to
@@ -879,13 +904,25 @@ func (h *Handler) CancelTaskByUser(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	cancelled, err := h.TaskService.CancelTask(r.Context(), taskUUID)
+	cancelled, err := h.TaskService.CancelTaskWithResult(r.Context(), taskUUID)
 	if err != nil {
 		writeError(w, http.StatusBadRequest, err.Error())
 		return
 	}
 
-	writeJSON(w, http.StatusOK, taskToResponse(*cancelled, workspaceID))
+	resp := CancelTaskByUserResponse{
+		AgentTaskResponse: taskToResponse(cancelled.Task, workspaceID),
+	}
+	if cancelled.CancelledChatMessage != nil {
+		resp.CancelledChatMessage = &CancelledChatMessageResponse{
+			ChatSessionID:  cancelled.CancelledChatMessage.ChatSessionID,
+			MessageID:      cancelled.CancelledChatMessage.MessageID,
+			Content:        cancelled.CancelledChatMessage.Content,
+			RestoreToInput: cancelled.CancelledChatMessage.RestoreToInput,
+		}
+	}
+
+	writeJSON(w, http.StatusOK, resp)
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/internal/handler/chat_test.go b/server/internal/handler/chat_test.go
index 78bb8ea5d9..2208936528 100644
--- a/server/internal/handler/chat_test.go
+++ b/server/internal/handler/chat_test.go
@@ -90,6 +90,21 @@ func TestSendChatMessage_LinksAttachments(t *testing.T) {
 	if sendResp.MessageID == "" {
 		t.Fatal("expected non-empty message_id in send response")
 	}
+	if sendResp.TaskID == "" {
+		t.Fatal("expected non-empty task_id in send response")
+	}
+
+	var messageTaskID string
+	if err := testPool.QueryRow(
+		context.Background(),
+		`SELECT COALESCE(task_id::text, '') FROM chat_message WHERE id = $1`,
+		sendResp.MessageID,
+	).Scan(&messageTaskID); err != nil {
+		t.Fatalf("query chat message task id: %v", err)
+	}
+	if messageTaskID != sendResp.TaskID {
+		t.Fatalf("chat message task_id mismatch: want %s, got %s", sendResp.TaskID, messageTaskID)
+	}
 
 	// 3. Verify the attachment row now points at the new message.
 	var dbMessageID *string
diff --git a/server/internal/handler/daemon.go b/server/internal/handler/daemon.go
index ef254fde6b..ac049ffa2c 100644
--- a/server/internal/handler/daemon.go
+++ b/server/internal/handler/daemon.go
@@ -1481,6 +1481,7 @@ func (h *Handler) ClaimTaskByRuntime(w http.ResponseWriter, r *http.Request) {
 		if json.Unmarshal(task.Context, &qc) == nil && qc.Type == service.QuickCreateContextType {
 			hasQuickCreate = true
 			resp.QuickCreatePrompt = qc.Prompt
+			resp.QuickCreateAttachmentIDs = append([]string(nil), qc.AttachmentIDs...)
 			resp.ThreadName = qc.Prompt
 			resp.WorkspaceID = qc.WorkspaceID
 
diff --git a/server/internal/handler/daemon_test.go b/server/internal/handler/daemon_test.go
index c741b69c63..eb08cf7787 100644
--- a/server/internal/handler/daemon_test.go
+++ b/server/internal/handler/daemon_test.go
@@ -2388,10 +2388,11 @@ func TestCompleteTask_AssignmentTriggered_DoesNotSuppressTrivialDoneOutput(t *te
 }
 
 type claimRuntimeGuardTask struct {
-	PriorSessionID string `json:"prior_session_id"`
-	PriorWorkDir   string `json:"prior_work_dir"`
-	ChatMessage    string `json:"chat_message"`
-	ThreadName     string `json:"thread_name"`
+	PriorSessionID           string   `json:"prior_session_id"`
+	PriorWorkDir             string   `json:"prior_work_dir"`
+	ChatMessage              string   `json:"chat_message"`
+	ThreadName               string   `json:"thread_name"`
+	QuickCreateAttachmentIDs []string `json:"quick_create_attachment_ids"`
 }
 
 func claimTaskForRuntimeGuard(t *testing.T, runtimeID, daemonID string) *claimRuntimeGuardTask {
@@ -3036,11 +3037,13 @@ func TestClaimTask_QuickCreatePopulatesThreadName(t *testing.T) {
 	agentID, runtimeID, daemonID := createRuntimeGuardAgent(t, ctx)
 
 	quickPrompt := "create a follow-up issue for Codex session titles"
+	attachmentID := "019ec09d-6222-722b-bdfa-427b105d80be"
 	quickContext, _ := json.Marshal(map[string]any{
-		"type":         "quick_create",
-		"prompt":       quickPrompt,
-		"requester_id": testUserID,
-		"workspace_id": testWorkspaceID,
+		"type":           "quick_create",
+		"prompt":         quickPrompt,
+		"requester_id":   testUserID,
+		"workspace_id":   testWorkspaceID,
+		"attachment_ids": []string{attachmentID},
 	})
 
 	if _, err := testPool.Exec(ctx, `
@@ -3054,6 +3057,9 @@ func TestClaimTask_QuickCreatePopulatesThreadName(t *testing.T) {
 	if task.ThreadName != quickPrompt {
 		t.Fatalf("quick-create task thread_name = %q, want prompt", task.ThreadName)
 	}
+	if len(task.QuickCreateAttachmentIDs) != 1 || task.QuickCreateAttachmentIDs[0] != attachmentID {
+		t.Fatalf("quick-create attachment ids = %#v, want [%q]", task.QuickCreateAttachmentIDs, attachmentID)
+	}
 }
 
 func TestClaimTask_ChatForceFreshSessionSkipsPriorSession(t *testing.T) {
diff --git a/server/internal/handler/issue.go b/server/internal/handler/issue.go
index 3e7830cfc2..aee2a12560 100644
--- a/server/internal/handler/issue.go
+++ b/server/internal/handler/issue.go
@@ -1671,11 +1671,12 @@ func (h *Handler) ChildIssueProgress(w http.ResponseWriter, r *http.Request) {
 // keeping the sub-issue intent of the entry point regardless of whether
 // the user submits via manual or agent mode.
 type QuickCreateIssueRequest struct {
-	AgentID       string `json:"agent_id,omitempty"`
-	SquadID       string `json:"squad_id,omitempty"`
-	Prompt        string `json:"prompt"`
-	ProjectID     string `json:"project_id,omitempty"`
-	ParentIssueID string `json:"parent_issue_id,omitempty"`
+	AgentID       string   `json:"agent_id,omitempty"`
+	SquadID       string   `json:"squad_id,omitempty"`
+	Prompt        string   `json:"prompt"`
+	ProjectID     string   `json:"project_id,omitempty"`
+	ParentIssueID string   `json:"parent_issue_id,omitempty"`
+	AttachmentIDs []string `json:"attachment_ids,omitempty"`
 }
 
 // QuickCreateIssueResponse echoes the queued task id so the frontend can
@@ -1791,10 +1792,11 @@ func (h *Handler) QuickCreateIssue(w http.ResponseWriter, r *http.Request) {
 
 	// Daemon CLI version gate. The agent-side prompt + create-flow rely on
 	// behaviors introduced in MinQuickCreateCLIVersion (URL attachment
-	// handling, no-retry on partial failure). Older daemons either
-	// double-create issues on partial CLI failures or mishandle pasted
-	// screenshot URLs; fail closed before enqueuing rather than surface
-	// the breakage as an inbox failure twenty seconds later. Dev-built
+	// handling, quick-create attachment binding, no-retry on partial failure).
+	// Older daemons either double-create issues on partial CLI failures, drop
+	// attachment bindings, or mishandle pasted screenshot URLs; fail closed
+	// before enqueuing rather than surface the breakage as an inbox failure
+	// twenty seconds later. Dev-built
 	// daemons (git-describe shape) are exempted inside CheckMinCLIVersion
 	// so `make daemon` works without weakening staging or production.
 	if status, payload := h.checkQuickCreateDaemonVersion(r.Context(), agent.RuntimeID); status != 0 {
@@ -1802,6 +1804,11 @@ func (h *Handler) QuickCreateIssue(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	attachmentIDs, ok := parseUUIDSliceOrBadRequest(w, req.AttachmentIDs, "attachment_ids")
+	if !ok {
+		return
+	}
+
 	// Optional project_id — validate it belongs to the same workspace before
 	// pinning the task to it. The handler is the trust boundary; the frontend
 	// already only shows projects from the active workspace, but we re-check
@@ -1843,7 +1850,7 @@ func (h *Handler) QuickCreateIssue(w http.ResponseWriter, r *http.Request) {
 		parentIssueUUID = pid
 	}
 
-	task, err := h.TaskService.EnqueueQuickCreateTask(r.Context(), wsUUID, requesterUUID, agentUUID, squadUUID, prompt, projectUUID, parentIssueUUID)
+	task, err := h.TaskService.EnqueueQuickCreateTask(r.Context(), wsUUID, requesterUUID, agentUUID, squadUUID, prompt, projectUUID, parentIssueUUID, attachmentIDs)
 	if err != nil {
 		slog.Warn("quick-create enqueue failed", append(logger.RequestAttrs(r), "error", err)...)
 		writeError(w, http.StatusInternalServerError, "failed to enqueue quick-create task")
@@ -1887,7 +1894,7 @@ func (h *Handler) isRuntimeOnline(ctx context.Context, runtimeID pgtype.UUID) bo
 //	422 {
 //	  "code": "daemon_version_unsupported",
 //	  "current_version": "0.2.18" | "",
-//	  "min_version":     "0.2.20",
+//	  "min_version":     "0.2.21",
 //	  "runtime_id":      "<uuid>"
 //	}
 func (h *Handler) checkQuickCreateDaemonVersion(ctx context.Context, runtimeID pgtype.UUID) (int, map[string]any) {
diff --git a/server/internal/handler/quick_create_parent_test.go b/server/internal/handler/quick_create_parent_test.go
index 41a09ac74a..07a3fe6af8 100644
--- a/server/internal/handler/quick_create_parent_test.go
+++ b/server/internal/handler/quick_create_parent_test.go
@@ -125,11 +125,13 @@ func TestQuickCreateIssueParentTrustBoundary(t *testing.T) {
 	}
 
 	t.Run("same workspace parent enqueues with context", func(t *testing.T) {
+		attachmentID := "019ec09d-6222-722b-bdfa-427b105d80be"
 		w := httptest.NewRecorder()
 		req := newRequest("POST", "/api/issues/quick-create", map[string]any{
 			"agent_id":        agentID,
 			"prompt":          "Create a follow-up issue for the local parent",
 			"parent_issue_id": localParentID,
+			"attachment_ids":  []string{attachmentID},
 		})
 		testHandler.QuickCreateIssue(w, req)
 		if w.Code != http.StatusAccepted {
@@ -162,6 +164,9 @@ func TestQuickCreateIssueParentTrustBoundary(t *testing.T) {
 		if qc.ParentIssueID != localParentID {
 			t.Fatalf("expected parent_issue_id=%q in context, got %q", localParentID, qc.ParentIssueID)
 		}
+		if len(qc.AttachmentIDs) != 1 || qc.AttachmentIDs[0] != attachmentID {
+			t.Fatalf("expected attachment_ids=[%q] in context, got %#v", attachmentID, qc.AttachmentIDs)
+		}
 	})
 
 	t.Run("foreign workspace parent is rejected", func(t *testing.T) {
@@ -199,4 +204,21 @@ func TestQuickCreateIssueParentTrustBoundary(t *testing.T) {
 			t.Fatalf("bogus parent must not enqueue a task: expected %d quick-create tasks, got %d", before, got)
 		}
 	})
+
+	t.Run("bogus uuid attachment id is rejected", func(t *testing.T) {
+		before := countQuickCreateTasks(t)
+		w := httptest.NewRecorder()
+		req := newRequest("POST", "/api/issues/quick-create", map[string]any{
+			"agent_id":       agentID,
+			"prompt":         "Try a malformed attachment UUID",
+			"attachment_ids": []string{"not-a-uuid"},
+		})
+		testHandler.QuickCreateIssue(w, req)
+		if w.Code != http.StatusBadRequest {
+			t.Fatalf("expected 400 for bogus attachment id, got %d: %s", w.Code, w.Body.String())
+		}
+		if got := countQuickCreateTasks(t); got != before {
+			t.Fatalf("bogus attachment id must not enqueue a task: expected %d quick-create tasks, got %d", before, got)
+		}
+	})
 }
diff --git a/server/internal/handler/runtime_local_skills.go b/server/internal/handler/runtime_local_skills.go
index ef7357d5a0..6aa6bc7279 100644
--- a/server/internal/handler/runtime_local_skills.go
+++ b/server/internal/handler/runtime_local_skills.go
@@ -3,6 +3,7 @@ package handler
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"log/slog"
 	"net/http"
 	"sort"
@@ -11,6 +12,8 @@ import (
 	"time"
 
 	"github.com/go-chi/chi/v5"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/multica-ai/multica/server/internal/util"
 	db "github.com/multica-ai/multica/server/pkg/db/generated"
 	"github.com/multica-ai/multica/server/pkg/protocol"
@@ -24,8 +27,35 @@ const (
 	RuntimeLocalSkillCompleted RuntimeLocalSkillRequestStatus = "completed"
 	RuntimeLocalSkillFailed    RuntimeLocalSkillRequestStatus = "failed"
 	RuntimeLocalSkillTimeout   RuntimeLocalSkillRequestStatus = "timeout"
+	// RuntimeLocalSkillConflict is a terminal state set when a fresh import
+	// hits an existing same-name skill. It is not an error: the request carries
+	// structured Conflict metadata so the caller (Desktop UI / CLI) can offer
+	// overwrite / rename / skip instead of silently failing. See MUL-2800.
+	RuntimeLocalSkillConflict RuntimeLocalSkillRequestStatus = "conflict"
 )
 
+// LocalSkillImportAction selects how a runtime-local-skill import resolves when
+// a skill with the same name already exists in the workspace.
+type LocalSkillImportAction string
+
+const (
+	// LocalSkillImportActionCreate is the default: create a new skill, and
+	// surface a structured `conflict` if the name is already taken.
+	LocalSkillImportActionCreate LocalSkillImportAction = ""
+	// LocalSkillImportActionOverwrite re-imports onto an existing skill,
+	// identified by TargetSkillID. Only the skill's creator may overwrite.
+	LocalSkillImportActionOverwrite LocalSkillImportAction = "overwrite"
+)
+
+// LocalSkillImportConflict is the structured result attached to a request that
+// terminated in RuntimeLocalSkillConflict. CanOverwrite reflects the
+// creator-only re-import policy (canOverwriteSkillByLocalImport).
+type LocalSkillImportConflict struct {
+	ExistingSkillID   string `json:"existing_skill_id"`
+	ExistingCreatedBy string `json:"existing_created_by,omitempty"`
+	CanOverwrite      bool   `json:"can_overwrite"`
+}
+
 const (
 	// runtimeLocalSkillPendingTimeout bounds how long a request can sit in
 	// pending before the server marks it timed out. The value must accommodate
@@ -62,11 +92,28 @@ type LocalSkillListStore interface {
 	Fail(ctx context.Context, id string, errMsg string) error
 }
 
+// LocalSkillImportRequestInput carries the fields needed to enqueue a
+// runtime-local-skill import. SupportsConflict gates the structured-conflict
+// contract: only clients that opt in receive the `conflict` terminal status;
+// older clients keep the legacy `failed` ("a skill with this name already
+// exists") behavior so an already-installed Desktop build doesn't regress when
+// it talks to an upgraded backend. See MUL-2800.
+type LocalSkillImportRequestInput struct {
+	RuntimeID        string
+	CreatorID        string
+	SkillKey         string
+	Name             *string
+	Description      *string
+	Action           LocalSkillImportAction
+	TargetSkillID    string
+	SupportsConflict bool
+}
+
 // LocalSkillImportStore is the same contract as LocalSkillListStore but for
 // runtime-local-skill import requests. Kept as a separate interface because the
 // Create signature carries import-specific fields (skill_key, optional rename).
 type LocalSkillImportStore interface {
-	Create(ctx context.Context, runtimeID, creatorID, skillKey string, name, description *string) (*RuntimeLocalSkillImportRequest, error)
+	Create(ctx context.Context, input LocalSkillImportRequestInput) (*RuntimeLocalSkillImportRequest, error)
 	Get(ctx context.Context, id string) (*RuntimeLocalSkillImportRequest, error)
 	HasPending(ctx context.Context, runtimeID string) (bool, error)
 	PopPending(ctx context.Context, runtimeID string) (*RuntimeLocalSkillImportRequest, error)
@@ -75,6 +122,9 @@ type LocalSkillImportStore interface {
 	// multiple imports per heartbeat cycle.
 	PopPendingBatch(ctx context.Context, runtimeID string, limit int) ([]*RuntimeLocalSkillImportRequest, error)
 	Complete(ctx context.Context, id string, skill SkillResponse) error
+	// Conflict transitions a request to the terminal RuntimeLocalSkillConflict
+	// state, attaching structured conflict metadata for the caller to act on.
+	Conflict(ctx context.Context, id string, info LocalSkillImportConflict) error
 	Fail(ctx context.Context, id string, errMsg string) error
 }
 
@@ -143,18 +193,25 @@ type RuntimeLocalSkillListRequest struct {
 }
 
 type RuntimeLocalSkillImportRequest struct {
-	ID           string                         `json:"id"`
-	RuntimeID    string                         `json:"runtime_id"`
-	SkillKey     string                         `json:"skill_key"`
-	Name         *string                        `json:"name,omitempty"`
-	Description  *string                        `json:"description,omitempty"`
-	Status       RuntimeLocalSkillRequestStatus `json:"status"`
-	Skill        *SkillResponse                 `json:"skill,omitempty"`
-	Error        string                         `json:"error,omitempty"`
-	CreatedAt    time.Time                      `json:"created_at"`
-	UpdatedAt    time.Time                      `json:"updated_at"`
-	CreatorID    string                         `json:"-"`
-	RunStartedAt *time.Time                     `json:"-"`
+	ID            string                 `json:"id"`
+	RuntimeID     string                 `json:"runtime_id"`
+	SkillKey      string                 `json:"skill_key"`
+	Name          *string                `json:"name,omitempty"`
+	Description   *string                `json:"description,omitempty"`
+	Action        LocalSkillImportAction `json:"action,omitempty"`
+	TargetSkillID string                 `json:"target_skill_id,omitempty"`
+	// SupportsConflict records whether the initiating client opted into the
+	// structured-conflict contract; consulted at report time to decide between
+	// the new `conflict` status and the legacy `failed` behavior.
+	SupportsConflict bool                           `json:"supports_conflict,omitempty"`
+	Status           RuntimeLocalSkillRequestStatus `json:"status"`
+	Skill            *SkillResponse                 `json:"skill,omitempty"`
+	Conflict         *LocalSkillImportConflict      `json:"conflict,omitempty"`
+	Error            string                         `json:"error,omitempty"`
+	CreatedAt        time.Time                      `json:"created_at"`
+	UpdatedAt        time.Time                      `json:"updated_at"`
+	CreatorID        string                         `json:"-"`
+	RunStartedAt     *time.Time                     `json:"-"`
 }
 
 // InMemoryLocalSkillListStore is the single-node implementation — good enough
@@ -277,7 +334,7 @@ func NewInMemoryLocalSkillImportStore() *InMemoryLocalSkillImportStore {
 	return &InMemoryLocalSkillImportStore{requests: make(map[string]*RuntimeLocalSkillImportRequest)}
 }
 
-func (s *InMemoryLocalSkillImportStore) Create(_ context.Context, runtimeID, creatorID, skillKey string, name, description *string) (*RuntimeLocalSkillImportRequest, error) {
+func (s *InMemoryLocalSkillImportStore) Create(_ context.Context, input LocalSkillImportRequestInput) (*RuntimeLocalSkillImportRequest, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
@@ -288,15 +345,18 @@ func (s *InMemoryLocalSkillImportStore) Create(_ context.Context, runtimeID, cre
 	}
 
 	req := &RuntimeLocalSkillImportRequest{
-		ID:          randomID(),
-		RuntimeID:   runtimeID,
-		SkillKey:    skillKey,
-		Name:        name,
-		Description: description,
-		Status:      RuntimeLocalSkillPending,
-		CreatedAt:   time.Now(),
-		UpdatedAt:   time.Now(),
-		CreatorID:   creatorID,
+		ID:               randomID(),
+		RuntimeID:        input.RuntimeID,
+		SkillKey:         input.SkillKey,
+		Name:             input.Name,
+		Description:      input.Description,
+		Action:           input.Action,
+		TargetSkillID:    input.TargetSkillID,
+		SupportsConflict: input.SupportsConflict,
+		Status:           RuntimeLocalSkillPending,
+		CreatedAt:        time.Now(),
+		UpdatedAt:        time.Now(),
+		CreatorID:        input.CreatorID,
 	}
 	s.requests[req.ID] = req
 	return req, nil
@@ -396,6 +456,19 @@ func (s *InMemoryLocalSkillImportStore) Complete(_ context.Context, id string, s
 	return nil
 }
 
+func (s *InMemoryLocalSkillImportStore) Conflict(_ context.Context, id string, info LocalSkillImportConflict) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if req, ok := s.requests[id]; ok {
+		req.Status = RuntimeLocalSkillConflict
+		conflict := info
+		req.Conflict = &conflict
+		req.UpdatedAt = time.Now()
+	}
+	return nil
+}
+
 func (s *InMemoryLocalSkillImportStore) Fail(_ context.Context, id string, errMsg string) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -412,6 +485,14 @@ type CreateRuntimeLocalSkillImportRequest struct {
 	SkillKey    string  `json:"skill_key"`
 	Name        *string `json:"name,omitempty"`
 	Description *string `json:"description,omitempty"`
+	// Action selects create (default) vs overwrite. When overwrite,
+	// TargetSkillID must reference the existing same-name skill.
+	Action        LocalSkillImportAction `json:"action,omitempty"`
+	TargetSkillID string                 `json:"target_skill_id,omitempty"`
+	// SupportsConflict opts the client into the structured-conflict contract.
+	// Omit it (older clients) to keep the legacy `failed` behavior on a
+	// same-name collision. An overwrite request implies the new contract.
+	SupportsConflict bool `json:"supports_conflict,omitempty"`
 }
 
 type reportedRuntimeLocalSkill struct {
@@ -435,7 +516,8 @@ func cleanOptionalString(value *string) *string {
 }
 
 func runtimeLocalSkillRequestTerminal(status RuntimeLocalSkillRequestStatus) bool {
-	return status == RuntimeLocalSkillCompleted || status == RuntimeLocalSkillFailed || status == RuntimeLocalSkillTimeout
+	return status == RuntimeLocalSkillCompleted || status == RuntimeLocalSkillFailed ||
+		status == RuntimeLocalSkillTimeout || status == RuntimeLocalSkillConflict
 }
 
 func (h *Handler) requireRuntimeLocalSkillAccess(w http.ResponseWriter, r *http.Request, runtimeID string) (runtimeIDAndWorkspace, bool) {
@@ -542,14 +624,36 @@ func (h *Handler) InitiateImportLocalSkill(w http.ResponseWriter, r *http.Reques
 		return
 	}
 
-	importReq, err := h.LocalSkillImportStore.Create(
-		r.Context(),
-		rt.runtimeID,
-		creatorID,
-		strings.TrimSpace(req.SkillKey),
-		cleanOptionalString(req.Name),
-		cleanOptionalString(req.Description),
-	)
+	targetSkillID := ""
+	switch req.Action {
+	case LocalSkillImportActionCreate:
+		// nothing extra
+	case LocalSkillImportActionOverwrite:
+		// Existence + creator permission are re-verified authoritatively at
+		// report time (the skill may change between confirm and write); here we
+		// only require a well-formed target so we never enqueue a doomed write.
+		uuid, ok := parseUUIDOrBadRequest(w, strings.TrimSpace(req.TargetSkillID), "target_skill_id")
+		if !ok {
+			return
+		}
+		targetSkillID = uuidToString(uuid)
+	default:
+		writeError(w, http.StatusBadRequest, "invalid action")
+		return
+	}
+
+	importReq, err := h.LocalSkillImportStore.Create(r.Context(), LocalSkillImportRequestInput{
+		RuntimeID:     rt.runtimeID,
+		CreatorID:     creatorID,
+		SkillKey:      strings.TrimSpace(req.SkillKey),
+		Name:          cleanOptionalString(req.Name),
+		Description:   cleanOptionalString(req.Description),
+		Action:        req.Action,
+		TargetSkillID: targetSkillID,
+		// An overwrite request is inherently a new-client action, so it implies
+		// the structured-conflict contract even if the flag is omitted.
+		SupportsConflict: req.SupportsConflict || req.Action == LocalSkillImportActionOverwrite,
+	})
 	if err != nil {
 		writeError(w, http.StatusInternalServerError, "failed to enqueue local skill import: "+err.Error())
 		return
@@ -671,21 +775,11 @@ func (h *Handler) ReportLocalSkillImportResult(w http.ResponseWriter, r *http.Re
 	}
 
 	if body.Status != "completed" {
-		if err := h.LocalSkillImportStore.Fail(r.Context(), requestID, body.Error); err != nil {
-			slog.Error("local skill import Fail failed", "error", err, "request_id", requestID)
-			writeError(w, http.StatusInternalServerError, "failed to persist failure")
-			return
-		}
-		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+		h.failLocalSkillImport(w, r, requestID, body.Error)
 		return
 	}
 	if body.Skill == nil {
-		if err := h.LocalSkillImportStore.Fail(r.Context(), requestID, "daemon returned an empty skill bundle"); err != nil {
-			slog.Error("local skill import Fail failed", "error", err, "request_id", requestID)
-			writeError(w, http.StatusInternalServerError, "failed to persist failure")
-			return
-		}
-		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+		h.failLocalSkillImport(w, r, requestID, "daemon returned an empty skill bundle")
 		return
 	}
 	creatorUUID, err := util.ParseUUID(req.CreatorID)
@@ -715,33 +809,103 @@ func (h *Handler) ReportLocalSkillImportResult(w http.ResponseWriter, r *http.Re
 		files = append(files, f)
 	}
 
+	config := map[string]any{
+		"origin": map[string]any{
+			"type":        "runtime_local",
+			"runtime_id":  runtimeID,
+			"provider":    body.Skill.Provider,
+			"source_path": body.Skill.SourcePath,
+		},
+	}
+
+	// Overwrite path: re-import onto an existing skill. Existence and creator
+	// permission are re-verified inside overwriteSkillWithFiles, in the same tx
+	// as the write, so a target deleted (or a creator change) between the user's
+	// confirm and this report fails cleanly without falling back to create.
+	if req.Action == LocalSkillImportActionOverwrite {
+		targetUUID, perr := util.ParseUUID(req.TargetSkillID)
+		if perr != nil {
+			failMsg := "stored target_skill_id is invalid"
+			if ferr := h.LocalSkillImportStore.Fail(r.Context(), requestID, failMsg); ferr != nil {
+				slog.Error("local skill import Fail failed", "error", ferr, "request_id", requestID)
+			}
+			writeError(w, http.StatusInternalServerError, failMsg)
+			return
+		}
+		resp, oerr := h.overwriteSkillWithFiles(r.Context(), skillOverwriteInput{
+			WorkspaceID:   rt.WorkspaceID,
+			TargetSkillID: targetUUID,
+			UserID:        req.CreatorID,
+			ExpectedName:  sanitizeNullBytes(name),
+			Description:   description,
+			Content:       body.Skill.Content,
+			Config:        config,
+			Files:         files,
+		})
+		if oerr != nil {
+			failMsg := oerr.Error()
+			switch {
+			case errors.Is(oerr, errSkillOverwriteNotFound):
+				failMsg = "target skill no longer exists"
+			case errors.Is(oerr, errSkillOverwriteForbidden):
+				failMsg = "you no longer have permission to overwrite this skill"
+			case errors.Is(oerr, errSkillOverwriteNameMismatch):
+				failMsg = "target skill name no longer matches the imported skill"
+			}
+			h.failLocalSkillImport(w, r, requestID, failMsg)
+			return
+		}
+		if err := h.LocalSkillImportStore.Complete(r.Context(), requestID, resp.SkillResponse); err != nil {
+			// The overwrite already committed; unlike the create path we must
+			// NOT delete the skill to "roll back" (that would destroy a
+			// pre-existing skill and its agent bindings). Surface 5xx so the
+			// daemon retries — the retry re-applies the same UPDATE idempotently.
+			slog.Error("local skill import overwrite Complete failed",
+				"error", err, "request_id", requestID, "skill_id", resp.ID)
+			writeError(w, http.StatusInternalServerError, "failed to persist import completion")
+			return
+		}
+		h.publish(protocol.EventSkillUpdated, uuidToString(rt.WorkspaceID), "member", req.CreatorID, map[string]any{"skill": resp})
+		slog.Debug("runtime local skill overwritten", "runtime_id", runtimeID, "request_id", requestID, "skill_id", resp.ID)
+		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+		return
+	}
+
+	// Create path: detect a same-name conflict before writing. For opted-in
+	// clients this is a structured terminal state (not a failure) so the caller
+	// can offer overwrite / rename / skip; older clients keep the legacy
+	// `failed` behavior (see resolveLocalSkillConflict).
+	if existing, found, lerr := h.lookupSkillByName(r.Context(), rt.WorkspaceID, sanitizeNullBytes(name)); lerr != nil {
+		h.failLocalSkillImport(w, r, requestID, "failed to check for existing skill: "+lerr.Error())
+		return
+	} else if found {
+		h.resolveLocalSkillConflict(w, r, req, existing)
+		return
+	}
+
 	resp, err := h.createSkillWithFiles(r.Context(), skillCreateInput{
 		WorkspaceID: rt.WorkspaceID,
 		CreatorID:   creatorUUID,
 		Name:        name,
 		Description: description,
 		Content:     body.Skill.Content,
-		Config: map[string]any{
-			"origin": map[string]any{
-				"type":        "runtime_local",
-				"runtime_id":  runtimeID,
-				"provider":    body.Skill.Provider,
-				"source_path": body.Skill.SourcePath,
-			},
-		},
-		Files: files,
+		Config:      config,
+		Files:       files,
 	})
 	if err != nil {
-		failMsg := err.Error()
+		// A unique-violation here means another import won the race between our
+		// lookup and the insert — surface it as a conflict, not a hard failure.
 		if isUniqueViolation(err) {
-			failMsg = "a skill with this name already exists"
-		}
-		if ferr := h.LocalSkillImportStore.Fail(r.Context(), requestID, failMsg); ferr != nil {
-			slog.Error("local skill import Fail failed", "error", ferr, "request_id", requestID)
-			writeError(w, http.StatusInternalServerError, "failed to persist failure")
+			if existing, found, lerr := h.lookupSkillByName(r.Context(), rt.WorkspaceID, sanitizeNullBytes(name)); lerr == nil && found {
+				h.resolveLocalSkillConflict(w, r, req, existing)
+				return
+			}
+			// Lost the row again (deleted between insert-fail and re-lookup):
+			// fall through to the legacy unique-violation message.
+			h.failLocalSkillImport(w, r, requestID, "a skill with this name already exists")
 			return
 		}
-		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+		h.failLocalSkillImport(w, r, requestID, err.Error())
 		return
 	}
 
@@ -766,3 +930,64 @@ func (h *Handler) ReportLocalSkillImportResult(w http.ResponseWriter, r *http.Re
 	slog.Debug("runtime local skill imported", "runtime_id", runtimeID, "request_id", requestID, "skill_id", resp.ID)
 	writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
 }
+
+// failLocalSkillImport marks the request failed and writes the standard daemon
+// response (200 ok). If the store write itself fails it returns 500 so the
+// daemon retries.
+func (h *Handler) failLocalSkillImport(w http.ResponseWriter, r *http.Request, requestID, failMsg string) {
+	if err := h.LocalSkillImportStore.Fail(r.Context(), requestID, failMsg); err != nil {
+		slog.Error("local skill import Fail failed", "error", err, "request_id", requestID)
+		writeError(w, http.StatusInternalServerError, "failed to persist failure")
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+}
+
+// resolveLocalSkillConflict terminates a same-name create import. Clients that
+// opted into the structured-conflict contract (SupportsConflict) receive the
+// `conflict` status plus metadata so they can offer overwrite / rename / skip;
+// older clients keep the legacy `failed` ("a skill with this name already
+// exists") behavior so an installed Desktop build that predates the contract
+// doesn't regress when it hits an upgraded backend.
+func (h *Handler) resolveLocalSkillConflict(w http.ResponseWriter, r *http.Request, req *RuntimeLocalSkillImportRequest, existing db.Skill) {
+	if req.SupportsConflict {
+		h.reportLocalSkillConflict(w, r, req.ID, req.CreatorID, existing)
+		return
+	}
+	h.failLocalSkillImport(w, r, req.ID, "a skill with this name already exists")
+}
+
+// reportLocalSkillConflict records a same-name conflict as the terminal
+// RuntimeLocalSkillConflict state with structured metadata the caller uses to
+// offer overwrite / rename / skip.
+func (h *Handler) reportLocalSkillConflict(w http.ResponseWriter, r *http.Request, requestID, creatorID string, existing db.Skill) {
+	info := LocalSkillImportConflict{
+		ExistingSkillID: uuidToString(existing.ID),
+		CanOverwrite:    canOverwriteSkillByLocalImport(creatorID, existing),
+	}
+	if existing.CreatedBy.Valid {
+		info.ExistingCreatedBy = uuidToString(existing.CreatedBy)
+	}
+	if err := h.LocalSkillImportStore.Conflict(r.Context(), requestID, info); err != nil {
+		slog.Error("local skill import Conflict failed", "error", err, "request_id", requestID)
+		writeError(w, http.StatusInternalServerError, "failed to persist conflict")
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+}
+
+// lookupSkillByName resolves a skill by (workspace, name). found=false with a
+// nil error means there is no such skill — i.e. no conflict.
+func (h *Handler) lookupSkillByName(ctx context.Context, workspaceID pgtype.UUID, name string) (db.Skill, bool, error) {
+	skill, err := h.Queries.GetSkillByWorkspaceAndName(ctx, db.GetSkillByWorkspaceAndNameParams{
+		WorkspaceID: workspaceID,
+		Name:        name,
+	})
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return db.Skill{}, false, nil
+		}
+		return db.Skill{}, false, err
+	}
+	return skill, true, nil
+}
diff --git a/server/internal/handler/runtime_local_skills_overwrite_test.go b/server/internal/handler/runtime_local_skills_overwrite_test.go
new file mode 100644
index 0000000000..bf467e207e
--- /dev/null
+++ b/server/internal/handler/runtime_local_skills_overwrite_test.go
@@ -0,0 +1,434 @@
+package handler
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+// createImportTargetSkill inserts a skill (owned by ownerID) plus the given
+// path->content files directly into the DB, returning its id. Used as the
+// pre-existing skill that conflict / overwrite imports collide with.
+func createImportTargetSkill(t *testing.T, name, ownerID string, files map[string]string) string {
+	t.Helper()
+
+	var skillID string
+	if err := testPool.QueryRow(context.Background(), `
+		INSERT INTO skill (workspace_id, name, description, content, config, created_by)
+		VALUES ($1, $2, 'original description', '# original', '{}'::jsonb, $3)
+		RETURNING id
+	`, testWorkspaceID, name, ownerID).Scan(&skillID); err != nil {
+		t.Fatalf("create target skill: %v", err)
+	}
+	for path, content := range files {
+		if _, err := testPool.Exec(context.Background(), `
+			INSERT INTO skill_file (skill_id, path, content) VALUES ($1, $2, $3)
+		`, skillID, path, content); err != nil {
+			t.Fatalf("create skill file: %v", err)
+		}
+	}
+	t.Cleanup(func() {
+		testPool.Exec(context.Background(), `DELETE FROM skill WHERE id = $1`, skillID)
+	})
+	return skillID
+}
+
+// bindAgentToSkill creates a workspace agent and binds it to skillID via
+// agent_skill, returning the agent id. Lets overwrite tests assert the binding
+// survives the re-import.
+func bindAgentToSkill(t *testing.T, skillID string) string {
+	t.Helper()
+
+	agentName := fmt.Sprintf("overwrite-test-agent-%d", time.Now().UnixNano())
+	var agentID string
+	if err := testPool.QueryRow(context.Background(), `
+		INSERT INTO agent (
+			workspace_id, name, description, runtime_mode, runtime_config,
+			runtime_id, visibility, max_concurrent_tasks, owner_id
+		)
+		VALUES ($1, $2, '', 'cloud', '{}'::jsonb, $3, 'workspace', 1, $4)
+		RETURNING id
+	`, testWorkspaceID, agentName, testRuntimeID, testUserID).Scan(&agentID); err != nil {
+		t.Fatalf("create agent: %v", err)
+	}
+	if _, err := testPool.Exec(context.Background(), `
+		INSERT INTO agent_skill (agent_id, skill_id) VALUES ($1, $2)
+	`, agentID, skillID); err != nil {
+		t.Fatalf("bind agent skill: %v", err)
+	}
+	t.Cleanup(func() {
+		testPool.Exec(context.Background(), `DELETE FROM agent WHERE id = $1`, agentID)
+	})
+	return agentID
+}
+
+func countAgentSkillBindings(t *testing.T, skillID string) int {
+	t.Helper()
+
+	var count int
+	if err := testPool.QueryRow(context.Background(), `
+		SELECT count(*) FROM agent_skill WHERE skill_id = $1
+	`, skillID).Scan(&count); err != nil {
+		t.Fatalf("count agent_skill: %v", err)
+	}
+	return count
+}
+
+func getSkillRow(t *testing.T, skillID string) (name, description, content, createdBy string) {
+	t.Helper()
+
+	if err := testPool.QueryRow(context.Background(), `
+		SELECT name, description, content, COALESCE(created_by::text, '')
+		FROM skill WHERE id = $1
+	`, skillID).Scan(&name, &description, &content, &createdBy); err != nil {
+		t.Fatalf("get skill row: %v", err)
+	}
+	return
+}
+
+// reportBundleBody builds the daemon "completed" report body for an import.
+func reportBundleBody(name, description, content string, files map[string]string) map[string]any {
+	fileList := make([]map[string]any, 0, len(files))
+	for p, c := range files {
+		fileList = append(fileList, map[string]any{"path": p, "content": c})
+	}
+	return map[string]any{
+		"status": "completed",
+		"skill": map[string]any{
+			"name":        name,
+			"description": description,
+			"content":     content,
+			"source_path": "~/.claude/skills/review-helper",
+			"provider":    "claude",
+			"files":       fileList,
+		},
+	}
+}
+
+func initiateLocalSkillImport(t *testing.T, runtimeID string, body map[string]any) string {
+	t.Helper()
+
+	w := httptest.NewRecorder()
+	req := withURLParams(
+		newRequestAsUser(testUserID, http.MethodPost, "/api/runtimes/"+runtimeID+"/local-skills/import", body),
+		"runtimeId", runtimeID,
+	)
+	testHandler.InitiateImportLocalSkill(w, req)
+	if w.Code != http.StatusOK {
+		t.Fatalf("InitiateImportLocalSkill: expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var importReq RuntimeLocalSkillImportRequest
+	if err := json.NewDecoder(w.Body).Decode(&importReq); err != nil {
+		t.Fatalf("decode import request: %v", err)
+	}
+	return importReq.ID
+}
+
+func reportLocalSkillImport(t *testing.T, runtimeID, requestID string, body map[string]any) {
+	t.Helper()
+
+	w := httptest.NewRecorder()
+	req := withURLParams(
+		newDaemonTokenRequest(http.MethodPost, "/api/daemon/runtimes/"+runtimeID+"/local-skills/import/"+requestID+"/result", body, testWorkspaceID, "overwrite-test-daemon"),
+		"runtimeId", runtimeID,
+		"requestId", requestID,
+	)
+	testHandler.ReportLocalSkillImportResult(w, req)
+	if w.Code != http.StatusOK {
+		t.Fatalf("ReportLocalSkillImportResult: expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+}
+
+func pollLocalSkillImport(t *testing.T, runtimeID, requestID string) RuntimeLocalSkillImportRequest {
+	t.Helper()
+
+	w := httptest.NewRecorder()
+	req := withURLParams(
+		newRequestAsUser(testUserID, http.MethodGet, "/api/runtimes/"+runtimeID+"/local-skills/import/"+requestID, nil),
+		"runtimeId", runtimeID,
+		"requestId", requestID,
+	)
+	testHandler.GetLocalSkillImportRequest(w, req)
+	if w.Code != http.StatusOK {
+		t.Fatalf("GetLocalSkillImportRequest: expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var got RuntimeLocalSkillImportRequest
+	if err := json.NewDecoder(w.Body).Decode(&got); err != nil {
+		t.Fatalf("decode poll response: %v", err)
+	}
+	return got
+}
+
+// runLocalSkillImport drives initiate -> report -> poll and returns the
+// terminal request.
+func runLocalSkillImport(t *testing.T, runtimeID string, initBody, reportBody map[string]any) RuntimeLocalSkillImportRequest {
+	t.Helper()
+	requestID := initiateLocalSkillImport(t, runtimeID, initBody)
+	reportLocalSkillImport(t, runtimeID, requestID, reportBody)
+	return pollLocalSkillImport(t, runtimeID, requestID)
+}
+
+func TestRuntimeLocalSkillImport_ConflictCreatorCanOverwrite(t *testing.T) {
+	if testHandler == nil {
+		t.Skip("database not available")
+	}
+
+	runtimeID := createRuntimeLocalSkillTestRuntime(t, testUserID)
+	name := fmt.Sprintf("conflict-creator-%d", time.Now().UnixNano())
+	existingID := createImportTargetSkill(t, name, testUserID, nil)
+
+	got := runLocalSkillImport(t, runtimeID,
+		map[string]any{"skill_key": "review-helper", "supports_conflict": true},
+		reportBundleBody(name, "incoming description", "# incoming", map[string]string{"a.md": "A"}),
+	)
+
+	if got.Status != RuntimeLocalSkillConflict {
+		t.Fatalf("status = %s, want conflict", got.Status)
+	}
+	if got.Conflict == nil {
+		t.Fatal("expected conflict metadata")
+	}
+	if got.Conflict.ExistingSkillID != existingID {
+		t.Fatalf("existing_skill_id = %q, want %q", got.Conflict.ExistingSkillID, existingID)
+	}
+	if got.Conflict.ExistingCreatedBy != testUserID {
+		t.Fatalf("existing_created_by = %q, want %q", got.Conflict.ExistingCreatedBy, testUserID)
+	}
+	if !got.Conflict.CanOverwrite {
+		t.Fatal("creator should be allowed to overwrite")
+	}
+	// A conflict must neither create a second skill nor mutate the original.
+	if n := countSkillsByName(t, name); n != 1 {
+		t.Fatalf("expected exactly 1 skill named %q, got %d", name, n)
+	}
+	if _, desc, _, _ := getSkillRow(t, existingID); desc != "original description" {
+		t.Fatalf("conflict must not modify the existing skill, description = %q", desc)
+	}
+}
+
+func TestRuntimeLocalSkillImport_ConflictNonCreatorCannotOverwrite(t *testing.T) {
+	if testHandler == nil {
+		t.Skip("database not available")
+	}
+
+	runtimeID := createRuntimeLocalSkillTestRuntime(t, testUserID)
+	otherUserID := createRuntimeLocalSkillTestMember(t, "member")
+	name := fmt.Sprintf("conflict-noncreator-%d", time.Now().UnixNano())
+	existingID := createImportTargetSkill(t, name, otherUserID, nil)
+
+	got := runLocalSkillImport(t, runtimeID,
+		map[string]any{"skill_key": "review-helper", "supports_conflict": true},
+		reportBundleBody(name, "incoming description", "# incoming", nil),
+	)
+
+	if got.Status != RuntimeLocalSkillConflict {
+		t.Fatalf("status = %s, want conflict", got.Status)
+	}
+	if got.Conflict == nil {
+		t.Fatal("expected conflict metadata")
+	}
+	if got.Conflict.ExistingSkillID != existingID {
+		t.Fatalf("existing_skill_id = %q, want %q", got.Conflict.ExistingSkillID, existingID)
+	}
+	if got.Conflict.ExistingCreatedBy != otherUserID {
+		t.Fatalf("existing_created_by = %q, want %q", got.Conflict.ExistingCreatedBy, otherUserID)
+	}
+	if got.Conflict.CanOverwrite {
+		t.Fatal("a non-creator must not be allowed to overwrite")
+	}
+}
+
+func TestRuntimeLocalSkillImport_OverwritePreservesIdentityAndBindings(t *testing.T) {
+	if testHandler == nil {
+		t.Skip("database not available")
+	}
+
+	runtimeID := createRuntimeLocalSkillTestRuntime(t, testUserID)
+	name := fmt.Sprintf("overwrite-keep-%d", time.Now().UnixNano())
+	existingID := createImportTargetSkill(t, name, testUserID, map[string]string{
+		"keep.md":  "old keep",
+		"prune.md": "should be removed",
+	})
+	bindAgentToSkill(t, existingID)
+
+	got := runLocalSkillImport(t, runtimeID,
+		map[string]any{"skill_key": "review-helper", "action": "overwrite", "target_skill_id": existingID},
+		reportBundleBody(name, "overwritten description", "# overwritten", map[string]string{"keep.md": "new keep"}),
+	)
+
+	if got.Status != RuntimeLocalSkillCompleted {
+		t.Fatalf("status = %s, want completed (error=%q)", got.Status, got.Error)
+	}
+	if got.Skill == nil {
+		t.Fatal("expected overwritten skill in response")
+	}
+	// Same row: UUID and creator preserved.
+	if got.Skill.ID != existingID {
+		t.Fatalf("overwrite must preserve UUID: got %q, want %q", got.Skill.ID, existingID)
+	}
+	if got.Skill.CreatedBy == nil || *got.Skill.CreatedBy != testUserID {
+		t.Fatalf("created_by not preserved: %v", got.Skill.CreatedBy)
+	}
+	if got.Skill.Description != "overwritten description" {
+		t.Fatalf("description not replaced: %q", got.Skill.Description)
+	}
+	// Files fully replaced: prune.md (absent from the new bundle) is gone.
+	if n := countSkillFiles(t, existingID); n != 1 {
+		t.Fatalf("expected 1 file after overwrite, got %d", n)
+	}
+	// Agent binding preserved — the agent must NOT need to re-add the skill.
+	if n := countAgentSkillBindings(t, existingID); n != 1 {
+		t.Fatalf("expected agent binding to survive overwrite, got %d", n)
+	}
+}
+
+func TestRuntimeLocalSkillImport_OverwriteNonCreatorFails(t *testing.T) {
+	if testHandler == nil {
+		t.Skip("database not available")
+	}
+
+	runtimeID := createRuntimeLocalSkillTestRuntime(t, testUserID)
+	otherUserID := createRuntimeLocalSkillTestMember(t, "member")
+	name := fmt.Sprintf("overwrite-forbidden-%d", time.Now().UnixNano())
+	existingID := createImportTargetSkill(t, name, otherUserID, nil)
+
+	got := runLocalSkillImport(t, runtimeID,
+		map[string]any{"skill_key": "review-helper", "action": "overwrite", "target_skill_id": existingID},
+		reportBundleBody(name, "incoming description", "# incoming", nil),
+	)
+
+	if got.Status != RuntimeLocalSkillFailed {
+		t.Fatalf("status = %s, want failed", got.Status)
+	}
+	// Original skill (owned by someone else) must be untouched.
+	if _, desc, _, _ := getSkillRow(t, existingID); desc != "original description" {
+		t.Fatalf("forbidden overwrite must not mutate the skill, description = %q", desc)
+	}
+}
+
+func TestRuntimeLocalSkillImport_OverwriteTargetDeletedFails(t *testing.T) {
+	if testHandler == nil {
+		t.Skip("database not available")
+	}
+
+	runtimeID := createRuntimeLocalSkillTestRuntime(t, testUserID)
+	name := fmt.Sprintf("overwrite-deleted-%d", time.Now().UnixNano())
+	deletedID := createImportTargetSkill(t, name, testUserID, nil)
+	// Simulate the target being deleted between the user's confirm and the
+	// daemon report.
+	if _, err := testPool.Exec(context.Background(), `DELETE FROM skill WHERE id = $1`, deletedID); err != nil {
+		t.Fatalf("delete target skill: %v", err)
+	}
+
+	got := runLocalSkillImport(t, runtimeID,
+		map[string]any{"skill_key": "review-helper", "action": "overwrite", "target_skill_id": deletedID},
+		reportBundleBody(name, "incoming description", "# incoming", map[string]string{"a.md": "A"}),
+	)
+
+	if got.Status != RuntimeLocalSkillFailed {
+		t.Fatalf("status = %s, want failed", got.Status)
+	}
+	// Must NOT fall back to creating a new skill by name.
+	if n := countSkillsByName(t, name); n != 0 {
+		t.Fatalf("deleted-target overwrite must not create a skill, got %d", n)
+	}
+}
+
+func TestRuntimeLocalSkillImport_OverwriteRetryIsIdempotent(t *testing.T) {
+	if testHandler == nil {
+		t.Skip("database not available")
+	}
+
+	runtimeID := createRuntimeLocalSkillTestRuntime(t, testUserID)
+	name := fmt.Sprintf("overwrite-idempotent-%d", time.Now().UnixNano())
+	existingID := createImportTargetSkill(t, name, testUserID, map[string]string{"old.md": "old"})
+
+	requestID := initiateLocalSkillImport(t, runtimeID, map[string]any{
+		"skill_key":       "review-helper",
+		"action":          "overwrite",
+		"target_skill_id": existingID,
+	})
+
+	// First report wins and overwrites the skill.
+	reportLocalSkillImport(t, runtimeID, requestID,
+		reportBundleBody(name, "first overwrite", "# first", map[string]string{"first.md": "1"}))
+
+	// A retry of the SAME request id with a different bundle must be ignored
+	// (the request is already terminal) — no second write.
+	reportLocalSkillImport(t, runtimeID, requestID,
+		reportBundleBody(name, "second overwrite", "# second", map[string]string{"second.md": "2", "extra.md": "3"}))
+
+	got := pollLocalSkillImport(t, runtimeID, requestID)
+	if got.Status != RuntimeLocalSkillCompleted {
+		t.Fatalf("status = %s, want completed", got.Status)
+	}
+	if _, desc, _, _ := getSkillRow(t, existingID); desc != "first overwrite" {
+		t.Fatalf("retry must not re-apply, description = %q", desc)
+	}
+	if n := countSkillFiles(t, existingID); n != 1 {
+		t.Fatalf("retry must not re-write files, got %d files", n)
+	}
+}
+
+// TestRuntimeLocalSkillImport_LegacyClientGetsFailedOnConflict verifies the
+// installed-app compatibility gate: a client that does NOT opt into the
+// structured-conflict contract keeps the legacy `failed` + "already exists"
+// behavior on a same-name collision, instead of the new `conflict` status its
+// older poll loop wouldn't understand.
+func TestRuntimeLocalSkillImport_LegacyClientGetsFailedOnConflict(t *testing.T) {
+	if testHandler == nil {
+		t.Skip("database not available")
+	}
+
+	runtimeID := createRuntimeLocalSkillTestRuntime(t, testUserID)
+	name := fmt.Sprintf("legacy-conflict-%d", time.Now().UnixNano())
+	createImportTargetSkill(t, name, testUserID, nil)
+
+	got := runLocalSkillImport(t, runtimeID,
+		// No supports_conflict (and no action) — an old client.
+		map[string]any{"skill_key": "review-helper"},
+		reportBundleBody(name, "incoming description", "# incoming", nil),
+	)
+
+	if got.Status != RuntimeLocalSkillFailed {
+		t.Fatalf("status = %s, want failed (legacy contract)", got.Status)
+	}
+	if got.Conflict != nil {
+		t.Fatalf("legacy client must not receive structured conflict metadata: %+v", got.Conflict)
+	}
+	if got.Error != "a skill with this name already exists" {
+		t.Fatalf("error = %q, want legacy already-exists message", got.Error)
+	}
+}
+
+// TestRuntimeLocalSkillImport_OverwriteNameMismatchFails verifies the guard
+// against a stale / wrong target_skill_id: if the target's name no longer
+// matches the imported skill, the overwrite fails instead of writing one
+// skill's content onto another.
+func TestRuntimeLocalSkillImport_OverwriteNameMismatchFails(t *testing.T) {
+	if testHandler == nil {
+		t.Skip("database not available")
+	}
+
+	runtimeID := createRuntimeLocalSkillTestRuntime(t, testUserID)
+	targetName := fmt.Sprintf("overwrite-target-%d", time.Now().UnixNano())
+	otherName := fmt.Sprintf("overwrite-other-%d", time.Now().UnixNano())
+	targetID := createImportTargetSkill(t, targetName, testUserID, nil)
+
+	// Overwrite targets targetID but the imported bundle is named otherName.
+	got := runLocalSkillImport(t, runtimeID,
+		map[string]any{"skill_key": "review-helper", "action": "overwrite", "target_skill_id": targetID},
+		reportBundleBody(otherName, "incoming description", "# incoming", map[string]string{"a.md": "A"}),
+	)
+
+	if got.Status != RuntimeLocalSkillFailed {
+		t.Fatalf("status = %s, want failed (name mismatch)", got.Status)
+	}
+	if _, desc, _, _ := getSkillRow(t, targetID); desc != "original description" {
+		t.Fatalf("name-mismatch overwrite must not mutate the target, description = %q", desc)
+	}
+}
diff --git a/server/internal/handler/runtime_local_skills_redis_store.go b/server/internal/handler/runtime_local_skills_redis_store.go
index 61657f1948..b67c4eaaf2 100644
--- a/server/internal/handler/runtime_local_skills_redis_store.go
+++ b/server/internal/handler/runtime_local_skills_redis_store.go
@@ -262,18 +262,21 @@ func NewRedisLocalSkillImportStore(rdb *redis.Client) *RedisLocalSkillImportStor
 	return &RedisLocalSkillImportStore{rdb: rdb}
 }
 
-func (s *RedisLocalSkillImportStore) Create(ctx context.Context, runtimeID, creatorID, skillKey string, name, description *string) (*RuntimeLocalSkillImportRequest, error) {
+func (s *RedisLocalSkillImportStore) Create(ctx context.Context, input LocalSkillImportRequestInput) (*RuntimeLocalSkillImportRequest, error) {
 	now := time.Now()
 	req := &RuntimeLocalSkillImportRequest{
-		ID:          randomID(),
-		RuntimeID:   runtimeID,
-		SkillKey:    skillKey,
-		Name:        name,
-		Description: description,
-		Status:      RuntimeLocalSkillPending,
-		CreatedAt:   now,
-		UpdatedAt:   now,
-		CreatorID:   creatorID,
+		ID:               randomID(),
+		RuntimeID:        input.RuntimeID,
+		SkillKey:         input.SkillKey,
+		Name:             input.Name,
+		Description:      input.Description,
+		Action:           input.Action,
+		TargetSkillID:    input.TargetSkillID,
+		SupportsConflict: input.SupportsConflict,
+		Status:           RuntimeLocalSkillPending,
+		CreatedAt:        now,
+		UpdatedAt:        now,
+		CreatorID:        input.CreatorID,
 	}
 	data, err := s.marshalImport(req)
 	if err != nil {
@@ -282,11 +285,11 @@ func (s *RedisLocalSkillImportStore) Create(ctx context.Context, runtimeID, crea
 
 	pipe := s.rdb.TxPipeline()
 	pipe.Set(ctx, localSkillImportKey(req.ID), data, runtimeLocalSkillStoreRetention)
-	pipe.ZAdd(ctx, localSkillImportPendingKey(runtimeID), redis.Z{
+	pipe.ZAdd(ctx, localSkillImportPendingKey(input.RuntimeID), redis.Z{
 		Score:  float64(now.UnixNano()),
 		Member: req.ID,
 	})
-	pipe.Expire(ctx, localSkillImportPendingKey(runtimeID), runtimeLocalSkillStoreRetention*2)
+	pipe.Expire(ctx, localSkillImportPendingKey(input.RuntimeID), runtimeLocalSkillStoreRetention*2)
 	if _, err := pipe.Exec(ctx); err != nil {
 		return nil, fmt.Errorf("persist import request: %w", err)
 	}
@@ -494,6 +497,21 @@ func (s *RedisLocalSkillImportStore) Complete(ctx context.Context, id string, sk
 	return s.persistImportRequest(ctx, req)
 }
 
+func (s *RedisLocalSkillImportStore) Conflict(ctx context.Context, id string, info LocalSkillImportConflict) error {
+	req, err := s.loadImportRequest(ctx, id)
+	if err != nil {
+		return err
+	}
+	if req == nil {
+		return nil
+	}
+	req.Status = RuntimeLocalSkillConflict
+	conflict := info
+	req.Conflict = &conflict
+	req.UpdatedAt = time.Now()
+	return s.persistImportRequest(ctx, req)
+}
+
 func (s *RedisLocalSkillImportStore) Fail(ctx context.Context, id string, errMsg string) error {
 	req, err := s.loadImportRequest(ctx, id)
 	if err != nil {
diff --git a/server/internal/handler/runtime_local_skills_redis_store_test.go b/server/internal/handler/runtime_local_skills_redis_store_test.go
index 4c782c9698..2faaea1306 100644
--- a/server/internal/handler/runtime_local_skills_redis_store_test.go
+++ b/server/internal/handler/runtime_local_skills_redis_store_test.go
@@ -225,7 +225,15 @@ func TestRedisLocalSkillImportStore_PreservesCreatorID(t *testing.T) {
 
 	name := "Review Helper"
 	desc := "Desc"
-	req, err := store.Create(ctx, "runtime-1", "user-42", "review-helper", &name, &desc)
+	req, err := store.Create(ctx, LocalSkillImportRequestInput{
+		RuntimeID:     "runtime-1",
+		CreatorID:     "user-42",
+		SkillKey:      "review-helper",
+		Name:          &name,
+		Description:   &desc,
+		Action:        LocalSkillImportActionOverwrite,
+		TargetSkillID: "target-skill-99",
+	})
 	if err != nil {
 		t.Fatalf("create: %v", err)
 	}
@@ -249,6 +257,47 @@ func TestRedisLocalSkillImportStore_PreservesCreatorID(t *testing.T) {
 	if got.Description == nil || *got.Description != desc {
 		t.Fatalf("description lost: %v", got.Description)
 	}
+	// The overwrite intent must survive the round trip — it is consumed at
+	// report time, not delivered to the daemon.
+	if got.Action != LocalSkillImportActionOverwrite {
+		t.Fatalf("action lost round trip: %q", got.Action)
+	}
+	if got.TargetSkillID != "target-skill-99" {
+		t.Fatalf("target_skill_id lost round trip: %q", got.TargetSkillID)
+	}
+}
+
+func TestRedisLocalSkillImportStore_PreservesConflict(t *testing.T) {
+	rdb := newRedisTestClient(t)
+	ctx := context.Background()
+	store := NewRedisLocalSkillImportStore(rdb)
+
+	req, err := store.Create(ctx, LocalSkillImportRequestInput{
+		RuntimeID: "runtime-1",
+		CreatorID: "user-1",
+		SkillKey:  "review-helper",
+	})
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+	info := LocalSkillImportConflict{ExistingSkillID: "skill-7", ExistingCreatedBy: "user-2", CanOverwrite: false}
+	if err := store.Conflict(ctx, req.ID, info); err != nil {
+		t.Fatalf("conflict: %v", err)
+	}
+
+	got, err := store.Get(ctx, req.ID)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Status != RuntimeLocalSkillConflict {
+		t.Fatalf("status = %s, want conflict", got.Status)
+	}
+	if got.Conflict == nil {
+		t.Fatalf("conflict metadata lost round trip")
+	}
+	if got.Conflict.ExistingSkillID != "skill-7" || got.Conflict.ExistingCreatedBy != "user-2" || got.Conflict.CanOverwrite {
+		t.Fatalf("conflict metadata corrupted: %+v", got.Conflict)
+	}
 }
 
 func TestRedisLocalSkillImportStore_PopPendingAcrossInstances(t *testing.T) {
@@ -258,7 +307,11 @@ func TestRedisLocalSkillImportStore_PopPendingAcrossInstances(t *testing.T) {
 	nodeA := NewRedisLocalSkillImportStore(rdb)
 	nodeB := NewRedisLocalSkillImportStore(rdb)
 
-	req, err := nodeA.Create(ctx, "runtime-import", "user-1", "review-helper", nil, nil)
+	req, err := nodeA.Create(ctx, LocalSkillImportRequestInput{
+		RuntimeID: "runtime-import",
+		CreatorID: "user-1",
+		SkillKey:  "review-helper",
+	})
 	if err != nil {
 		t.Fatalf("create: %v", err)
 	}
@@ -365,7 +418,11 @@ func TestRedisLocalSkillImportStore_PopPendingBatch(t *testing.T) {
 	// Create 5 pending imports.
 	ids := make([]string, 5)
 	for i := range ids {
-		req, err := store.Create(ctx, "runtime-batch", "user-1", fmt.Sprintf("skill-%d", i), nil, nil)
+		req, err := store.Create(ctx, LocalSkillImportRequestInput{
+			RuntimeID: "runtime-batch",
+			CreatorID: "user-1",
+			SkillKey:  fmt.Sprintf("skill-%d", i),
+		})
 		if err != nil {
 			t.Fatalf("create %d: %v", i, err)
 		}
diff --git a/server/internal/handler/runtime_local_skills_test.go b/server/internal/handler/runtime_local_skills_test.go
index cd13cce70f..d92afe6342 100644
--- a/server/internal/handler/runtime_local_skills_test.go
+++ b/server/internal/handler/runtime_local_skills_test.go
@@ -187,7 +187,11 @@ func TestInMemoryLocalSkillListStore_TimesOutRunningRequests(t *testing.T) {
 func TestInMemoryLocalSkillImportStore_TimesOutRunningRequests(t *testing.T) {
 	ctx := context.Background()
 	store := NewInMemoryLocalSkillImportStore()
-	req, err := store.Create(ctx, "runtime-xyz", "user-1", "review-helper", nil, nil)
+	req, err := store.Create(ctx, LocalSkillImportRequestInput{
+		RuntimeID: "runtime-xyz",
+		CreatorID: "user-1",
+		SkillKey:  "review-helper",
+	})
 	if err != nil {
 		t.Fatalf("create: %v", err)
 	}
@@ -237,7 +241,11 @@ func TestGetLocalSkillImportRequest_RequiresRuntimeOwner(t *testing.T) {
 
 	runtimeID := createRuntimeLocalSkillTestRuntime(t, testUserID)
 	adminUserID := createRuntimeLocalSkillTestMember(t, "admin")
-	importReq, err := testHandler.LocalSkillImportStore.Create(context.Background(), runtimeID, testUserID, "review-helper", nil, nil)
+	importReq, err := testHandler.LocalSkillImportStore.Create(context.Background(), LocalSkillImportRequestInput{
+		RuntimeID: runtimeID,
+		CreatorID: testUserID,
+		SkillKey:  "review-helper",
+	})
 	if err != nil {
 		t.Fatalf("create import request: %v", err)
 	}
@@ -477,14 +485,13 @@ func TestReportLocalSkillImportResult_IgnoresTimedOutRequests(t *testing.T) {
 
 	runtimeID := createRuntimeLocalSkillTestRuntime(t, testUserID)
 	ctx := context.Background()
-	importReq, err := testHandler.LocalSkillImportStore.Create(
-		ctx,
-		runtimeID,
-		testUserID,
-		"review-helper",
-		cleanOptionalString(ptr("Timed Out Import")),
-		cleanOptionalString(ptr("Should not be created")),
-	)
+	importReq, err := testHandler.LocalSkillImportStore.Create(ctx, LocalSkillImportRequestInput{
+		RuntimeID:   runtimeID,
+		CreatorID:   testUserID,
+		SkillKey:    "review-helper",
+		Name:        cleanOptionalString(ptr("Timed Out Import")),
+		Description: cleanOptionalString(ptr("Should not be created")),
+	})
 	if err != nil {
 		t.Fatalf("create import request: %v", err)
 	}
@@ -534,7 +541,11 @@ func TestReportLocalSkillImportResult_RejectsCrossWorkspaceDaemonToken(t *testin
 	}
 
 	runtimeID := createRuntimeLocalSkillTestRuntime(t, testUserID)
-	importReq, err := testHandler.LocalSkillImportStore.Create(context.Background(), runtimeID, testUserID, "review-helper", nil, nil)
+	importReq, err := testHandler.LocalSkillImportStore.Create(context.Background(), LocalSkillImportRequestInput{
+		RuntimeID: runtimeID,
+		CreatorID: testUserID,
+		SkillKey:  "review-helper",
+	})
 	if err != nil {
 		t.Fatalf("create import request: %v", err)
 	}
diff --git a/server/internal/handler/skill.go b/server/internal/handler/skill.go
index ecf5efa2ef..cd045426dd 100644
--- a/server/internal/handler/skill.go
+++ b/server/internal/handler/skill.go
@@ -101,9 +101,18 @@ type SkillWithFilesResponse struct {
 	Files []SkillFileResponse `json:"files"`
 }
 
+type SkillImportResult struct {
+	Status        string                  `json:"status"`
+	Reason        string                  `json:"reason,omitempty"`
+	Skill         *SkillWithFilesResponse `json:"skill,omitempty"`
+	ExistingSkill *ExistingSkillIdentity  `json:"existing_skill,omitempty"`
+}
+
 type ExistingSkillIdentity struct {
-	ID   string `json:"id"`
-	Name string `json:"name"`
+	ID           string `json:"id"`
+	Name         string `json:"name"`
+	CreatedBy    string `json:"created_by,omitempty"`
+	CanOverwrite bool   `json:"can_overwrite,omitempty"`
 }
 
 func writeSkillImportDuplicateConflict(w http.ResponseWriter, existing ExistingSkillIdentity) {
@@ -138,7 +147,19 @@ func (h *Handler) existingSkillIdentityByName(ctx context.Context, workspaceID p
 		}
 		return ExistingSkillIdentity{}, false, err
 	}
-	return ExistingSkillIdentity{ID: uuidToString(skill.ID), Name: skill.Name}, true, nil
+	return existingSkillIdentity(skill, ""), true, nil
+}
+
+func existingSkillIdentity(skill db.Skill, userID string) ExistingSkillIdentity {
+	identity := ExistingSkillIdentity{
+		ID:           uuidToString(skill.ID),
+		Name:         skill.Name,
+		CanOverwrite: canOverwriteSkillByLocalImport(userID, skill),
+	}
+	if skill.CreatedBy.Valid {
+		identity.CreatedBy = uuidToString(skill.CreatedBy)
+	}
+	return identity
 }
 
 // decodeSkillConfig decodes a JSONB skill.config blob, defaulting to {} when
@@ -390,6 +411,15 @@ func (h *Handler) canManageSkill(w http.ResponseWriter, r *http.Request, skill d
 	return true
 }
 
+// canOverwriteSkillByLocalImport reports whether userID may overwrite skill via
+// a runtime-local-skill re-import. This is intentionally NARROWER than
+// canManageSkill: only the original creator may overwrite by re-importing.
+// Workspace owners/admins who want to change a skill they did not create must
+// edit it in-app instead. See MUL-2701 / MUL-2800.
+func canOverwriteSkillByLocalImport(userID string, skill db.Skill) bool {
+	return skill.CreatedBy.Valid && uuidToString(skill.CreatedBy) == userID
+}
+
 func (h *Handler) UpdateSkill(w http.ResponseWriter, r *http.Request) {
 	id := chi.URLParam(r, "id")
 	skill, ok := h.loadSkillForUser(w, r, id)
@@ -521,7 +551,25 @@ func (h *Handler) DeleteSkill(w http.ResponseWriter, r *http.Request) {
 // --- Skill import ---
 
 type ImportSkillRequest struct {
-	URL string `json:"url"`
+	URL        string `json:"url"`
+	OnConflict string `json:"on_conflict,omitempty"`
+}
+
+const (
+	importOnConflictFail      = "fail"
+	importOnConflictOverwrite = "overwrite"
+	importOnConflictRename    = "rename"
+	importOnConflictSkip      = "skip"
+)
+
+const maxImportRenameAttempts = 50
+
+func validImportOnConflict(strategy string) bool {
+	switch strategy {
+	case "", importOnConflictFail, importOnConflictOverwrite, importOnConflictRename, importOnConflictSkip:
+		return true
+	}
+	return false
 }
 
 // Per-import bundle limits. These mirror the local-runtime importer so that
@@ -1719,6 +1767,116 @@ func skillMdNotFoundError(owner, repo, skillName string) error {
 	return fmt.Errorf("SKILL.md not found in repository %s/%s for skill %s", owner, repo, skillName)
 }
 
+func skillImportConflictReason() string {
+	return "a skill with this name already exists; use --on-conflict overwrite to replace it or --on-conflict rename to import a copy"
+}
+
+func (h *Handler) createImportedSkillWithName(ctx context.Context, workspaceID, creatorID pgtype.UUID, name string, imported *importedSkill, config map[string]any, files []CreateSkillFileRequest) (SkillWithFilesResponse, error) {
+	return h.createSkillWithFiles(ctx, skillCreateInput{
+		WorkspaceID: workspaceID,
+		CreatorID:   creatorID,
+		Name:        name,
+		Description: imported.description,
+		Content:     imported.content,
+		Config:      config,
+		Files:       files,
+	})
+}
+
+func (h *Handler) createRenamedImportedSkill(ctx context.Context, workspaceID, creatorID pgtype.UUID, baseName string, imported *importedSkill, config map[string]any, files []CreateSkillFileRequest) (SkillWithFilesResponse, error) {
+	for suffix := 2; suffix < maxImportRenameAttempts+2; suffix++ {
+		candidate := fmt.Sprintf("%s-%d", baseName, suffix)
+		resp, err := h.createImportedSkillWithName(ctx, workspaceID, creatorID, candidate, imported, config, files)
+		if err == nil {
+			return resp, nil
+		}
+		if !isUniqueViolation(err) {
+			return SkillWithFilesResponse{}, err
+		}
+	}
+	return SkillWithFilesResponse{}, fmt.Errorf("failed to find an available renamed skill name after %d attempts", maxImportRenameAttempts)
+}
+
+func skillImportOverwriteFailure(err error) (int, string) {
+	switch {
+	case errors.Is(err, errSkillOverwriteNotFound):
+		return http.StatusConflict, "target skill no longer exists"
+	case errors.Is(err, errSkillOverwriteForbidden):
+		return http.StatusForbidden, "only the skill creator can overwrite this skill"
+	case errors.Is(err, errSkillOverwriteNameMismatch):
+		return http.StatusConflict, "target skill name no longer matches the imported skill"
+	default:
+		return http.StatusInternalServerError, "failed to overwrite skill: " + err.Error()
+	}
+}
+
+func (h *Handler) resolveImportSkillConflict(w http.ResponseWriter, r *http.Request, strategy string, workspaceID string, workspaceUUID, creatorUUID pgtype.UUID, creatorID string, name string, imported *importedSkill, config map[string]any, files []CreateSkillFileRequest, existing db.Skill) {
+	existingInfo := existingSkillIdentity(existing, creatorID)
+	switch strategy {
+	case importOnConflictSkip:
+		writeJSON(w, http.StatusOK, SkillImportResult{
+			Status:        "skipped",
+			Reason:        "a skill with this name already exists",
+			ExistingSkill: &existingInfo,
+		})
+	case importOnConflictOverwrite:
+		if !canOverwriteSkillByLocalImport(creatorID, existing) {
+			writeJSON(w, http.StatusForbidden, SkillImportResult{
+				Status:        "failed",
+				Reason:        "only the skill creator can overwrite this skill",
+				ExistingSkill: &existingInfo,
+			})
+			return
+		}
+		resp, err := h.overwriteSkillWithFiles(r.Context(), skillOverwriteInput{
+			WorkspaceID:   workspaceUUID,
+			TargetSkillID: existing.ID,
+			UserID:        creatorID,
+			ExpectedName:  name,
+			Description:   imported.description,
+			Content:       imported.content,
+			Config:        config,
+			Files:         files,
+		})
+		if err != nil {
+			status, reason := skillImportOverwriteFailure(err)
+			writeJSON(w, status, SkillImportResult{
+				Status:        "failed",
+				Reason:        reason,
+				ExistingSkill: &existingInfo,
+			})
+			return
+		}
+		actorType, actorID := h.resolveActor(r, creatorID, workspaceID)
+		h.publish(protocol.EventSkillUpdated, workspaceID, actorType, actorID, map[string]any{"skill": resp})
+		writeJSON(w, http.StatusOK, SkillImportResult{Status: "updated", Skill: &resp})
+	case importOnConflictRename:
+		resp, err := h.createRenamedImportedSkill(r.Context(), workspaceUUID, creatorUUID, name, imported, config, files)
+		if err != nil {
+			writeJSON(w, http.StatusInternalServerError, SkillImportResult{
+				Status:        "failed",
+				Reason:        "failed to create renamed skill: " + err.Error(),
+				ExistingSkill: &existingInfo,
+			})
+			return
+		}
+		actorType, actorID := h.resolveActor(r, creatorID, workspaceID)
+		h.publish(protocol.EventSkillCreated, workspaceID, actorType, actorID, map[string]any{"skill": resp})
+		writeJSON(w, http.StatusCreated, SkillImportResult{
+			Status:        "created",
+			Reason:        "renamed to avoid an existing skill",
+			Skill:         &resp,
+			ExistingSkill: &existingInfo,
+		})
+	default:
+		writeJSON(w, http.StatusConflict, SkillImportResult{
+			Status:        "conflict",
+			Reason:        skillImportConflictReason(),
+			ExistingSkill: &existingInfo,
+		})
+	}
+}
+
 // --- Import handler ---
 
 func (h *Handler) ImportSkill(w http.ResponseWriter, r *http.Request) {
@@ -1739,6 +1897,15 @@ func (h *Handler) ImportSkill(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusBadRequest, "invalid request body")
 		return
 	}
+	if !validImportOnConflict(req.OnConflict) {
+		writeError(w, http.StatusBadRequest, "on_conflict must be one of: fail, overwrite, rename, skip")
+		return
+	}
+	structuredResult := req.OnConflict != ""
+	strategy := req.OnConflict
+	if strategy == "" {
+		strategy = importOnConflictFail
+	}
 
 	source, normalized, err := detectImportSource(req.URL)
 	if err != nil {
@@ -1779,19 +1946,31 @@ func (h *Handler) ImportSkill(w http.ResponseWriter, r *http.Request) {
 	if imported.origin != nil {
 		config["origin"] = imported.origin
 	}
+	name := sanitizeNullBytes(imported.name)
 
-	resp, err := h.createSkillWithFiles(r.Context(), skillCreateInput{
-		WorkspaceID: workspaceUUID,
-		CreatorID:   creatorUUID,
-		Name:        imported.name,
-		Description: imported.description,
-		Content:     imported.content,
-		Config:      config,
-		Files:       files,
-	})
+	if structuredResult {
+		if existing, found, lerr := h.lookupSkillByName(r.Context(), workspaceUUID, name); lerr != nil {
+			writeJSON(w, http.StatusInternalServerError, SkillImportResult{
+				Status: "failed",
+				Reason: "failed to check for existing skill: " + lerr.Error(),
+			})
+			return
+		} else if found {
+			h.resolveImportSkillConflict(w, r, strategy, workspaceID, workspaceUUID, creatorUUID, creatorID, name, imported, config, files, existing)
+			return
+		}
+	}
+
+	resp, err := h.createImportedSkillWithName(r.Context(), workspaceUUID, creatorUUID, name, imported, config, files)
 	if err != nil {
 		if isUniqueViolation(err) {
-			if existing, found, findErr := h.existingSkillIdentityByName(r.Context(), workspaceUUID, imported.name); findErr == nil && found {
+			if structuredResult {
+				if existing, found, lerr := h.lookupSkillByName(r.Context(), workspaceUUID, name); lerr == nil && found {
+					h.resolveImportSkillConflict(w, r, strategy, workspaceID, workspaceUUID, creatorUUID, creatorID, name, imported, config, files, existing)
+					return
+				}
+			}
+			if existing, found, findErr := h.existingSkillIdentityByName(r.Context(), workspaceUUID, name); findErr == nil && found {
 				writeSkillImportDuplicateConflict(w, existing)
 			} else {
 				writeError(w, http.StatusConflict, "a skill with this name already exists")
@@ -1803,6 +1982,10 @@ func (h *Handler) ImportSkill(w http.ResponseWriter, r *http.Request) {
 	}
 	actorType, actorID := h.resolveActor(r, creatorID, workspaceID)
 	h.publish(protocol.EventSkillCreated, workspaceID, actorType, actorID, map[string]any{"skill": resp})
+	if structuredResult {
+		writeJSON(w, http.StatusCreated, SkillImportResult{Status: "created", Skill: &resp})
+		return
+	}
 	writeJSON(w, http.StatusCreated, resp)
 }
 
diff --git a/server/internal/handler/skill_create.go b/server/internal/handler/skill_create.go
index 12b10ffbde..ab0c467869 100644
--- a/server/internal/handler/skill_create.go
+++ b/server/internal/handler/skill_create.go
@@ -3,7 +3,9 @@ package handler
 import (
 	"context"
 	"encoding/json"
+	"errors"
 
+	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgtype"
 	skillpkg "github.com/multica-ai/multica/server/internal/skill"
 	db "github.com/multica-ai/multica/server/pkg/db/generated"
@@ -89,3 +91,126 @@ func (h *Handler) createSkillWithFiles(ctx context.Context, input skillCreateInp
 
 	return result, nil
 }
+
+// errSkillOverwriteNotFound / errSkillOverwriteForbidden are the terminal
+// boundary cases of overwriteSkillWithFiles: the target was deleted (or moved
+// out of the workspace) or the caller lost overwrite permission between the
+// user's confirm and this write. Callers map them to a failed import and must
+// NOT fall back to creating a new skill.
+var (
+	errSkillOverwriteNotFound     = errors.New("target skill not found")
+	errSkillOverwriteForbidden    = errors.New("not permitted to overwrite target skill")
+	errSkillOverwriteNameMismatch = errors.New("target skill name does not match the imported skill")
+)
+
+type skillOverwriteInput struct {
+	WorkspaceID   pgtype.UUID
+	TargetSkillID pgtype.UUID
+	UserID        string // re-checked against the skill creator inside the tx
+	// ExpectedName, when non-empty, must equal the target's current name. Guards
+	// against a client sending the wrong target_skill_id and overwriting a
+	// different skill than the one the conflict dialog showed the user. The
+	// caller passes the sanitized effective import name.
+	ExpectedName string
+	Description  string
+	Content      string
+	Config       any
+	Files        []CreateSkillFileRequest
+}
+
+// overwriteSkillWithFiles re-imports a bundle onto an existing skill in a single
+// transaction. It re-verifies, inside that tx, that the target still exists in
+// the workspace and that UserID may overwrite it (creator-only — see
+// canOverwriteSkillByLocalImport). A target deleted or a creator change between
+// the user's confirm and this write fails cleanly via errSkillOverwriteNotFound
+// / errSkillOverwriteForbidden rather than falling back to create.
+//
+// Preserved: id, created_by, created_at, name, and agent_skill bindings (the
+// row identity and the binding table are never touched). Replaced: description,
+// content, config (origin), and the full file set — files absent from the new
+// bundle are pruned via DeleteSkillFilesBySkill. On any error the tx rolls back,
+// leaving the original skill unchanged.
+func (h *Handler) overwriteSkillWithFiles(ctx context.Context, input skillOverwriteInput) (SkillWithFilesResponse, error) {
+	config, err := json.Marshal(input.Config)
+	if err != nil {
+		return SkillWithFilesResponse{}, err
+	}
+	if input.Config == nil {
+		config = []byte("{}")
+	}
+
+	tx, err := h.TxStarter.Begin(ctx)
+	if err != nil {
+		return SkillWithFilesResponse{}, err
+	}
+	defer tx.Rollback(ctx)
+
+	qtx := h.Queries.WithTx(tx)
+
+	existing, err := qtx.GetSkillInWorkspace(ctx, db.GetSkillInWorkspaceParams{
+		ID:          input.TargetSkillID,
+		WorkspaceID: input.WorkspaceID,
+	})
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return SkillWithFilesResponse{}, errSkillOverwriteNotFound
+		}
+		return SkillWithFilesResponse{}, err
+	}
+	if !canOverwriteSkillByLocalImport(input.UserID, existing) {
+		return SkillWithFilesResponse{}, errSkillOverwriteForbidden
+	}
+	// The overwrite is keyed on target_skill_id, but the conflict the user
+	// confirmed was a same-name collision; reject if the target's name no longer
+	// matches the imported skill so a stale/wrong target_skill_id can't write
+	// one skill's content onto another.
+	if input.ExpectedName != "" && existing.Name != input.ExpectedName {
+		return SkillWithFilesResponse{}, errSkillOverwriteNameMismatch
+	}
+
+	// Name is intentionally left unset (COALESCE keeps the existing name): the
+	// overwrite targets the same-name skill, so preserving it avoids any
+	// unique-name churn.
+	skill, err := qtx.UpdateSkill(ctx, db.UpdateSkillParams{
+		ID:          existing.ID,
+		Description: pgtype.Text{String: sanitizeNullBytes(input.Description), Valid: true},
+		Content:     pgtype.Text{String: sanitizeNullBytes(input.Content), Valid: true},
+		Config:      config,
+	})
+	if err != nil {
+		// A committed concurrent DELETE can land between the read above and this
+		// UPDATE (READ COMMITTED), so UpdateSkill matches 0 rows. Classify it as
+		// the same "target gone" terminal case rather than a generic failure.
+		if errors.Is(err, pgx.ErrNoRows) {
+			return SkillWithFilesResponse{}, errSkillOverwriteNotFound
+		}
+		return SkillWithFilesResponse{}, err
+	}
+
+	// Full replace: drop every existing file, then re-insert the new set so
+	// files no longer present in the local source are removed.
+	if err := qtx.DeleteSkillFilesBySkill(ctx, skill.ID); err != nil {
+		return SkillWithFilesResponse{}, err
+	}
+	fileResps := make([]SkillFileResponse, 0, len(input.Files))
+	for _, f := range input.Files {
+		sf, err := qtx.UpsertSkillFile(ctx, db.UpsertSkillFileParams{
+			SkillID: skill.ID,
+			Path:    sanitizeNullBytes(f.Path),
+			Content: sanitizeNullBytes(f.Content),
+		})
+		if err != nil {
+			return SkillWithFilesResponse{}, err
+		}
+		fileResps = append(fileResps, skillFileToResponse(sf))
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return SkillWithFilesResponse{}, err
+	}
+
+	return SkillWithFilesResponse{
+		SkillResponse: skillToResponse(skill),
+		Files:         fileResps,
+	}, nil
+}
diff --git a/server/internal/handler/skill_import_duplicate_test.go b/server/internal/handler/skill_import_duplicate_test.go
index 1c4312ebb0..f2e3e8e4cd 100644
--- a/server/internal/handler/skill_import_duplicate_test.go
+++ b/server/internal/handler/skill_import_duplicate_test.go
@@ -3,6 +3,7 @@ package handler
 import (
 	"context"
 	"encoding/json"
+	"net/http"
 	"net/http/httptest"
 	"testing"
 )
@@ -46,3 +47,103 @@ func TestWriteSkillImportDuplicateConflictIncludesExistingSkill(t *testing.T) {
 		t.Fatalf("existing_skill = %#v", existing)
 	}
 }
+
+func withMockClawHubImport(t *testing.T, skillName string) string {
+	t.Helper()
+	slug := "review-helper"
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/v1/skills/" + slug:
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"skill": map[string]any{
+					"slug":        slug,
+					"displayName": skillName,
+					"summary":     "Imported test skill",
+					"tags":        map[string]string{"latest": "1.0.0"},
+				},
+			})
+		case "/api/v1/skills/" + slug + "/versions/1.0.0":
+			_ = json.NewEncoder(w).Encode(map[string]any{
+				"version": map[string]any{
+					"version": "1.0.0",
+					"files": []map[string]any{
+						{"path": "SKILL.md", "size": 16},
+					},
+				},
+			})
+		case "/api/v1/skills/" + slug + "/file":
+			_, _ = w.Write([]byte("# Imported\n"))
+		default:
+			t.Fatalf("unexpected ClawHub path: %s", r.URL.String())
+		}
+	}))
+	prev := clawHubAPIBase
+	clawHubAPIBase = srv.URL + "/api/v1"
+	t.Cleanup(func() {
+		clawHubAPIBase = prev
+		srv.Close()
+	})
+	return "https://clawhub.ai/acme/" + slug
+}
+
+func TestImportSkillOnConflictSkipReturnsStructuredResult(t *testing.T) {
+	if testHandler == nil || testPool == nil {
+		t.Skip("handler test DB not configured")
+	}
+	namePrefix := "url-import-skip"
+	skillName := namePrefix + "-" + t.Name()
+	existingID := insertHandlerTestSkill(t, namePrefix, "# Existing")
+	importURL := withMockClawHubImport(t, skillName)
+
+	w := httptest.NewRecorder()
+	req := newRequestAsUser(testUserID, http.MethodPost, "/api/skills/import", map[string]any{
+		"url":         importURL,
+		"on_conflict": "skip",
+	})
+	testHandler.ImportSkill(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200: %s", w.Code, w.Body.String())
+	}
+	var body SkillImportResult
+	if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
+		t.Fatalf("decode body: %v", err)
+	}
+	if body.Status != "skipped" {
+		t.Fatalf("status = %q", body.Status)
+	}
+	if body.ExistingSkill == nil || body.ExistingSkill.ID != existingID || body.ExistingSkill.Name != skillName {
+		t.Fatalf("existing_skill = %#v", body.ExistingSkill)
+	}
+}
+
+func TestImportSkillOnConflictRenameCreatesSuffixedSkill(t *testing.T) {
+	if testHandler == nil || testPool == nil {
+		t.Skip("handler test DB not configured")
+	}
+	namePrefix := "url-import-rename"
+	skillName := namePrefix + "-" + t.Name()
+	insertHandlerTestSkill(t, namePrefix, "# Existing")
+	importURL := withMockClawHubImport(t, skillName)
+
+	w := httptest.NewRecorder()
+	req := newRequestAsUser(testUserID, http.MethodPost, "/api/skills/import", map[string]any{
+		"url":         importURL,
+		"on_conflict": "rename",
+	})
+	testHandler.ImportSkill(w, req)
+
+	if w.Code != http.StatusCreated {
+		t.Fatalf("status = %d, want 201: %s", w.Code, w.Body.String())
+	}
+	var body SkillImportResult
+	if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil {
+		t.Fatalf("decode body: %v", err)
+	}
+	if body.Status != "created" || body.Skill == nil {
+		t.Fatalf("body = %#v", body)
+	}
+	if body.Skill.Name != skillName+"-2" {
+		t.Fatalf("created skill name = %q, want %q", body.Skill.Name, skillName+"-2")
+	}
+}
diff --git a/server/internal/integrations/octo/doc.go b/server/internal/integrations/octo/doc.go
index 253f38ef73..0280c6d876 100644
--- a/server/internal/integrations/octo/doc.go
+++ b/server/internal/integrations/octo/doc.go
@@ -33,5 +33,5 @@
 // Expired binding tokens and stale inbound-dedup rows are purged by the
 // octo_cleanup scheduler job (internal/scheduler/jobs_octo_cleanup.go). The
 // DB-layer queries this package depends on are defined in
-// pkg/db/queries/octo.sql (migration 119).
+// pkg/db/queries/octo.sql (migration 120).
 package octo
diff --git a/server/internal/metrics/labels.go b/server/internal/metrics/labels.go
index 04d185b582..8b0564a957 100644
--- a/server/internal/metrics/labels.go
+++ b/server/internal/metrics/labels.go
@@ -114,6 +114,7 @@ var (
 	knownRuntimeProviders = map[string]string{
 		"antigravity":   "antigravity",
 		"claude":        "claude",
+		"codebuddy":     "codebuddy",
 		"codex":         "codex",
 		"copilot":       "copilot",
 		"cursor":        "cursor",
diff --git a/server/internal/service/builtin_skills/multica-skill-importing/SKILL.md b/server/internal/service/builtin_skills/multica-skill-importing/SKILL.md
index ce3a4887b2..c38c8bcaa8 100644
--- a/server/internal/service/builtin_skills/multica-skill-importing/SKILL.md
+++ b/server/internal/service/builtin_skills/multica-skill-importing/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: multica-skill-importing
-description: "Use when a user provides a skill URL, slug, or clear intent to import/install a specific skill into the current Multica workspace. Teaches the workspace import API/CLI path (POST /api/skills/import), the supported URL source families, the SkillWithFilesResponse shape returned on success, duplicate 409 handling with the existing_skill body, additive agent binding vs replace-all, and the reserved SKILL.md supporting-file rule. Do not use it to decide which skill the user needs, and never treat an external local installer like npx skills add as the final Multica install."
+description: "Use when a user provides a skill URL, slug, or clear intent to import/install a specific skill into the current Multica workspace. Teaches the workspace import API/CLI path (POST /api/skills/import), the supported URL source families, --on-conflict fail|overwrite|rename|skip behavior and structured import results, additive agent binding vs replace-all, and the reserved SKILL.md supporting-file rule. Do not use it to decide which skill the user needs, and never treat an external local installer like npx skills add as the final Multica install."
 user-invocable: false
 allowed-tools: Bash(multica *)
 ---
@@ -28,11 +28,11 @@ import endpoint, driven by this CLI:
 multica skill import --url <url> --output json
 ```
 
-That CLI sends:
+The CLI defaults to `--on-conflict fail`. Current CLIs send:
 
 ```text
 POST /api/skills/import
-body: { "url": "<url>" }
+body: { "url": "<url>", "on_conflict": "fail" }
 ```
 
 Do not finish with `npx skills add`. That installs into an external/local skill
@@ -66,17 +66,30 @@ directly; search is not required by the API:
 multica skill import --url <url> --output json
 ```
 
-2. Treat a successful response as the source of truth. The body is a workspace
-`SkillWithFilesResponse` — it embeds the standard `SkillResponse` and adds the
-supporting `files` array. Report the relevant fields:
+2. Treat the response as the source of truth. Current CLI imports use the
+structured import result envelope:
 
-- `id`
-- `name`
-- `description`
-- `config.origin` (provenance: which source the skill was imported from — set
-  only when the source supplied an origin, so treat it as possibly absent)
-- `files` / files count
-- `created_at` / `updated_at`
+```json
+{
+  "status": "created|updated|conflict|skipped|failed",
+  "reason": "...",
+  "skill": { "...": "SkillWithFilesResponse when created/updated" },
+  "existing_skill": { "id": "...", "name": "...", "can_overwrite": true }
+}
+```
+
+For `created` / `updated`, `skill` is a workspace `SkillWithFilesResponse`: it
+embeds the standard `SkillResponse` and adds the supporting `files` array. Report
+the relevant fields:
+
+- `status` and `reason` when present.
+- `skill.id` / `skill.name` / `skill.description`.
+- `skill.config.origin` (provenance: which source the skill was imported from —
+  set only when the source supplied an origin, so treat it as possibly absent).
+- `skill.files` / files count.
+- `skill.created_at` / `skill.updated_at`.
+- `existing_skill.id` / `existing_skill.name` when status is `conflict`,
+  `skipped`, or `failed` due to an existing skill.
 
 Because the response is structured, read these returned fields instead of guessing
 whether the import succeeded.
@@ -118,9 +131,46 @@ rename it to a non-reserved path. (The hard `400` rejection — "SKILL.md is res
 for the primary skill content" — only fires on the dedicated single-file endpoint
 `PUT /api/skills/{id}/files`, not on import.)
 
-## Duplicate imports (409)
+## Same-name conflicts: `--on-conflict`
+
+Default behavior is safe: `multica skill import --url <url>` is equivalent to
+`--on-conflict fail`. If the imported skill name already exists, the command
+prints a structured `conflict` result and exits non-zero; no skill is created or
+updated.
+
+Choose an explicit strategy only when the user asked for it or the intent is
+clear:
+
+- `--on-conflict fail` (default): do nothing on conflict; report `status:
+  conflict` with a reason that suggests overwrite or rename.
+- `--on-conflict overwrite`: update the existing same-name skill in place, but
+  only if the current user is the skill's original creator. This preserves the
+  skill ID, `created_by`, `created_at`, and agent-skill bindings; it replaces
+  description, content, provenance config, and supporting files. Non-creators get
+  `status: failed`.
+- `--on-conflict rename`: create a new skill with an automatic suffix such as
+  `-2` / `-3`; the existing skill is untouched.
+- `--on-conflict skip`: leave the existing skill untouched and report `status:
+  skipped`.
+
+Concrete examples:
+
+```bash
+# Safe default. Fails with status=conflict if review-helper already exists.
+multica skill import --url https://skills.sh/acme/repo/review-helper --output json
+
+# Replace the existing same-name skill, preserving its ID and agent bindings.
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict overwrite --output json
+
+# Keep the existing skill and import a copy such as review-helper-2.
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict rename --output json
+
+# Batch-friendly behavior: leave the existing skill alone and mark it skipped.
+multica skill import --url https://skills.sh/acme/repo/review-helper --on-conflict skip --output json
+```
 
-A duplicate import returns `409`. On current servers the body carries the existing
+Legacy compatibility: clients that do not send `on_conflict` keep the old
+contract. A duplicate import returns `409` and the body carries the existing
 workspace skill identity:
 
 ```json
@@ -133,19 +183,17 @@ workspace skill identity:
 }
 ```
 
-`multica skill import --url <url> --output json` prints that structured conflict
-body and exits successfully (exit 0) for this duplicate case. Treat
-`existing_skill.id` and `existing_skill.name` as the source of truth, then fetch
-details if needed:
+Current CLI normalizes that legacy shape into `status: conflict` and exits
+non-zero for the default `fail` strategy. Treat `existing_skill.id` and
+`existing_skill.name` as the source of truth, then fetch details if needed:
 
 ```bash
 multica skill get <skill-id> --output json
 ```
 
-Legacy fallback: a legacy server or old CLI may return a `409` whose body is only a
-string like `a skill with this name already exists`, with no `existing_skill` key.
-The CLI cannot recognize that as the duplicate case, so it exits non-zero. Recover
-by finding the existing workspace skill yourself:
+Older servers may return a `409` whose body is only a string like `a skill with
+this name already exists`, with no `existing_skill` key. Recover by finding the
+existing workspace skill yourself:
 
 ```bash
 multica skill list --output json
diff --git a/server/internal/service/builtin_skills/multica-skill-importing/references/skill-importing-source-map.md b/server/internal/service/builtin_skills/multica-skill-importing/references/skill-importing-source-map.md
index 5df7eeed18..b24ab662d8 100644
--- a/server/internal/service/builtin_skills/multica-skill-importing/references/skill-importing-source-map.md
+++ b/server/internal/service/builtin_skills/multica-skill-importing/references/skill-importing-source-map.md
@@ -17,44 +17,48 @@ grep -n "func IsReservedContentPath"    server/internal/skill/reserved.go
 
 | Behavior | File:line |
 |---|---|
-| `ImportSkill` handler (`POST /api/skills/import`) | `server/internal/handler/skill.go:1724` |
-| Decodes `ImportSkillRequest` (`{ "url": ... }`) | `server/internal/handler/skill.go:1737-1741`, struct at `:523` |
-| Detects source family + normalizes URL | `server/internal/handler/skill.go:1743` (calls `detectImportSource`) |
-| Persists provenance into `config.origin` | `server/internal/handler/skill.go:1776-1781` — set at `:1780` **only when** `imported.origin != nil` (`:1779`); otherwise `config` stays `{}` and `origin` is absent |
-| Builds skill + files via `createSkillWithFiles` (def `server/internal/handler/skill_create.go:72`, tx body `:27`) | call site `server/internal/handler/skill.go:1783` |
-| Success: `201 Created` with the response body | `server/internal/handler/skill.go:1806` |
-| Route registration `r.Post("/import", h.ImportSkill)` | `server/cmd/server/router.go:621` (under `/api/skills`, `:617`) |
+| `ImportSkill` handler (`POST /api/skills/import`) | `server/internal/handler/skill.go:1882` |
+| Decodes `ImportSkillRequest` (`{ "url": ..., "on_conflict": ... }`) | `server/internal/handler/skill.go:1895-1899`, struct at `:553` |
+| Validates `on_conflict` (`fail`, `overwrite`, `rename`, `skip`) | `server/internal/handler/skill.go:1900-1908`, helper `validImportOnConflict` at `:566` |
+| Detects source family + normalizes URL | `server/internal/handler/skill.go:1910` (calls `detectImportSource`) |
+| Persists provenance into `config.origin` | `server/internal/handler/skill.go:1944-1948` — set only when `imported.origin != nil`; otherwise `config` stays `{}` and `origin` is absent |
+| Structured conflict dispatcher | `server/internal/handler/skill.go:1813-1878` |
+| Builds skill + files via `createSkillWithFiles` (def `server/internal/handler/skill_create.go:77`, tx body `:29`) | wrapped by `createImportedSkillWithName` at `server/internal/handler/skill.go:1774` |
+| Structured success: `201 Created` with `{status:"created", skill}` when `on_conflict` was sent | `server/internal/handler/skill.go:1985-1988` |
+| Legacy success: `201 Created` with bare `SkillWithFilesResponse` when `on_conflict` was omitted | `server/internal/handler/skill.go:1990` |
+| Route registration `r.Post("/import", h.ImportSkill)` | `server/cmd/server/router.go:874` |
 
 ## CLI: `multica skill import --url`
 
 | Behavior | File:line |
 |---|---|
 | `skill import` command def | `server/cmd/multica/cmd_skill.go:60-64` |
-| `--url` flag | `server/cmd/multica/cmd_skill.go:143` |
+| `--url` flag | `server/cmd/multica/cmd_skill.go:142` |
+| `--on-conflict` flag (default `fail`) | `server/cmd/multica/cmd_skill.go:143` |
 | `--output` flag (default `json`) | `server/cmd/multica/cmd_skill.go:144` |
 | `runSkillImport` | `server/cmd/multica/cmd_skill.go:412` |
 | Requires `--url` | `server/cmd/multica/cmd_skill.go:418-421` |
-| `POST /api/skills/import` | `server/cmd/multica/cmd_skill.go:431` |
-| On error, tries conflict handler; returns `nil` (exit 0) when handled | `server/cmd/multica/cmd_skill.go:432-434` |
+| Reads and validates `--on-conflict` | `server/cmd/multica/cmd_skill.go:422-425` |
+| Sends `on_conflict` in the request body | `server/cmd/multica/cmd_skill.go:428-431` |
+| `POST /api/skills/import` | `server/cmd/multica/cmd_skill.go:436` |
+| Structured HTTP error body handling | `server/cmd/multica/cmd_skill.go:437-440`, `handleSkillImportError` at `:454` |
+| Prints structured result (`json` or table) | `server/cmd/multica/cmd_skill.go:443`, helper at `:497` |
 
-## Duplicate 409 handling
+## Same-name conflict handling
 
 | Behavior | File:line |
 |---|---|
-| `ImportSkill` unique-violation branch | `server/internal/handler/skill.go:1793-1800` |
-| Structured 409 via `writeSkillImportDuplicateConflict` (looks up existing skill) | `server/internal/handler/skill.go:1794-1795` |
-| `writeSkillImportDuplicateConflict` writes `{error, existing_skill}` at status 409 | `server/internal/handler/skill.go:109-114` |
-| `ExistingSkillIdentity` (`{id,name}`) | `server/internal/handler/skill.go:104-107` |
-| `existingSkillIdentityByName` (GetSkillByWorkspaceAndName) | `server/internal/handler/skill.go:130-142` |
-| Defensive fallback: plain-string 409 when lookup misses (delete-race) | `server/internal/handler/skill.go:1796-1798` |
-| CLI `handleSkillImportConflict` | `server/cmd/multica/cmd_skill.go:447` |
-| Requires HTTP 409 + non-empty body | `server/cmd/multica/cmd_skill.go:449-451` |
-| Requires `existing_skill` key (else `false` → non-zero exit) | `server/cmd/multica/cmd_skill.go:457-459` |
-| Under `--output json`: prints body, returns `true` (caller exits 0) | `server/cmd/multica/cmd_skill.go:461-465` |
-
-A legacy plain-string 409 (no `existing_skill` key) fails the `:457-459` guard,
-so `handleSkillImportConflict` returns `false`, `runSkillImport` falls through to
-`return fmt.Errorf("import skill: ...")` at `:435` → non-zero exit.
+| `SkillImportResult` (`status`, `reason`, `skill`, `existing_skill`) | `server/internal/handler/skill.go:104-109` |
+| `ExistingSkillIdentity` (`id`, `name`, `created_by`, `can_overwrite`) | `server/internal/handler/skill.go:112-117` |
+| Pre-create lookup for structured conflict flow | `server/internal/handler/skill.go:1951-1962` |
+| Race-safe unique-violation fallback into structured conflict flow | `server/internal/handler/skill.go:1966-1971` |
+| Default `fail`: `status:"conflict"` and HTTP 409 | `server/internal/handler/skill.go:1872-1877` |
+| `overwrite`: creator-only update, preserves skill identity/bindings via `overwriteSkillWithFiles` | `server/internal/handler/skill.go:1823-1852`, tx helper at `server/internal/handler/skill_create.go:133` |
+| `rename`: creates suffixed name with bounded attempts | `server/internal/handler/skill.go:1854-1870`, helper at `:1786` |
+| `skip`: returns `status:"skipped"` and leaves existing skill untouched | `server/internal/handler/skill.go:1816-1821` |
+| Legacy duplicate branch when `on_conflict` was omitted | `server/internal/handler/skill.go:1973-1978` |
+| Legacy duplicate response `{error, existing_skill}` | `server/internal/handler/skill.go:118-123` |
+| CLI normalizes legacy `{existing_skill}` body into `status:"conflict"` | `server/cmd/multica/cmd_skill.go:454-482`, helper at `:484` |
 
 ## Response shape: `SkillWithFilesResponse`
 
@@ -64,35 +68,36 @@ so `handleSkillImportConflict` returns `false`, `runSkillImport` falls through t
 | `SkillResponse` fields (`id, workspace_id, name, description, content, config, created_by, created_at, updated_at`) | `server/internal/handler/skill.go:41-51` |
 | `SkillFileResponse` fields | `server/internal/handler/skill.go:80-87` |
 | `createSkillWithFilesInTx` returns `SkillWithFilesResponse{SkillResponse, Files}` | `server/internal/handler/skill_create.go:66-69` |
-| `config.origin` set on import | `server/internal/handler/skill.go:1780` |
+| `config.origin` set on import | `server/internal/handler/skill.go:1947` |
 
-The import response is a `SkillWithFilesResponse` (not a bare `SkillResponse`):
-it carries every `SkillResponse` field plus the `files` array.
+For current CLI imports, `SkillWithFilesResponse` appears under
+`SkillImportResult.skill` when status is `created` or `updated`. Legacy clients
+that omit `on_conflict` still receive a bare `SkillWithFilesResponse`.
 
 ## URL source families (`detectImportSource`)
 
 | Behavior | File:line |
 |---|---|
-| `detectImportSource` | `server/internal/handler/skill.go:723-756` |
-| `skills.sh` / `www.skills.sh` | `server/internal/handler/skill.go:743-744` |
-| `clawhub.ai` / `www.clawhub.ai` | `server/internal/handler/skill.go:745-746` |
-| `github.com` / `www.github.com` | `server/internal/handler/skill.go:747-748` |
-| Bare slug (no host) defaults to ClawHub | `server/internal/handler/skill.go:750-753` |
-| `parseGitHubURL` handles `/tree/{ref}/...` and `/blob/{ref}/.../SKILL.md` | `server/internal/handler/skill.go:1402-1455` (tree/blob check `:1415-1432`) |
+| `detectImportSource` | `server/internal/handler/skill.go:773-804` |
+| `skills.sh` / `www.skills.sh` | `server/internal/handler/skill.go:791-792` |
+| `clawhub.ai` / `www.clawhub.ai` | `server/internal/handler/skill.go:793-794` |
+| `github.com` / `www.github.com` | `server/internal/handler/skill.go:795-796` |
+| Bare slug (no host) defaults to ClawHub | `server/internal/handler/skill.go:798-800` |
+| `parseGitHubURL` handles `/tree/{ref}/...` and `/blob/{ref}/.../SKILL.md` | `server/internal/handler/skill.go:1450-1503` (tree/blob check `:1463-1480`) |
 
 ## Additive add vs replace-all set
 
 | Behavior | File:line |
 |---|---|
-| `AddAgentSkills` (additive: AddAgentSkill loop, no RemoveAll) | `server/internal/handler/skill.go:1978`; loop `:2009-2017` |
-| Route `POST /api/agents/{id}/skills/add` | `server/cmd/server/router.go:598` |
-| `SetAgentSkills` (replace-all: RemoveAllAgentSkills then re-add) | `server/internal/handler/skill.go:1923`; `RemoveAllAgentSkills` `:1955`; re-add `:1960-1968` |
-| Route `PUT /api/agents/{id}/skills` | `server/cmd/server/router.go:597` |
+| `AddAgentSkills` (additive: AddAgentSkill loop, no RemoveAll) | `server/internal/handler/skill.go:2161`; loop `:2192-2200` |
+| Route `POST /api/agents/{id}/skills/add` | `server/cmd/server/router.go:851` |
+| `SetAgentSkills` (replace-all: RemoveAllAgentSkills then re-add) | `server/internal/handler/skill.go:2106`; `RemoveAllAgentSkills` `:2138`; re-add `:2143-2151` |
+| Route `PUT /api/agents/{id}/skills` | `server/cmd/server/router.go:850` |
 | CLI `agent skills add` def ("without replacing existing assignments") | `server/cmd/multica/cmd_agent.go:125-130` |
-| `runAgentSkillsAdd` → `POST .../skills/add` | `server/cmd/multica/cmd_agent.go:839`; POST `:860` |
+| `runAgentSkillsAdd` → `POST .../skills/add` | `server/cmd/multica/cmd_agent.go:797`; POST `:818` |
 | CLI `agent skills set` def ("replaces all current assignments") | `server/cmd/multica/cmd_agent.go:118-123` |
-| `runAgentSkillsSet` → `PUT .../skills` | `server/cmd/multica/cmd_agent.go:814`; PUT `:832` |
-| CLI `agent skills list` | `server/cmd/multica/cmd_agent.go:782`; GET `:792` |
+| `runAgentSkillsSet` → `PUT .../skills` | `server/cmd/multica/cmd_agent.go:772`; PUT `:790` |
+| CLI `agent skills list` | `server/cmd/multica/cmd_agent.go:740`; GET `:750` |
 
 ## Reserved primary-content filename (`SKILL.md`)
 
@@ -101,8 +106,8 @@ it carries every `SkillResponse` field plus the `files` array.
 | `ContentFilename = "SKILL.md"` | `server/internal/skill/reserved.go:12` |
 | `IsReservedContentPath` (cleans path, case-insensitive compare) | `server/internal/skill/reserved.go:25-27` |
 | Import/create path: reserved supporting file is **silently skipped** (`continue`) | `server/internal/handler/skill_create.go:50-54` |
-| `UpdateSkill` (PUT `/api/skills/{id}`) replace-files path: also silently skips | `server/internal/handler/skill.go:461-464` |
-| `UpsertSkillFile` (PUT `/api/skills/{id}/files`): **rejects 400** "SKILL.md is reserved for the primary skill content" | `server/internal/handler/skill.go:1851-1854` |
+| `UpdateSkill` (PUT `/api/skills/{id}`) replace-files path: also silently skips | `server/internal/handler/skill.go:490-494` |
+| `UpsertSkillFile` (PUT `/api/skills/{id}/files`): **rejects 400** "SKILL.md is reserved for the primary skill content" | `server/internal/handler/skill.go:2014`; reserved check `:2034-2036` |
 
 Reason `SKILL.md` is reserved: the daemon writes the skill's `Content` to that path
 itself when preparing the execution environment, so a supporting file may not also
diff --git a/server/internal/service/builtin_skills_test.go b/server/internal/service/builtin_skills_test.go
index 48e9f05225..a72972d862 100644
--- a/server/internal/service/builtin_skills_test.go
+++ b/server/internal/service/builtin_skills_test.go
@@ -276,6 +276,13 @@ func TestSkillImportingSkillCoversWorkspaceImportContracts(t *testing.T) {
 		"skills.sh",
 		"github.com",
 		"config.origin",
+		"--on-conflict fail",
+		"--on-conflict overwrite",
+		"--on-conflict rename",
+		"--on-conflict skip",
+		"status",
+		"conflict",
+		"skipped",
 		"409",
 		"existing_skill",
 		"id",
diff --git a/server/internal/service/task.go b/server/internal/service/task.go
index 4d4e758c8d..58471129f4 100644
--- a/server/internal/service/task.go
+++ b/server/internal/service/task.go
@@ -565,12 +565,13 @@ func (s *TaskService) enqueueMentionTask(ctx context.Context, issue db.Issue, ag
 // onto the agent's Instructions, matching the behavior of issue-bound
 // tasks assigned to the squad.
 type QuickCreateContext struct {
-	Type        string `json:"type"`
-	Prompt      string `json:"prompt"`
-	RequesterID string `json:"requester_id"`
-	WorkspaceID string `json:"workspace_id"`
-	ProjectID   string `json:"project_id,omitempty"`
-	SquadID     string `json:"squad_id,omitempty"`
+	Type          string   `json:"type"`
+	Prompt        string   `json:"prompt"`
+	RequesterID   string   `json:"requester_id"`
+	WorkspaceID   string   `json:"workspace_id"`
+	ProjectID     string   `json:"project_id,omitempty"`
+	SquadID       string   `json:"squad_id,omitempty"`
+	AttachmentIDs []string `json:"attachment_ids,omitempty"`
 	// ParentIssueID is the optional UUID of the parent issue the new issue
 	// should be filed under. Set when the user opens the modal from "Add
 	// sub issue" on an existing issue; the daemon claim handler resolves the
@@ -602,7 +603,7 @@ const QuickCreateContextType = "quick_create"
 // parentIssueID is optional (zero-valued pgtype.UUID when the user didn't
 // open the modal from "Add sub issue"). The handler is responsible for
 // validating it belongs to the same workspace before passing it in.
-func (s *TaskService) EnqueueQuickCreateTask(ctx context.Context, workspaceID, requesterID pgtype.UUID, agentID, squadID pgtype.UUID, prompt string, projectID, parentIssueID pgtype.UUID) (db.AgentTaskQueue, error) {
+func (s *TaskService) EnqueueQuickCreateTask(ctx context.Context, workspaceID, requesterID pgtype.UUID, agentID, squadID pgtype.UUID, prompt string, projectID, parentIssueID pgtype.UUID, attachmentIDs []pgtype.UUID) (db.AgentTaskQueue, error) {
 	agent, err := s.Queries.GetAgent(ctx, agentID)
 	if err != nil {
 		return db.AgentTaskQueue{}, fmt.Errorf("load agent: %w", err)
@@ -629,6 +630,14 @@ func (s *TaskService) EnqueueQuickCreateTask(ctx context.Context, workspaceID, r
 	if parentIssueID.Valid {
 		payload.ParentIssueID = util.UUIDToString(parentIssueID)
 	}
+	if len(attachmentIDs) > 0 {
+		payload.AttachmentIDs = make([]string, 0, len(attachmentIDs))
+		for _, id := range attachmentIDs {
+			if id.Valid {
+				payload.AttachmentIDs = append(payload.AttachmentIDs, util.UUIDToString(id))
+			}
+		}
+	}
 	contextJSON, err := json.Marshal(payload)
 	if err != nil {
 		return db.AgentTaskQueue{}, fmt.Errorf("marshal quick-create context: %w", err)
@@ -812,16 +821,38 @@ func (s *TaskService) CaptureCancelledTasks(ctx context.Context, cancelled []db.
 	}
 }
 
+type CancelledChatMessageResult struct {
+	ChatSessionID  string
+	MessageID      string
+	Content        string
+	RestoreToInput bool
+}
+
+type CancelTaskResult struct {
+	Task                 db.AgentTaskQueue
+	CancelledChatMessage *CancelledChatMessageResult
+}
+
 // CancelTask cancels a single task by ID. It broadcasts a task:cancelled event
 // so frontends can update immediately.
 func (s *TaskService) CancelTask(ctx context.Context, taskID pgtype.UUID) (*db.AgentTaskQueue, error) {
+	result, err := s.CancelTaskWithResult(ctx, taskID)
+	if err != nil {
+		return nil, err
+	}
+	return &result.Task, nil
+}
+
+// CancelTaskWithResult cancels a single task and returns any chat-specific
+// cleanup result needed by user-facing callers.
+func (s *TaskService) CancelTaskWithResult(ctx context.Context, taskID pgtype.UUID) (*CancelTaskResult, error) {
 	task, err := s.Queries.CancelAgentTask(ctx, taskID)
 	if errors.Is(err, pgx.ErrNoRows) {
 		existing, err := s.Queries.GetAgentTask(ctx, taskID)
 		if err != nil {
 			return nil, fmt.Errorf("cancel task: %w", err)
 		}
-		return &existing, nil
+		return &CancelTaskResult{Task: existing}, nil
 	}
 	if err != nil {
 		return nil, fmt.Errorf("cancel task: %w", err)
@@ -829,6 +860,7 @@ func (s *TaskService) CancelTask(ctx context.Context, taskID pgtype.UUID) (*db.A
 
 	slog.Info("task cancelled", "task_id", util.UUIDToString(task.ID), "issue_id", util.UUIDToString(task.IssueID))
 	s.captureTaskCancelled(ctx, task)
+	cancelledChatMessage := s.finalizeCancelledChatMessage(ctx, task)
 
 	// Reconcile agent status
 	s.ReconcileAgentStatus(ctx, task.AgentID)
@@ -836,7 +868,57 @@ func (s *TaskService) CancelTask(ctx context.Context, taskID pgtype.UUID) (*db.A
 	// Broadcast cancellation as a task:failed event so frontends clear the live card
 	s.broadcastTaskEvent(ctx, protocol.EventTaskCancelled, task)
 
-	return &task, nil
+	return &CancelTaskResult{
+		Task:                 task,
+		CancelledChatMessage: cancelledChatMessage,
+	}, nil
+}
+
+func (s *TaskService) finalizeCancelledChatMessage(ctx context.Context, task db.AgentTaskQueue) *CancelledChatMessageResult {
+	if !task.ChatSessionID.Valid {
+		return nil
+	}
+	var cancelled *CancelledChatMessageResult
+	if err := s.runInTx(ctx, func(qtx *db.Queries) error {
+		messages, err := qtx.ListTaskMessages(ctx, task.ID)
+		if err != nil {
+			return fmt.Errorf("list cancelled chat task messages: %w", err)
+		}
+		if len(messages) == 0 {
+			deleted, err := qtx.DeleteUserChatMessageByTask(ctx, task.ID)
+			if errors.Is(err, pgx.ErrNoRows) {
+				return nil
+			}
+			if err != nil {
+				return fmt.Errorf("delete empty cancelled chat user message: %w", err)
+			}
+			cancelled = &CancelledChatMessageResult{
+				ChatSessionID:  util.UUIDToString(deleted.ChatSessionID),
+				MessageID:      util.UUIDToString(deleted.ID),
+				Content:        deleted.Content,
+				RestoreToInput: true,
+			}
+			return nil
+		}
+		if _, err := qtx.CreateChatMessage(ctx, db.CreateChatMessageParams{
+			ChatSessionID: task.ChatSessionID,
+			Role:          "assistant",
+			Content:       "Stopped.",
+			TaskID:        task.ID,
+			ElapsedMs:     computeChatElapsedMs(task),
+		}); err != nil {
+			return fmt.Errorf("create cancelled chat message: %w", err)
+		}
+		return nil
+	}); err != nil {
+		slog.Error("failed to finalize cancelled chat message",
+			"task_id", util.UUIDToString(task.ID),
+			"chat_session_id", util.UUIDToString(task.ChatSessionID),
+			"error", err,
+		)
+		return nil
+	}
+	return cancelled
 }
 
 // ClaimTask atomically claims the next queued task for an agent,
diff --git a/server/migrations/119_user_created_at_index.down.sql b/server/migrations/119_user_created_at_index.down.sql
new file mode 100644
index 0000000000..ac166d2b1f
--- /dev/null
+++ b/server/migrations/119_user_created_at_index.down.sql
@@ -0,0 +1 @@
+DROP INDEX CONCURRENTLY IF EXISTS idx_user_created_at;
diff --git a/server/migrations/119_user_created_at_index.up.sql b/server/migrations/119_user_created_at_index.up.sql
new file mode 100644
index 0000000000..76869a466e
--- /dev/null
+++ b/server/migrations/119_user_created_at_index.up.sql
@@ -0,0 +1,8 @@
+-- Index on "user".created_at to support ordering/filtering users by signup time.
+--
+-- "user" is a reserved word so it stays double-quoted. The migration runner
+-- executes files outside an explicit transaction, so CONCURRENTLY is kept in
+-- its own single-statement migration to avoid Postgres' implicit transaction
+-- block for multi-statement query strings.
+CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_user_created_at
+    ON "user" (created_at);
diff --git a/server/migrations/119_octo_integration.down.sql b/server/migrations/120_octo_integration.down.sql
similarity index 100%
rename from server/migrations/119_octo_integration.down.sql
rename to server/migrations/120_octo_integration.down.sql
diff --git a/server/migrations/119_octo_integration.up.sql b/server/migrations/120_octo_integration.up.sql
similarity index 100%
rename from server/migrations/119_octo_integration.up.sql
rename to server/migrations/120_octo_integration.up.sql
diff --git a/server/pkg/agent/agent.go b/server/pkg/agent/agent.go
index 57e80f97e0..8570f9a1ef 100644
--- a/server/pkg/agent/agent.go
+++ b/server/pkg/agent/agent.go
@@ -1,6 +1,6 @@
 // Package agent provides a unified interface for executing prompts via
-// coding agents (Claude Code, Codex, Copilot, OpenCode, OpenClaw, Hermes,
-// Gemini, Pi, Cursor, Kimi, Kiro, Antigravity). It mirrors the happy-cli
+// coding agents (Claude Code, CodeBuddy, Codex, Copilot, OpenCode, OpenClaw,
+// Hermes, Gemini, Pi, Cursor, Kimi, Kiro, Antigravity). It mirrors the happy-cli
 // AgentBackend pattern, translated to idiomatic Go.
 package agent
 
@@ -116,13 +116,13 @@ type Result struct {
 
 // Config configures a Backend instance.
 type Config struct {
-	ExecutablePath string            // path to CLI binary (claude, codex, copilot, opencode, openclaw, hermes, gemini, pi, cursor, kimi, kiro-cli, agy)
+	ExecutablePath string            // path to CLI binary (claude, codebuddy, codex, copilot, opencode, openclaw, hermes, gemini, pi, cursor, kimi, kiro-cli, agy)
 	Env            map[string]string // extra environment variables
 	Logger         *slog.Logger
 }
 
 // New creates a Backend for the given agent type.
-// Supported types: "claude", "codex", "copilot", "opencode", "openclaw", "hermes", "gemini", "pi", "cursor", "kimi", "kiro", "antigravity".
+// Supported types: "claude", "codebuddy", "codex", "copilot", "opencode", "openclaw", "hermes", "gemini", "pi", "cursor", "kimi", "kiro", "antigravity".
 func New(agentType string, cfg Config) (Backend, error) {
 	if cfg.Logger == nil {
 		cfg.Logger = slog.Default()
@@ -131,6 +131,8 @@ func New(agentType string, cfg Config) (Backend, error) {
 	switch agentType {
 	case "claude":
 		return &claudeBackend{cfg: cfg}, nil
+	case "codebuddy":
+		return &codebuddyBackend{cfg: cfg}, nil
 	case "codex":
 		return &codexBackend{cfg: cfg}, nil
 	case "copilot":
@@ -154,7 +156,7 @@ func New(agentType string, cfg Config) (Backend, error) {
 	case "antigravity":
 		return &antigravityBackend{cfg: cfg}, nil
 	default:
-		return nil, fmt.Errorf("unknown agent type: %q (supported: claude, codex, copilot, opencode, openclaw, hermes, gemini, pi, cursor, kimi, kiro, antigravity)", agentType)
+		return nil, fmt.Errorf("unknown agent type: %q (supported: claude, codebuddy, codex, copilot, opencode, openclaw, hermes, gemini, pi, cursor, kimi, kiro, antigravity)", agentType)
 	}
 }
 
@@ -172,6 +174,7 @@ func DetectVersion(ctx context.Context, executablePath string) (string, error) {
 var launchHeaders = map[string]string{
 	"antigravity": "agy -p (print mode)",
 	"claude":      "claude (stream-json)",
+	"codebuddy":   "codebuddy (stream-json)",
 	"codex":       "codex app-server",
 	"copilot":     "copilot (json)",
 	"cursor":      "cursor-agent (stream-json)",
diff --git a/server/pkg/agent/agent_test.go b/server/pkg/agent/agent_test.go
index a237d6174e..e6bb8cc800 100644
--- a/server/pkg/agent/agent_test.go
+++ b/server/pkg/agent/agent_test.go
@@ -28,6 +28,17 @@ func TestNewReturnsCodexBackend(t *testing.T) {
 	}
 }
 
+func TestNewReturnsCodebuddyBackend(t *testing.T) {
+	t.Parallel()
+	b, err := New("codebuddy", Config{ExecutablePath: "/nonexistent/codebuddy"})
+	if err != nil {
+		t.Fatalf("New(codebuddy) error: %v", err)
+	}
+	if _, ok := b.(*codebuddyBackend); !ok {
+		t.Fatalf("expected *codebuddyBackend, got %T", b)
+	}
+}
+
 func TestNewReturnsCopilotBackend(t *testing.T) {
 	t.Parallel()
 	b, err := New("copilot", Config{ExecutablePath: "/nonexistent/copilot"})
@@ -83,7 +94,7 @@ func TestLaunchHeaderCoversAllSupportedBackends(t *testing.T) {
 	// runtime the daemon actually spawns. If a new backend is added, add an
 	// entry to launchHeaders in agent.go and extend this list.
 	supported := []string{
-		"antigravity", "claude", "codex", "copilot", "cursor", "gemini",
+		"antigravity", "claude", "codebuddy", "codex", "copilot", "cursor", "gemini",
 		"hermes", "kimi", "kiro", "openclaw", "opencode", "pi",
 	}
 	for _, t_ := range supported {
diff --git a/server/pkg/agent/codebuddy.go b/server/pkg/agent/codebuddy.go
new file mode 100644
index 0000000000..8576d9febb
--- /dev/null
+++ b/server/pkg/agent/codebuddy.go
@@ -0,0 +1,521 @@
+package agent
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log/slog"
+	"os"
+	"os/exec"
+	"strings"
+	"sync"
+	"time"
+)
+
+// codebuddyBackend implements Backend by spawning the CodeBuddy CLI
+// (a Claude Code fork) with --output-format stream-json.
+// It mirrors claude.go's execution model: concurrent stdin/stdout to
+// avoid pipe deadlocks, open stdin for control_request auto-approval,
+// and runContext for zero-timeout = no-deadline semantics.
+type codebuddyBackend struct {
+	cfg Config
+}
+
+// codebuddyBlockedArgs are flags hardcoded by the daemon that must not be
+// overridden by user-configured custom_args. Overriding these would break
+// the daemon↔codebuddy communication protocol.
+var codebuddyBlockedArgs = map[string]blockedArgMode{
+	"-p":                blockedStandalone, // non-interactive mode
+	"--output-format":   blockedWithValue,  // stream-json protocol
+	"--input-format":    blockedWithValue,  // stream-json protocol
+	"--permission-mode": blockedWithValue,  // bypassPermissions for autonomous operation
+	"--mcp-config":      blockedWithValue,  // set by daemon from agent.mcp_config
+	// `--effort` is owned by the per-agent thinking_level picker so a
+	// user-supplied custom_arg cannot silently outvote it.
+	"--effort": blockedWithValue,
+}
+
+func buildCodebuddyArgs(opts ExecOptions, logger *slog.Logger) []string {
+	args := []string{
+		"-p",
+		"--output-format", "stream-json",
+		"--input-format", "stream-json",
+		"--verbose",
+		"--strict-mcp-config",
+		"--permission-mode", "bypassPermissions",
+		"--disallowedTools", "AskUserQuestion",
+	}
+	if opts.Model != "" {
+		args = append(args, "--model", opts.Model)
+	}
+	if opts.ThinkingLevel != "" {
+		args = append(args, "--effort", opts.ThinkingLevel)
+	}
+	if opts.MaxTurns > 0 {
+		args = append(args, "--max-turns", fmt.Sprintf("%d", opts.MaxTurns))
+	}
+	if opts.SystemPrompt != "" {
+		args = append(args, "--append-system-prompt", opts.SystemPrompt)
+	}
+	if opts.ResumeSessionID != "" {
+		args = append(args, "--resume", opts.ResumeSessionID)
+	}
+	args = append(args, filterCustomArgs(opts.ExtraArgs, codebuddyBlockedArgs, logger)...)
+	args = append(args, filterCustomArgs(opts.CustomArgs, codebuddyBlockedArgs, logger)...)
+	return args
+}
+
+func (b *codebuddyBackend) Execute(ctx context.Context, prompt string, opts ExecOptions) (*Session, error) {
+	execPath := b.cfg.ExecutablePath
+	if execPath == "" {
+		execPath = "codebuddy"
+	}
+	if _, err := exec.LookPath(execPath); err != nil {
+		return nil, fmt.Errorf("codebuddy executable not found at %q: %w", execPath, err)
+	}
+
+	timeout := opts.Timeout
+	runCtx, cancel := runContext(ctx, timeout)
+
+	args := buildCodebuddyArgs(opts, b.cfg.Logger)
+
+	// If the caller provided an MCP config, write it to a temp file and pass
+	// --mcp-config <path> so the agent uses a controlled set of MCP servers.
+	var mcpConfigPath string
+	var mcpFileCleanup func()
+	if len(opts.McpConfig) > 0 {
+		path, err := writeMcpConfigToTemp(opts.McpConfig)
+		if err != nil {
+			cancel()
+			return nil, err
+		}
+		mcpConfigPath = path
+		mcpFileCleanup = func() { os.Remove(mcpConfigPath) }
+		args = append(args, "--mcp-config", mcpConfigPath)
+	}
+	// Clean up the temp file if we return before the goroutine takes ownership.
+	defer func() {
+		if mcpFileCleanup != nil {
+			mcpFileCleanup()
+		}
+	}()
+
+	cmd := exec.CommandContext(runCtx, execPath, args...)
+	hideAgentWindow(cmd)
+	b.cfg.Logger.Info("agent command", "exec", execPath, "args", args)
+	cmd.WaitDelay = 10 * time.Second
+	if opts.Cwd != "" {
+		cmd.Dir = opts.Cwd
+	}
+	cmd.Env = buildEnv(b.cfg.Env)
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		cancel()
+		return nil, fmt.Errorf("codebuddy stdout pipe: %w", err)
+	}
+	stdin, err := cmd.StdinPipe()
+	if err != nil {
+		cancel()
+		return nil, fmt.Errorf("codebuddy stdin pipe: %w", err)
+	}
+	var closeStdinOnce sync.Once
+	closeStdin := func() { closeStdinOnce.Do(func() { _ = stdin.Close() }) }
+
+	stderrBuf := newStderrTail(newLogWriter(b.cfg.Logger, "[codebuddy:stderr] "), agentStderrTailBytes)
+	cmd.Stderr = stderrBuf
+
+	if err := cmd.Start(); err != nil {
+		closeStdin()
+		cancel()
+		return nil, fmt.Errorf("start codebuddy: %w", err)
+	}
+
+	b.cfg.Logger.Info("codebuddy started", "pid", cmd.Process.Pid, "cwd", opts.Cwd, "model", opts.Model)
+
+	// cmd.Start() succeeded — transfer temp file ownership to the goroutine.
+	mcpFileCleanup = nil
+
+	msgCh := make(chan Message, 256)
+	resCh := make(chan Result, 1)
+
+	// Write the prompt in a dedicated goroutine to prevent deadlock.
+	// CodeBuddy (like Claude Code) emits a startup banner to stdout before
+	// reading stdin; a synchronous write would block once the pipe buffer
+	// fills. Keep stdin open after writing so control_request events can
+	// be answered mid-run.
+	writeDone := make(chan error, 1)
+	go func() {
+		err := writeCodebuddyInput(stdin, prompt)
+		if err != nil {
+			closeStdin()
+		}
+		writeDone <- err
+	}()
+
+	go func() {
+		defer cancel()
+		defer close(msgCh)
+		defer close(resCh)
+		if mcpConfigPath != "" {
+			defer os.Remove(mcpConfigPath)
+		}
+
+		startTime := time.Now()
+		var output strings.Builder
+		var sessionID string
+		finalStatus := "completed"
+		var finalError string
+		usage := make(map[string]TokenUsage)
+
+		// Close stdout when the context is cancelled so scanner.Scan() unblocks.
+		go func() {
+			<-runCtx.Done()
+			closeStdin()
+			_ = stdout.Close()
+		}()
+
+		scanner := bufio.NewScanner(stdout)
+		scanner.Buffer(make([]byte, 0, 1024*1024), 10*1024*1024)
+
+		for scanner.Scan() {
+			line := strings.TrimSpace(scanner.Text())
+			if line == "" {
+				continue
+			}
+
+			var msg codebuddySDKMessage
+			if err := json.Unmarshal([]byte(line), &msg); err != nil {
+				continue
+			}
+
+			switch msg.Type {
+			case "assistant":
+				b.handleAssistant(msg, msgCh, &output, usage)
+			case "user":
+				b.handleUser(msg, msgCh)
+			case "system":
+				if msg.SessionID != "" {
+					sessionID = msg.SessionID
+				}
+				trySend(msgCh, Message{Type: MessageStatus, Status: "running", SessionID: sessionID})
+			case "result":
+				sessionID = msg.SessionID
+				if msg.ResultText != "" {
+					output.Reset()
+					output.WriteString(msg.ResultText)
+				}
+				if resultUsage := codebuddyResultUsage(msg, opts.Model); len(resultUsage) > 0 {
+					usage = resultUsage
+				}
+				if msg.IsError {
+					finalStatus = "failed"
+					finalError = msg.ResultText
+				}
+				closeStdin()
+			case "log":
+				if msg.Log != nil {
+					trySend(msgCh, Message{
+						Type:    MessageLog,
+						Level:   msg.Log.Level,
+						Content: msg.Log.Message,
+					})
+				}
+			case "control_request":
+				b.handleControlRequest(msg, stdin)
+			}
+		}
+
+		closeStdin()
+
+		// Wait for process exit.
+		exitErr := cmd.Wait()
+		duration := time.Since(startTime)
+		// writeDone is buffered (cap 1) and the writer always sends — by the
+		// time cmd has exited, the prompt write has either succeeded, hit a
+		// broken pipe, or been unblocked by the kill that ended cmd.
+		writeErr := <-writeDone
+
+		switch {
+		case runCtx.Err() == context.DeadlineExceeded:
+			finalStatus = "timeout"
+			finalError = fmt.Sprintf("codebuddy timed out after %s", timeout)
+		case runCtx.Err() == context.Canceled:
+			finalStatus = "aborted"
+			finalError = "execution cancelled"
+		case writeErr != nil && finalStatus == "completed" && sessionID == "":
+			// No result event landed and the prompt write failed — codebuddy
+			// died before reading the prompt. Surface the write error; the
+			// stderr tail attached below carries the real reason.
+			finalStatus = "failed"
+			finalError = fmt.Sprintf("write codebuddy input: %v", writeErr)
+		case exitErr != nil && finalStatus == "completed":
+			finalStatus = "failed"
+			finalError = fmt.Sprintf("codebuddy exited with error: %v", exitErr)
+		}
+
+		if finalError != "" {
+			finalError = withAgentStderr(finalError, "codebuddy", stderrBuf.Tail())
+		}
+
+		b.cfg.Logger.Info("codebuddy finished", "pid", cmd.Process.Pid, "status", finalStatus, "duration", duration.Round(time.Millisecond).String())
+
+		reportedSessionID := resolveSessionID(opts.ResumeSessionID, sessionID, finalStatus == "failed")
+		if reportedSessionID != sessionID {
+			b.cfg.Logger.Info("codebuddy resume did not land; clearing fresh session id for daemon fallback",
+				"requested_resume", opts.ResumeSessionID,
+				"emitted_session", sessionID,
+			)
+		}
+
+		resCh <- Result{
+			Status:     finalStatus,
+			Output:     output.String(),
+			Error:      finalError,
+			DurationMs: duration.Milliseconds(),
+			SessionID:  reportedSessionID,
+			Usage:      usage,
+		}
+	}()
+
+	return &Session{Messages: msgCh, Result: resCh}, nil
+}
+
+func (b *codebuddyBackend) handleAssistant(msg codebuddySDKMessage, ch chan<- Message, output *strings.Builder, usage map[string]TokenUsage) {
+	var content codebuddyMessageContent
+	if err := json.Unmarshal(msg.Message, &content); err != nil {
+		return
+	}
+
+	// Accumulate token usage per model.
+	if content.Usage != nil && content.Model != "" {
+		u := usage[content.Model]
+		u.InputTokens += content.Usage.InputTokens
+		u.OutputTokens += content.Usage.OutputTokens
+		u.CacheReadTokens += content.Usage.CacheReadInputTokens
+		u.CacheWriteTokens += content.Usage.CacheCreationInputTokens
+		usage[content.Model] = u
+	}
+
+	for _, block := range content.Content {
+		switch block.Type {
+		case "text":
+			if block.Text != "" {
+				output.WriteString(block.Text)
+				trySend(ch, Message{Type: MessageText, Content: block.Text})
+			}
+		case "thinking":
+			if block.Text != "" {
+				trySend(ch, Message{Type: MessageThinking, Content: block.Text})
+			}
+		case "tool_use":
+			var input map[string]any
+			if block.Input != nil {
+				_ = json.Unmarshal(block.Input, &input)
+			}
+			trySend(ch, Message{
+				Type:   MessageToolUse,
+				Tool:   block.Name,
+				CallID: block.ID,
+				Input:  input,
+			})
+		}
+	}
+}
+
+func (b *codebuddyBackend) handleUser(msg codebuddySDKMessage, ch chan<- Message) {
+	var content codebuddyMessageContent
+	if err := json.Unmarshal(msg.Message, &content); err != nil {
+		return
+	}
+
+	for _, block := range content.Content {
+		if block.Type == "tool_result" {
+			resultStr := ""
+			if block.Content != nil {
+				resultStr = string(block.Content)
+			}
+			trySend(ch, Message{
+				Type:   MessageToolResult,
+				CallID: block.ToolUseID,
+				Output: resultStr,
+			})
+		}
+	}
+}
+
+func (b *codebuddyBackend) handleControlRequest(msg codebuddySDKMessage, stdin interface{ Write([]byte) (int, error) }) {
+	// Auto-approve all tool uses in autonomous/daemon mode.
+	var req codebuddyControlRequestPayload
+	if err := json.Unmarshal(msg.Request, &req); err != nil {
+		return
+	}
+
+	var inputMap map[string]any
+	if req.Input != nil {
+		_ = json.Unmarshal(req.Input, &inputMap)
+	}
+	if inputMap == nil {
+		inputMap = map[string]any{}
+	}
+
+	response := map[string]any{
+		"type": "control_response",
+		"response": map[string]any{
+			"subtype":    "success",
+			"request_id": msg.RequestID,
+			"response": map[string]any{
+				"behavior":     "allow",
+				"updatedInput": inputMap,
+			},
+		},
+	}
+
+	data, err := json.Marshal(response)
+	if err != nil {
+		b.cfg.Logger.Warn("codebuddy: failed to marshal control response", "error", err)
+		return
+	}
+	data = append(data, '\n')
+	if _, err := stdin.Write(data); err != nil {
+		b.cfg.Logger.Warn("codebuddy: failed to write control response", "error", err)
+	}
+}
+
+func writeCodebuddyInput(w io.Writer, prompt string) error {
+	payload := map[string]any{
+		"type": "user",
+		"message": map[string]any{
+			"role": "user",
+			"content": []map[string]string{
+				{
+					"type": "text",
+					"text": prompt,
+				},
+			},
+		},
+	}
+	data, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("marshal codebuddy input: %w", err)
+	}
+	data = append(data, '\n')
+	if _, err := w.Write(data); err != nil {
+		return err
+	}
+	return nil
+}
+
+// ── Codebuddy SDK JSON types ──
+
+type codebuddySDKMessage struct {
+	Type      string          `json:"type"`
+	Message   json.RawMessage `json:"message,omitempty"`
+	Subtype   string          `json:"subtype,omitempty"`
+	SessionID string          `json:"session_id,omitempty"`
+	Model     string          `json:"model,omitempty"`
+
+	// result fields
+	ResultText string                               `json:"result,omitempty"`
+	IsError    bool                                  `json:"is_error,omitempty"`
+	DurationMs float64                              `json:"duration_ms,omitempty"`
+	NumTurns   int                                  `json:"num_turns,omitempty"`
+	Usage      *codebuddyUsage                      `json:"usage,omitempty"`
+	ModelUsage map[string]codebuddyResultModelUsage `json:"modelUsage,omitempty"`
+
+	// log fields
+	Log *codebuddyLogEntry `json:"log,omitempty"`
+
+	// control request fields
+	RequestID string          `json:"request_id,omitempty"`
+	Request   json.RawMessage `json:"request,omitempty"`
+}
+
+type codebuddyLogEntry struct {
+	Level   string `json:"level"`
+	Message string `json:"message"`
+}
+
+type codebuddyMessageContent struct {
+	Role    string                  `json:"role"`
+	Model   string                  `json:"model"`
+	Content []codebuddyContentBlock `json:"content"`
+	Usage   *codebuddyUsage         `json:"usage,omitempty"`
+}
+
+type codebuddyUsage struct {
+	InputTokens              int64 `json:"input_tokens"`
+	OutputTokens             int64 `json:"output_tokens"`
+	CacheReadInputTokens     int64 `json:"cache_read_input_tokens"`
+	CacheCreationInputTokens int64 `json:"cache_creation_input_tokens"`
+}
+
+type codebuddyResultModelUsage struct {
+	InputTokens              int64 `json:"inputTokens"`
+	OutputTokens             int64 `json:"outputTokens"`
+	CacheReadInputTokens     int64 `json:"cacheReadInputTokens"`
+	CacheCreationInputTokens int64 `json:"cacheCreationInputTokens"`
+}
+
+type codebuddyContentBlock struct {
+	Type      string          `json:"type"`
+	Text      string          `json:"text,omitempty"`
+	ID        string          `json:"id,omitempty"`
+	Name      string          `json:"name,omitempty"`
+	Input     json.RawMessage `json:"input,omitempty"`
+	ToolUseID string          `json:"tool_use_id,omitempty"`
+	Content   json.RawMessage `json:"content,omitempty"`
+}
+
+type codebuddyControlRequestPayload struct {
+	Subtype  string          `json:"subtype"`
+	ToolName string          `json:"tool_name,omitempty"`
+	Input    json.RawMessage `json:"input,omitempty"`
+}
+
+func codebuddyResultUsage(msg codebuddySDKMessage, fallbackModel string) map[string]TokenUsage {
+	if len(msg.ModelUsage) > 0 {
+		usage := make(map[string]TokenUsage, len(msg.ModelUsage))
+		for model, u := range msg.ModelUsage {
+			if model == "" || !codebuddyUsageHasTokens(u.InputTokens, u.OutputTokens, u.CacheReadInputTokens, u.CacheCreationInputTokens) {
+				continue
+			}
+			usage[model] = TokenUsage{
+				InputTokens:      u.InputTokens,
+				OutputTokens:     u.OutputTokens,
+				CacheReadTokens:  u.CacheReadInputTokens,
+				CacheWriteTokens: u.CacheCreationInputTokens,
+			}
+		}
+		if len(usage) > 0 {
+			return usage
+		}
+	}
+
+	model := msg.Model
+	if model == "" {
+		model = fallbackModel
+	}
+	if msg.Usage == nil || model == "" || !codebuddyUsageHasTokens(
+		msg.Usage.InputTokens,
+		msg.Usage.OutputTokens,
+		msg.Usage.CacheReadInputTokens,
+		msg.Usage.CacheCreationInputTokens,
+	) {
+		return nil
+	}
+	return map[string]TokenUsage{
+		model: {
+			InputTokens:      msg.Usage.InputTokens,
+			OutputTokens:     msg.Usage.OutputTokens,
+			CacheReadTokens:  msg.Usage.CacheReadInputTokens,
+			CacheWriteTokens: msg.Usage.CacheCreationInputTokens,
+		},
+	}
+}
+
+func codebuddyUsageHasTokens(input, output, cacheRead, cacheWrite int64) bool {
+	return input > 0 || output > 0 || cacheRead > 0 || cacheWrite > 0
+}
diff --git a/server/pkg/agent/codebuddy_test.go b/server/pkg/agent/codebuddy_test.go
new file mode 100644
index 0000000000..e3fccfc22a
--- /dev/null
+++ b/server/pkg/agent/codebuddy_test.go
@@ -0,0 +1,474 @@
+package agent
+
+import (
+	"context"
+	"encoding/json"
+	"log/slog"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestBuildCodebuddyArgs_Basic(t *testing.T) {
+	t.Parallel()
+
+	args := buildCodebuddyArgs(ExecOptions{
+		Model:        "claude-sonnet-4-20250514",
+		MaxTurns:     25,
+		SystemPrompt: "You are an agent.",
+	}, slog.Default())
+
+	expected := []string{
+		"-p",
+		"--output-format", "stream-json",
+		"--input-format", "stream-json",
+		"--verbose",
+		"--strict-mcp-config",
+		"--permission-mode", "bypassPermissions",
+		"--disallowedTools", "AskUserQuestion",
+		"--model", "claude-sonnet-4-20250514",
+		"--max-turns", "25",
+		"--append-system-prompt", "You are an agent.",
+	}
+
+	if len(args) != len(expected) {
+		t.Fatalf("expected %d args, got %d: %v", len(expected), len(args), args)
+	}
+	for i, want := range expected {
+		if args[i] != want {
+			t.Fatalf("args[%d] = %q, want %q\nfull args: %v", i, args[i], want, args)
+		}
+	}
+}
+
+func TestBuildCodebuddyArgs_InjectsEffort(t *testing.T) {
+	t.Parallel()
+
+	args := buildCodebuddyArgs(ExecOptions{
+		ThinkingLevel: "high",
+	}, slog.Default())
+
+	found := false
+	for i := 0; i+1 < len(args); i++ {
+		if args[i] == "--effort" && args[i+1] == "high" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Fatalf("expected --effort high in args: %v", args)
+	}
+}
+
+func TestBuildCodebuddyArgs_OmitsEffortWhenEmpty(t *testing.T) {
+	t.Parallel()
+
+	args := buildCodebuddyArgs(ExecOptions{}, slog.Default())
+
+	for _, a := range args {
+		if a == "--effort" {
+			t.Fatalf("--effort should not appear when ThinkingLevel is empty: %v", args)
+		}
+	}
+}
+
+func TestBuildCodebuddyArgs_BlocksUserEffortOverride(t *testing.T) {
+	t.Parallel()
+
+	args := buildCodebuddyArgs(ExecOptions{
+		ThinkingLevel: "medium",
+		CustomArgs:    []string{"--effort", "max"},
+	}, slog.Default())
+
+	// Should have exactly one --effort (the daemon-injected one).
+	count := 0
+	for i, a := range args {
+		if a == "--effort" {
+			count++
+			if i+1 < len(args) && args[i+1] != "medium" {
+				t.Fatalf("expected --effort medium, got --effort %s", args[i+1])
+			}
+		}
+	}
+	if count != 1 {
+		t.Fatalf("expected exactly 1 --effort, got %d in: %v", count, args)
+	}
+}
+
+func TestBuildCodebuddyArgs_ExtraArgsBeforeCustomArgs(t *testing.T) {
+	t.Parallel()
+
+	args := buildCodebuddyArgs(ExecOptions{
+		ExtraArgs:  []string{"--output-format", "text", "--max-budget-usd", "1.00"},
+		CustomArgs: []string{"--max-budget-usd", "2.00", "--permission-mode", "plan"},
+	}, slog.Default())
+
+	joined := strings.Join(args, " ")
+	// Blocked flags should be filtered from both layers.
+	if strings.Contains(joined, "--output-format text") || strings.Contains(joined, "--permission-mode plan") {
+		t.Fatalf("blocked args should be filtered from both layers: %v", args)
+	}
+
+	extraIdx, customIdx := -1, -1
+	for i := 0; i+1 < len(args); i++ {
+		if args[i] == "--max-budget-usd" && args[i+1] == "1.00" {
+			extraIdx = i
+		}
+		if args[i] == "--max-budget-usd" && args[i+1] == "2.00" {
+			customIdx = i
+		}
+	}
+	if extraIdx == -1 || customIdx == -1 || extraIdx > customIdx {
+		t.Fatalf("expected extra args before custom args, got %v", args)
+	}
+}
+
+func TestBuildCodebuddyArgs_Resume(t *testing.T) {
+	t.Parallel()
+
+	args := buildCodebuddyArgs(ExecOptions{
+		ResumeSessionID: "sess-abc123",
+	}, slog.Default())
+
+	found := false
+	for i := 0; i+1 < len(args); i++ {
+		if args[i] == "--resume" && args[i+1] == "sess-abc123" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Fatalf("expected --resume sess-abc123 in args: %v", args)
+	}
+}
+
+func TestCodebuddyExecute_Success(t *testing.T) {
+	t.Parallel()
+	if runtime.GOOS == "windows" {
+		t.Skip("shell-script fixture is POSIX-only")
+	}
+
+	fakePath := filepath.Join(t.TempDir(), "codebuddy")
+	script := "#!/bin/sh\n" +
+		"IFS= read -r _\n" +
+		`printf '%s\n' '{"type":"system","session_id":"sess-cb-001"}'` + "\n" +
+		`printf '%s\n' '{"type":"assistant","message":{"role":"assistant","model":"claude-sonnet-4-20250514","content":[{"type":"text","text":"Hello from codebuddy"}]}}'` + "\n" +
+		`printf '%s\n' '{"type":"result","subtype":"success","is_error":false,"session_id":"sess-cb-001","result":"Hello from codebuddy","modelUsage":{"claude-sonnet-4-20250514":{"inputTokens":100,"outputTokens":50,"cacheReadInputTokens":10,"cacheCreationInputTokens":5}}}'` + "\n"
+	writeTestExecutable(t, fakePath, []byte(script))
+
+	b := &codebuddyBackend{cfg: Config{ExecutablePath: fakePath, Logger: slog.Default()}}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	session, err := b.Execute(ctx, "say hello", ExecOptions{Timeout: 5 * time.Second})
+	if err != nil {
+		t.Fatalf("execute: %v", err)
+	}
+
+	// Drain messages.
+	var gotText bool
+	for msg := range session.Messages {
+		if msg.Type == MessageText && msg.Content == "Hello from codebuddy" {
+			gotText = true
+		}
+	}
+	if !gotText {
+		t.Fatal("expected text message 'Hello from codebuddy'")
+	}
+
+	select {
+	case result, ok := <-session.Result:
+		if !ok {
+			t.Fatal("result channel closed without a value")
+		}
+		if result.Status != "completed" {
+			t.Fatalf("expected status=completed, got %q (error=%q)", result.Status, result.Error)
+		}
+		if result.Output != "Hello from codebuddy" {
+			t.Fatalf("expected output 'Hello from codebuddy', got %q", result.Output)
+		}
+		if result.SessionID != "sess-cb-001" {
+			t.Fatalf("expected session_id=sess-cb-001, got %q", result.SessionID)
+		}
+		usage, ok := result.Usage["claude-sonnet-4-20250514"]
+		if !ok {
+			t.Fatalf("expected usage for claude-sonnet-4-20250514, got %#v", result.Usage)
+		}
+		if usage.InputTokens != 100 || usage.OutputTokens != 50 || usage.CacheReadTokens != 10 || usage.CacheWriteTokens != 5 {
+			t.Fatalf("unexpected usage: %+v", usage)
+		}
+	case <-time.After(10 * time.Second):
+		t.Fatal("timeout waiting for result")
+	}
+}
+
+func TestCodebuddyExecute_NotFound(t *testing.T) {
+	t.Parallel()
+
+	b := &codebuddyBackend{cfg: Config{ExecutablePath: "/nonexistent/path/codebuddy", Logger: slog.Default()}}
+
+	ctx := context.Background()
+	_, err := b.Execute(ctx, "prompt", ExecOptions{})
+	if err == nil {
+		t.Fatal("expected error for missing executable")
+	}
+	if !strings.Contains(err.Error(), "codebuddy executable not found") {
+		t.Fatalf("expected 'codebuddy executable not found' in error, got %q", err.Error())
+	}
+}
+
+func TestCodebuddyExecuteSurfacesStderr(t *testing.T) {
+	t.Parallel()
+	if runtime.GOOS == "windows" {
+		t.Skip("shell-script fixture is POSIX-only")
+	}
+
+	fakePath := filepath.Join(t.TempDir(), "codebuddy")
+	script := "#!/bin/sh\n" +
+		"IFS= read -r _\n" +
+		"echo \"FATAL ERROR: segfault in codebuddy runtime\" >&2\n" +
+		"exit 1\n"
+	writeTestExecutable(t, fakePath, []byte(script))
+
+	b := &codebuddyBackend{cfg: Config{ExecutablePath: fakePath, Logger: slog.Default()}}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	session, err := b.Execute(ctx, "prompt-ignored", ExecOptions{Timeout: 5 * time.Second})
+	if err != nil {
+		t.Fatalf("execute: %v", err)
+	}
+
+	// Drain messages.
+	go func() {
+		for range session.Messages {
+		}
+	}()
+
+	select {
+	case result, ok := <-session.Result:
+		if !ok {
+			t.Fatal("result channel closed without a value")
+		}
+		if result.Status != "failed" {
+			t.Fatalf("expected status=failed, got %q (error=%q)", result.Status, result.Error)
+		}
+		if !strings.Contains(result.Error, "codebuddy exited with error") {
+			t.Fatalf("expected error to mention exit, got %q", result.Error)
+		}
+		if !strings.Contains(result.Error, "segfault in codebuddy runtime") {
+			t.Fatalf("expected error to include stderr content, got %q", result.Error)
+		}
+		if !strings.Contains(result.Error, "codebuddy stderr:") {
+			t.Fatalf("expected stderr label in error, got %q", result.Error)
+		}
+	case <-time.After(10 * time.Second):
+		t.Fatal("timeout waiting for result")
+	}
+}
+
+func TestWriteCodebuddyInput(t *testing.T) {
+	t.Parallel()
+
+	var buf strings.Builder
+	err := writeCodebuddyInput(&buf, "hello world")
+	if err != nil {
+		t.Fatalf("writeCodebuddyInput: %v", err)
+	}
+
+	data := buf.String()
+	if len(data) == 0 || data[len(data)-1] != '\n' {
+		t.Fatalf("expected newline-terminated payload, got %q", data)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal([]byte(strings.TrimSpace(data)), &payload); err != nil {
+		t.Fatalf("unmarshal payload: %v", err)
+	}
+	if payload["type"] != "user" {
+		t.Fatalf("expected type user, got %v", payload["type"])
+	}
+
+	message, ok := payload["message"].(map[string]any)
+	if !ok {
+		t.Fatalf("expected message object, got %T", payload["message"])
+	}
+	if message["role"] != "user" {
+		t.Fatalf("expected role user, got %v", message["role"])
+	}
+
+	content, ok := message["content"].([]any)
+	if !ok || len(content) != 1 {
+		t.Fatalf("expected one content block, got %v", message["content"])
+	}
+	block, ok := content[0].(map[string]any)
+	if !ok {
+		t.Fatalf("expected content block object, got %T", content[0])
+	}
+	if block["type"] != "text" || block["text"] != "hello world" {
+		t.Fatalf("unexpected content block: %v", block)
+	}
+}
+
+func TestCodebuddyHandleAssistantText(t *testing.T) {
+	t.Parallel()
+
+	b := &codebuddyBackend{cfg: Config{Logger: slog.Default()}}
+	ch := make(chan Message, 10)
+	var output strings.Builder
+
+	msg := codebuddySDKMessage{
+		Type: "assistant",
+		Message: mustMarshal(t, codebuddyMessageContent{
+			Role: "assistant",
+			Content: []codebuddyContentBlock{
+				{Type: "text", Text: "codebuddy says hi"},
+			},
+		}),
+	}
+
+	b.handleAssistant(msg, ch, &output, make(map[string]TokenUsage))
+
+	if output.String() != "codebuddy says hi" {
+		t.Fatalf("expected output 'codebuddy says hi', got %q", output.String())
+	}
+	select {
+	case m := <-ch:
+		if m.Type != MessageText || m.Content != "codebuddy says hi" {
+			t.Fatalf("unexpected message: %+v", m)
+		}
+	default:
+		t.Fatal("expected message on channel")
+	}
+}
+
+func TestParseCodebuddyModels_FullHelp(t *testing.T) {
+	t.Parallel()
+	helpOutput := `Usage: codebuddy [options] [command] [prompt]
+
+Options:
+  --model <model>                                  Model for the current session. Please provide the model ID. Currently supported: (claude-sonnet-4.6, claude-opus-4.7, gemini-3.1-pro, gpt-5.5, glm-5.1-ioa, minimax-m2.7-ioa, kimi-k2.6-ioa, hy3-preview-ioa, deepseek-v3-2-volc-ioa)
+  --effort <level>                                 Reasoning effort level (low, medium, high, xhigh)
+`
+	models := parseCodebuddyModels(helpOutput)
+	if len(models) != 9 {
+		t.Fatalf("expected 9 models, got %d: %+v", len(models), models)
+	}
+	if !models[0].Default {
+		t.Error("first model should be marked as default")
+	}
+	if models[0].ID != "claude-sonnet-4.6" {
+		t.Errorf("first model ID = %q, want claude-sonnet-4.6", models[0].ID)
+	}
+	if models[0].Provider != "anthropic" {
+		t.Errorf("claude model provider = %q, want anthropic", models[0].Provider)
+	}
+	// Spot check providers
+	providers := map[string]string{}
+	for _, m := range models {
+		providers[m.ID] = m.Provider
+	}
+	checks := map[string]string{
+		"gpt-5.5":                "openai",
+		"gemini-3.1-pro":        "google",
+		"glm-5.1-ioa":           "zhipu",
+		"minimax-m2.7-ioa":      "minimax",
+		"kimi-k2.6-ioa":         "kimi",
+		"hy3-preview-ioa":       "hunyuan",
+		"deepseek-v3-2-volc-ioa": "deepseek",
+	}
+	for id, want := range checks {
+		if got := providers[id]; got != want {
+			t.Errorf("provider(%q) = %q, want %q", id, got, want)
+		}
+	}
+}
+
+func TestParseCodebuddyModels_Malformed(t *testing.T) {
+	t.Parallel()
+	models := parseCodebuddyModels("totally unrelated output\nno model line here")
+	if len(models) != 0 {
+		t.Fatalf("expected 0 models from malformed output, got %d", len(models))
+	}
+}
+
+func TestParseCodebuddyEffortHelp(t *testing.T) {
+	t.Parallel()
+	helpOutput := `  --effort <level>                                 Reasoning effort level (low, medium, high, xhigh)`
+	levels := parseCodebuddyEffortHelp(helpOutput)
+	expected := []string{"low", "medium", "high", "xhigh"}
+	if len(levels) != len(expected) {
+		t.Fatalf("expected %d levels, got %d: %v", len(expected), len(levels), levels)
+	}
+	for i, l := range levels {
+		if l != expected[i] {
+			t.Errorf("level[%d]: expected %q, got %q", i, expected[i], l)
+		}
+	}
+}
+
+func TestParseCodebuddyEffortHelp_Missing(t *testing.T) {
+	t.Parallel()
+	levels := parseCodebuddyEffortHelp("no effort line here")
+	if len(levels) != 0 {
+		t.Fatalf("expected nil for missing effort line, got %v", levels)
+	}
+}
+
+func TestIsKnownThinkingValue_Codebuddy(t *testing.T) {
+	t.Parallel()
+	cases := []struct {
+		value string
+		want  bool
+	}{
+		{"", true},
+		{"low", true},
+		{"medium", true},
+		{"high", true},
+		{"xhigh", true},
+		{"max", false},
+		{"none", false},
+	}
+	for _, tc := range cases {
+		got := IsKnownThinkingValue("codebuddy", tc.value)
+		if got != tc.want {
+			t.Errorf("IsKnownThinkingValue(codebuddy, %q) = %v, want %v", tc.value, got, tc.want)
+		}
+	}
+}
+
+func TestCodebuddyHandleUserToolResult(t *testing.T) {
+	t.Parallel()
+
+	b := &codebuddyBackend{cfg: Config{Logger: slog.Default()}}
+	ch := make(chan Message, 10)
+
+	msg := codebuddySDKMessage{
+		Type: "user",
+		Message: mustMarshal(t, codebuddyMessageContent{
+			Role: "user",
+			Content: []codebuddyContentBlock{
+				{
+					Type:      "tool_result",
+					ToolUseID: "call-cb-1",
+					Content:   mustMarshal(t, "tool output here"),
+				},
+			},
+		}),
+	}
+
+	b.handleUser(msg, ch)
+
+	select {
+	case m := <-ch:
+		if m.Type != MessageToolResult || m.CallID != "call-cb-1" {
+			t.Fatalf("unexpected message: %+v", m)
+		}
+	default:
+		t.Fatal("expected message on channel")
+	}
+}
diff --git a/server/pkg/agent/hermes.go b/server/pkg/agent/hermes.go
index ad03246a48..930e575308 100644
--- a/server/pkg/agent/hermes.go
+++ b/server/pkg/agent/hermes.go
@@ -5,6 +5,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"log/slog"
@@ -298,6 +299,17 @@ func (b *hermesBackend) Execute(ctx context.Context, prompt string, opts ExecOpt
 				b.cfg.Logger.Warn("hermes set_session_model failed", "error", err, "requested_model", opts.Model)
 				finalStatus = "failed"
 				finalError = fmt.Sprintf("hermes could not switch to model %q: %v", opts.Model, err)
+				if opts.ResumeSessionID != "" && isACPSessionNotFound(err) {
+					// On a resumed session with a model override, the dead
+					// session surfaces here instead of at session/prompt.
+					// Same fix as the prompt path below: clear the id so
+					// the daemon's resume-failure fallback retries fresh.
+					b.cfg.Logger.Warn("resumed session not found at set_model time; clearing session id so the daemon retries fresh",
+						"backend", "hermes",
+						"session_id", sessionID,
+					)
+					sessionID = ""
+				}
 				resCh <- Result{
 					Status:     finalStatus,
 					Error:      finalError,
@@ -338,6 +350,23 @@ func (b *hermesBackend) Execute(ctx context.Context, prompt string, opts ExecOpt
 			} else {
 				finalStatus = "failed"
 				finalError = fmt.Sprintf("hermes session/prompt failed: %v", err)
+				if opts.ResumeSessionID != "" && isACPSessionNotFound(err) {
+					// The agent no longer knows the session we resumed.
+					// Hermes echoes the requested id back from
+					// session/resume even when the session is gone, so
+					// resolveResumedSessionID can't catch this — it only
+					// surfaces here, at prompt time. Return an empty
+					// SessionID so the daemon's resume-failure fallback
+					// retries with a fresh session and stores the
+					// replacement id; keeping the stale id makes every
+					// future dispatch on this (agent, issue) fail the
+					// same way.
+					b.cfg.Logger.Warn("resumed session not found at prompt time; clearing session id so the daemon retries fresh",
+						"backend", "hermes",
+						"session_id", sessionID,
+					)
+					sessionID = ""
+				}
 			}
 		} else {
 			// The prompt completed. Check if we got a promptDone result
@@ -607,6 +636,46 @@ func (c *hermesClient) handleAgentRequest(raw map[string]json.RawMessage) {
 	}
 }
 
+// acpRPCError is a JSON-RPC error frame returned by the agent process.
+// It renders exactly like the flat string handleResponse used to build
+// with fmt.Errorf, so logs and surfaced task errors are unchanged, but
+// keeps the code and message structured so callers can branch on the
+// error class (see isACPSessionNotFound) instead of parsing text.
+type acpRPCError struct {
+	Method  string
+	Code    int
+	Message string
+	Data    string
+}
+
+func (e *acpRPCError) Error() string {
+	if e.Data != "" {
+		return fmt.Sprintf("%s: %s (code=%d, data=%s)", e.Method, e.Message, e.Code, e.Data)
+	}
+	return fmt.Sprintf("%s: %s (code=%d)", e.Method, e.Message, e.Code)
+}
+
+// isACPSessionNotFound reports whether err is the agent rejecting a
+// session id it no longer knows. Runtimes signal this with codes and
+// wording that vary — Hermes says "Session not found" under -32603
+// (Internal error), Kiro puts "No session found with id ..." in
+// `data` under -32603, and kimi-cli raises invalid_params (-32602)
+// with {"session_id": "Session not found"} in `data` for every
+// unknown-session path (src/kimi_cli/acp/server.py) — so neither the
+// code nor the text alone is discriminating and both are matched.
+func isACPSessionNotFound(err error) bool {
+	var rpcErr *acpRPCError
+	if !errors.As(err, &rpcErr) {
+		return false
+	}
+	if rpcErr.Code != -32603 && rpcErr.Code != -32602 {
+		return false
+	}
+	text := strings.ToLower(rpcErr.Message + " " + rpcErr.Data)
+	return strings.Contains(text, "session not found") ||
+		strings.Contains(text, "no session found")
+}
+
 func (c *hermesClient) handleResponse(raw map[string]json.RawMessage) {
 	var id int
 	if err := json.Unmarshal(raw["id"], &id); err != nil {
@@ -651,11 +720,7 @@ func (c *hermesClient) handleResponse(raw map[string]json.RawMessage) {
 				detail = string(rpcErr.Data)
 			}
 		}
-		if detail != "" {
-			pr.ch <- rpcResult{err: fmt.Errorf("%s: %s (code=%d, data=%s)", pr.method, rpcErr.Message, rpcErr.Code, detail)}
-		} else {
-			pr.ch <- rpcResult{err: fmt.Errorf("%s: %s (code=%d)", pr.method, rpcErr.Message, rpcErr.Code)}
-		}
+		pr.ch <- rpcResult{err: &acpRPCError{Method: pr.method, Code: rpcErr.Code, Message: rpcErr.Message, Data: detail}}
 	} else {
 		// If this is a prompt response, extract usage and stop reason.
 		if pr.method == "session/prompt" {
diff --git a/server/pkg/agent/hermes_test.go b/server/pkg/agent/hermes_test.go
index bc2ec9f1e9..c3d052e37d 100644
--- a/server/pkg/agent/hermes_test.go
+++ b/server/pkg/agent/hermes_test.go
@@ -3,6 +3,7 @@ package agent
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"log/slog"
 	"os"
 	"path/filepath"
@@ -1512,6 +1513,231 @@ func TestHermesBackendPromotesProviderErrorWithNonEmptyOutput(t *testing.T) {
 	}
 }
 
+// TestIsACPSessionNotFound pins the discrimination the resumed-session
+// recovery relies on: only a JSON-RPC -32603 whose text names a missing
+// session counts. Provider errors (429s, auth failures) and plain
+// transport errors must NOT match — those failures happen on sessions
+// that still exist, and clearing the id for them would discard a
+// healthy session.
+func TestIsACPSessionNotFound(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name string
+		err  error
+		want bool
+	}{
+		{
+			name: "hermes session not found in message",
+			err:  &acpRPCError{Method: "session/prompt", Code: -32603, Message: "Session not found"},
+			want: true,
+		},
+		{
+			name: "kiro no session found in data",
+			err:  &acpRPCError{Method: "session/prompt", Code: -32603, Message: "Internal error", Data: "No session found with id ses_abc"},
+			want: true,
+		},
+		{
+			name: "internal error without session wording",
+			err:  &acpRPCError{Method: "session/prompt", Code: -32603, Message: "Internal error", Data: "upstream provider returned HTTP 429"},
+			want: false,
+		},
+		{
+			name: "kimi session not found as invalid_params data",
+			// kimi-cli raises RequestError.invalid_params({"session_id":
+			// "Session not found"}) for every unknown-session path
+			// (src/kimi_cli/acp/server.py), so -32602 must match too.
+			err:  &acpRPCError{Method: "session/set_model", Code: -32602, Message: "Invalid params", Data: `{"session_id": "Session not found"}`},
+			want: true,
+		},
+		{
+			name: "invalid params without session wording",
+			err:  &acpRPCError{Method: "session/set_model", Code: -32602, Message: "model not available: bogus-model"},
+			want: false,
+		},
+		{
+			name: "session wording under an unrelated code",
+			err:  &acpRPCError{Method: "session/prompt", Code: -32601, Message: "Session not found"},
+			want: false,
+		},
+		{
+			name: "plain error",
+			err:  fmt.Errorf("session/prompt: Session not found (code=-32603)"),
+			want: false,
+		},
+		{
+			name: "wrapped rpc error",
+			err:  fmt.Errorf("request failed: %w", &acpRPCError{Method: "session/prompt", Code: -32603, Message: "Session not found"}),
+			want: true,
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			if got := isACPSessionNotFound(tc.err); got != tc.want {
+				t.Errorf("isACPSessionNotFound(%v) = %v, want %v", tc.err, got, tc.want)
+			}
+		})
+	}
+}
+
+// fakeHermesACPStaleResumeScript impersonates the failure shape from
+// GitHub multica#4010: session/resume succeeds and echoes back the
+// requested sessionId (hermes' observed behavior even when it no longer
+// knows the session), and the subsequent session/prompt then fails with
+// JSON-RPC -32603 "Session not found".
+func fakeHermesACPStaleResumeScript() string {
+	return `#!/bin/sh
+while IFS= read -r line; do
+  id=$(printf '%s' "$line" | sed -n 's/.*"id":\([0-9]*\).*/\1/p')
+  case "$line" in
+    *'"method":"initialize"'*)
+      printf '{"jsonrpc":"2.0","id":%s,"result":{"protocolVersion":1,"agentCapabilities":{}}}\n' "$id"
+      ;;
+    *'"method":"session/resume"'*)
+      sid=$(printf '%s' "$line" | sed -n 's/.*"sessionId":"\([^"]*\)".*/\1/p')
+      printf '{"jsonrpc":"2.0","id":%s,"result":{"sessionId":"%s"}}\n' "$id" "$sid"
+      ;;
+    *'"method":"session/prompt"'*)
+      printf '{"jsonrpc":"2.0","id":%s,"error":{"code":-32603,"message":"Session not found"}}\n' "$id"
+      exit 0
+      ;;
+  esac
+done
+`
+}
+
+// TestHermesBackendClearsSessionIDWhenResumedSessionNotFound pins the
+// fix for GitHub multica#4010: when a resumed session turns out to be
+// gone on the agent side (resume echoes the requested id, prompt then
+// fails -32603 "Session not found"), the Result must carry an empty
+// SessionID. The daemon's resume-failure fallback keys on
+// `SessionID == ""` — with the stale id still in the Result, the retry
+// never fires and every future dispatch on the same (agent, issue)
+// loops on the dead session.
+func TestHermesBackendClearsSessionIDWhenResumedSessionNotFound(t *testing.T) {
+	t.Parallel()
+
+	fakePath := filepath.Join(t.TempDir(), "hermes")
+	writeTestExecutable(t, fakePath, []byte(fakeHermesACPStaleResumeScript()))
+
+	backend, err := New("hermes", Config{ExecutablePath: fakePath, Logger: slog.Default()})
+	if err != nil {
+		t.Fatalf("new hermes backend: %v", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	session, err := backend.Execute(ctx, "prompt-ignored", ExecOptions{
+		Timeout:         5 * time.Second,
+		ResumeSessionID: "ses_stale",
+	})
+	if err != nil {
+		t.Fatalf("execute: %v", err)
+	}
+	go func() {
+		for range session.Messages {
+		}
+	}()
+
+	select {
+	case result, ok := <-session.Result:
+		if !ok {
+			t.Fatal("result channel closed without a value")
+		}
+		if result.Status != "failed" {
+			t.Fatalf("expected status=failed, got %q (error=%q)", result.Status, result.Error)
+		}
+		if !strings.Contains(result.Error, "Session not found") {
+			t.Errorf("expected error to surface the session-not-found message, got %q", result.Error)
+		}
+		if result.SessionID != "" {
+			t.Errorf("expected empty session id so the daemon's fresh-session retry fires, got %q", result.SessionID)
+		}
+	case <-time.After(10 * time.Second):
+		t.Fatal("timeout waiting for result")
+	}
+}
+
+// fakeHermesACPStaleResumeSetModelScript is the model-override variant
+// of fakeHermesACPStaleResumeScript: session/resume echoes the requested
+// sessionId back, and the dead session then surfaces at
+// session/set_model (which runs before session/prompt whenever the
+// caller picked a model) with the same -32603 "Session not found".
+func fakeHermesACPStaleResumeSetModelScript() string {
+	return `#!/bin/sh
+while IFS= read -r line; do
+  id=$(printf '%s' "$line" | sed -n 's/.*"id":\([0-9]*\).*/\1/p')
+  case "$line" in
+    *'"method":"initialize"'*)
+      printf '{"jsonrpc":"2.0","id":%s,"result":{"protocolVersion":1,"agentCapabilities":{}}}\n' "$id"
+      ;;
+    *'"method":"session/resume"'*)
+      sid=$(printf '%s' "$line" | sed -n 's/.*"sessionId":"\([^"]*\)".*/\1/p')
+      printf '{"jsonrpc":"2.0","id":%s,"result":{"sessionId":"%s"}}\n' "$id" "$sid"
+      ;;
+    *'"method":"session/set_model"'*)
+      printf '{"jsonrpc":"2.0","id":%s,"error":{"code":-32603,"message":"Session not found"}}\n' "$id"
+      exit 0
+      ;;
+  esac
+done
+`
+}
+
+// TestHermesBackendClearsSessionIDWhenSetModelSessionNotFound pins the
+// set_model sibling of the prompt-path fix above: with a model
+// override, session/set_model runs before session/prompt, so a dead
+// resumed session surfaces there instead. The Result must carry an
+// empty SessionID here too, or the daemon's fresh-session retry never
+// fires for any agent configured with a model.
+func TestHermesBackendClearsSessionIDWhenSetModelSessionNotFound(t *testing.T) {
+	t.Parallel()
+
+	fakePath := filepath.Join(t.TempDir(), "hermes")
+	writeTestExecutable(t, fakePath, []byte(fakeHermesACPStaleResumeSetModelScript()))
+
+	backend, err := New("hermes", Config{ExecutablePath: fakePath, Logger: slog.Default()})
+	if err != nil {
+		t.Fatalf("new hermes backend: %v", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	session, err := backend.Execute(ctx, "prompt-ignored", ExecOptions{
+		Timeout:         5 * time.Second,
+		ResumeSessionID: "ses_stale",
+		Model:           "some-model",
+	})
+	if err != nil {
+		t.Fatalf("execute: %v", err)
+	}
+	go func() {
+		for range session.Messages {
+		}
+	}()
+
+	select {
+	case result, ok := <-session.Result:
+		if !ok {
+			t.Fatal("result channel closed without a value")
+		}
+		if result.Status != "failed" {
+			t.Fatalf("expected status=failed, got %q (error=%q)", result.Status, result.Error)
+		}
+		if !strings.Contains(result.Error, `could not switch to model "some-model"`) {
+			t.Errorf("expected error to name the requested model, got %q", result.Error)
+		}
+		if result.SessionID != "" {
+			t.Errorf("expected empty session id so the daemon's fresh-session retry fires, got %q", result.SessionID)
+		}
+	case <-time.After(10 * time.Second):
+		t.Fatal("timeout waiting for result")
+	}
+}
+
 // fakeHermesACPTransientRetryScript emits a single retryable per-
 // attempt warning to stderr and then completes with a normal agent
 // text turn — the situation where the upstream LLM blipped on
diff --git a/server/pkg/agent/kimi.go b/server/pkg/agent/kimi.go
index 896b276e79..db266e4f5b 100644
--- a/server/pkg/agent/kimi.go
+++ b/server/pkg/agent/kimi.go
@@ -273,6 +273,17 @@ func (b *kimiBackend) Execute(ctx context.Context, prompt string, opts ExecOptio
 				b.cfg.Logger.Warn("kimi set_session_model failed", "error", err, "requested_model", opts.Model)
 				finalStatus = "failed"
 				finalError = fmt.Sprintf("kimi could not switch to model %q: %v", opts.Model, err)
+				if opts.ResumeSessionID != "" && isACPSessionNotFound(err) {
+					// On a resumed session with a model override, the dead
+					// session surfaces here instead of at session/prompt.
+					// Same fix as the prompt path below: clear the id so
+					// the daemon's resume-failure fallback retries fresh.
+					b.cfg.Logger.Warn("resumed session not found at set_model time; clearing session id so the daemon retries fresh",
+						"backend", "kimi",
+						"session_id", sessionID,
+					)
+					sessionID = ""
+				}
 				resCh <- Result{
 					Status:     finalStatus,
 					Error:      finalError,
@@ -307,6 +318,19 @@ func (b *kimiBackend) Execute(ctx context.Context, prompt string, opts ExecOptio
 			} else {
 				finalStatus = "failed"
 				finalError = fmt.Sprintf("kimi session/prompt failed: %v", err)
+				if opts.ResumeSessionID != "" && isACPSessionNotFound(err) {
+					// See the hermes backend: the runtime echoes the
+					// requested id back from session/resume even when
+					// the session is gone, so the stale id only fails
+					// here, at prompt time. Empty SessionID lets the
+					// daemon's resume-failure fallback retry fresh and
+					// store the replacement id.
+					b.cfg.Logger.Warn("resumed session not found at prompt time; clearing session id so the daemon retries fresh",
+						"backend", "kimi",
+						"session_id", sessionID,
+					)
+					sessionID = ""
+				}
 			}
 		} else {
 			select {
diff --git a/server/pkg/agent/kimi_test.go b/server/pkg/agent/kimi_test.go
index b4df8124dd..5734908130 100644
--- a/server/pkg/agent/kimi_test.go
+++ b/server/pkg/agent/kimi_test.go
@@ -149,6 +149,85 @@ func TestKimiBackendSetModelFailureFailsTask(t *testing.T) {
 	}
 }
 
+// fakeKimiACPStaleResumeSetModelScript impersonates kimi-cli when a
+// resumed session is gone and the caller picked a model:
+// session/resume echoes the requested sessionId back, then
+// session/set_model rejects the unknown session the way kimi-cli
+// actually does — RequestError.invalid_params (-32602) with
+// {"session_id": "Session not found"} in data
+// (src/kimi_cli/acp/server.py, set_session_model).
+func fakeKimiACPStaleResumeSetModelScript() string {
+	return `#!/bin/sh
+while IFS= read -r line; do
+  id=$(printf '%s' "$line" | sed -n 's/.*"id":\([0-9]*\).*/\1/p')
+  case "$line" in
+    *'"method":"initialize"'*)
+      printf '{"jsonrpc":"2.0","id":%s,"result":{"protocolVersion":1,"agentCapabilities":{}}}\n' "$id"
+      ;;
+    *'"method":"session/resume"'*)
+      sid=$(printf '%s' "$line" | sed -n 's/.*"sessionId":"\([^"]*\)".*/\1/p')
+      printf '{"jsonrpc":"2.0","id":%s,"result":{"sessionId":"%s"}}\n' "$id" "$sid"
+      ;;
+    *'"method":"session/set_model"'*)
+      printf '{"jsonrpc":"2.0","id":%s,"error":{"code":-32602,"message":"Invalid params","data":{"session_id":"Session not found"}}}\n' "$id"
+      exit 0
+      ;;
+  esac
+done
+`
+}
+
+// TestKimiBackendClearsSessionIDWhenSetModelSessionNotFound pins the
+// set_model sibling of the resumed-session fix: with a model override,
+// session/set_model runs before session/prompt, so a dead resumed
+// session surfaces there. The Result must carry an empty SessionID so
+// the daemon's fresh-session retry (gated on SessionID == "") fires.
+func TestKimiBackendClearsSessionIDWhenSetModelSessionNotFound(t *testing.T) {
+	t.Parallel()
+
+	fakePath := filepath.Join(t.TempDir(), "kimi")
+	writeTestExecutable(t, fakePath, []byte(fakeKimiACPStaleResumeSetModelScript()))
+
+	backend, err := New("kimi", Config{ExecutablePath: fakePath, Logger: slog.Default()})
+	if err != nil {
+		t.Fatalf("new kimi backend: %v", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	session, err := backend.Execute(ctx, "prompt-ignored", ExecOptions{
+		Timeout:         5 * time.Second,
+		ResumeSessionID: "ses_stale",
+		Model:           "kimi-for-coding",
+	})
+	if err != nil {
+		t.Fatalf("execute: %v", err)
+	}
+	go func() {
+		for range session.Messages {
+		}
+	}()
+
+	select {
+	case result, ok := <-session.Result:
+		if !ok {
+			t.Fatal("result channel closed without a value")
+		}
+		if result.Status != "failed" {
+			t.Fatalf("expected status=failed, got %q (error=%q)", result.Status, result.Error)
+		}
+		if !strings.Contains(result.Error, `could not switch to model "kimi-for-coding"`) {
+			t.Errorf("expected error to name the requested model, got %q", result.Error)
+		}
+		if result.SessionID != "" {
+			t.Errorf("expected empty session id so the daemon's fresh-session retry fires, got %q", result.SessionID)
+		}
+	case <-time.After(10 * time.Second):
+		t.Fatal("timeout waiting for result")
+	}
+}
+
 // TestKimiBackendInvokesACPSubcommand pins the argv for `kimi`. An
 // earlier fix tried passing `--yolo` to bypass per-tool approval
 // prompts, but the `acp` subcommand in kimi-cli takes no options
diff --git a/server/pkg/agent/kiro.go b/server/pkg/agent/kiro.go
index d85f2fea23..f6d79473d0 100644
--- a/server/pkg/agent/kiro.go
+++ b/server/pkg/agent/kiro.go
@@ -257,6 +257,17 @@ func (b *kiroBackend) Execute(ctx context.Context, prompt string, opts ExecOptio
 				b.cfg.Logger.Warn("kiro set_session_model failed", "error", err, "requested_model", opts.Model)
 				finalStatus = "failed"
 				finalError = fmt.Sprintf("kiro could not switch to model %q: %v", opts.Model, err)
+				if opts.ResumeSessionID != "" && isACPSessionNotFound(err) {
+					// On a resumed session with a model override, the dead
+					// session surfaces here instead of at session/prompt.
+					// Same fix as the prompt path below: clear the id so
+					// the daemon's resume-failure fallback retries fresh.
+					b.cfg.Logger.Warn("resumed session not found at set_model time; clearing session id so the daemon retries fresh",
+						"backend", "kiro",
+						"session_id", sessionID,
+					)
+					sessionID = ""
+				}
 				resCh <- Result{
 					Status:     finalStatus,
 					Error:      finalError,
@@ -296,6 +307,19 @@ func (b *kiroBackend) Execute(ctx context.Context, prompt string, opts ExecOptio
 			} else {
 				finalStatus = "failed"
 				finalError = fmt.Sprintf("kiro session/prompt failed: %v", err)
+				if opts.ResumeSessionID != "" && isACPSessionNotFound(err) {
+					// See the hermes backend: the runtime echoes the
+					// requested id back from session/resume even when
+					// the session is gone, so the stale id only fails
+					// here, at prompt time. Empty SessionID lets the
+					// daemon's resume-failure fallback retry fresh and
+					// store the replacement id.
+					b.cfg.Logger.Warn("resumed session not found at prompt time; clearing session id so the daemon retries fresh",
+						"backend", "kiro",
+						"session_id", sessionID,
+					)
+					sessionID = ""
+				}
 			}
 		} else {
 			select {
diff --git a/server/pkg/agent/kiro_test.go b/server/pkg/agent/kiro_test.go
index 5ac23f34f8..7175f0440f 100644
--- a/server/pkg/agent/kiro_test.go
+++ b/server/pkg/agent/kiro_test.go
@@ -162,6 +162,82 @@ func TestKiroBackendSetModelFailureFailsTask(t *testing.T) {
 	}
 }
 
+// fakeKiroACPStaleLoadSetModelScript impersonates kiro when a resumed
+// session is gone and the caller picked a model: session/load returns
+// an empty result (so the requested id is kept), then
+// session/set_model rejects the unknown session with kiro's observed
+// wording — -32603 with "No session found with id ..." in data.
+func fakeKiroACPStaleLoadSetModelScript() string {
+	return `#!/bin/sh
+while IFS= read -r line; do
+  id=$(printf '%s' "$line" | sed -n 's/.*"id":\([0-9]*\).*/\1/p')
+  case "$line" in
+    *'"method":"initialize"'*)
+      printf '{"jsonrpc":"2.0","id":%s,"result":{"protocolVersion":1,"agentCapabilities":{"loadSession":true}}}\n' "$id"
+      ;;
+    *'"method":"session/load"'*)
+      printf '{"jsonrpc":"2.0","id":%s,"result":{}}\n' "$id"
+      ;;
+    *'"method":"session/set_model"'*)
+      printf '{"jsonrpc":"2.0","id":%s,"error":{"code":-32603,"message":"Internal error","data":"No session found with id ses_stale"}}\n' "$id"
+      exit 0
+      ;;
+  esac
+done
+`
+}
+
+// TestKiroBackendClearsSessionIDWhenSetModelSessionNotFound pins the
+// set_model sibling of the resumed-session fix: with a model override,
+// session/set_model runs before session/prompt, so a dead resumed
+// session surfaces there. The Result must carry an empty SessionID so
+// the daemon's fresh-session retry (gated on SessionID == "") fires.
+func TestKiroBackendClearsSessionIDWhenSetModelSessionNotFound(t *testing.T) {
+	t.Parallel()
+
+	fakePath := filepath.Join(t.TempDir(), "kiro-cli")
+	writeTestExecutable(t, fakePath, []byte(fakeKiroACPStaleLoadSetModelScript()))
+
+	backend, err := New("kiro", Config{ExecutablePath: fakePath, Logger: slog.Default()})
+	if err != nil {
+		t.Fatalf("new kiro backend: %v", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	session, err := backend.Execute(ctx, "prompt-ignored", ExecOptions{
+		Timeout:         5 * time.Second,
+		ResumeSessionID: "ses_stale",
+		Model:           "auto",
+	})
+	if err != nil {
+		t.Fatalf("execute: %v", err)
+	}
+	go func() {
+		for range session.Messages {
+		}
+	}()
+
+	select {
+	case result, ok := <-session.Result:
+		if !ok {
+			t.Fatal("result channel closed without a value")
+		}
+		if result.Status != "failed" {
+			t.Fatalf("expected status=failed, got %q (error=%q)", result.Status, result.Error)
+		}
+		if !strings.Contains(result.Error, `could not switch to model "auto"`) {
+			t.Errorf("expected error to name the requested model, got %q", result.Error)
+		}
+		if result.SessionID != "" {
+			t.Errorf("expected empty session id so the daemon's fresh-session retry fires, got %q", result.SessionID)
+		}
+	case <-time.After(10 * time.Second):
+		t.Fatal("timeout waiting for result")
+	}
+}
+
 func TestKiroBackendInvokesACPWithTrustAllTools(t *testing.T) {
 	t.Parallel()
 
diff --git a/server/pkg/agent/models.go b/server/pkg/agent/models.go
index fea6d3abd1..bfc9e1076d 100644
--- a/server/pkg/agent/models.go
+++ b/server/pkg/agent/models.go
@@ -9,6 +9,7 @@ import (
 	"io"
 	"os"
 	"os/exec"
+	"regexp"
 	"sort"
 	"strings"
 	"sync"
@@ -141,6 +142,15 @@ func ListModels(ctx context.Context, providerType, executablePath string) ([]Mod
 		return cachedDiscovery(providerType, func() ([]Model, error) {
 			return discoverOpenclawAgents(ctx, executablePath)
 		})
+	case "codebuddy":
+		return cachedDiscovery(providerType, func() ([]Model, error) {
+			models, err := discoverCodebuddyModels(ctx, executablePath)
+			if err != nil {
+				return nil, err
+			}
+			annotateCodebuddyThinking(ctx, models, executablePath)
+			return models, nil
+		})
 	default:
 		return nil, fmt.Errorf("unknown agent type: %q", providerType)
 	}
@@ -1307,3 +1317,111 @@ func isOpenclawIdentifier(s string) bool {
 	}
 	return true
 }
+
+// ── CodeBuddy model discovery ──
+
+// codebuddyModelRe matches the `--model <model> ... Currently supported: (m1, m2, ...)`
+// line in `codebuddy --help` output.
+var codebuddyModelRe = regexp.MustCompile(`--model\s*<[^>]+>\s*.*?Currently supported:\s*\(([^)]+)\)`)
+
+// discoverCodebuddyModels runs `codebuddy --help` and extracts the
+// supported model list from its output. Falls back to a static list
+// when the binary is missing or the output cannot be parsed.
+func discoverCodebuddyModels(ctx context.Context, executablePath string) ([]Model, error) {
+	if executablePath == "" {
+		executablePath = "codebuddy"
+	}
+	if _, err := exec.LookPath(executablePath); err != nil {
+		return codebuddyStaticModels(), nil
+	}
+	helpOut := codebuddyHelpOutput(ctx, executablePath)
+	if helpOut == "" {
+		return codebuddyStaticModels(), nil
+	}
+	models := parseCodebuddyModels(helpOut)
+	if len(models) == 0 {
+		return codebuddyStaticModels(), nil
+	}
+	return models, nil
+}
+
+// parseCodebuddyModels extracts model IDs from codebuddy --help output.
+// The help text contains a line like:
+//
+//	--model <model>  ... Currently supported: (model1, model2, ...)
+//
+// The first model in the list is marked as default.
+func parseCodebuddyModels(helpOutput string) []Model {
+	match := codebuddyModelRe.FindStringSubmatch(helpOutput)
+	if len(match) < 2 {
+		return nil
+	}
+	raw := strings.Split(match[1], ",")
+	var models []Model
+	for _, s := range raw {
+		id := strings.TrimSpace(s)
+		if id == "" {
+			continue
+		}
+		models = append(models, Model{
+			ID:       id,
+			Label:    codebuddyModelLabel(id),
+			Provider: codebuddyModelProvider(id),
+			Default:  len(models) == 0,
+		})
+	}
+	return models
+}
+
+// codebuddyModelProvider infers a provider name from a model ID prefix.
+func codebuddyModelProvider(id string) string {
+	switch {
+	case strings.HasPrefix(id, "claude-"):
+		return "anthropic"
+	case strings.HasPrefix(id, "gemini-"):
+		return "google"
+	case strings.HasPrefix(id, "gpt-"):
+		return "openai"
+	case strings.HasPrefix(id, "glm-"):
+		return "zhipu"
+	case strings.HasPrefix(id, "minimax-"):
+		return "minimax"
+	case strings.HasPrefix(id, "kimi-"):
+		return "kimi"
+	case len(id) >= 3 && id[0] == 'h' && id[1] == 'y' && id[2] >= '0' && id[2] <= '9':
+		return "hunyuan"
+	case strings.HasPrefix(id, "deepseek-"):
+		return "deepseek"
+	default:
+		return ""
+	}
+}
+
+// codebuddyModelLabel generates a human-readable label from a model ID.
+// Capitalizes each dash-separated part; special-cases GPT/GLM to uppercase
+// and rewrites the "-ioa" suffix as "IOA".
+func codebuddyModelLabel(id string) string {
+	parts := strings.Split(id, "-")
+	for i, p := range parts {
+		if strings.EqualFold(p, "gpt") || strings.EqualFold(p, "glm") {
+			parts[i] = strings.ToUpper(p)
+		} else if strings.EqualFold(p, "ioa") {
+			parts[i] = "IOA"
+		} else if len(p) > 0 {
+			parts[i] = strings.ToUpper(p[:1]) + p[1:]
+		}
+	}
+	return strings.Join(parts, " ")
+}
+
+// codebuddyStaticModels is the fallback catalog when dynamic discovery
+// fails (binary missing, parse error, timeout).
+func codebuddyStaticModels() []Model {
+	return []Model{
+		{ID: "claude-sonnet-4.6", Label: "Claude Sonnet 4.6", Provider: "anthropic", Default: true},
+		{ID: "claude-opus-4.7", Label: "Claude Opus 4.7", Provider: "anthropic"},
+		{ID: "gemini-3.1-pro", Label: "Gemini 3.1 Pro", Provider: "google"},
+		{ID: "gpt-5.5", Label: "GPT 5.5", Provider: "openai"},
+		{ID: "deepseek-v3-2-volc-ioa", Label: "Deepseek V3 2 Volc IOA", Provider: "deepseek"},
+	}
+}
diff --git a/server/pkg/agent/thinking.go b/server/pkg/agent/thinking.go
index 851111a09e..537862a0f2 100644
--- a/server/pkg/agent/thinking.go
+++ b/server/pkg/agent/thinking.go
@@ -358,6 +358,141 @@ func parseCodexDebugModels(raw []byte) map[string]*ModelThinking {
 	return out
 }
 
+// ── CodeBuddy ────────────────────────────────────────────────────────
+//
+// CodeBuddy uses the same `--effort <level>` flag as Claude but with a
+// different level set (no `max`). Discovery parses `--help` identically
+// to the claude approach. All models get the same effort levels since
+// CodeBuddy doesn't document per-model restrictions.
+
+var codebuddyEffortRe = regexp.MustCompile(`--effort\s*(?:<[^>]+>)?\s*[^(]*\(([^)]+)\)`)
+
+var codebuddyEffortLabel = map[string]string{
+	"low":    "Low",
+	"medium": "Medium",
+	"high":   "High",
+	"xhigh":  "Extra high",
+}
+
+var codebuddyStaticEffortFallback = []string{"low", "medium", "high", "xhigh"}
+
+// codebuddyHelpCache caches the raw --help output so both model discovery
+// (models.go) and effort discovery avoid redundant slow CLI invocations.
+// CodeBuddy's --help takes ~30s; calling it twice on cold start wastes ~30s.
+var (
+	codebuddyHelpMu    sync.Mutex
+	codebuddyHelpStore = map[string]codebuddyHelpEntry{}
+)
+
+const codebuddyHelpTTL = 60 * time.Second
+
+type codebuddyHelpEntry struct {
+	output    string
+	expiresAt time.Time
+}
+
+// codebuddyHelpOutput runs `codebuddy --help` (cached for codebuddyHelpTTL).
+// Both discoverCodebuddyModels and codebuddyEffortSuperset call this so a
+// single cold invocation feeds both.
+func codebuddyHelpOutput(ctx context.Context, executablePath string) string {
+	if executablePath == "" {
+		executablePath = "codebuddy"
+	}
+	key := executablePath
+	codebuddyHelpMu.Lock()
+	if entry, ok := codebuddyHelpStore[key]; ok && time.Now().Before(entry.expiresAt) {
+		codebuddyHelpMu.Unlock()
+		return entry.output
+	}
+	codebuddyHelpMu.Unlock()
+
+	runCtx, cancel := context.WithTimeout(ctx, 35*time.Second)
+	defer cancel()
+	cmd := exec.CommandContext(runCtx, executablePath, "--help")
+	hideAgentWindow(cmd)
+	out, _ := cmd.CombinedOutput()
+	result := string(out)
+
+	if result != "" {
+		codebuddyHelpMu.Lock()
+		codebuddyHelpStore[key] = codebuddyHelpEntry{output: result, expiresAt: time.Now().Add(codebuddyHelpTTL)}
+		codebuddyHelpMu.Unlock()
+	}
+	return result
+}
+
+func annotateCodebuddyThinking(ctx context.Context, models []Model, executablePath string) {
+	if executablePath == "" {
+		executablePath = "codebuddy"
+	}
+	version, _ := DetectVersion(ctx, executablePath)
+	key := thinkingCacheKey{provider: "codebuddy", executablePath: executablePath, cliVersion: version}
+	if cached, ok := thinkingCacheGet(key); ok {
+		for i := range models {
+			if t, ok := cached[models[i].ID]; ok && t != nil {
+				models[i].Thinking = t
+			}
+		}
+		return
+	}
+
+	levels := codebuddyEffortSuperset(ctx, executablePath)
+	thinkingLevels := make([]ThinkingLevel, 0, len(levels))
+	for _, value := range levels {
+		label, ok := codebuddyEffortLabel[value]
+		if !ok {
+			label = strings.Title(value) //nolint:staticcheck
+		}
+		thinkingLevels = append(thinkingLevels, ThinkingLevel{Value: value, Label: label})
+	}
+
+	result := map[string]*ModelThinking{}
+	if len(thinkingLevels) > 0 {
+		thinking := &ModelThinking{
+			SupportedLevels: thinkingLevels,
+			DefaultLevel:    "medium",
+		}
+		for _, m := range models {
+			result[m.ID] = thinking
+		}
+	}
+	thinkingCachePut(key, result)
+
+	for i := range models {
+		if t, ok := result[models[i].ID]; ok && t != nil {
+			models[i].Thinking = t
+		}
+	}
+}
+
+func codebuddyEffortSuperset(ctx context.Context, executablePath string) []string {
+	helpOut := codebuddyHelpOutput(ctx, executablePath)
+	if helpOut == "" {
+		return append([]string(nil), codebuddyStaticEffortFallback...)
+	}
+	parsed := parseCodebuddyEffortHelp(helpOut)
+	if len(parsed) == 0 {
+		return append([]string(nil), codebuddyStaticEffortFallback...)
+	}
+	return parsed
+}
+
+func parseCodebuddyEffortHelp(helpText string) []string {
+	match := codebuddyEffortRe.FindStringSubmatch(helpText)
+	if len(match) < 2 {
+		return nil
+	}
+	var out []string
+	for _, raw := range strings.Split(match[1], ",") {
+		token := strings.TrimSpace(raw)
+		if token == "" {
+			continue
+		}
+		out = append(out, token)
+	}
+	return out
+}
+
 // ── Shared validation ────────────────────────────────────────────────
 
 // ValidateThinkingLevel reports whether `value` is in the supported
@@ -469,6 +604,12 @@ var providerThinkingEnums = map[string]map[string]bool{
 		"high":    true,
 		"xhigh":   true,
 	},
+	"codebuddy": {
+		"low":    true,
+		"medium": true,
+		"high":   true,
+		"xhigh":  true,
+	},
 }
 
 // IsKnownThinkingValue reports whether `value` is a recognised effort
diff --git a/server/pkg/agent/version.go b/server/pkg/agent/version.go
index 82e82e59f7..df0a40de16 100644
--- a/server/pkg/agent/version.go
+++ b/server/pkg/agent/version.go
@@ -19,11 +19,12 @@ var MinVersions = map[string]string{
 // MinQuickCreateCLIVersion gates the agent-create (quick-create) flow against
 // the multica CLI version reported by the daemon at registration time. The
 // quick-create prompt that the agent runs depends on CLI behavior introduced
-// after this version (attachment URL handling, no-retry semantics on
-// `multica issue create` failure — see PR #1851); older daemons would either
-// double-create issues or mishandle pasted screenshot URLs. Treated as a hard
-// requirement: missing / unparsable / below this threshold all fail closed.
-const MinQuickCreateCLIVersion = "0.2.20"
+// after this version (attachment URL handling, quick-create attachment
+// binding, no-retry semantics on `multica issue create` failure — see PR
+// #1851); older daemons would either double-create issues or mishandle pasted
+// screenshot URLs. Treated as a hard requirement: missing / unparsable / below
+// this threshold all fail closed.
+const MinQuickCreateCLIVersion = "0.2.21"
 
 // Errors returned by CheckMinCLIVersion. Callers branch on these to surface
 // "needs upgrade" vs "version not reported" with the right user message.
diff --git a/server/pkg/agent/version_test.go b/server/pkg/agent/version_test.go
index da65ce14e3..66d5ed66e8 100644
--- a/server/pkg/agent/version_test.go
+++ b/server/pkg/agent/version_test.go
@@ -58,14 +58,15 @@ func TestCheckMinCLIVersion(t *testing.T) {
 		input   string
 		wantErr error
 	}{
-		{"tagged release at minimum", "v0.2.20", nil},
+		{"tagged release at minimum", "v0.2.21", nil},
 		{"tagged release above minimum", "0.3.1", nil},
+		{"previous tagged release below minimum", "v0.2.20", ErrCLIVersionTooOld},
 		{"tagged release below minimum", "v0.2.15", ErrCLIVersionTooOld},
 		{"empty string", "", ErrCLIVersionMissing},
 		{"unparsable", "not-a-version", ErrCLIVersionMissing},
 		{"git-describe dev build past old tag", "v0.2.15-235-gdaf0e935", nil},
 		{"git-describe dirty dev build", "v0.2.15-235-gdaf0e935-dirty", nil},
-		{"git-describe dev build past current tag", "v0.2.20-3-gabc1234", nil},
+		{"git-describe dev build past current tag", "v0.2.21-3-gabc1234", nil},
 	}
 	for _, tt := range tests {
 		err := CheckMinCLIVersion(tt.input)
diff --git a/server/pkg/db/generated/chat.sql.go b/server/pkg/db/generated/chat.sql.go
index 3b176c8f59..67298a4fa3 100644
--- a/server/pkg/db/generated/chat.sql.go
+++ b/server/pkg/db/generated/chat.sql.go
@@ -164,6 +164,28 @@ func (q *Queries) DeleteChatSession(ctx context.Context, arg DeleteChatSessionPa
 	return err
 }
 
+const deleteUserChatMessageByTask = `-- name: DeleteUserChatMessageByTask :one
+DELETE FROM chat_message
+WHERE task_id = $1 AND role = 'user'
+RETURNING id, chat_session_id, role, content, task_id, created_at, failure_reason, elapsed_ms
+`
+
+func (q *Queries) DeleteUserChatMessageByTask(ctx context.Context, taskID pgtype.UUID) (ChatMessage, error) {
+	row := q.db.QueryRow(ctx, deleteUserChatMessageByTask, taskID)
+	var i ChatMessage
+	err := row.Scan(
+		&i.ID,
+		&i.ChatSessionID,
+		&i.Role,
+		&i.Content,
+		&i.TaskID,
+		&i.CreatedAt,
+		&i.FailureReason,
+		&i.ElapsedMs,
+	)
+	return i, err
+}
+
 const getChatMessage = `-- name: GetChatMessage :one
 SELECT id, chat_session_id, role, content, task_id, created_at, failure_reason, elapsed_ms FROM chat_message
 WHERE id = $1
@@ -329,6 +351,22 @@ func (q *Queries) GetPendingChatTask(ctx context.Context, chatSessionID pgtype.U
 	return i, err
 }
 
+const linkChatMessageToTask = `-- name: LinkChatMessageToTask :exec
+UPDATE chat_message
+SET task_id = $2
+WHERE id = $1 AND role = 'user'
+`
+
+type LinkChatMessageToTaskParams struct {
+	ID     pgtype.UUID `json:"id"`
+	TaskID pgtype.UUID `json:"task_id"`
+}
+
+func (q *Queries) LinkChatMessageToTask(ctx context.Context, arg LinkChatMessageToTaskParams) error {
+	_, err := q.db.Exec(ctx, linkChatMessageToTask, arg.ID, arg.TaskID)
+	return err
+}
+
 const listAllChatSessionsByCreator = `-- name: ListAllChatSessionsByCreator :many
 SELECT cs.id, cs.workspace_id, cs.agent_id, cs.creator_id, cs.title, cs.session_id, cs.work_dir, cs.status, cs.created_at, cs.updated_at, cs.unread_since, cs.runtime_id,
        (cs.unread_since IS NOT NULL)::bool AS has_unread
diff --git a/server/pkg/db/generated/octo.sql.go b/server/pkg/db/generated/octo.sql.go
index 40c27063a5..55d0a42136 100644
--- a/server/pkg/db/generated/octo.sql.go
+++ b/server/pkg/db/generated/octo.sql.go
@@ -241,7 +241,7 @@ type CreateOctoInstallationParams struct {
 }
 
 // Octo IM Bot integration queries. The migration that defines these tables
-// lives at server/migrations/119_octo_integration.up.sql.
+// lives at server/migrations/120_octo_integration.up.sql.
 //
 // Scoping convention: every public-facing read goes through a workspace-scoped
 // variant where one exists. The lookups that take only a UUID PK (e.g.
diff --git a/server/pkg/db/queries/chat.sql b/server/pkg/db/queries/chat.sql
index b909effd0e..269cea67f3 100644
--- a/server/pkg/db/queries/chat.sql
+++ b/server/pkg/db/queries/chat.sql
@@ -78,6 +78,16 @@ INSERT INTO chat_message (chat_session_id, role, content, task_id, failure_reaso
 VALUES ($1, $2, $3, sqlc.narg(task_id), sqlc.narg(failure_reason), sqlc.narg(elapsed_ms))
 RETURNING *;
 
+-- name: LinkChatMessageToTask :exec
+UPDATE chat_message
+SET task_id = $2
+WHERE id = $1 AND role = 'user';
+
+-- name: DeleteUserChatMessageByTask :one
+DELETE FROM chat_message
+WHERE task_id = $1 AND role = 'user'
+RETURNING *;
+
 -- name: ListChatMessages :many
 SELECT * FROM chat_message
 WHERE chat_session_id = $1
diff --git a/server/pkg/db/queries/octo.sql b/server/pkg/db/queries/octo.sql
index f8a0148f32..556962c753 100644
--- a/server/pkg/db/queries/octo.sql
+++ b/server/pkg/db/queries/octo.sql
@@ -1,5 +1,5 @@
 -- Octo IM Bot integration queries. The migration that defines these tables
--- lives at server/migrations/119_octo_integration.up.sql.
+-- lives at server/migrations/120_octo_integration.up.sql.
 --
 -- Scoping convention: every public-facing read goes through a workspace-scoped
 -- variant where one exists. The lookups that take only a UUID PK (e.g.