diff --git a/dashboard/src/lib/ctxClient.ts b/dashboard/src/lib/ctxClient.ts
index e1c9295..72b7e15 100644
--- a/dashboard/src/lib/ctxClient.ts
+++ b/dashboard/src/lib/ctxClient.ts
@@ -41,12 +41,18 @@ import type {
   RetrieveRequest,
   RetrieveResponse,
   SeedResponse,
+  SkillConfirmRequest,
+  SkillConfirmResponse,
   SkillContextRequest,
   SkillContextResponse,
+  SkillExportRequest,
+  SkillExportResponse,
   SkillMdRequest,
   SkillMdResponse,
   SkillToolsRequest,
   SkillToolsResponse,
+  SkillUpdateRequest,
+  SkillUpdateResponse,
   StatusIdResponse,
   UpstreamRequest,
   UpstreamResponse,
@@ -187,6 +193,11 @@ export const ctx = {
   skillTools: (req: SkillToolsRequest) => post<SkillToolsResponse>("/skill_tools", req),
   skillContext: (req: SkillContextRequest) => post<SkillContextResponse>("/skill_context", req),
   skillMd: (req: SkillMdRequest) => post<SkillMdResponse>("/skill_md", req),
+  updateSkill: (req: SkillUpdateRequest) => put<SkillUpdateResponse>("/skill", req),
+  confirmSkill: (req: SkillConfirmRequest) =>
+    post<SkillConfirmResponse>("/skill/confirm", req),
+  exportSkill: (req: SkillExportRequest) =>
+    post<SkillExportResponse>("/skill/export", req),
   envVault: {
     items: () => get<EnvVaultItemsResponse>("/env-vault/items"),
     upsert: (req: EnvVaultUpsertRequest) =>
diff --git a/dashboard/src/lib/i18n.tsx b/dashboard/src/lib/i18n.tsx
index 55b9ca5..d6bcb57 100644
--- a/dashboard/src/lib/i18n.tsx
+++ b/dashboard/src/lib/i18n.tsx
@@ -282,6 +282,35 @@ const zh: Dict = {
   "skills.export": "导出格式",
   "skills.export.download": "下载",
   "skills.export.noSkills": "暂无技能",
+  "skills.export.toDir": "导出到目录",
+  "skills.export.title": "导出 Skill",
+  "skills.export.desc": "将已确认的 skill 导出为 SKILL.md，供其他 agent 使用",
+  "skills.export.targetDir": "目标目录",
+  "skills.export.pickDir": "选择目录",
+  "skills.export.dirPlaceholder": "导出目录的绝对路径",
+  "skills.export.manualHint": "非桌面环境请手动输入绝对路径",
+  "skills.export.quickTargets": "常用目标",
+  "skills.export.target.user": "用户默认技能目录",
+  "skills.export.target.project": "当前项目技能目录",
+  "skills.export.target.codex": "Codex 技能目录",
+  "skills.export.target.cursor": "Cursor 技能目录",
+  "skills.export.target.recent": "最近使用",
+  "skills.export.conflictStrategy": "冲突策略",
+  "skills.export.conflict.overwrite": "覆盖",
+  "skills.export.conflict.skip": "跳过",
+  "skills.export.conflict.rename": "重命名",
+  "skills.export.conflict.hint": "目标已存在同名 SKILL.md 时的处理方式",
+  "skills.export.spec": "格式",
+  "skills.export.spec.hermes": "Hermes",
+  "skills.export.spec.agent": "Agent (Anthropic)",
+  "skills.export.submit": "导出",
+  "skills.export.exporting": "导出中…",
+  "skills.export.success": "已导出到 {path}（写入 {written} 个 skill）",
+  "skills.export.skipped": "跳过 {n} 个未确认 skill",
+  "skills.export.error": "导出失败",
+  "skills.export.needConfirm": "未确认的 skill 不可导出，请先在详情中确认",
+  "skills.export.noSelection": "请至少选择一个已确认的 skill",
+  "skills.export.noConfirmed": "暂无已确认的 skill 可导出",
   "skills.systemPrompt": "注入 Agent 的 Prompt 片段",
   "skills.systemPrompt.hint": "将 prompt 类型的 skill 格式化为 <available_skills> 块，复制后粘贴到你的 LLM 系统提示中，LLM 即可感知并遵循这些技能规范",
   "skills.systemPrompt.copy": "复制",
@@ -294,6 +323,22 @@ const zh: Dict = {
   "skills.detail.confidence": "置信度",
   "skills.detail.source": "来源",
   "skills.detail.createdAt": "创建时间",
+  "skills.detail.edit": "编辑",
+  "skills.detail.save": "保存",
+  "skills.detail.cancel": "取消",
+  "skills.detail.confirm": "确认",
+  "skills.detail.confirmed": "已确认",
+  "skills.detail.status": "状态",
+  "skills.detail.name": "名称",
+  "skills.detail.tags": "标签",
+  "skills.detail.tagsHint": "逗号分隔",
+  "skills.detail.parametersHint": "JSON 格式",
+  "skills.detail.parametersInvalid": "参数不是合法 JSON",
+  "skills.detail.saveError": "保存失败",
+  "skills.detail.confirmError": "确认失败",
+  "skills.status.auto": "自动生成",
+  "skills.status.edited": "已编辑",
+  "skills.status.confirmed": "已确认",
 
   // env vault
   "envVault.vault.title": "环境变量保险箱",
@@ -642,6 +687,35 @@ const en: Dict = {
   "skills.export": "Export formats",
   "skills.export.download": "Download",
   "skills.export.noSkills": "No skills yet",
+  "skills.export.toDir": "Export to directory",
+  "skills.export.title": "Export Skill",
+  "skills.export.desc": "Export confirmed skills as SKILL.md for use by other agents",
+  "skills.export.targetDir": "Target directory",
+  "skills.export.pickDir": "Pick directory",
+  "skills.export.dirPlaceholder": "Absolute path of export directory",
+  "skills.export.manualHint": "Non-desktop: paste an absolute path manually",
+  "skills.export.quickTargets": "Quick targets",
+  "skills.export.target.user": "User default skills dir",
+  "skills.export.target.project": "Current project skills dir",
+  "skills.export.target.codex": "Codex skills dir",
+  "skills.export.target.cursor": "Cursor skills dir",
+  "skills.export.target.recent": "Recent used",
+  "skills.export.conflictStrategy": "Conflict strategy",
+  "skills.export.conflict.overwrite": "Overwrite",
+  "skills.export.conflict.skip": "Skip",
+  "skills.export.conflict.rename": "Rename",
+  "skills.export.conflict.hint": "How to handle name conflicts when target SKILL.md exists",
+  "skills.export.spec": "Format",
+  "skills.export.spec.hermes": "Hermes",
+  "skills.export.spec.agent": "Agent (Anthropic)",
+  "skills.export.submit": "Export",
+  "skills.export.exporting": "Exporting…",
+  "skills.export.success": "Exported to {path} ({written} skill(s) written)",
+  "skills.export.skipped": "Skipped {n} unconfirmed skill(s)",
+  "skills.export.error": "Export failed",
+  "skills.export.needConfirm": "Unconfirmed skills cannot be exported. Please confirm them first.",
+  "skills.export.noSelection": "Please select at least one confirmed skill",
+  "skills.export.noConfirmed": "No confirmed skills available to export",
   "skills.systemPrompt": "Agent Prompt Injection",
   "skills.systemPrompt.hint": "Formats your prompt-type skills as an <available_skills> block. Paste into your LLM system prompt so the model knows about and follows these skill specifications.",
   "skills.systemPrompt.copy": "Copy",
@@ -654,6 +728,22 @@ const en: Dict = {
   "skills.detail.confidence": "Confidence",
   "skills.detail.source": "Source",
   "skills.detail.createdAt": "Created at",
+  "skills.detail.edit": "Edit",
+  "skills.detail.save": "Save",
+  "skills.detail.cancel": "Cancel",
+  "skills.detail.confirm": "Confirm",
+  "skills.detail.confirmed": "Confirmed",
+  "skills.detail.status": "Status",
+  "skills.detail.name": "Name",
+  "skills.detail.tags": "Tags",
+  "skills.detail.tagsHint": "Comma separated",
+  "skills.detail.parametersHint": "JSON format",
+  "skills.detail.parametersInvalid": "Parameters is not valid JSON",
+  "skills.detail.saveError": "Save failed",
+  "skills.detail.confirmError": "Confirm failed",
+  "skills.status.auto": "Auto-generated",
+  "skills.status.edited": "Edited",
+  "skills.status.confirmed": "Confirmed",
 
   "envVault.vault.title": "Env Vault",
   "envVault.vault.desc": "Reusable KEY=value records, stored encrypted on disk (fixed app-level key, no passphrase).",
@@ -1000,6 +1090,35 @@ const ja: Dict = {
   "skills.export": "エクスポート形式",
   "skills.export.download": "ダウンロード",
   "skills.export.noSkills": "スキルなし",
+  "skills.export.toDir": "ディレクトリにエクスポート",
+  "skills.export.title": "Skill をエクスポート",
+  "skills.export.desc": "確認済みスキルを SKILL.md としてエクスポートし、他の agent で利用可能にします",
+  "skills.export.targetDir": "出力先ディレクトリ",
+  "skills.export.pickDir": "ディレクトリを選択",
+  "skills.export.dirPlaceholder": "エクスポート先の絶対パス",
+  "skills.export.manualHint": "デスクトップ以外：絶対パスを手動で入力してください",
+  "skills.export.quickTargets": "クイックターゲット",
+  "skills.export.target.user": "ユーザー既定スキルディレクトリ",
+  "skills.export.target.project": "現在のプロジェクトスキルディレクトリ",
+  "skills.export.target.codex": "Codex スキルディレクトリ",
+  "skills.export.target.cursor": "Cursor スキルディレクトリ",
+  "skills.export.target.recent": "最近使用したディレクトリ",
+  "skills.export.conflictStrategy": "競合戦略",
+  "skills.export.conflict.overwrite": "上書き",
+  "skills.export.conflict.skip": "スキップ",
+  "skills.export.conflict.rename": "リネーム",
+  "skills.export.conflict.hint": "同名 SKILL.md が既に存在する場合の処理方法",
+  "skills.export.spec": "形式",
+  "skills.export.spec.hermes": "Hermes",
+  "skills.export.spec.agent": "Agent (Anthropic)",
+  "skills.export.submit": "エクスポート",
+  "skills.export.exporting": "エクスポート中…",
+  "skills.export.success": "{path} にエクスポートしました（{written} 個のスキルを書き込み）",
+  "skills.export.skipped": "{n} 個の未確認スキルをスキップしました",
+  "skills.export.error": "エクスポートに失敗しました",
+  "skills.export.needConfirm": "未確認のスキルはエクスポートできません。先に確認してください。",
+  "skills.export.noSelection": "少なくとも1つの確認済みスキルを選択してください",
+  "skills.export.noConfirmed": "エクスポート可能な確認済みスキルがありません",
   "skills.systemPrompt": "Agent プロンプト注入",
   "skills.systemPrompt.hint": "prompt タイプのスキルを <available_skills> ブロックとしてフォーマットします。LLM のシステムプロンプトに貼り付けると、モデルがこれらのスキル仕様を認識・遵守できるようになります。",
   "skills.systemPrompt.copy": "コピー",
@@ -1012,6 +1131,22 @@ const ja: Dict = {
   "skills.detail.confidence": "信頼度",
   "skills.detail.source": "ソース",
   "skills.detail.createdAt": "作成日時",
+  "skills.detail.edit": "編集",
+  "skills.detail.save": "保存",
+  "skills.detail.cancel": "キャンセル",
+  "skills.detail.confirm": "確認",
+  "skills.detail.confirmed": "確認済み",
+  "skills.detail.status": "ステータス",
+  "skills.detail.name": "名称",
+  "skills.detail.tags": "タグ",
+  "skills.detail.tagsHint": "カンマ区切り",
+  "skills.detail.parametersHint": "JSON形式",
+  "skills.detail.parametersInvalid": "パラメータが有効なJSONではありません",
+  "skills.detail.saveError": "保存に失敗しました",
+  "skills.detail.confirmError": "確認に失敗しました",
+  "skills.status.auto": "自動生成",
+  "skills.status.edited": "編集済み",
+  "skills.status.confirmed": "確認済み",
 
   "envVault.vault.title": "環境変数ボールト",
   "envVault.vault.desc": "再利用可能な KEY=value レコードを、暗号化してローカル保存します（アプリ固定キー、パスフレーズ不要）。",
diff --git a/dashboard/src/lib/types.ts b/dashboard/src/lib/types.ts
index 0aee9da..6da0d13 100644
--- a/dashboard/src/lib/types.ts
+++ b/dashboard/src/lib/types.ts
@@ -489,6 +489,56 @@ export interface SkillMdResponse {
   skills: SkillMdItem[];
 }
 
+// --- Skill editing & confirmation (Issue #40) ---
+
+export type SkillStatus = "auto-generated" | "edited" | "confirmed";
+
+export interface SkillUpdateRequest {
+  scope: string;
+  item_id: string;
+  name?: string;
+  description?: string;
+  body?: string;
+  parameters?: Record<string, unknown>;
+  tags?: string[];
+}
+
+export interface SkillConfirmRequest {
+  scope: string;
+  item_id: string;
+}
+
+export interface SkillUpdateResponse {
+  item: ContextItem;
+  status: SkillStatus;
+}
+
+export interface SkillConfirmResponse {
+  item: ContextItem;
+  status: "confirmed";
+}
+
+export type SkillConflictStrategy = "overwrite" | "skip" | "rename";
+
+export interface SkillExportRequest {
+  scope: string;
+  out_dir: string;
+  item_ids?: string[] | null;
+  conflict_strategy?: SkillConflictStrategy;
+  require_confirmed?: boolean;
+  spec?: string;
+}
+
+export interface SkillExportResponse {
+  written: number;
+  unchanged: number;
+  skipped_low_confidence: number;
+  skipped_unpublishable: number;
+  skipped_unconfirmed: number;
+  skipped_conflict: number;
+  out_dir: string;
+}
+
 // --- Env Vault ---
 
 export interface EnvVaultItem {
diff --git a/dashboard/src/panels/SkillsPanel.tsx b/dashboard/src/panels/SkillsPanel.tsx
index d3dd1d5..3c8d046 100644
--- a/dashboard/src/panels/SkillsPanel.tsx
+++ b/dashboard/src/panels/SkillsPanel.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import type { ReactNode } from "react";
 
 import { Badge } from "@/components/ui/badge";
@@ -7,13 +7,31 @@ import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import {
   Dialog,
   DialogContent,
+  DialogFooter,
   DialogHeader,
   DialogTitle,
 } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { Textarea } from "@/components/ui/textarea";
 import { useScope } from "@/context/ScopeContext";
 import { ctx } from "@/lib/ctxClient";
 import { useI18n } from "@/lib/i18n";
-import type { ContextItem } from "@/lib/types";
+import { isNativeDialogAvailable, openDirectory } from "@/lib/tauriDialog";
+import { errorMessage } from "@/lib/utils";
+import type {
+  ContextItem,
+  SkillConflictStrategy,
+  SkillExportResponse,
+  SkillStatus,
+} from "@/lib/types";
 
 function triggerDownload(filename: string, content: string, mimeType = "application/json") {
   const blob = new Blob([content], { type: mimeType });
@@ -87,38 +105,108 @@ function ContentBlock({
   );
 }
 
+// ─── Status helpers ──────────────────────────────────────────────────────────
+
+function getSkillStatus(item: ContextItem): SkillStatus {
+  if (item.content && typeof item.content === "object") {
+    const status = (item.content as Record<string, unknown>).status;
+    if (status === "auto-generated" || status === "edited" || status === "confirmed") {
+      return status;
+    }
+  }
+  if (item.provenance.verified) return "confirmed";
+  if (item.updated_at) return "edited";
+  return "auto-generated";
+}
+
+function StatusBadge({ status }: { status: SkillStatus }) {
+  const { t } = useI18n();
+  if (status === "confirmed") {
+    return (
+      <Badge className="bg-emerald-100 text-emerald-700 border-emerald-300 text-xs font-normal">
+        {t("skills.status.confirmed")}
+      </Badge>
+    );
+  }
+  if (status === "edited") {
+    return (
+      <Badge className="bg-amber-100 text-amber-700 border-amber-300 text-xs font-normal">
+        {t("skills.status.edited")}
+      </Badge>
+    );
+  }
+  return (
+    <Badge variant="secondary" className="text-xs font-normal">
+      {t("skills.status.auto")}
+    </Badge>
+  );
+}
+
+function StatusDot({ status }: { status: SkillStatus }) {
+  const color =
+    status === "confirmed" ? "bg-emerald-500"
+    : status === "edited" ? "bg-amber-500"
+    : "bg-slate-400";
+  return <span className={`inline-block w-2 h-2 rounded-full ${color} shrink-0`} />;
+}
+
+// ─── Skill detail dialog (view + edit + confirm) ─────────────────────────────
+
+interface EditForm {
+  name: string;
+  description: string;
+  body: string;
+  parameters: string; // JSON text
+  tags: string; // comma-separated
+}
+
 function SkillDetailDialog({
   item,
   onClose,
+  onItemUpdated,
 }: {
   item: ContextItem | null;
   onClose: () => void;
+  onItemUpdated: (updated: ContextItem) => void;
 }) {
   const { t } = useI18n();
+  const { scope } = useScope();
+  const [editMode, setEditMode] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const [confirming, setConfirming] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [form, setForm] = useState<EditForm>({ name: "", description: "", body: "", parameters: "", tags: "" });
+
+  // Reset state when item changes
+  useEffect(() => {
+    setEditMode(false);
+    setError(null);
+  }, [item?.id]);
+
   if (!item) return null;
 
-  // Handle both string-content and dict-content skills
   const isStringContent = typeof item.content === "string";
   const dictContent =
     item.content && typeof item.content === "object"
       ? (item.content as Record<string, unknown>)
       : null;
 
-  const name = (dictContent?.name as string) || item.summary || item.id;
-  const description = dictContent?.description as string | undefined;
-  // For string-content skills, the body IS the raw content string
-  const body = isStringContent
+  const status = getSkillStatus(item);
+
+  // Read-only field extraction
+  const viewName = getSkillName(item);
+  const viewDescription = dictContent?.description as string | undefined;
+  const viewBody = isStringContent
     ? (item.content as string)
     : (dictContent?.body as string | undefined);
-  const parameters = dictContent?.parameters as Record<string, unknown> | undefined;
-  const inputSchema = dictContent?.inputSchema as Record<string, unknown> | undefined;
-  const version = dictContent?.version as string | undefined;
+  const viewParameters = dictContent?.parameters as Record<string, unknown> | undefined;
+  const viewInputSchema = dictContent?.inputSchema as Record<string, unknown> | undefined;
+  const viewVersion = dictContent?.version as string | undefined;
   const contentTags = dictContent?.tags as string[] | undefined;
-  // Show item.tags but exclude generic stage/type tags already visible as Badge
   const displayTags = [
     ...(contentTags ?? []),
     ...(item.tags ?? []).filter(
-      (t) => !["prompt_skill", "tool_skill", "mcp_skill", "prompt", "tool", "mcp"].includes(t),
+      (tg) => !["prompt_skill", "tool_skill", "mcp_skill", "prompt", "tool", "mcp"].includes(tg),
     ),
   ].filter((v, i, a) => a.indexOf(v) === i);
 
@@ -126,6 +214,70 @@ function SkillDetailDialog({
   const confidenceColor =
     confidence >= 80 ? "text-green-500" : confidence >= 60 ? "text-yellow-500" : "text-red-500";
 
+  function enterEditMode() {
+    setForm({
+      name: viewName,
+      description: viewDescription ?? "",
+      body: viewBody ?? "",
+      parameters: viewParameters ? JSON.stringify(viewParameters, null, 2) : "{}",
+      tags: displayTags.join(", "),
+    });
+    setError(null);
+    setEditMode(true);
+  }
+
+  async function handleSave() {
+    if (!item) return;
+    setError(null);
+
+    // Validate parameters JSON
+    let parsedParameters: Record<string, unknown> | undefined;
+    try {
+      parsedParameters = JSON.parse(form.parameters);
+    } catch {
+      setError(t("skills.detail.parametersInvalid"));
+      return;
+    }
+
+    const tagsArray = form.tags
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean);
+
+    setSaving(true);
+    try {
+      const res = await ctx.updateSkill({
+        scope,
+        item_id: item.id,
+        name: form.name,
+        description: form.description,
+        body: form.body,
+        parameters: parsedParameters,
+        tags: tagsArray,
+      });
+      onItemUpdated(res.item);
+      setEditMode(false);
+    } catch (e) {
+      setError(t("skills.detail.saveError"));
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  async function handleConfirm() {
+    if (!item) return;
+    setError(null);
+    setConfirming(true);
+    try {
+      const res = await ctx.confirmSkill({ scope, item_id: item.id });
+      onItemUpdated(res.item);
+    } catch (e) {
+      setError(t("skills.detail.confirmError"));
+    } finally {
+      setConfirming(false);
+    }
+  }
+
   return (
     <Dialog open={!!item} onOpenChange={(open) => { if (!open) onClose(); }}>
       <DialogContent className="max-w-2xl max-h-[85vh] flex flex-col p-0 gap-0 overflow-hidden">
@@ -133,62 +285,138 @@ function SkillDetailDialog({
         <div className="px-6 pt-6 pb-4 border-b shrink-0">
           <DialogHeader>
             <DialogTitle className="leading-snug pr-6">
-              {name}
+              {editMode ? form.name : viewName}
             </DialogTitle>
           </DialogHeader>
-          {description && !isStringContent && (
-            <p className="mt-2 text-sm text-muted-foreground leading-relaxed">{description}</p>
+          {!editMode && viewDescription && !isStringContent && (
+            <p className="mt-2 text-sm text-muted-foreground leading-relaxed">{viewDescription}</p>
+          )}
+          {!editMode && viewVersion && (
+            <p className="mt-1 text-xs text-muted-foreground">v{viewVersion}</p>
           )}
-          {version && (
-            <p className="mt-1 text-xs text-muted-foreground">v{version}</p>
+          {!editMode && (
+            <div className="mt-2">
+              <StatusBadge status={status} />
+            </div>
           )}
         </div>
 
         {/* Scrollable body */}
         <div className="flex-1 overflow-y-auto px-6 py-4 space-y-5">
-          {body && (
-            <ContentBlock
-              label={t("skills.detail.body")}
-              text={body}
-              mono={false}
-            />
-          )}
+          {editMode ? (
+            <>
+              {/* Edit mode fields */}
+              <div className="space-y-1.5">
+                <Label className="text-xs font-medium text-muted-foreground uppercase tracking-wide">
+                  {t("skills.detail.name")}
+                </Label>
+                <Input
+                  value={form.name}
+                  onChange={(e) => setForm({ ...form, name: e.target.value })}
+                />
+              </div>
 
-          {parameters && (
-            <ContentBlock
-              label={t("skills.detail.parameters")}
-              text={JSON.stringify(parameters, null, 2)}
-              mono
-            />
-          )}
+              <div className="space-y-1.5">
+                <Label className="text-xs font-medium text-muted-foreground uppercase tracking-wide">
+                  {t("skills.detail.description")}
+                </Label>
+                <Textarea
+                  value={form.description}
+                  onChange={(e) => setForm({ ...form, description: e.target.value })}
+                  rows={2}
+                />
+              </div>
 
-          {inputSchema && (
-            <ContentBlock
-              label={t("skills.detail.inputSchema")}
-              text={JSON.stringify(inputSchema, null, 2)}
-              mono
-            />
-          )}
+              <div className="space-y-1.5">
+                <Label className="text-xs font-medium text-muted-foreground uppercase tracking-wide">
+                  {t("skills.detail.body")}
+                </Label>
+                <Textarea
+                  value={form.body}
+                  onChange={(e) => setForm({ ...form, body: e.target.value })}
+                  rows={6}
+                />
+              </div>
 
-          {displayTags.length > 0 && (
-            <div>
-              <p className="text-xs font-medium text-muted-foreground uppercase tracking-wide mb-1.5">
-                Tags
-              </p>
-              <div className="flex flex-wrap gap-1.5">
-                {displayTags.map((tag) => (
-                  <Badge key={tag} variant="outline" className="text-xs font-normal">
-                    {tag}
-                  </Badge>
-                ))}
+              <div className="space-y-1.5">
+                <Label className="text-xs font-medium text-muted-foreground uppercase tracking-wide">
+                  {t("skills.detail.parameters")}
+                </Label>
+                <p className="text-xs text-muted-foreground">{t("skills.detail.parametersHint")}</p>
+                <Textarea
+                  value={form.parameters}
+                  onChange={(e) => setForm({ ...form, parameters: e.target.value })}
+                  className="font-mono text-xs"
+                  rows={5}
+                />
               </div>
-            </div>
+
+              <div className="space-y-1.5">
+                <Label className="text-xs font-medium text-muted-foreground uppercase tracking-wide">
+                  {t("skills.detail.tags")}
+                </Label>
+                <p className="text-xs text-muted-foreground">{t("skills.detail.tagsHint")}</p>
+                <Input
+                  value={form.tags}
+                  onChange={(e) => setForm({ ...form, tags: e.target.value })}
+                />
+              </div>
+            </>
+          ) : (
+            <>
+              {/* View mode fields */}
+              {viewBody && (
+                <ContentBlock
+                  label={t("skills.detail.body")}
+                  text={viewBody}
+                  mono={false}
+                />
+              )}
+
+              {viewParameters && (
+                <ContentBlock
+                  label={t("skills.detail.parameters")}
+                  text={JSON.stringify(viewParameters, null, 2)}
+                  mono
+                />
+              )}
+
+              {viewInputSchema && (
+                <ContentBlock
+                  label={t("skills.detail.inputSchema")}
+                  text={JSON.stringify(viewInputSchema, null, 2)}
+                  mono
+                />
+              )}
+
+              {displayTags.length > 0 && (
+                <div>
+                  <p className="text-xs font-medium text-muted-foreground uppercase tracking-wide mb-1.5">
+                    {t("skills.detail.tags")}
+                  </p>
+                  <div className="flex flex-wrap gap-1.5">
+                    {displayTags.map((tag) => (
+                      <Badge key={tag} variant="outline" className="text-xs font-normal">
+                        {tag}
+                      </Badge>
+                    ))}
+                  </div>
+                </div>
+              )}
+            </>
           )}
         </div>
 
+        {/* Error message */}
+        {error && (
+          <div className="px-6 py-2 bg-red-50 border-t shrink-0">
+            <p className="text-xs text-red-600">{error}</p>
+          </div>
+        )}
+
         {/* Metadata footer */}
         <div className="px-6 py-3 border-t bg-muted/40 shrink-0">
-          <div className="grid grid-cols-3 gap-4 text-xs text-muted-foreground">
+          <div className="grid grid-cols-4 gap-4 text-xs text-muted-foreground">
             <div>
               <p className="font-medium mb-0.5">{t("skills.detail.confidence")}</p>
               <p className={`font-semibold ${confidenceColor}`}>{confidence}%</p>
@@ -201,8 +429,376 @@ function SkillDetailDialog({
               <p className="font-medium mb-0.5">{t("skills.detail.createdAt")}</p>
               <p>{new Date(item.created_at).toLocaleDateString()}</p>
             </div>
+            <div>
+              <p className="font-medium mb-0.5">{t("skills.detail.status")}</p>
+              <StatusBadge status={status} />
+            </div>
           </div>
         </div>
+
+        {/* Action footer */}
+        <DialogFooter className="px-6 py-3 border-t shrink-0 flex-row justify-end gap-2">
+          {editMode ? (
+            <>
+              <Button
+                size="sm"
+                variant="ghost"
+                onClick={() => { setEditMode(false); setError(null); }}
+                disabled={saving}
+              >
+                {t("skills.detail.cancel")}
+              </Button>
+              <Button
+                size="sm"
+                onClick={handleSave}
+                disabled={saving}
+              >
+                {saving ? "..." : t("skills.detail.save")}
+              </Button>
+            </>
+          ) : (
+            <>
+              <Button
+                size="sm"
+                variant="outline"
+                onClick={enterEditMode}
+              >
+                {t("skills.detail.edit")}
+              </Button>
+              <Button
+                size="sm"
+                onClick={handleConfirm}
+                disabled={confirming || status === "confirmed"}
+              >
+                {confirming ? "..." : status === "confirmed" ? t("skills.detail.confirmed") : t("skills.detail.confirm")}
+              </Button>
+            </>
+          )}
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+// --- Skill export dialog ---
+
+const SKILL_EXPORT_DIR_KEY = "ctx.skillExportDir";
+const QUICK_TARGETS: { key: string; path: string }[] = [
+  { key: "skills.export.target.user", path: "~/.contextseek/skills" },
+  { key: "skills.export.target.project", path: ".claude/skills" },
+  { key: "skills.export.target.codex", path: "~/.codex/skills" },
+  { key: "skills.export.target.cursor", path: "~/.cursor/skills" },
+];
+
+function SkillExportDialog({
+  open,
+  onClose,
+  items,
+  scope,
+}: {
+  open: boolean;
+  onClose: () => void;
+  items: ContextItem[];
+  scope: string;
+}) {
+  const { t } = useI18n();
+  const nativeDialog = isNativeDialogAvailable();
+
+  const confirmedItems = useMemo(
+    () => items.filter((it) => getSkillStatus(it) === "confirmed"),
+    [items],
+  );
+
+  const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set());
+  const [outDir, setOutDir] = useState("");
+  const [conflictStrategy, setConflictStrategy] =
+    useState<SkillConflictStrategy>("rename");
+  const [spec, setSpec] = useState("hermes");
+  const [exporting, setExporting] = useState(false);
+  const [exportResult, setExportResult] = useState<SkillExportResponse | null>(
+    null,
+  );
+  const [error, setError] = useState<string | null>(null);
+
+  // Initialise when dialog opens.
+  useEffect(() => {
+    if (open) {
+      const saved = window.localStorage.getItem(SKILL_EXPORT_DIR_KEY) ?? "";
+      setOutDir(saved);
+      setSelectedIds(new Set(confirmedItems.map((it) => it.id)));
+      setError(null);
+      setExportResult(null);
+    }
+  }, [open, confirmedItems]);
+
+  function toggleItem(id: string) {
+    setSelectedIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  }
+
+  async function handlePickDir() {
+    const picked = await openDirectory({ defaultPath: outDir || undefined });
+    if (picked) setOutDir(picked);
+  }
+
+  async function handleExport() {
+    const trimmedDir = outDir.trim();
+    if (selectedIds.size === 0 || !trimmedDir) return;
+    setExporting(true);
+    setError(null);
+    setExportResult(null);
+    window.localStorage.setItem(SKILL_EXPORT_DIR_KEY, trimmedDir);
+    try {
+      const res = await ctx.exportSkill({
+        scope,
+        out_dir: trimmedDir,
+        item_ids: Array.from(selectedIds),
+        conflict_strategy: conflictStrategy,
+        require_confirmed: true,
+        spec,
+      });
+      setExportResult(res);
+    } catch (e) {
+      setError(errorMessage(e) || t("skills.export.error"));
+    } finally {
+      setExporting(false);
+    }
+  }
+
+  const hasConfirmed = confirmedItems.length > 0;
+  const recentDir = window.localStorage.getItem(SKILL_EXPORT_DIR_KEY) ?? "";
+
+  return (
+    <Dialog open={open} onOpenChange={(o) => { if (!o) onClose(); }}>
+      <DialogContent className="max-w-xl max-h-[85vh] flex flex-col p-0 gap-0 overflow-hidden">
+        {/* Header */}
+        <div className="px-6 pt-6 pb-4 border-b shrink-0">
+          <DialogHeader>
+            <DialogTitle className="leading-snug">
+              {t("skills.export.title")}
+            </DialogTitle>
+          </DialogHeader>
+          <p className="mt-2 text-sm text-muted-foreground leading-relaxed">
+            {t("skills.export.desc")}
+          </p>
+        </div>
+
+        {/* Scrollable body */}
+        <div className="flex-1 overflow-y-auto px-6 py-4 space-y-5">
+          {/* Skill selection list */}
+          <div className="space-y-1.5">
+            <Label className="text-xs font-medium text-muted-foreground uppercase tracking-wide">
+              {t("skills.distilled")}
+            </Label>
+            {hasConfirmed ? (
+              <div className="max-h-48 overflow-y-auto rounded-md border space-y-0.5 p-1">
+                {confirmedItems.map((item) => (
+                  <button
+                    key={item.id}
+                    onClick={() => toggleItem(item.id)}
+                    className={`w-full flex items-center gap-2 rounded px-2 py-1.5 text-left text-xs hover:bg-muted transition-colors ${
+                      selectedIds.has(item.id) ? "bg-muted" : ""
+                    }`}
+                  >
+                    <span
+                      className={`inline-flex items-center justify-center w-4 h-4 rounded border shrink-0 ${
+                        selectedIds.has(item.id)
+                          ? "bg-primary border-primary text-primary-foreground"
+                          : "border-muted-foreground/30"
+                      }`}
+                    >
+                      {selectedIds.has(item.id) && (
+                        <svg className="w-3 h-3" viewBox="0 0 12 12" fill="none">
+                          <path d="M2 6l3 3 5-6" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" />
+                        </svg>
+                      )}
+                    </span>
+                    <StatusDot status={getSkillStatus(item)} />
+                    <span className="truncate flex-1">
+                      {getSkillName(item)}
+                    </span>
+                  </button>
+                ))}
+                {items.length > confirmedItems.length && (
+                  <p className="text-xs text-muted-foreground px-2 py-1.5">
+                    {t("skills.export.needConfirm")}
+                  </p>
+                )}
+              </div>
+            ) : (
+              <p className="text-xs text-muted-foreground px-2 py-2">
+                {t("skills.export.noConfirmed")}
+              </p>
+            )}
+          </div>
+
+          {/* Quick targets */}
+          <div className="space-y-1.5">
+            <Label className="text-xs font-medium text-muted-foreground uppercase tracking-wide">
+              {t("skills.export.quickTargets")}
+            </Label>
+            <div className="flex flex-wrap gap-2">
+              {QUICK_TARGETS.map((target) => (
+                <Button
+                  key={target.key}
+                  size="sm"
+                  variant="outline"
+                  className="text-xs h-7"
+                  onClick={() => setOutDir(target.path)}
+                >
+                  {t(target.key)}
+                </Button>
+              ))}
+              {recentDir && (
+                <Button
+                  size="sm"
+                  variant="outline"
+                  className="text-xs h-7"
+                  onClick={() => setOutDir(recentDir)}
+                >
+                  {t("skills.export.target.recent")}
+                </Button>
+              )}
+            </div>
+          </div>
+
+          {/* Target directory input */}
+          <div className="space-y-1.5">
+            <Label className="text-xs font-medium text-muted-foreground uppercase tracking-wide">
+              {t("skills.export.targetDir")}
+            </Label>
+            <div className="flex gap-2">
+              <Input
+                value={outDir}
+                onChange={(e) => setOutDir(e.target.value)}
+                placeholder={t("skills.export.dirPlaceholder")}
+                className="font-mono text-xs flex-1"
+              />
+              {nativeDialog && (
+                <Button
+                  size="sm"
+                  variant="outline"
+                  onClick={() => void handlePickDir()}
+                  className="shrink-0"
+                >
+                  {t("skills.export.pickDir")}
+                </Button>
+              )}
+            </div>
+            {!nativeDialog && (
+              <p className="text-xs text-muted-foreground">
+                {t("skills.export.manualHint")}
+              </p>
+            )}
+          </div>
+
+          {/* Conflict strategy + format */}
+          <div className="grid grid-cols-2 gap-4">
+            <div className="space-y-1.5">
+              <Label className="text-xs font-medium text-muted-foreground uppercase tracking-wide">
+                {t("skills.export.conflictStrategy")}
+              </Label>
+              <Select
+                value={conflictStrategy}
+                onValueChange={(v) =>
+                  setConflictStrategy(v as SkillConflictStrategy)
+                }
+              >
+                <SelectTrigger className="text-xs">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="rename">
+                    {t("skills.export.conflict.rename")}
+                  </SelectItem>
+                  <SelectItem value="overwrite">
+                    {t("skills.export.conflict.overwrite")}
+                  </SelectItem>
+                  <SelectItem value="skip">
+                    {t("skills.export.conflict.skip")}
+                  </SelectItem>
+                </SelectContent>
+              </Select>
+              <p className="text-xs text-muted-foreground">
+                {t("skills.export.conflict.hint")}
+              </p>
+            </div>
+            <div className="space-y-1.5">
+              <Label className="text-xs font-medium text-muted-foreground uppercase tracking-wide">
+                {t("skills.export.spec")}
+              </Label>
+              <Select value={spec} onValueChange={setSpec}>
+                <SelectTrigger className="text-xs">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="hermes">
+                    {t("skills.export.spec.hermes")}
+                  </SelectItem>
+                  <SelectItem value="agent">
+                    {t("skills.export.spec.agent")}
+                  </SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+          </div>
+        </div>
+
+        {/* Error message */}
+        {error && (
+          <div className="px-6 py-2 bg-red-50 border-t shrink-0">
+            <p className="text-xs text-red-600">{error}</p>
+          </div>
+        )}
+
+        {/* Success message */}
+        {exportResult && (
+          <div className="px-6 py-2 bg-emerald-50 border-t shrink-0 space-y-1">
+            <p className="text-xs text-emerald-700">
+              {t("skills.export.success", {
+                path: exportResult.out_dir,
+                written: exportResult.written,
+              })}
+            </p>
+            {exportResult.skipped_unconfirmed > 0 && (
+              <p className="text-xs text-amber-600">
+                {t("skills.export.skipped", {
+                  n: exportResult.skipped_unconfirmed,
+                })}
+              </p>
+            )}
+            {exportResult.skipped_conflict > 0 && (
+              <p className="text-xs text-amber-600">
+                {t("skills.export.conflict.skip")}: {exportResult.skipped_conflict}
+              </p>
+            )}
+          </div>
+        )}
+
+        {/* Action footer */}
+        <DialogFooter className="px-6 py-3 border-t shrink-0 flex-row justify-end gap-2">
+          <Button
+            size="sm"
+            variant="ghost"
+            onClick={onClose}
+            disabled={exporting}
+          >
+            {t("skills.detail.cancel")}
+          </Button>
+          <Button
+            size="sm"
+            onClick={() => void handleExport()}
+            disabled={exporting || selectedIds.size === 0 || !outDir.trim()}
+          >
+            {exporting
+              ? t("skills.export.exporting")
+              : t("skills.export.submit")}
+          </Button>
+        </DialogFooter>
       </DialogContent>
     </Dialog>
   );
@@ -212,6 +808,10 @@ function getSkillName(item: ContextItem): string {
   if (item.content && typeof item.content === "object") {
     return (item.content as Record<string, unknown>).name as string || item.summary || item.id.slice(0, 8);
   }
+  // string-content skill: use summary, or first 40 chars of content
+  if (typeof item.content === "string") {
+    return item.summary || item.content.slice(0, 40);
+  }
   return item.summary || item.id.slice(0, 8);
 }
 
@@ -291,6 +891,7 @@ export function SkillsPanel() {
   const [loading, setLoading] = useState(true);
   const [selectedItem, setSelectedItem] = useState<ContextItem | null>(null);
   const [downloadingMd, setDownloadingMd] = useState(false);
+  const [exportDialogOpen, setExportDialogOpen] = useState(false);
 
   useEffect(() => {
     let cancelled = false;
@@ -311,6 +912,12 @@ export function SkillsPanel() {
     };
   }, [scope]);
 
+  // Update item in list when edited/confirmed
+  function handleItemUpdated(updated: ContextItem) {
+    setSelectedItem(updated);
+    setItems((prev) => prev.map((it) => (it.id === updated.id ? updated : it)));
+  }
+
   async function handleDownloadSkillMd() {
     setDownloadingMd(true);
     try {
@@ -342,7 +949,18 @@ export function SkillsPanel() {
 
   return (
     <div className="space-y-4 p-6">
-      <SkillDetailDialog item={selectedItem} onClose={() => setSelectedItem(null)} />
+      <SkillDetailDialog
+        item={selectedItem}
+        onClose={() => setSelectedItem(null)}
+        onItemUpdated={handleItemUpdated}
+      />
+
+      <SkillExportDialog
+        open={exportDialogOpen}
+        onClose={() => setExportDialogOpen(false)}
+        items={items}
+        scope={scope}
+      />
 
       <div className="grid gap-4 lg:grid-cols-3">
         {/* Skills list */}
@@ -354,10 +972,11 @@ export function SkillsPanel() {
                   <button
                     key={item.id}
                     onClick={() => setSelectedItem(item)}
-                    className="w-full flex items-center rounded px-2 py-1.5 text-left text-xs hover:bg-muted transition-colors cursor-pointer"
+                    className="w-full flex items-center gap-2 rounded px-2 py-1.5 text-left text-xs hover:bg-muted transition-colors cursor-pointer"
                   >
+                    <StatusDot status={getSkillStatus(item)} />
                     <span className="truncate flex-1">
-                      {item.summary ?? item.id}
+                      {getSkillName(item)}
                     </span>
                   </button>
                 ))}
@@ -386,6 +1005,15 @@ export function SkillsPanel() {
               >
                 {t("skills.export.download")}
               </Button>
+              <Button
+                size="sm"
+                variant="outline"
+                disabled={!hasSkills}
+                onClick={() => setExportDialogOpen(true)}
+                className="w-full text-xs"
+              >
+                {t("skills.export.toDir")}
+              </Button>
             </div>
           </SectionCard>
         </div>
@@ -395,4 +1023,4 @@ export function SkillsPanel() {
       <SystemPromptCard items={items} />
     </div>
   );
-}
+}
\ No newline at end of file
diff --git a/dashboard/vite.config.ts b/dashboard/vite.config.ts
index 7180029..bffe2b4 100644
--- a/dashboard/vite.config.ts
+++ b/dashboard/vite.config.ts
@@ -8,7 +8,7 @@ import { defineConfig } from "vite";
 // that both `vite dev` and `vite preview` work without setting VITE_CTX_BASE.
 const API_SEGMENTS =
   "add|retrieve|expand|forget|delete|compact|dream|feedback|upstream|" +
-  "evidence_chain|chain_confidence|skill_tools|skill_context|skill_md|items|" +
+  "evidence_chain|chain_confidence|skill_tools|skill_context|skill_md|skill|items|" +
   "overview|global_overview|scopes|config|metrics|plugs|seed|health|install|restart|__desktop";
 const API_PROXY_PATTERN = `^/(${API_SEGMENTS})(/|$|\\?)`;
 const API_PROXY_TARGET = { target: "http://127.0.0.1:8000", changeOrigin: true };
diff --git a/src/contextseek/client/contextseek.py b/src/contextseek/client/contextseek.py
index 774a988..ed0dcb8 100644
--- a/src/contextseek/client/contextseek.py
+++ b/src/contextseek/client/contextseek.py
@@ -2102,6 +2102,158 @@ def skill_feedback(
             "relevance_boost": item.relevance_boost,
         }
 
+    # ------------------------------------------------------------------
+    # Skill editing & human confirmation (Issue #40)
+    # ------------------------------------------------------------------
+
+    def _find_skill_by_item_id(self, scope: str, item_id: str) -> ContextItem | None:
+        """Locate a skill-stage item by its ``ContextItem.id`` within a scope.
+
+        Unlike ``_find_skill_item`` (which matches by ``skill_id`` inside
+        dict-content), this works for **both** string-content and dict-content
+        skills, since ``item_id`` is always available.
+        """
+        for it in self.items(scope=scope, stage=Stage.skill):
+            if it.id == item_id:
+                return it
+        return None
+
+    def update_skill(
+        self,
+        *,
+        scope: str,
+        item_id: str,
+        name: str | None = None,
+        description: str | None = None,
+        body: str | None = None,
+        parameters: dict[str, Any] | None = None,
+        tags: list[str] | None = None,
+    ) -> ContextItem:
+        """Edit a skill's name, description, body, parameters, and tags.
+
+        Only fields that are **not** ``None`` are updated.  String-content
+        skills are upgraded to dict-content (SkillIR format) so the ``status``
+        field can be tracked.
+
+        After editing, ``content["status"]`` is set to ``"edited"`` and
+        ``item.updated_at`` is stamped, but provenance is **not** changed —
+        confidence / verified are only modified by :meth:`confirm_skill`.
+
+        Raises:
+            ValueError: when no skill with ``item_id`` exists in ``scope``.
+        """
+        from contextseek.domain.skill_ir import SkillIR
+
+        item = self._find_skill_by_item_id(scope, item_id)
+        if item is None:
+            raise ValueError(f"skill not found: {item_id}")
+
+        # Parse into SkillIR (handles both dict and string content)
+        ir = SkillIR.from_content(item.content)
+
+        if name is not None:
+            ir.name = name
+        if description is not None:
+            ir.description = description
+        if body is not None:
+            ir.body = body
+        if parameters is not None:
+            ir.parameters = parameters
+        if tags is not None:
+            ir.tags = tags
+
+        item.content = ir.to_content()
+        item.content["status"] = "edited"
+        item.updated_at = _utc_now()
+
+        ref = self.resolver.ref_for(scope, item.id)
+        self.adapter.write(ref, serialize_context_item(item))
+
+        self._emit_audit(
+            action="skill_updated",
+            scope=scope,
+            detail={
+                "item_id": item_id,
+                "updated_fields": [
+                    k
+                    for k, v in {
+                        "name": name,
+                        "description": description,
+                        "body": body,
+                        "parameters": parameters,
+                        "tags": tags,
+                    }.items()
+                    if v is not None
+                ],
+            },
+        )
+        return item
+
+    def confirm_skill(
+        self,
+        *,
+        scope: str,
+        item_id: str,
+    ) -> ContextItem:
+        """Human-confirm a skill.
+
+        Sets ``provenance.confidence = 1.0`` and ``provenance.verified = True``,
+        and marks ``content["status"] = "confirmed"``.  String-content skills
+        are upgraded to dict-content so the status field can be tracked.
+
+        Raises:
+            ValueError: when no skill with ``item_id`` exists in ``scope``.
+        """
+        from contextseek.domain.skill_ir import SkillIR
+
+        item = self._find_skill_by_item_id(scope, item_id)
+        if item is None:
+            raise ValueError(f"skill not found: {item_id}")
+
+        # Provenance is frozen=True — use dataclasses.replace
+        item.provenance = replace(
+            item.provenance, confidence=1.0, verified=True
+        )
+
+        # Ensure content is dict so we can store the status field
+        if not isinstance(item.content, dict):
+            ir = SkillIR.from_content(item.content)
+            item.content = ir.to_content()
+        item.content["status"] = "confirmed"
+
+        item.updated_at = _utc_now()
+
+        ref = self.resolver.ref_for(scope, item.id)
+        self.adapter.write(ref, serialize_context_item(item))
+
+        self._emit_audit(
+            action="skill_confirmed",
+            scope=scope,
+            detail={"item_id": item_id},
+        )
+        return item
+
+    def skill_status(self, item: ContextItem) -> str:
+        """Infer the human-facing status of a skill item.
+
+        Returns one of ``"auto-generated"``, ``"edited"``, ``"confirmed"``.
+
+        Priority:
+        1. Explicit ``content["status"]`` field (set by update_skill / confirm_skill)
+        2. ``provenance.verified`` → ``"confirmed"``
+        3. ``updated_at`` is not None → ``"edited"``
+        4. Fallback → ``"auto-generated"``
+        """
+        if isinstance(item.content, dict):
+            status = item.content.get("status")
+            if status in ("auto-generated", "edited", "confirmed"):
+                return status  # type: ignore[return-value]
+        if item.provenance.verified:
+            return "confirmed"
+        if item.updated_at is not None:
+            return "edited"
+        return "auto-generated"
+
     def dream(
         self,
         *,
diff --git a/src/contextseek/daemon/skill_export.py b/src/contextseek/daemon/skill_export.py
index a657f38..f42461a 100644
--- a/src/contextseek/daemon/skill_export.py
+++ b/src/contextseek/daemon/skill_export.py
@@ -41,6 +41,8 @@ class ExportReport:
     pruned: int = 0
     skipped_low_confidence: int = 0
     skipped_unpublishable: int = 0
+    skipped_unconfirmed: int = 0
+    skipped_conflict: int = 0
     out_dir: str = ""
 
 
@@ -73,6 +75,9 @@ def export_skills(
     dry_run: bool = False,
     prune: bool = True,
     spec: str = "hermes",
+    item_ids: list[str] | None = None,
+    conflict_strategy: str = "rename",
+    require_confirmed: bool = False,
 ) -> ExportReport:
     """Write prompt skills in *scope* to ``out_dir/<slug>/SKILL.md``.
 
@@ -81,6 +86,20 @@ def export_skills(
     Skills frontmatter; point ``out_dir`` at ``.claude/skills/`` to land
     directly into a Claude Code / claude.ai skills directory).
 
+    ``item_ids`` — when provided, only skills whose item id is in this list
+    are exported.  Selective export disables pruning automatically so that
+    other previously-exported skills are not removed.
+
+    ``conflict_strategy`` controls how an *external* (non-manifest) SKILL.md
+    in the target directory is handled: ``"overwrite"`` replaces it,
+    ``"skip"`` leaves it untouched, ``"rename"`` writes to a disambiguated
+    slug directory instead.
+
+    ``require_confirmed`` — when True, skills that have not been
+    human-confirmed (``content["status"] != "confirmed"`` and
+    ``provenance.verified is not True``) are skipped and counted in
+    ``skipped_unconfirmed``.
+
     Idempotent: keyed by the skill's stable ``skill_id`` (falling back to the
     item id for legacy skills), a SKILL.md whose content is unchanged is left
     untouched. A manifest (``out_dir/.contextseek-export.json``) records which
@@ -91,6 +110,16 @@ def export_skills(
     report = ExportReport(out_dir=str(base))
     exporter = SkillExporter()
 
+    # Validate conflict_strategy.
+    if conflict_strategy not in ("overwrite", "skip", "rename"):
+        raise ValueError(
+            f"conflict_strategy must be 'overwrite', 'skip', or 'rename', got '{conflict_strategy}'"
+        )
+
+    # Selective export disables prune so other skills are preserved.
+    if item_ids is not None:
+        prune = False
+
     def persist_item(item: Any) -> None:
         """Best-effort persistence for clients that expose adapter+resolver."""
         if dry_run:
@@ -114,6 +143,10 @@ def persist_item(item: Any) -> None:
     skills = ctx.skills(scope, skill_type="prompt")
     selected = []
     for item in skills:
+        # Selective export: only items in the provided id set.
+        if item_ids is not None and item.id not in item_ids:
+            continue
+
         if item.provenance.confidence < min_confidence:
             report.skipped_low_confidence += 1
             continue
@@ -121,7 +154,16 @@ def persist_item(item: Any) -> None:
         if ir.publish_status == "deprecated" or "needs_review" in item.tags:
             report.skipped_unpublishable += 1
             continue
-        # Quality-gate/render-check passed by this point → at least validated.
+        # Require human confirmation if requested.
+        if require_confirmed:
+            content_status = ""
+            if isinstance(item.content, dict):
+                content_status = item.content.get("status", "")
+            is_confirmed = content_status == "confirmed" or item.provenance.verified
+            if not is_confirmed:
+                report.skipped_unconfirmed += 1
+                continue
+        # Quality-gate/render-check passed by this point -> at least validated.
         if can_transition(ir.publish_status, "validated"):
             ir.publish_status = "validated"
             item.content = ir.to_content()
@@ -145,7 +187,6 @@ def persist_item(item: Any) -> None:
         key = SkillIR.from_content(item.content).skill_id or item.id
         md = render(item)
         digest = _content_hash(md)
-        new_manifest[key] = {"slug": slug, "hash": digest}
 
         skill_file = base / slug / "SKILL.md"
         prev = old_manifest.get(key)
@@ -160,9 +201,36 @@ def persist_item(item: Any) -> None:
                 ir.publish_status = "published"
                 item.content = ir.to_content()
                 persist_item(item)
+            new_manifest[key] = {"slug": slug, "hash": digest}
             report.unchanged += 1
             continue
 
+        # Conflict detection: file exists but is NOT in our manifest (external).
+        external_conflict = skill_file.exists() and prev is None
+        if external_conflict:
+            if conflict_strategy == "skip":
+                report.skipped_conflict += 1
+                continue
+            elif conflict_strategy == "rename":
+                # Find a disambiguated slug that doesn't collide.
+                base_slug = slug
+                suffix = item.id[8:16] if len(item.id) >= 16 else item.id[:8]
+                candidate = f"{base_slug}-{suffix}"
+                idx = 0
+                while candidate in used_slugs or (base / candidate / "SKILL.md").exists():
+                    candidate = f"{base_slug}-{suffix}-{idx}"
+                    idx += 1
+                    if idx > 999:
+                        # Safety valve: extremely unlikely to reach here.
+                        candidate = f"{base_slug}-{suffix}-{item.id}"
+                        break
+                slug = candidate
+                used_slugs.add(slug)
+                skill_file = base / slug / "SKILL.md"
+            # else: overwrite -- fall through to normal write
+
+        new_manifest[key] = {"slug": slug, "hash": digest}
+
         if not dry_run:
             skill_file.parent.mkdir(parents=True, exist_ok=True)
             skill_file.write_text(md, encoding="utf-8")
diff --git a/src/contextseek/http/server.py b/src/contextseek/http/server.py
index 25e1a9c..a3951e4 100644
--- a/src/contextseek/http/server.py
+++ b/src/contextseek/http/server.py
@@ -25,7 +25,7 @@
     from fastapi import FastAPI, HTTPException
     from fastapi.middleware.cors import CORSMiddleware
     from fastapi.staticfiles import StaticFiles
-    from pydantic import BaseModel, Field
+    from pydantic import BaseModel, Field, field_validator
     from starlette.exceptions import HTTPException as StarletteHTTPException
 except ImportError as exc:
     msg = (
@@ -158,6 +158,44 @@ class ItemsRequest(BaseModel):
     stage: str | None = None
 
 
+class SkillUpdateRequest(BaseModel):
+    scope: str
+    item_id: str
+    name: str | None = None
+    description: str | None = None
+    body: str | None = None
+    parameters: dict[str, Any] | None = None
+    tags: list[str] | None = None
+
+
+class SkillConfirmRequest(BaseModel):
+    scope: str
+    item_id: str
+
+
+class SkillExportRequest(BaseModel):
+    scope: str
+    out_dir: str
+    item_ids: list[str] | None = None
+    conflict_strategy: str = "rename"
+    require_confirmed: bool = True
+    spec: str = "hermes"
+
+    @field_validator("conflict_strategy")
+    @classmethod
+    def validate_conflict_strategy(cls, v: str) -> str:
+        if v not in ("overwrite", "skip", "rename"):
+            raise ValueError("conflict_strategy must be 'overwrite', 'skip', or 'rename'")
+        return v
+
+    @field_validator("spec")
+    @classmethod
+    def validate_spec(cls, v: str) -> str:
+        if v not in ("hermes", "agent"):
+            raise ValueError("spec must be 'hermes' or 'agent'")
+        return v
+
+
 class PlugInstallRequest(BaseModel):
     linker: str
     dry_run: bool = False
@@ -180,6 +218,7 @@ class PlugInstallRequest(BaseModel):
     "skill_tools",
     "skill_context",
     "skill_md",
+    "skill",
     "items",
     "overview",
     "global_overview",
@@ -1231,6 +1270,75 @@ async def skill_md(req: SkillMdRequest) -> dict[str, Any]:
         ]
         return {"skills": result}
 
+    @app.put("/skill")
+    async def update_skill(req: SkillUpdateRequest) -> dict[str, Any]:
+        """Edit a skill's name, description, body, parameters, and tags."""
+        try:
+            updated = ctx.update_skill(
+                scope=req.scope,
+                item_id=req.item_id,
+                name=req.name,
+                description=req.description,
+                body=req.body,
+                parameters=req.parameters,
+                tags=req.tags,
+            )
+        except ValueError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+        return {
+            "item": serialize_context_item(updated),
+            "status": ctx.skill_status(updated),
+        }
+
+    @app.post("/skill/confirm")
+    async def confirm_skill(req: SkillConfirmRequest) -> dict[str, Any]:
+        """Human-confirm a skill (sets confidence=1.0, verified=True)."""
+        try:
+            updated = ctx.confirm_skill(
+                scope=req.scope,
+                item_id=req.item_id,
+            )
+        except ValueError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+        return {
+            "item": serialize_context_item(updated),
+            "status": "confirmed",
+        }
+
+    @app.post("/skill/export")
+    async def export_skill(req: SkillExportRequest) -> dict[str, Any]:
+        """Export confirmed skills as SKILL.md files to a target directory."""
+        from contextseek.daemon.skill_export import export_skills
+
+        try:
+            report = export_skills(
+                ctx,
+                scope=req.scope,
+                out_dir=req.out_dir,
+                item_ids=req.item_ids,
+                conflict_strategy=req.conflict_strategy,
+                require_confirmed=req.require_confirmed,
+                spec=req.spec,
+                prune=False,
+            )
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+        return {
+            "written": report.written,
+            "unchanged": report.unchanged,
+            "skipped_low_confidence": report.skipped_low_confidence,
+            "skipped_unpublishable": report.skipped_unpublishable,
+            "skipped_unconfirmed": report.skipped_unconfirmed,
+            "skipped_conflict": report.skipped_conflict,
+            "out_dir": report.out_dir,
+        }
+
     @app.post("/items")
     async def list_items(req: ItemsRequest) -> dict[str, Any]:
         from contextseek.domain.stages import Stage
diff --git a/tests/unit_tests/test_http_server.py b/tests/unit_tests/test_http_server.py
index c95ecce..bfc2e64 100644
--- a/tests/unit_tests/test_http_server.py
+++ b/tests/unit_tests/test_http_server.py
@@ -668,6 +668,248 @@ def fake_install(self, *, linker=None, dry_run=False, check=False):
     assert status.json()["entries"] == job["entries"]
 
 
+# ─── Skill editing & confirmation (Issue #40) ────────────────────────────────
+
+
+def _sample_skill_item(
+    *,
+    item_id: str = "skill-001",
+    content: dict | str | None = None,
+    verified: bool = False,
+    confidence: float = 0.7,
+) -> ContextItem:
+    from contextseek.domain.stages import Stage
+
+    if content is None:
+        content = {
+            "skill_type": "prompt",
+            "kind": "prompt",
+            "name": "Memory Optimization",
+            "description": "Agent memory optimization skill",
+            "body": "Always call ctx.retrieve before LLM calls.",
+            "version": "1.0.0",
+            "tags": ["memory", "best-practice"],
+            "parameters": {},
+            "skill_id": "sk_abc123",
+            "source_fingerprint": "fp_test",
+            "publish_status": "drafted",
+        }
+    return ContextItem(
+        id=item_id,
+        scope="contextseek",
+        content=content,
+        stage=Stage.skill,
+        provenance=Provenance(
+            source_type="distillation",
+            source_id="distillation-pipeline",
+            confidence=confidence,
+            verified=verified,
+        ),
+        tags=["技能", "记忆"],
+    )
+
+
+def test_http_update_skill_returns_updated_item() -> None:
+    ctx = MagicMock(name="ContextSeek")
+    base_content = _sample_skill_item().content  # type: ignore[assignment]
+    updated = _sample_skill_item(
+        content={
+            **base_content,  # type: ignore[dict-item]
+            "name": "New Name",
+            "body": "New body text",
+            "status": "edited",
+        },
+    )
+    ctx.update_skill.return_value = updated
+    ctx.skill_status.return_value = "edited"
+    app = create_app(client=ctx)
+
+    res = _asgi_put(
+        app,
+        "/skill",
+        json={
+            "scope": "contextseek",
+            "item_id": "skill-001",
+            "name": "New Name",
+            "body": "New body text",
+        },
+    )
+    assert res.status_code == 200
+    body = res.json()
+    assert body["status"] == "edited"
+    assert body["item"]["content"]["name"] == "New Name"
+    assert body["item"]["content"]["status"] == "edited"
+    ctx.update_skill.assert_called_once()
+
+
+def test_http_update_skill_not_found() -> None:
+    ctx = MagicMock(name="ContextSeek")
+    ctx.update_skill.side_effect = ValueError("skill not found: missing-id")
+    app = create_app(client=ctx)
+
+    res = _asgi_put(
+        app,
+        "/skill",
+        json={"scope": "contextseek", "item_id": "missing-id", "name": "x"},
+    )
+    assert res.status_code == 404
+    assert "skill not found" in res.json()["detail"]
+
+
+def test_http_confirm_skill_returns_confirmed_item() -> None:
+    ctx = MagicMock(name="ContextSeek")
+    base_content = _sample_skill_item().content  # type: ignore[assignment]
+    confirmed = _sample_skill_item(
+        content={
+            **base_content,  # type: ignore[dict-item]
+            "status": "confirmed",
+        },
+        verified=True,
+        confidence=1.0,
+    )
+    ctx.confirm_skill.return_value = confirmed
+    app = create_app(client=ctx)
+
+    res = _asgi_post(
+        app,
+        "/skill/confirm",
+        json={"scope": "contextseek", "item_id": "skill-001"},
+    )
+    assert res.status_code == 200
+    body = res.json()
+    assert body["status"] == "confirmed"
+    assert body["item"]["provenance"]["confidence"] == 1.0
+    assert body["item"]["provenance"]["verified"] is True
+    ctx.confirm_skill.assert_called_once()
+
+
+def test_http_confirm_skill_not_found() -> None:
+    ctx = MagicMock(name="ContextSeek")
+    ctx.confirm_skill.side_effect = ValueError("skill not found: missing-id")
+    app = create_app(client=ctx)
+
+    res = _asgi_post(
+        app,
+        "/skill/confirm",
+        json={"scope": "contextseek", "item_id": "missing-id"},
+    )
+    assert res.status_code == 404
+    assert "skill not found" in res.json()["detail"]
+
+
+def test_http_skill_export_success(tmp_path) -> None:
+    from contextseek.daemon.skill_export import ExportReport
+
+    ctx = MagicMock(name="ContextSeek")
+    report = ExportReport(written=2, unchanged=0, out_dir=str(tmp_path))
+    ctx.skills.return_value = []
+
+    import contextseek.daemon.skill_export as se_mod
+
+    original_fn = se_mod.export_skills
+    se_mod.export_skills = lambda *args, **kwargs: report
+    try:
+        app = create_app(client=ctx)
+        res = _asgi_post(
+            app,
+            "/skill/export",
+            json={
+                "scope": "contextseek",
+                "out_dir": str(tmp_path),
+                "item_ids": ["skill-001", "skill-002"],
+                "conflict_strategy": "rename",
+                "require_confirmed": True,
+                "spec": "hermes",
+            },
+        )
+    finally:
+        se_mod.export_skills = original_fn
+
+    assert res.status_code == 200
+    body = res.json()
+    assert body["written"] == 2
+    assert body["out_dir"] == str(tmp_path)
+    assert body["skipped_unconfirmed"] == 0
+
+
+def test_http_skill_export_require_confirmed(tmp_path) -> None:
+    from contextseek.daemon.skill_export import ExportReport
+
+    ctx = MagicMock(name="ContextSeek")
+    report = ExportReport(
+        written=1, skipped_unconfirmed=1, out_dir=str(tmp_path)
+    )
+
+    import contextseek.daemon.skill_export as se_mod
+
+    original_fn = se_mod.export_skills
+    se_mod.export_skills = lambda *args, **kwargs: report
+    try:
+        app = create_app(client=ctx)
+        res = _asgi_post(
+            app,
+            "/skill/export",
+            json={
+                "scope": "contextseek",
+                "out_dir": str(tmp_path),
+                "require_confirmed": True,
+            },
+        )
+    finally:
+        se_mod.export_skills = original_fn
+
+    assert res.status_code == 200
+    body = res.json()
+    assert body["skipped_unconfirmed"] == 1
+    assert body["written"] == 1
+
+
+def test_http_skill_export_error_returns_500(tmp_path) -> None:
+    ctx = MagicMock(name="ContextSeek")
+    ctx.skills.side_effect = RuntimeError("internal error")
+    app = create_app(client=ctx)
+
+    res = _asgi_post(
+        app,
+        "/skill/export",
+        json={"scope": "contextseek", "out_dir": str(tmp_path)},
+    )
+    assert res.status_code == 500
+    assert "internal error" in res.json()["detail"]
+
+
+def test_http_skill_export_invalid_conflict_strategy(tmp_path) -> None:
+    ctx = MagicMock(name="ContextSeek")
+    app = create_app(client=ctx)
+
+    res = _asgi_post(
+        app,
+        "/skill/export",
+        json={
+            "scope": "contextseek",
+            "out_dir": str(tmp_path),
+            "conflict_strategy": "invalid",
+        },
+    )
+    assert res.status_code == 422  # Pydantic validation error
+
+
+def test_http_skill_export_invalid_spec(tmp_path) -> None:
+    ctx = MagicMock(name="ContextSeek")
+    app = create_app(client=ctx)
+
+    res = _asgi_post(
+        app,
+        "/skill/export",
+        json={
+            "scope": "contextseek",
+            "out_dir": str(tmp_path),
+            "spec": "invalid",
+        },
+    )
+    assert res.status_code == 422  # Pydantic validation error
+
+
 def test_http_plug_status_refresh_detects_missing_targets_for_all_linkers(
     monkeypatch,
     tmp_path,
@@ -839,3 +1081,132 @@ def fake_available_linker_names():
     status = _asgi_get(app, "/plugs/powermem")
     assert status.status_code == 200
     assert status.json()["entries"] == job["entries"]
+
+
+# ─── Skill editing & confirmation (Issue #40) ────────────────────────────────
+
+
+def _sample_skill_item(
+    *,
+    item_id: str = "skill-001",
+    content: dict | str | None = None,
+    verified: bool = False,
+    confidence: float = 0.7,
+) -> ContextItem:
+    from contextseek.domain.stages import Stage
+
+    if content is None:
+        content = {
+            "skill_type": "prompt",
+            "kind": "prompt",
+            "name": "Memory Optimization",
+            "description": "Agent memory optimization skill",
+            "body": "Always call ctx.retrieve before LLM calls.",
+            "version": "1.0.0",
+            "tags": ["memory", "best-practice"],
+            "parameters": {},
+            "skill_id": "sk_abc123",
+            "source_fingerprint": "fp_test",
+            "publish_status": "drafted",
+        }
+    return ContextItem(
+        id=item_id,
+        scope="contextseek",
+        content=content,
+        stage=Stage.skill,
+        provenance=Provenance(
+            source_type="distillation",
+            source_id="distillation-pipeline",
+            confidence=confidence,
+            verified=verified,
+        ),
+        tags=["技能", "记忆"],
+    )
+
+
+def test_http_update_skill_returns_updated_item() -> None:
+    ctx = MagicMock(name="ContextSeek")
+    base_content = _sample_skill_item().content  # type: ignore[assignment]
+    updated = _sample_skill_item(
+        content={
+            **base_content,  # type: ignore[dict-item]
+            "name": "New Name",
+            "body": "New body text",
+            "status": "edited",
+        },
+    )
+    ctx.update_skill.return_value = updated
+    ctx.skill_status.return_value = "edited"
+    app = create_app(client=ctx)
+
+    res = _asgi_put(
+        app,
+        "/skill",
+        json={
+            "scope": "contextseek",
+            "item_id": "skill-001",
+            "name": "New Name",
+            "body": "New body text",
+        },
+    )
+    assert res.status_code == 200
+    body = res.json()
+    assert body["status"] == "edited"
+    assert body["item"]["content"]["name"] == "New Name"
+    assert body["item"]["content"]["status"] == "edited"
+    ctx.update_skill.assert_called_once()
+
+
+def test_http_update_skill_not_found() -> None:
+    ctx = MagicMock(name="ContextSeek")
+    ctx.update_skill.side_effect = ValueError("skill not found: missing-id")
+    app = create_app(client=ctx)
+
+    res = _asgi_put(
+        app,
+        "/skill",
+        json={"scope": "contextseek", "item_id": "missing-id", "name": "x"},
+    )
+    assert res.status_code == 404
+    assert "skill not found" in res.json()["detail"]
+
+
+def test_http_confirm_skill_returns_confirmed_item() -> None:
+    ctx = MagicMock(name="ContextSeek")
+    base_content = _sample_skill_item().content  # type: ignore[assignment]
+    confirmed = _sample_skill_item(
+        content={
+            **base_content,  # type: ignore[dict-item]
+            "status": "confirmed",
+        },
+        verified=True,
+        confidence=1.0,
+    )
+    ctx.confirm_skill.return_value = confirmed
+    app = create_app(client=ctx)
+
+    res = _asgi_post(
+        app,
+        "/skill/confirm",
+        json={"scope": "contextseek", "item_id": "skill-001"},
+    )
+    assert res.status_code == 200
+    body = res.json()
+    assert body["status"] == "confirmed"
+    assert body["item"]["provenance"]["confidence"] == 1.0
+    assert body["item"]["provenance"]["verified"] is True
+    ctx.confirm_skill.assert_called_once()
+
+
+def test_http_confirm_skill_not_found() -> None:
+    ctx = MagicMock(name="ContextSeek")
+    ctx.confirm_skill.side_effect = ValueError("skill not found: missing-id")
+    app = create_app(client=ctx)
+
+    res = _asgi_post(
+        app,
+        "/skill/confirm",
+        json={"scope": "contextseek", "item_id": "missing-id"},
+    )
+    assert res.status_code == 404
+    assert "skill not found" in res.json()["detail"]
diff --git a/tests/unit_tests/test_mcp_skills.py b/tests/unit_tests/test_mcp_skills.py
index 310348c..14f0bec 100644
--- a/tests/unit_tests/test_mcp_skills.py
+++ b/tests/unit_tests/test_mcp_skills.py
@@ -215,3 +215,180 @@ def test_acceptance_mcp_call_then_feedback_flows_to_signal(self):
             r for r in ctx.audit_log.records if r.action == "skill_feedback_ingested"
         ]
         assert ingested and ingested[-1].detail["skill_id"] == tid
+
+
+# ─── Skill editing & human confirmation (Issue #40) ──────────────────────────
+
+
+def _seed_by_item_id(ctx: ContextSeek, ir: SkillIR, *, tags=None) -> str:
+    """Seed a skill and return its ContextItem.id (not skill_id)."""
+    item = ContextItem(
+        id=_generate_id(),
+        content=ir.to_content(),
+        scope=SCOPE,
+        provenance=Provenance(
+            source_type=SourceType.distillation, source_id="k", confidence=0.8
+        ),
+        stage=Stage.skill,
+        tags=tags or [],
+    )
+    ctx.adapter.write(
+        ctx.resolver.ref_for(SCOPE, item.id), serialize_context_item(item)
+    )
+    return item.id
+
+
+def _seed_string_content(ctx: ContextSeek, body: str = "old body") -> str:
+    """Seed a string-content skill and return its ContextItem.id."""
+    item = ContextItem(
+        id=_generate_id(),
+        content=body,
+        scope=SCOPE,
+        provenance=Provenance(
+            source_type=SourceType.distillation, source_id="k", confidence=0.7
+        ),
+        stage=Stage.skill,
+        tags=[],
+    )
+    ctx.adapter.write(
+        ctx.resolver.ref_for(SCOPE, item.id), serialize_context_item(item)
+    )
+    return item.id
+
+
+class TestUpdateSkill:
+    def test_update_dict_content_fields(self):
+        ctx = _ctx()
+        ir = _prompt_skill(name="Old", body="old body")
+        item_id = _seed_by_item_id(ctx, ir)
+
+        updated = ctx.update_skill(
+            scope=SCOPE, item_id=item_id, name="New Name", body="new body"
+        )
+        assert updated.content["name"] == "New Name"
+        assert updated.content["body"] == "new body"
+        assert updated.content["status"] == "edited"
+        assert updated.updated_at is not None
+        # provenance should not change on edit
+        assert updated.provenance.confidence == 0.8
+        assert updated.provenance.verified is False
+
+    def test_update_string_content_upgrades_to_dict(self):
+        ctx = _ctx()
+        item_id = _seed_string_content(ctx, "original body")
+
+        updated = ctx.update_skill(
+            scope=SCOPE, item_id=item_id, name="Upgraded", body="new body"
+        )
+        # Should now be dict content with status
+        assert isinstance(updated.content, dict)
+        assert updated.content["name"] == "Upgraded"
+        assert updated.content["body"] == "new body"
+        assert updated.content["status"] == "edited"
+
+    def test_update_persists_to_storage(self):
+        ctx = _ctx()
+        ir = _prompt_skill(name="Persist", body="v1")
+        item_id = _seed_by_item_id(ctx, ir)
+
+        ctx.update_skill(scope=SCOPE, item_id=item_id, body="v2")
+        # Reload from storage
+        reloaded = ctx._find_skill_by_item_id(SCOPE, item_id)
+        assert reloaded is not None
+        assert reloaded.content["body"] == "v2"
+        assert reloaded.content["status"] == "edited"
+
+    def test_update_unknown_raises(self):
+        ctx = _ctx()
+        with pytest.raises(ValueError):
+            ctx.update_skill(scope=SCOPE, item_id="nope", name="x")
+
+    def test_update_emits_audit_event(self):
+        ctx = _ctx()
+        ir = _prompt_skill(name="Audit", body="b")
+        item_id = _seed_by_item_id(ctx, ir)
+
+        ctx.update_skill(scope=SCOPE, item_id=item_id, name="Audited")
+        actions = {r.action for r in ctx.audit_log.records}
+        assert "skill_updated" in actions
+
+
+class TestConfirmSkill:
+    def test_confirm_sets_confidence_and_verified(self):
+        ctx = _ctx()
+        ir = _prompt_skill(name="Confirm", body="b")
+        item_id = _seed_by_item_id(ctx, ir)
+
+        confirmed = ctx.confirm_skill(scope=SCOPE, item_id=item_id)
+        assert confirmed.provenance.confidence == 1.0
+        assert confirmed.provenance.verified is True
+        assert confirmed.content["status"] == "confirmed"
+
+    def test_confirm_string_content_upgrades(self):
+        ctx = _ctx()
+        item_id = _seed_string_content(ctx)
+
+        confirmed = ctx.confirm_skill(scope=SCOPE, item_id=item_id)
+        assert isinstance(confirmed.content, dict)
+        assert confirmed.content["status"] == "confirmed"
+        assert confirmed.provenance.verified is True
+
+    def test_confirm_persists_to_storage(self):
+        ctx = _ctx()
+        ir = _prompt_skill(name="CPersist", body="b")
+        item_id = _seed_by_item_id(ctx, ir)
+
+        ctx.confirm_skill(scope=SCOPE, item_id=item_id)
+        reloaded = ctx._find_skill_by_item_id(SCOPE, item_id)
+        assert reloaded is not None
+        assert reloaded.provenance.confidence == 1.0
+        assert reloaded.provenance.verified is True
+
+    def test_confirm_unknown_raises(self):
+        ctx = _ctx()
+        with pytest.raises(ValueError):
+            ctx.confirm_skill(scope=SCOPE, item_id="nope")
+
+    def test_confirm_emits_audit_event(self):
+        ctx = _ctx()
+        ir = _prompt_skill(name="CAudit", body="b")
+        item_id = _seed_by_item_id(ctx, ir)
+
+        ctx.confirm_skill(scope=SCOPE, item_id=item_id)
+        actions = {r.action for r in ctx.audit_log.records}
+        assert "skill_confirmed" in actions
+
+
+class TestSkillStatus:
+    def test_auto_generated_default(self):
+        ctx = _ctx()
+        ir = _prompt_skill(name="Auto", body="b")
+        item_id = _seed_by_item_id(ctx, ir)
+        item = ctx._find_skill_by_item_id(SCOPE, item_id)
+        assert item is not None
+        assert ctx.skill_status(item) == "auto-generated"
+
+    def test_edited_after_update(self):
+        ctx = _ctx()
+        ir = _prompt_skill(name="Ed", body="b")
+        item_id = _seed_by_item_id(ctx, ir)
+        ctx.update_skill(scope=SCOPE, item_id=item_id, name="Edited")
+        item = ctx._find_skill_by_item_id(SCOPE, item_id)
+        assert item is not None
+        assert ctx.skill_status(item) == "edited"
+
+    def test_confirmed_after_confirm(self):
+        ctx = _ctx()
+        ir = _prompt_skill(name="Conf", body="b")
+        item_id = _seed_by_item_id(ctx, ir)
+        ctx.confirm_skill(scope=SCOPE, item_id=item_id)
+        item = ctx._find_skill_by_item_id(SCOPE, item_id)
+        assert item is not None
+        assert ctx.skill_status(item) == "confirmed"
+
+    def test_string_content_without_status_is_auto(self):
+        ctx = _ctx()
+        item_id = _seed_string_content(ctx)
+        item = ctx._find_skill_by_item_id(SCOPE, item_id)
+        assert item is not None
+        assert ctx.skill_status(item) == "auto-generated"
diff --git a/tests/unit_tests/test_skill_export.py b/tests/unit_tests/test_skill_export.py
index 007af7d..ecd1d63 100644
--- a/tests/unit_tests/test_skill_export.py
+++ b/tests/unit_tests/test_skill_export.py
@@ -232,3 +232,161 @@ def test_export_advances_publish_status_to_published(tmp_path: pathlib.Path) ->
 
     stored = deserialize_context_item(ctx.adapter.read(ref))
     assert SkillIR.from_content(stored.content).publish_status == "published"
+
+
+# ---------------------------------------------------------------------------
+# Tests for selective export, conflict strategy, and confirmation gate
+# ---------------------------------------------------------------------------
+
+
+def test_export_selected_item_ids_only(tmp_path: pathlib.Path) -> None:
+    a = _skill("Alpha Skill")
+    b = _skill("Beta Skill")
+    c = _skill("Gamma Skill")
+    ctx = _StubClient([a, b, c])
+
+    report = export_skills(
+        ctx,
+        scope="me/work",
+        out_dir=tmp_path,
+        item_ids=[a.id, c.id],
+    )
+    assert report.written == 2
+    assert (tmp_path / "alpha-skill" / "SKILL.md").exists()
+    assert not (tmp_path / "beta-skill").exists()
+    assert (tmp_path / "gamma-skill" / "SKILL.md").exists()
+
+
+def test_export_require_confirmed_skips_unconfirmed(tmp_path: pathlib.Path) -> None:
+    unconfirmed = _skill("Unconfirmed", confidence=0.9)
+    confirmed = _skill("Confirmed", confidence=0.9, content={
+        "skill_type": "prompt",
+        "name": "Confirmed",
+        "description": "Confirmed description",
+        "version": "1.0.0",
+        "tags": ["alpha"],
+        "body": "do stuff",
+        "status": "confirmed",
+    })
+
+    ctx = _StubClient([unconfirmed, confirmed])
+    report = export_skills(
+        ctx,
+        scope="me/work",
+        out_dir=tmp_path,
+        require_confirmed=True,
+    )
+    assert report.skipped_unconfirmed == 1
+    assert report.written == 1
+    assert (tmp_path / "confirmed" / "SKILL.md").exists()
+    assert not (tmp_path / "unconfirmed").exists()
+
+
+def test_conflict_strategy_skip(tmp_path: pathlib.Path) -> None:
+    # Pre-create an external (non-manifest) SKILL.md in the target directory.
+    ext_dir = tmp_path / "alpha-skill"
+    ext_dir.mkdir(parents=True)
+    (ext_dir / "SKILL.md").write_text("# hand-written\n\nmanual content", encoding="utf-8")
+
+    ctx = _StubClient([_skill("Alpha Skill")])
+    report = export_skills(
+        ctx,
+        scope="me/work",
+        out_dir=tmp_path,
+        conflict_strategy="skip",
+    )
+    assert report.skipped_conflict == 1
+    assert report.written == 0
+    # External file untouched.
+    assert (ext_dir / "SKILL.md").read_text(encoding="utf-8").startswith("# hand-written")
+
+
+def test_conflict_strategy_overwrite(tmp_path: pathlib.Path) -> None:
+    ext_dir = tmp_path / "alpha-skill"
+    ext_dir.mkdir(parents=True)
+    original = "# hand-written\n\nmanual content"
+    (ext_dir / "SKILL.md").write_text(original, encoding="utf-8")
+
+    ctx = _StubClient([_skill("Alpha Skill")])
+    report = export_skills(
+        ctx,
+        scope="me/work",
+        out_dir=tmp_path,
+        conflict_strategy="overwrite",
+    )
+    assert report.written == 1
+    assert report.skipped_conflict == 0
+    content = (ext_dir / "SKILL.md").read_text(encoding="utf-8")
+    assert content.startswith("---")
+    assert "Alpha Skill" in content
+
+
+def test_conflict_strategy_rename(tmp_path: pathlib.Path) -> None:
+    ext_dir = tmp_path / "alpha-skill"
+    ext_dir.mkdir(parents=True)
+    original = "# hand-written\n\nmanual content"
+    (ext_dir / "SKILL.md").write_text(original, encoding="utf-8")
+
+    skill = _skill("Alpha Skill")
+    ctx = _StubClient([skill])
+    report = export_skills(
+        ctx,
+        scope="me/work",
+        out_dir=tmp_path,
+        conflict_strategy="rename",
+    )
+    assert report.written == 1
+    assert report.skipped_conflict == 0
+    # External file untouched.
+    assert (ext_dir / "SKILL.md").read_text(encoding="utf-8") == original
+    # New file written to a renamed slug directory.
+    suffix = skill.id[8:16] if len(skill.id) >= 16 else skill.id[:8]
+    renamed_dir = tmp_path / f"alpha-skill-{suffix}"
+    assert (renamed_dir / "SKILL.md").exists()
+    assert (renamed_dir / "SKILL.md").read_text(encoding="utf-8").startswith("---")
+
+
+def test_export_with_item_ids_disables_prune(tmp_path: pathlib.Path) -> None:
+    skill_a = _skill("Alpha")
+    skill_b = _skill("Beta")
+    # Initial full export writes both.
+    export_skills(_StubClient([skill_a, skill_b]), scope="me/work", out_dir=tmp_path)
+    assert (tmp_path / "alpha" / "SKILL.md").exists()
+    assert (tmp_path / "beta" / "SKILL.md").exists()
+
+    # Selective export of only Alpha — Beta must NOT be pruned.
+    report = export_skills(
+        _StubClient([skill_a, skill_b]),
+        scope="me/work",
+        out_dir=tmp_path,
+        item_ids=[skill_a.id],
+    )
+    assert report.pruned == 0
+    assert (tmp_path / "alpha" / "SKILL.md").exists()
+    assert (tmp_path / "beta" / "SKILL.md").exists()
+
+
+def test_export_invalid_conflict_strategy_raises(tmp_path: pathlib.Path) -> None:
+    import pytest
+
+    ctx = _StubClient([_skill("Alpha")])
+    with pytest.raises(ValueError, match="conflict_strategy"):
+        export_skills(
+            ctx,
+            scope="me/work",
+            out_dir=tmp_path,
+            conflict_strategy="bogus",
+        )
+
+
+def test_export_empty_item_ids_exports_nothing(tmp_path: pathlib.Path) -> None:
+    ctx = _StubClient([_skill("Alpha"), _skill("Beta")])
+    report = export_skills(
+        ctx,
+        scope="me/work",
+        out_dir=tmp_path,
+        item_ids=[],
+    )
+    assert report.written == 0
+    assert not (tmp_path / "alpha").exists()
+    assert not (tmp_path / "beta").exists()