diff --git a/CHANGELOG.md b/CHANGELOG.md
index 99cf728e..b892ce27 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@ All notable changes to **omp-web** (`@kahme247/ompweb`) are documented in this f
 ### Added
 
 - Choose **Classifier** or **Vendor default** in Settings → AI Model Defaults → **Auto Thinking Source** when Reasoning is `auto`. The choice is saved in omp's native config for newly started or restarted agents. Vendor mode prefers the publisher's effort, then omp's per-model default, then normal Auto fallback. Requires an omp release containing [can1357/oh-my-pi#14114](https://github.com/can1357/oh-my-pi/pull/14114).
+- Show conflicting skill names and deduplicated installations when an OMP session starts, with resolution details, a **×** button that dismisses the notice for the session until the diagnostic report changes, and a persisted **Turn off** action that disables startup notices. Inspect a running session manually in **Settings → Extensions & Tools → Skills**, even when notices are off; inspection never resumes a stopped session. Requires an OMP runtime with the skill-diagnostics RPC commands; older runtimes report live diagnostics as unavailable.
 - Ask a side question with `/btw <question>`: omp answers from the current conversation in a panel above the composer, even while the agent is working, and the question never enters the chat. Cancel a running answer, copy it, or ask follow-ups in the same topic. `/btw` on its own lists the session's past side questions, including ones asked in the terminal, each expandable to all its turns with **Copy** and **Follow up**. Side questions are text-only: with an attachment in the composer, `/btw` is refused and the draft is kept. An answer that omp lost (for example after its process restarted) shows as **Interrupted** instead of spinning. Requires an omp with the `btw` RPC commands; older omp shows "/btw requires a newer omp" instead of sending the text to the model.
 - Show omp's Claude usage-limit badge in the composer toolbar, matching the terminal status line during the wrap-up allowance or once `/slow` low priority takes over. Reset times use the browser's locale and timezone. Requires an omp version whose `get_state` reports structured `usageLimit` state.
 - Add a **Slow** toggle next to **Fast** in the composer toolbar, the equivalent of omp's `/slow`. On Claude models it turns low priority on or off in your omp settings, so it applies to every session and terminal; on OpenAI and Google models it switches this session to the provider's flex tier. Once the session's omp process runs, the toggle follows omp's `get_state` (`slowModeSupported`); before that, including in a new session, it follows the selected model's provider (`anthropic`, `openai`, `openai-codex`, `google`, `google-vertex`) and, on Claude, the `providers.anthropic.slowMode` setting. Clicking it there starts the session's omp process.
diff --git a/README.md b/README.md
index 0e5a7884..74223bc3 100644
--- a/README.md
+++ b/README.md
@@ -35,6 +35,20 @@ Queue **Delete** and **Edit** additionally require `remove_queued_message`. Dele
 
 The queue panel shows omp's own queue (`queuedMessages` in `get_state` and `queue_update` events, omp 18.4.4 or later), so every device viewing a session sees the same queued messages. **Stop** moves the text of messages still waiting in the queue back into the composer instead of letting the agent run them; a steer the model already picked up through live steering still runs. Older omp runtimes show no queue panel, and Stop cannot take queued messages back.
 
+Skill startup notices require an OMP runtime with `get_skill_diagnostics`,
+`set_skill_startup_diagnostics`, and `skill_diagnostics_update`. Conflicts and
+redundant installations appear above the composer when its OMP session starts;
+an empty new-chat page does not start OMP just for diagnostics. **Details** shows
+the resolved default, variants, identical copies, backing paths, sources, and
+selection reason. The **×** button dismisses the notice for that session until
+the diagnostic report changes. **Turn off** and **Settings →
+Interface & Behavior → Skill startup notices** use OMP's persisted
+`skills.showStartupDiagnostics` preference, not a separate browser setting.
+**Settings → Extensions & Tools → Skills → View skill diagnostics** remains
+available for a selected running session when notices are off. Inspection does
+not resume stopped sessions. Missing support or no running session is unavailable,
+not a clean result.
+
 ## Quick Start
 
 **Run directly without installing:**
diff --git a/app/api/agent/[id]/route.ts b/app/api/agent/[id]/route.ts
index f4eb1ba9..d6b39454 100644
--- a/app/api/agent/[id]/route.ts
+++ b/app/api/agent/[id]/route.ts
@@ -18,6 +18,13 @@ const NO_SPAWN_REPLIES: Record<string, unknown> = {
   btw_cancel: { cancelled: false },
 };
 
+// Live diagnostics of a skill-resolving omp. A saved or exited session has none,
+// and resuming a full child (MCP, LSP) just to answer a read-only inspection or
+// flip one setting is not what the click asked for: with no live wrapper these
+// answer 409 instead of starting omp, and a live idle child is never replaced
+// because the advisor flag differs.
+const LIVE_SESSION_ONLY = new Set(["get_skill_diagnostics", "set_skill_startup_diagnostics"]);
+
 /** omp-web's own failures carry a stable code the client can localize; omp's
  * errors stay opaque English text. */
 function commandErrorResponse(error: unknown) {
@@ -60,14 +67,21 @@ export async function POST(
     // running and pick the flag up at the next natural respawn.
     const existing = getRpcSession(id);
     const noSpawn = Object.hasOwn(NO_SPAWN_REPLIES, body.type);
+    const liveOnly = LIVE_SESSION_ONLY.has(body.type);
     if (existing?.isAlive()) {
-      if (noSpawn || existing.advisorSpawned === advisor || existing.isRunning()) {
+      if (noSpawn || liveOnly || existing.advisorSpawned === advisor || existing.isRunning()) {
         const result = await existing.send(body);
         return NextResponse.json({ success: true, data: result });
       }
       await existing.destroyAndWait();
     }
     if (noSpawn) return NextResponse.json({ success: true, data: NO_SPAWN_REPLIES[body.type] });
+    if (liveOnly) {
+      return NextResponse.json(
+        { error: "Skill diagnostics require a running session", code: "skill_diagnostics_unavailable" },
+        { status: 409 },
+      );
+    }
 
     const resolved = await resolveSessionPathOr404(id);
     if ("response" in resolved) return resolved.response;
diff --git a/components/ChatWindow.tsx b/components/ChatWindow.tsx
index 6257d52d..30bb80ba 100644
--- a/components/ChatWindow.tsx
+++ b/components/ChatWindow.tsx
@@ -13,6 +13,7 @@ import { ExtensionDialog } from "./ExtensionDialog";
 import { SubagentTranscriptDialog } from "./SubagentTranscriptDialog";
 import { ChatMinimap, useMessageRefs } from "./ChatMinimap";
 import { ComposerPanels } from "./ComposerPanels";
+import { SkillDiagnosticsNotice } from "./SkillDiagnostics";
 import { BtwHistoryDialog, type BtwPanelProps } from "./BtwPanel";
 import OmpWebLogo from "./OmpWebLogo";
 import { CHAT_COLUMN_MAX_WIDTH, MINIMAP_WIDTH } from "@/lib/chat-layout";
@@ -532,6 +533,7 @@ export function ChatWindow({ session, newSessionCwd, newSessionWorkspace, toolCa
     isCompacting, compactResult, tokensPerSecond, displayModel: displayModelValue, sessionStats,
     slashCommands, slashCommandsLoading, queuedMessages, advisorActive, advisorEnabled, handleAdvisorChange,
     notices, dismissNotice, extensionDialog, extensionCustomUi, extensionStatuses, extensionWidgets, respondToExtensionUi, sendExtensionCustomInput,
+    skillDiagnostics, setSkillStartupDiagnostics,
     isAutoModelSelection,
     agentPhase, activeGoal, activePlan,
     liveToolResults,
@@ -1232,6 +1234,7 @@ export function ChatWindow({ session, newSessionCwd, newSessionWorkspace, toolCa
             </div>
             {newSessionWorkspace}
             <NoticeShelf notices={notices} onDismiss={dismissNotice} align="right" />
+            <SkillDiagnosticsNotice snapshot={skillDiagnostics} onDisable={() => setSkillStartupDiagnostics(false)} />
             <ComposerPanels todoPhases={[]} subagents={[]} onSelectSubagent={setSelectedSubagent} btw={btwPanel} />
             {/* ChatInput insets itself by CHAT_COLUMN_PADDING; cancel this column's
                 padding so the composer matches its in-session width. */}
@@ -1447,6 +1450,7 @@ export function ChatWindow({ session, newSessionCwd, newSessionWorkspace, toolCa
                 />
               </div>
             )}
+            <SkillDiagnosticsNotice snapshot={skillDiagnostics} onDisable={() => setSkillStartupDiagnostics(false)} />
             <ComposerPanels
               todoPhases={todoPhases}
               subagents={subagents}
diff --git a/components/SettingsConfig.tsx b/components/SettingsConfig.tsx
index c9c7f0e6..346d90ca 100644
--- a/components/SettingsConfig.tsx
+++ b/components/SettingsConfig.tsx
@@ -61,6 +61,7 @@ type NativeSettings = {
   autolearn?: { enabled?: boolean; autoContinue?: boolean; minToolCalls?: number };
   mnemopi?: { scoping?: "global" | "per-project" | "per-project-tagged"; autoRecall?: boolean; autoRetain?: boolean; noEmbeddings?: boolean };
   mcp?: { enableProjectConfig?: boolean; renderMarkdownResults?: boolean; notifications?: boolean; notificationDebounceMs?: number };
+  skills?: { showStartupDiagnostics?: boolean };
   retry?: { enabled?: boolean; maxRetries?: number; modelFallback?: boolean };
 };
 
@@ -141,6 +142,7 @@ type SettingIndexEntry = {
 
 const SETTING_INDEX: SettingIndexEntry[] = [
   // Interface & Behavior
+  { id: "skill-startup-notices", tab: "general", sectionKey: "settingsConfig.interfaceBehavior", labelKey: "settingsConfig.skillStartupNotices", descKey: "settingsConfig.skillStartupNoticesDesc", fallbackSection: "Interface & Behavior", fallbackLabel: "Skill startup notices", fallbackDesc: "Show conflicts and redundant skill copies when an OMP session starts.", scope: "Native OMP" },
   { id: "completion-sound", tab: "general", sectionKey: "settingsConfig.interfaceBehavior", labelKey: "settingsConfig.completionSound", descKey: "settingsConfig.completionSoundDesc", fallbackSection: "Interface & Behavior", fallbackLabel: "Completion sound", fallbackDesc: "Play a tone when the agent completes a run.", scope: "UI" },
   { id: "keep-tool-calls-collapsed", tab: "general", sectionKey: "settingsConfig.interfaceBehavior", labelKey: "settingsConfig.keepToolCallsCollapsed", descKey: "settingsConfig.keepToolCallsCollapsedDesc", fallbackSection: "Interface & Behavior", fallbackLabel: "Keep tool calls collapsed", fallbackDesc: "Show only compact headers while tools execute.", scope: "UI" },
   { id: "open-url-automatically", tab: "general", sectionKey: "settingsConfig.interfaceBehavior", labelKey: "settingsConfig.openUrlAutomatically", descKey: "settingsConfig.openUrlAutomaticallyDesc", fallbackSection: "Interface & Behavior", fallbackLabel: "Open agent links without asking", fallbackDesc: "Links the agent opens from the session you are viewing open in a new tab right away. Links from other sessions always ask first. Your browser may still block pop-ups.", scope: "UI" },
@@ -884,7 +886,7 @@ export function SettingsConfig({ activeTab, toolCallsDefaultCollapsed, onToolCal
   }, [ompUpdating, t, checkForUpdate, restartSessions]);
 
 
-  const currentTab = getNormalizedActive(activeTab);
+  const currentTab = activeTab === "skills" ? activeTab : getNormalizedActive(activeTab);
   const nativeSettingsRequired = currentTab === "general" || currentTab === "safety" || currentTab === "models" || currentTab === "intelligence" || currentTab === "mcp";
   useEffect(() => {
     if (currentTab === "system") {
@@ -1140,6 +1142,9 @@ export function SettingsConfig({ activeTab, toolCallsDefaultCollapsed, onToolCal
                   <NativeSetting searchId="provider-usage" label={t("settingsConfig.providerUsage")} description={t("settingsConfig.providerUsageDesc")} scope="UI">
                     <ToggleSwitch checked={providerUsageVisible} onChange={onProviderUsageVisibleChange} />
                   </NativeSetting>
+                  <NativeSetting searchId="skill-startup-notices" label={t("settingsConfig.skillStartupNotices")} description={t("settingsConfig.skillStartupNoticesDesc")} scope="Native OMP">
+                    <ToggleSwitch checked={nativeSettings?.skills?.showStartupDiagnostics !== false} disabled={nativeSettingsLoading} onChange={(enabled) => patchSection("skills", { showStartupDiagnostics: enabled })} />
+                  </NativeSetting>
                   <NativeSetting searchId="chat-font-size" label={t("settingsConfig.chatFontSize")} description={t("settingsConfig.chatFontSizeDesc")} scope="UI">
                     <select
                       style={nativeSelectStyle}
@@ -1488,6 +1493,7 @@ export function SettingsConfig({ activeTab, toolCallsDefaultCollapsed, onToolCal
                 <div style={{ marginBottom: 4 }}>
                   <h2 className="display-serif" style={{ fontSize: 22, fontWeight: 600, margin: 0, color: "var(--text)", letterSpacing: "-0.01em" }}>{t("settingsConfig.extensionsTools")}</h2>
                   <p className="settings-content-subtitle" style={{ margin: "4px 0 16px", fontSize: 13, color: "var(--text-muted)", lineHeight: 1.45 }}>{t("settingsConfig.extensionsToolsDesc")}</p>
+                  {cwd && <button type="button" className="settings-back ui-focus-ring" onClick={() => handleSelectTab("skills")}>{t("skillsConfig.title")}</button>}
                 </div>
                 {cwd && (
                   <div style={{ display: "flex", flexDirection: "column", gap: 10, width: "100%" }}>
@@ -1518,8 +1524,8 @@ export function SettingsConfig({ activeTab, toolCallsDefaultCollapsed, onToolCal
 
             {/* SKILLS SUB-PANEL CONTRACT MATCH */}
             {cwd && currentTab === "skills" && (
-              <div role="tabpanel" id="settings-panel-skills" aria-labelledby="settings-tab-skills" className="settings-panel-inner" style={{ display: currentTab === "skills" ? "flex" : "none", width: "100%", maxWidth: 940, minHeight: isMobile ? undefined : 600, flexDirection: "column", padding: isMobile ? "16px 14px 32px" : "32px 24px 64px" }}>
-                <SkillsConfig embedded cwd={cwd} onClose={onClose} />
+              <div role="tabpanel" id="settings-panel-skills" aria-labelledby="settings-tab-mcp" className="settings-panel-inner" style={{ display: currentTab === "skills" ? "flex" : "none", width: "100%", maxWidth: 940, minHeight: isMobile ? undefined : 600, flexDirection: "column", padding: isMobile ? "16px 14px 32px" : "32px 24px 64px" }}>
+                <SkillsConfig embedded cwd={cwd} sessionId={sessionId} onClose={onClose} />
               </div>
             )}
 
diff --git a/components/SkillDiagnostics.test.mjs b/components/SkillDiagnostics.test.mjs
new file mode 100644
index 00000000..6b1a128e
--- /dev/null
+++ b/components/SkillDiagnostics.test.mjs
@@ -0,0 +1,70 @@
+import "../tests/setup-dom.mjs";
+import assert from "node:assert/strict";
+import test, { afterEach } from "node:test";
+import React from "react";
+import { cleanup, render, screen, waitFor } from "@testing-library/react/pure.js";
+import userEvent from "@testing-library/user-event";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, { jsx: { runtime: "automatic" }, tsconfigPaths: true });
+const { SkillDiagnosticsDialog, SkillDiagnosticsNotice } = await jiti.import("./SkillDiagnostics.tsx");
+afterEach(cleanup);
+
+const snapshot = {
+  cwd: "/project",
+  showStartupDiagnostics: true,
+  diagnostics: [{
+    name: "review", reason: "source-order",
+    skills: [
+      { name: "review", filePath: "/first/review/SKILL.md", source: "native:user" },
+      { name: "second/review", filePath: "/second/review/SKILL.md", source: "agents:project" },
+    ], duplicates: [],
+  }],
+};
+
+test("diagnostic display neutralizes path-spoofing controls without discarding ordinary Unicode", () => {
+  const hostile = {
+    cwd: "/project\u202E",
+    showStartupDiagnostics: true,
+    diagnostics: [{
+      name: "調査\u202E", reason: "source-order",
+      skills: [{ name: "調査\u202E", filePath: "/技能/\u202Eevil\u0007/SKILL.md", source: "custom:user\u2066", pluginName: "補助\u2069" }],
+      duplicates: [{
+        skill: { name: "調査\u202E", filePath: "/mirror\u0085/SKILL.md", source: "custom:user" },
+        retained: { name: "調査\u202E", filePath: "/技能/\u202Eevil\u0007/SKILL.md", source: "custom:user" },
+      }],
+    }],
+  };
+  render(React.createElement(SkillDiagnosticsDialog, { open: true, onOpenChange: () => {}, snapshot: hostile }));
+  const text = screen.getByRole("dialog", { name: "Skill diagnostics" }).textContent;
+  assert.doesNotMatch(text, /[\p{Cc}\u202a-\u202e\u2066-\u2069]/u);
+  assert.ok(text.includes("/技能/evil/SKILL.md"));
+  assert.ok(text.includes("補助"));
+  assert.ok(text.includes("調査"));
+});
+
+test("losing a diagnostic snapshot closes details instead of reopening them on recovery", async () => {
+  const user = userEvent.setup();
+  const props = { snapshot, onDisable: async () => snapshot };
+  const view = render(React.createElement(SkillDiagnosticsNotice, props));
+  await user.click(screen.getByRole("button", { name: "Details" }));
+  assert.ok(screen.getByRole("dialog", { name: "Skill diagnostics" }));
+  view.rerender(React.createElement(SkillDiagnosticsNotice, { ...props, snapshot: null }));
+  view.rerender(React.createElement(SkillDiagnosticsNotice, props));
+  await waitFor(() => assert.equal(screen.queryByRole("dialog", { name: "Skill diagnostics" }) === null, true));
+  assert.ok(screen.getByRole("button", { name: "Details" }));
+});
+
+test("dismissing the notice hides that report until the diagnostics change", async () => {
+  const user = userEvent.setup();
+  const props = { snapshot, onDisable: async () => snapshot };
+  const view = render(React.createElement(SkillDiagnosticsNotice, props));
+  await user.click(screen.getByRole("button", { name: "Dismiss skill notice" }));
+  assert.equal(screen.queryByRole("status"), null);
+  view.rerender(React.createElement(SkillDiagnosticsNotice, { ...props, snapshot: structuredClone(snapshot) }));
+  assert.equal(screen.queryByRole("status"), null);
+  const changed = structuredClone(snapshot);
+  changed.diagnostics[0].name = "audit";
+  view.rerender(React.createElement(SkillDiagnosticsNotice, { ...props, snapshot: changed }));
+  assert.ok(screen.getByRole("status"));
+});
diff --git a/components/SkillDiagnostics.tsx b/components/SkillDiagnostics.tsx
new file mode 100644
index 00000000..1c1a2271
--- /dev/null
+++ b/components/SkillDiagnostics.tsx
@@ -0,0 +1,162 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import { CircleAlert, Info, Loader2, X } from "lucide-react";
+import { sendAgentCommand } from "@/lib/agent-client";
+import { useI18n } from "@/lib/i18n";
+import { parseSkillDiagnosticsSnapshot, type SkillDiagnosticEntry, type SkillDiagnosticsSnapshot } from "@/lib/skill-diagnostics";
+import { Dialog, DialogClose, DialogContent, DialogTitle } from "./ui/primitives";
+
+const actionStyle = {
+  display: "inline-flex", alignItems: "center", gap: 5,
+  padding: "4px 10px", background: "var(--bg)",
+  border: "1px solid var(--border)", borderRadius: "var(--radius-control)",
+  color: "var(--text-muted)", cursor: "pointer", fontSize: 12, fontFamily: "inherit",
+} as const;
+
+function displayText(value: string): string {
+  return value.replace(/[\p{Cc}\u202a-\u202e\u2066-\u2069]/gu, "");
+}
+
+function DiagnosticEntry({ label, entry }: { label: string; entry: SkillDiagnosticEntry }) {
+  const { t } = useI18n();
+  return (
+    <div className="grid min-w-0 gap-1 text-xs">
+      <div><span className="font-medium">{label}: </span><code style={{ overflowWrap: "anywhere" }}>{displayText(entry.name)}</code></div>
+      <code className="text-text-muted" style={{ overflowWrap: "anywhere" }}>{displayText(entry.filePath)}</code>
+      <span className="text-text-dim">{t("skillDiagnostics.source", { source: displayText(entry.source) })}{entry.pluginName ? ` · ${displayText(entry.pluginName)}` : ""}</span>
+    </div>
+  );
+}
+
+export function SkillDiagnosticsDialog({ open, onOpenChange, snapshot, loading = false, error }: {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  snapshot: SkillDiagnosticsSnapshot | null;
+  loading?: boolean;
+  error?: string | null;
+}) {
+  const { t } = useI18n();
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent ariaLabel={t("skillDiagnostics.title")} style={{ width: "min(92vw, 760px)", maxWidth: "min(92vw, 760px)", maxHeight: "85dvh", overflowY: "auto" }}>
+        <div className="flex items-start justify-between gap-3">
+          <DialogTitle>{t("skillDiagnostics.title")}</DialogTitle>
+          <DialogClose aria-label={t("skillDiagnostics.close")} className="ui-focus-ring cursor-pointer text-text-muted" style={{ background: "none", border: "none", borderRadius: "var(--radius-control)" }}>
+            <X size={16} strokeWidth={1.8} aria-hidden />
+          </DialogClose>
+        </div>
+        {loading ? <p role="status" className="flex items-center gap-2 text-sm text-text-muted"><Loader2 size={14} aria-hidden className="animate-spin" />{t("skillDiagnostics.loading")}</p> : error ? <p role="alert" className="text-sm" style={{ color: "var(--status-error)" }}>{error}</p> : snapshot ? (
+          <div className="grid gap-3">
+            <code className="text-xs text-text-dim" style={{ overflowWrap: "anywhere" }}>{displayText(snapshot.cwd)}</code>
+            {snapshot.diagnostics.length === 0 ? <p className="text-sm text-text-muted">{t("skillDiagnostics.clean")}</p> : snapshot.diagnostics.map((diagnostic) => {
+              const selected = diagnostic.skills.find((entry) => entry.name === diagnostic.name);
+              return (
+                <section key={diagnostic.name} className="grid min-w-0 gap-3 border border-border bg-bg-subtle p-3" style={{ borderRadius: "var(--radius-card)" }}>
+                  <h3 className="m-0 text-sm font-medium" style={{ overflowWrap: "anywhere" }}>{displayText(diagnostic.name)}</h3>
+                  {selected ? <>
+                    <DiagnosticEntry label={t("skillDiagnostics.default")} entry={selected} />
+                    <p className="m-0 text-xs text-text-muted">{t(`skillDiagnostics.reason.${diagnostic.reason}`)}</p>
+                  </> : <p className="m-0 text-xs text-text-muted">{t("skillDiagnostics.noDefault")}</p>}
+                  {diagnostic.skills.filter((entry) => entry !== selected).map((entry) => <DiagnosticEntry key={entry.filePath} label={t("skillDiagnostics.variant")} entry={entry} />)}
+                  {diagnostic.duplicates.map(({ skill, retained }) => (
+                    <div key={skill.filePath} className="grid min-w-0 gap-1">
+                      <DiagnosticEntry label={t("skillDiagnostics.redundant")} entry={skill} />
+                      <p className="m-0 text-xs text-text-dim" style={{ overflowWrap: "anywhere" }}>{t("skillDiagnostics.retained", { name: displayText(retained.name), path: displayText(retained.filePath) })}</p>
+                    </div>
+                  ))}
+                </section>
+              );
+            })}
+            <p className="m-0 text-xs text-text-muted">{t("skillDiagnostics.lineage")}</p>
+          </div>
+        ) : null}
+      </DialogContent>
+    </Dialog>
+  );
+}
+
+export function SkillDiagnosticsNotice({ snapshot, onDisable }: {
+  snapshot: SkillDiagnosticsSnapshot | null;
+  onDisable: () => Promise<SkillDiagnosticsSnapshot>;
+}) {
+  const { t, tn } = useI18n();
+  const [open, setOpen] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  // Dismissal hides this exact report for the session; a changed report shows again.
+  const [dismissedKey, setDismissedKey] = useState<string | null>(null);
+  useEffect(() => {
+    if (!snapshot) setOpen(false);
+  }, [snapshot]);
+  if (!snapshot) return null;
+  let conflicts = 0;
+  let duplicates = 0;
+  for (const diagnostic of snapshot.diagnostics) {
+    if (diagnostic.skills.length > 1) conflicts++;
+    duplicates += diagnostic.duplicates.length;
+  }
+  const reportKey = JSON.stringify(snapshot.diagnostics);
+  const visible = snapshot.showStartupDiagnostics && (conflicts > 0 || duplicates > 0) && dismissedKey !== reportKey;
+  const Icon = conflicts > 0 ? CircleAlert : Info;
+  return (
+    <>
+      {visible && <div role="status" aria-live="polite" className="flex flex-wrap items-center gap-2 border border-border bg-bg-subtle px-3 py-2 text-xs" style={{ marginBottom: 8, borderRadius: "var(--radius-card)", color: conflicts > 0 ? "var(--status-warning)" : "var(--text-muted)" }}>
+        <Icon size={14} aria-hidden />
+        <span className="min-w-0 flex-1">{[conflicts > 0 ? tn("skillDiagnostics.conflicts", conflicts) : null, duplicates > 0 ? tn("skillDiagnostics.duplicates", duplicates) : null].filter(Boolean).join(" · ")}</span>
+        <button type="button" className="ui-focus-ring" style={actionStyle} onClick={() => setOpen(true)}>{t("skillDiagnostics.details")}</button>
+        <button type="button" className="ui-focus-ring" style={actionStyle} disabled={saving} onClick={async () => {
+          setSaving(true); setError(null);
+          try {
+            const effective = await onDisable();
+            if (effective.showStartupDiagnostics) setError(t("skillDiagnostics.overridden"));
+          } catch {
+            setError(t("skillDiagnostics.saveFailed"));
+          } finally {
+            setSaving(false);
+          }
+        }}>{saving ? t("skillDiagnostics.saving") : t("skillDiagnostics.disable")}</button>
+        <button type="button" className="ui-focus-ring" style={{ display: "inline-flex", padding: 4, background: "none", border: "none", borderRadius: "var(--radius-control)", color: "var(--text-muted)", cursor: "pointer" }} aria-label={t("skillDiagnostics.dismiss")} title={t("skillDiagnostics.dismiss")} onClick={() => { setDismissedKey(reportKey); setError(null); }}><X size={14} aria-hidden /></button>
+        {error && <span role="alert" style={{ color: "var(--status-error)", width: "100%" }}>{error}</span>}
+      </div>}
+      <SkillDiagnosticsDialog open={open} onOpenChange={setOpen} snapshot={snapshot} />
+    </>
+  );
+}
+
+/** Explicit inspection never starts a new empty session. Missing support is not a clean result. */
+export function SkillDiagnosticsInspector({ sessionId }: { sessionId?: string | null }) {
+  const { t } = useI18n();
+  const [open, setOpen] = useState(false);
+  const [snapshot, setSnapshot] = useState<SkillDiagnosticsSnapshot | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const requestVersion = useRef({ value: 0 });
+  useEffect(() => {
+    const requests = requestVersion.current;
+    requests.value++;
+    setOpen(false); setSnapshot(null); setError(null); setLoading(false);
+    return () => { requests.value++; };
+  }, [sessionId]);
+  return (
+    <>
+      <button type="button" className="ui-focus-ring" style={actionStyle} disabled={!sessionId || loading} title={!sessionId ? t("skillDiagnostics.noSession") : undefined} onClick={async () => {
+        if (!sessionId) return;
+        const requests = requestVersion.current;
+        const version = ++requests.value;
+        setOpen(true); setLoading(true); setError(null); setSnapshot(null);
+        try {
+          const result = parseSkillDiagnosticsSnapshot(await sendAgentCommand<unknown>(sessionId, { type: "get_skill_diagnostics" }));
+          if (version !== requests.value) return;
+          if (!result) setError(t("skillDiagnostics.unavailable")); else setSnapshot(result);
+        } catch {
+          if (version === requests.value) setError(t("skillDiagnostics.unavailable"));
+        } finally {
+          if (version === requests.value) setLoading(false);
+        }
+      }}><Info size={13} aria-hidden />{t("skillDiagnostics.inspect")}</button>
+      {!sessionId && <p className="m-0 text-xs text-text-muted">{t("skillDiagnostics.noSession")}</p>}
+      <SkillDiagnosticsDialog open={open} onOpenChange={setOpen} snapshot={snapshot} loading={loading} error={error} />
+    </>
+  );
+}
diff --git a/components/SkillsConfig.tsx b/components/SkillsConfig.tsx
index 6f88b9d8..abee8bed 100644
--- a/components/SkillsConfig.tsx
+++ b/components/SkillsConfig.tsx
@@ -11,6 +11,7 @@ import {
 import { toast } from "@/components/ui/toast";
 import { Plus } from "lucide-react";
 import { SettingsTabs, type SettingsTab } from "./SettingsTabs";
+import { SkillDiagnosticsInspector } from "./SkillDiagnostics";
 import type {
   SkillInfo as Skill,
   SkillInstallScope,
@@ -728,11 +729,13 @@ export function SkillsConfig({
   onClose,
   onSelectTab,
   embedded = false,
+  sessionId,
 }: {
   cwd: string;
   onClose: () => void;
   onSelectTab?: (tab: SettingsTab) => void;
   embedded?: boolean;
+  sessionId?: string | null;
 }) {
   const isMobile = useIsMobile();
   const { t, tn } = useI18n();
@@ -957,6 +960,9 @@ export function SkillsConfig({
           </button>
         </div>)}
         {!embedded && onSelectTab && <SettingsTabs active="skills" onSelect={onSelectTab} />}
+        <div className="grid gap-1 border-b border-border px-3 py-2">
+          <SkillDiagnosticsInspector sessionId={sessionId} />
+        </div>
 
         {/* Body */}
         <div style={{ flex: 1, display: "flex", flexDirection: isMobile ? "column" : "row", overflow: "hidden" }}>
diff --git a/hooks/useAgentSession-stream.ts b/hooks/useAgentSession-stream.ts
index 3084bf33..8d9f3127 100644
--- a/hooks/useAgentSession-stream.ts
+++ b/hooks/useAgentSession-stream.ts
@@ -175,6 +175,8 @@ export type AgentStateResponse = {
   extensionStatuses?: ExtensionStatusItem[];
   extensionWidgets?: ExtensionWidgetItem[];
   queuedMessages?: QueuedMessages;
+  /** Untrusted until parsed by parseSkillDiagnosticsSnapshot. */
+  skillDiagnostics?: unknown;
   todoPhases?: TodoPhase[];
 };
 
diff --git a/hooks/useAgentSession.rpc.test.mjs b/hooks/useAgentSession.rpc.test.mjs
index b2ff37c8..6e51bbbb 100644
--- a/hooks/useAgentSession.rpc.test.mjs
+++ b/hooks/useAgentSession.rpc.test.mjs
@@ -3285,3 +3285,324 @@ test("overlapping Stops share one atomic withdrawal; an image-only entry does no
   assert.equal(getDraft("abort-atomic-twice")?.value, "words");
   clearDraft("abort-atomic-twice");
 });
+
+function skillDiagnosticsSnapshot(showStartupDiagnostics, name = "review") {
+  return {
+    cwd: "/workspace",
+    showStartupDiagnostics,
+    diagnostics: [{
+      name,
+      reason: "source-order",
+      skills: [
+        { name, filePath: `/workspace/.agents/skills/${name}/SKILL.md`, source: "project" },
+        { name, filePath: `/home/me/.agents/skills/${name}/SKILL.md`, source: "user", pluginName: "shared" },
+      ],
+      duplicates: [{
+        skill: { name, filePath: `/mirror/.agents/skills/${name}/SKILL.md`, source: "custom" },
+        retained: { name, filePath: `/workspace/.agents/skills/${name}/SKILL.md`, source: "project" },
+      }],
+    }],
+  };
+}
+
+test("skill diagnostics hydrate from state and follow defensive live updates", async () => {
+  resetWorld();
+  primeSession("skill-state", [userMsg("u0", "q")]);
+  const initial = skillDiagnosticsSnapshot(true);
+  world.agents.set("skill-state", {
+    running: true,
+    state: {
+      skillDiagnostics: {
+        ...initial,
+        diagnostics: [{
+          ...initial.diagnostics[0],
+          skills: initial.diagnostics[0].skills.map((skill) => ({ ...skill, body: "private" })),
+          privateDiagnostic: true,
+        }],
+        privateSnapshot: true,
+      },
+    },
+  });
+
+  const w = await mountSession("skill-state");
+  assert.deepEqual(w.latest.skillDiagnostics, initial, "get_state hydration recovers a startup frame emitted before SSE attached");
+
+  const updated = skillDiagnosticsSnapshot(false, "deploy");
+  await act(() => lastEs().emit({
+    type: "skill_diagnostics_update",
+    data: { ...updated, containRoot: "/private" },
+  }));
+  assert.deepEqual(w.latest.skillDiagnostics, updated);
+
+  await act(() => lastEs().emit({
+    type: "skill_diagnostics_update",
+    data: { cwd: "/workspace", showStartupDiagnostics: true, diagnostics: "none" },
+  }));
+  assert.equal(w.latest.skillDiagnostics, null, "malformed data is unsupported, not a fabricated clean result");
+
+  const recovered = skillDiagnosticsSnapshot(true, "recovered");
+  world.agents.set("skill-state", { running: true, state: { skillDiagnostics: recovered } });
+  await act(async () => {
+    lastEs().open();
+    await sleep(30);
+  });
+  assert.deepEqual(w.latest.skillDiagnostics, recovered, "stream attachment reconciles an update emitted before SSE attached");
+});
+
+/** Start the startup-diagnostics setter with its POST held. `respond` answers the held POST; `saving` is the hook's promise. */
+async function startHeldSkillSetter(w, sid, enabled) {
+  let respond;
+  world.holds.push({
+    match: (method, url, body) => method === "POST" && url.includes(`/api/agent/${sid}`) && body?.type === "set_skill_startup_diagnostics",
+    produce: () => new Promise((resolve) => { respond = (data) => resolve({ value: { success: true, data } }); }),
+  });
+  let saving;
+  await act(async () => {
+    saving = w.latest.setSkillStartupDiagnostics(enabled);
+    await sleep(20);
+  });
+  // The test awaits `saving` itself; this only keeps a failed assertion from leaving an unhandled rejection behind.
+  saving.catch(() => {});
+  return { saving, respond: (data) => respond(data) };
+}
+
+test("the startup diagnostics setter publishes OMP's effective snapshot and rejects unsupported replies", async () => {
+  resetWorld();
+  primeSession("skill-actions", [userMsg("u0", "q")]);
+  const on = skillDiagnosticsSnapshot(true);
+  const off = skillDiagnosticsSnapshot(false);
+  world.agents.set("skill-actions", { running: false, state: { skillDiagnostics: on } });
+  const w = await mountSession("skill-actions");
+  assert.deepEqual(w.latest.skillDiagnostics, on);
+
+  world.holds.push({
+    match: (method, url, body) => method === "POST" && url.includes("/api/agent/skill-actions") && body?.type === "set_skill_startup_diagnostics",
+    produce: async () => ({ value: { success: true, data: off } }),
+  });
+  let disabled;
+  await act(async () => {
+    disabled = await w.latest.setSkillStartupDiagnostics(false);
+  });
+  assert.deepEqual(disabled, off);
+  assert.deepEqual(w.latest.skillDiagnostics, off, "the effective snapshot replaces the previous one");
+
+  world.holds.push({
+    match: (method, url, body) => method === "POST" && url.includes("/api/agent/skill-actions") && body?.type === "set_skill_startup_diagnostics",
+    produce: async () => ({ value: { success: true, data: off } }),
+  });
+  let overridden;
+  await act(async () => {
+    overridden = await w.latest.setSkillStartupDiagnostics(true);
+  });
+  assert.deepEqual(overridden, off, "an override that keeps the setting off is returned as the effective value, not the requested one");
+  assert.deepEqual(w.latest.skillDiagnostics, off);
+
+  world.holds.push({
+    match: (method, url, body) => method === "POST" && url.includes("/api/agent/skill-actions") && body?.type === "set_skill_startup_diagnostics",
+    produce: async () => ({ value: { success: true, data: { cwd: "/workspace", showStartupDiagnostics: false, diagnostics: null } } }),
+  });
+  await assert.rejects(() => w.latest.setSkillStartupDiagnostics(false), /skill diagnostics/i);
+  assert.deepEqual(w.latest.skillDiagnostics, off, "a malformed response cannot erase the last supported snapshot");
+  await assert.rejects(() => w.latest.setSkillStartupDiagnostics("false"), /boolean/i);
+});
+
+test("the startup diagnostics setter does not start an empty chat and rejects stale session responses", async () => {
+  resetWorld();
+  const empty = await mountSession(null);
+  const callsBefore = world.calls.length;
+  await assert.rejects(() => empty.latest.setSkillStartupDiagnostics(false), /active session/i);
+  assert.equal(world.calls.length, callsBefore, "no active session means no lazy child-start request");
+
+  primeSession("old-skills", [userMsg("u0", "old")]);
+  const old = await mountSession("old-skills");
+  const held = await startHeldSkillSetter(old, "old-skills", false);
+  old.unmount();
+
+  primeSession("current-skills", [userMsg("u0", "current")]);
+  const current = await mountSession("current-skills");
+  held.respond(skillDiagnosticsSnapshot(false, "stale"));
+  await assert.rejects(held.saving, /stale/i);
+  assert.equal(current.latest.skillDiagnostics, null, "the previous chat cannot update the selected chat");
+});
+
+test("a saved setting whose own update frame beats the HTTP response resolves to the saved snapshot", async () => {
+  resetWorld();
+  primeSession("skill-own-frame", [userMsg("u0", "q")]);
+  const enabled = skillDiagnosticsSnapshot(true, "own-frame");
+  world.agents.set("skill-own-frame", { running: true, state: { skillDiagnostics: enabled } });
+  const w = await mountSession("skill-own-frame");
+  assert.deepEqual(w.latest.skillDiagnostics, enabled);
+
+  const { saving, respond } = await startHeldSkillSetter(w, "skill-own-frame", false);
+  const saved = skillDiagnosticsSnapshot(false, "own-frame");
+  try {
+    // OMP emits the update frame before it answers the command.
+    await act(() => lastEs().emit({ type: "skill_diagnostics_update", data: saved }));
+    assert.deepEqual(w.latest.skillDiagnostics, saved);
+  } finally {
+    respond(saved);
+  }
+  let result;
+  await act(async () => {
+    result = await saving;
+  });
+  assert.deepEqual(result, saved, "the control reports the saved setting instead of a stale failure");
+  assert.deepEqual(w.latest.skillDiagnostics, saved);
+});
+
+test("a setter response overtaken by a newer update returns the current snapshot without rolling it back", async () => {
+  resetWorld();
+  primeSession("skill-newer-frame", [userMsg("u0", "q")]);
+  world.agents.set("skill-newer-frame", { running: true, state: { skillDiagnostics: skillDiagnosticsSnapshot(true, "before") } });
+  const w = await mountSession("skill-newer-frame");
+
+  const { saving, respond } = await startHeldSkillSetter(w, "skill-newer-frame", false);
+  const newer = skillDiagnosticsSnapshot(false, "after-reload");
+  try {
+    await act(() => lastEs().emit({ type: "skill_diagnostics_update", data: newer }));
+  } finally {
+    respond(skillDiagnosticsSnapshot(false, "answered-before-reload"));
+  }
+  let result;
+  await act(async () => {
+    result = await saving;
+  });
+  assert.deepEqual(result, newer);
+  assert.deepEqual(w.latest.skillDiagnostics, newer, "the older response never replaces a newer update");
+});
+
+test("a state snapshot requested before a newer skill update cannot overwrite it when it resolves late", async () => {
+  resetWorld();
+  primeSession("skill-order", [userMsg("u0", "q")]);
+  world.agents.set("skill-order", { running: true, state: { skillDiagnostics: skillDiagnosticsSnapshot(true, "startup") } });
+  const w = await mountSession("skill-order");
+
+  let release;
+  world.holds.push({
+    match: (method, url) => method === "GET" && url === "/api/agent/skill-order",
+    produce: () => new Promise((resolve) => {
+      release = () => resolve({ value: { running: true, state: { skillDiagnostics: skillDiagnosticsSnapshot(true, "stale-state") } } });
+    }),
+  });
+  const newer = skillDiagnosticsSnapshot(false, "newer-update");
+  try {
+    await act(async () => {
+      lastEs().open(); // stream attachment requests an authoritative state snapshot
+      await sleep(20);
+    });
+    assert.ok(release, "precondition: the snapshot request is still in flight");
+    await act(() => lastEs().emit({ type: "skill_diagnostics_update", data: newer }));
+    assert.deepEqual(w.latest.skillDiagnostics, newer);
+  } finally {
+    release?.();
+  }
+  await act(async () => {
+    await sleep(30);
+  });
+  assert.deepEqual(w.latest.skillDiagnostics, newer, "the late older snapshot is dropped");
+});
+
+test("a fresh chat hydrates and follows skill diagnostics after slash discovery creates its runtime", async () => {
+  resetWorld();
+  const startup = skillDiagnosticsSnapshot(true, "fresh-startup");
+  world.holds.push({
+    match: (method, url) => method === "POST" && url === "/api/agent/new",
+    produce: async () => ({ value: { sessionId: "fresh-skills" } }),
+  });
+  world.agents.set("fresh-skills", { running: true, state: { skillDiagnostics: startup } });
+  const w = await mountSession(null, undefined, { newSessionCwd: "/workspace" });
+  assert.equal(w.latest.skillDiagnostics, null, "an empty new-chat page has no runtime or diagnostics");
+  assert.deepEqual(world.esInstances, [], "mounting an empty new chat must not attach a stream");
+
+  await act(async () => { await w.latest.loadSlashCommands(); });
+  const es = lastEs();
+  assert.match(es?.url ?? "", /\/api\/agent\/fresh-skills\/events$/, "the created runtime must be observed before its first prompt");
+  await act(async () => {
+    es.open();
+    await sleep(30);
+  });
+  assert.deepEqual(w.latest.skillDiagnostics, startup, "the startup frame emitted before attachment is recovered from state");
+
+  const updated = skillDiagnosticsSnapshot(false, "fresh-updated");
+  await act(() => es.emit({ type: "skill_diagnostics_update", data: updated }));
+  assert.deepEqual(w.latest.skillDiagnostics, updated, "live diagnostics follow the created runtime");
+  assert.equal(callsTo("POST", "/api/agent/fresh-skills").some((call) => call.body?.type === "prompt"), false, "discovery never starts a model run");
+  w.unmount();
+});
+
+test("a fresh chat runtime created after unmount cannot attach or apply skill diagnostics", async () => {
+  resetWorld();
+  let release;
+  world.holds.push({
+    match: (method, url) => method === "POST" && url === "/api/agent/new",
+    produce: () => new Promise((resolve) => { release = () => resolve({ value: { sessionId: "stale-fresh" } }); }),
+  });
+  world.agents.set("stale-fresh", { running: true, state: { skillDiagnostics: skillDiagnosticsSnapshot(true, "stale-fresh") } });
+  const w = await mountSession(null, undefined, { newSessionCwd: "/workspace" });
+  let discovery;
+  await act(async () => {
+    discovery = w.latest.loadSlashCommands();
+    await sleep(20);
+    w.unmount();
+  });
+  await act(async () => {
+    release();
+    await discovery;
+    await sleep(30);
+  });
+  assert.deepEqual(world.esInstances, [], "a stale create must not leak an event stream");
+  assert.equal(callsTo("GET", "/api/agent/stale-fresh").length, 0, "a stale create must not request diagnostics for a switched chat");
+  assert.equal(w.latest.skillDiagnostics, null);
+});
+
+test("a fresh chat's first prompt attaches one event stream instead of an observer plus its own", async () => {
+  resetWorld();
+  world.holds.push({
+    match: (method, url) => method === "POST" && url === "/api/agent/new",
+    produce: async () => ({ value: { sessionId: "fresh-send" } }),
+  });
+  const w = await mountSession(null, undefined, { newSessionCwd: "/workspace", onSessionCreated: () => {} });
+  let sent;
+  await act(async () => {
+    sent = w.latest.handleSend("first prompt");
+    await sleep(30); // create the runtime and attach the prompt's stream
+  });
+  const streamsBeforeOpen = world.esInstances.length;
+  let delivered;
+  // Settle the send before asserting, so a failed assertion leaves no run behind.
+  await act(async () => {
+    lastEs().open();
+    delivered = await sent;
+  });
+  w.unmount();
+  assert.equal(delivered, true);
+  assert.equal(streamsBeforeOpen, 1, "the prompt owns the only stream");
+  assert.equal(world.esInstances.length, 1);
+  assert.equal(callsTo("POST", "/api/agent/fresh-send").some((call) => call.body?.type === "prompt"), true);
+});
+
+test("a fresh chat's /btw question attaches one event stream instead of an observer plus its own", async () => {
+  resetWorld();
+  world.holds.push({
+    match: (method, url) => method === "POST" && url === "/api/agent/new",
+    produce: async () => ({ value: { sessionId: "fresh-btw" } }),
+  });
+  holdBtwCommand("btw", async () => ({ value: { success: true, data: { record: btwRecord() } } }));
+  const w = await mountSession(null, undefined, { newSessionCwd: "/workspace", onSessionCreated: () => {} });
+  let asked;
+  await act(async () => {
+    asked = w.latest.handleBuiltinSlashCommand("/btw what is 2+2");
+    await sleep(30); // create the runtime and attach the question's stream
+  });
+  const streamsBeforeOpen = world.esInstances.length;
+  let result;
+  // Settle the question before asserting, so a failed assertion leaves no request behind.
+  await act(async () => {
+    lastEs().open();
+    result = await asked;
+  });
+  w.unmount();
+  assert.deepEqual(result, { handled: true });
+  assert.equal(streamsBeforeOpen, 1, "the question owns the only stream");
+  assert.equal(world.esInstances.length, 1);
+});
diff --git a/hooks/useAgentSession.ts b/hooks/useAgentSession.ts
index 4ede381a..5bfc447a 100644
--- a/hooks/useAgentSession.ts
+++ b/hooks/useAgentSession.ts
@@ -16,6 +16,7 @@ import { normalizeToolCalls } from "@/lib/normalize";
 import { hasVisibleAssistantContent } from "@/lib/assistant-response";
 import type { ThinkingModelMeta } from "@/lib/thinking-levels";
 import { sendAgentCommand, setSessionAdvisorSpawn } from "@/lib/agent-client";
+import { parseSkillDiagnosticsSnapshot, type SkillDiagnosticsSnapshot } from "@/lib/skill-diagnostics";
 import { recoverDraftText, setDraft } from "@/lib/draft-store";
 import { formatExitedSessionNotice, translate } from "@/lib/i18n";
 import { usePrefersReducedMotion } from "@/hooks/usePrefersReducedMotion";
@@ -253,6 +254,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
   const [retryInfo, setRetryInfo] = useState<{ attempt: number; maxAttempts: number; errorMessage?: string } | null>(null);
   const [contextUsage, setContextUsage] = useState<{ percent: number | null; contextWindow: number; tokens: number | null } | null>(null);
   const [systemPrompt, setSystemPrompt] = useState<string | null>(null);
+  const [skillDiagnostics, setSkillDiagnostics] = useState<SkillDiagnosticsSnapshot | null>(null);
   const [forkingEntryId, setForkingEntryId] = useState<string | null>(null);
   const [currentModelOverride, setCurrentModelOverride] = useState<{ provider: string; modelId: string } | null>(null);
   const [pendingModel, setPendingModel] = useState<{ provider: string; modelId: string } | null>(null);
@@ -341,6 +343,21 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     queueAppliedSeqRef.current = seq;
     updateQueuedMessages(readQueueSnapshot(value) ?? EMPTY_QUEUE);
   }, [updateQueuedMessages]);
+  // Orders get_state responses, the setter reply, and SSE updates so a response
+  // started before a newer frame cannot overwrite it.
+  const skillDiagnosticsSeqRef = useRef(0);
+  const skillDiagnosticsAppliedSeqRef = useRef(0);
+  // What the view shows now, for a setter reply that a newer frame overtook.
+  const skillDiagnosticsRef = useRef<SkillDiagnosticsSnapshot | null>(null);
+  const publishSkillDiagnostics = useCallback((seq: number, snapshot: SkillDiagnosticsSnapshot | null) => {
+    skillDiagnosticsAppliedSeqRef.current = seq;
+    skillDiagnosticsRef.current = snapshot;
+    setSkillDiagnostics(snapshot);
+  }, []);
+  const applySkillDiagnosticsSnapshot = useCallback((seq: number, value: unknown) => {
+    if (seq <= skillDiagnosticsAppliedSeqRef.current) return;
+    publishSkillDiagnostics(seq, parseSkillDiagnosticsSnapshot(value) ?? null);
+  }, [publishSkillDiagnostics]);
   const [subagents, setSubagents] = useState<SubagentInfo[]>([]);
   const [subagentEvents, setSubagentEvents] = useState<Record<string, SubagentActivityEvent[]>>({});
   const [subagentTranscriptVersions, setSubagentTranscriptVersions] = useState<Record<string, number>>({});
@@ -741,11 +758,13 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
   // must reach the composer so the ladder/active level match reality.
   const refreshLiveModelState = useCallback(async (sid: string) => {
     const token = beginAuthoritativeModelSync();
+    const skillDiagnosticsRevision = ++skillDiagnosticsSeqRef.current;
     try {
       const res = await fetch(`/api/sessions/${encodeURIComponent(sid)}/state`);
       if (!res.ok) return;
       const agentState = await res.json() as { running: boolean; state?: AgentStateResponse };
-      if (sessionIdRef.current !== sid) return;
+      if (!hookAliveRef.current || sessionIdRef.current !== sid) return;
+      applySkillDiagnosticsSnapshot(skillDiagnosticsRevision, agentState.state?.skillDiagnostics);
       const applied = applyAuthoritativeModel(toThinkingModelMeta(agentState.state?.model), token);
       if (!applied) return; // stale snapshot — drop its thinking level too
       if (agentState.state?.thinkingLevel !== undefined) {
@@ -771,7 +790,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     } catch {
       // Best effort; the next loadSession/reconcile re-syncs.
     }
-  }, [applyAuthoritativeModel, beginAuthoritativeModelSync]);
+  }, [applyAuthoritativeModel, applySkillDiagnosticsSnapshot, beginAuthoritativeModelSync]);
 
   const loadSession = useCallback(async (sid: string, showLoading = false, includeState = false, fenceRunId?: number) => {
     const requestSeq = ++contextRequestSeqRef.current;
@@ -836,6 +855,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         // sync that started while this request was in flight.
         const token = beginAuthoritativeModelSync();
         const queueRevision = ++queueSeqRef.current;
+        const skillDiagnosticsRevision = ++skillDiagnosticsSeqRef.current;
         const stateRes = await fetch(`/api/sessions/${encodeURIComponent(sid)}/state`);
         if (!stateRes.ok) throw new Error(`HTTP ${stateRes.status}`);
         const agentState = await stateRes.json() as { running: boolean; state?: AgentStateResponse; exited?: ExitedRpcSession };
@@ -852,6 +872,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         }
 
         const liveState = agentState.state;
+        applySkillDiagnosticsSnapshot(skillDiagnosticsRevision, liveState?.skillDiagnostics);
         const modelApplied = applyAuthoritativeModel(toThinkingModelMeta(liveState?.model), token);
         if (liveState) {
           if (liveState.contextUsage !== undefined) setContextUsage(liveState.contextUsage ?? null);
@@ -899,7 +920,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
       // Ensure the flag is cleared even if the pre-state early-return path was taken
       if (showLoading && includeState && !messagesLoaded) initialHydrationPendingRef.current = false;
     }
-  }, [catchUp, refreshSubagentHistory, applyAuthoritativeModel, beginAuthoritativeModelSync, applyQueueStateSnapshot]);
+  }, [catchUp, refreshSubagentHistory, applyAuthoritativeModel, beginAuthoritativeModelSync, applyQueueStateSnapshot, applySkillDiagnosticsSnapshot]);
 
   const loadContext = useCallback(async (sid: string, leafId: string | null, includePreCompaction = false): Promise<boolean> => {
     const seq = ++contextRequestSeqRef.current;
@@ -952,6 +973,11 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     });
   }, [isNew, newSessionCwd, onSessionCreated]);
 
+  // Assigned after connectEvents is defined. A runtime created for an empty
+  // chat emits its startup frames before any stream exists, so it must be
+  // observed (and its state snapshot recovered on stream open) right away.
+  const observeCreatedSessionRef = useRef<((sid: string) => void) | null>(null);
+
   const ensureNewSession = useCallback(async () => {
     if (sessionIdRef.current) return sessionIdRef.current;
     if (!isNew || !newSessionCwd) return sessionIdRef.current;
@@ -987,6 +1013,11 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
           // Best-effort: the spawned process already has --advisor.
         }
       }
+      // A prompt or side question that created this runtime attaches its own stream,
+      // which would only replace an observer attached here.
+      if (hookAliveRef.current && !promptDispatchPendingRef.current && !btwAskPendingRef.current) {
+        observeCreatedSessionRef.current?.(realId);
+      }
       return realId;
     })();
 
@@ -1057,17 +1088,19 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
   // below can restore everything the mount flow sets up — not just the stream.
   const reconnectActionsRef = useRef<((sid: string) => void) | null>(null);
 
-  const refreshQueueSnapshot = useCallback(async (sid: string) => {
-    const revision = ++queueSeqRef.current;
+  const refreshAgentSnapshots = useCallback(async (sid: string) => {
+    const queueRevision = ++queueSeqRef.current;
+    const skillDiagnosticsRevision = ++skillDiagnosticsSeqRef.current;
     try {
       const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`);
-      if (!res.ok || sessionIdRef.current !== sid) return;
+      if (!res.ok || !hookAliveRef.current || sessionIdRef.current !== sid) return;
       const data = await res.json() as { state?: AgentStateResponse };
-      applyQueueStateSnapshot(revision, data.state?.queuedMessages);
+      applyQueueStateSnapshot(queueRevision, data.state?.queuedMessages);
+      applySkillDiagnosticsSnapshot(skillDiagnosticsRevision, data.state?.skillDiagnostics);
     } catch {
-      // The next queue_update or state snapshot heals the panel.
+      // The next live update or state snapshot heals these views.
     }
-  }, [applyQueueStateSnapshot]);
+  }, [applyQueueStateSnapshot, applySkillDiagnosticsSnapshot]);
 
   const connectEvents = useCallback((sid: string, restoreWrapper = false): Promise<EventStreamConnectionResult> => {
     // A backoff timer from an earlier CLOSED stream may still be pending (e.g.
@@ -1114,9 +1147,9 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         // Side questions: omp re-reads the persisted history on stream open, so
         // a snapshot here catches topics asked in the terminal or another tab.
         void refreshBtwHistory(sid);
-        // Subscribe, then snapshot: omp does not replay queue_update frames
-        // emitted before this stream opened (it coalesces against the last).
-        void refreshQueueSnapshot(sid);
+        // Subscribe, then snapshot: OMP does not replay queue or diagnostics
+        // updates emitted before this stream opened.
+        void refreshAgentSnapshots(sid);
       };
 
       es.onmessage = (e) => {
@@ -1188,7 +1221,11 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         // connection must be ready before they continue.
       };
     });
-}, [applyBtwFrame, catchUp, clearLiveToolResults, eventCoalescer, refreshBtwHistory, refreshQueueSnapshot]);
+}, [applyBtwFrame, catchUp, clearLiveToolResults, eventCoalescer, refreshBtwHistory, refreshAgentSnapshots]);
+  observeCreatedSessionRef.current = (sid: string) => {
+    if (!hookAliveRef.current || sessionIdRef.current !== sid || eventSourceRef.current) return;
+    void connectEvents(sid);
+  };
 
   // ---------------------------------------------------------------------
   // Host-tool bridge: omp-web registers tools the AGENT can call. The server
@@ -1673,6 +1710,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     if (token === null) return;
     try {
       const queueRevision = ++queueSeqRef.current;
+      const skillDiagnosticsRevision = ++skillDiagnosticsSeqRef.current;
       const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`);
       if (!res.ok) return;
       const data = await res.json() as { running?: boolean; state?: AgentStateResponse };
@@ -1682,6 +1720,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
       if (!hookAliveRef.current || sessionIdRef.current !== sid || promptRunIdRef.current !== runId
         || responseRunVersionRef.current !== responseVersion) return;
       const state = data.state;
+      applySkillDiagnosticsSnapshot(skillDiagnosticsRevision, state?.skillDiagnostics);
       if (!promptDispatchPendingRef.current && state?.responseObserved) runHadContentRef.current = true;
       // Mirror compaction state unconditionally: a missed compaction_end
       // would otherwise leave the "Stop compaction" UI stuck. No state
@@ -1721,7 +1760,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         void reconcileAgentState(sid);
       }
     }
-  }, [applyQueueStateSnapshot, finishPromptWithoutStream, refreshSubagentRoster]);
+  }, [applyQueueStateSnapshot, applySkillDiagnosticsSnapshot, finishPromptWithoutStream, refreshSubagentRoster]);
 
   // Recovery net for missed SSE events: while the agent is running, verify
   // against the server periodically and whenever the tab returns to the
@@ -1893,6 +1932,11 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
 
   const handleAgentEvent = useCallback((event: AgentEvent) => {
     switch (event.type) {
+      case "skill_diagnostics_update": {
+        const revision = ++skillDiagnosticsSeqRef.current;
+        applySkillDiagnosticsSnapshot(revision, event.data);
+        break;
+      }
       case "queue_update": {
         const snapshot = readQueueSnapshot(event);
         if (snapshot) {
@@ -1989,15 +2033,17 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
           void loadSession(endedSid, false, false, endedRunId);
           const endToken = beginAuthoritativeModelSync();
           const queueRevision = ++queueSeqRef.current;
+          const skillDiagnosticsRevision = ++skillDiagnosticsSeqRef.current;
           fetch(`/api/agent/${encodeURIComponent(endedSid)}`)
             .then((r) => (r.ok ? r.json() as Promise<{ state?: AgentStateResponse }> : null))
             .then((d) => {
               // Stale terminal snapshot: the user switched sessions or started
               // the next run while this request was in flight — drop it.
-              if (!d || sessionIdRef.current !== endedSid || promptRunIdRef.current !== endedRunId) return;
+              if (!d || !hookAliveRef.current || sessionIdRef.current !== endedSid || promptRunIdRef.current !== endedRunId) return;
               // The queue does not depend on a model: an exited wrapper still
               // means nothing is queued.
               applyQueueStateSnapshot(queueRevision, d.state?.queuedMessages);
+              applySkillDiagnosticsSnapshot(skillDiagnosticsRevision, d.state?.skillDiagnostics);
               if (!d.state?.model) return;
               const applied = applyAuthoritativeModel(toThinkingModelMeta(d.state.model), endToken);
               if (!applied) return; // stale snapshot — drop everything derived from it
@@ -2465,7 +2511,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         handleExtensionUiRequest(event as unknown as IncomingExtensionUiRequest);
         break;
     }
-}, [addNotice, catchUp, eventCoalescer, clearLiveToolResults, clearTerminalReconcileTimer, finishPromptWithoutStream, handleExtensionUiRequest, handleHostToolCall, handleHostUriRequest, loadSession, mergeSubagents, onAgentEnd, reconcileAgentState, refreshLiveModelState, resetSubagentActivityState, applyAuthoritativeModel, beginAuthoritativeModelSync, setLiveToolResult, surfaceQuotaOnStream, updateQueuedMessages, applyQueueStateSnapshot]);
+}, [addNotice, catchUp, eventCoalescer, clearLiveToolResults, clearTerminalReconcileTimer, finishPromptWithoutStream, handleExtensionUiRequest, handleHostToolCall, handleHostUriRequest, loadSession, mergeSubagents, onAgentEnd, reconcileAgentState, refreshLiveModelState, resetSubagentActivityState, applyAuthoritativeModel, applySkillDiagnosticsSnapshot, beginAuthoritativeModelSync, setLiveToolResult, surfaceQuotaOnStream, updateQueuedMessages, applyQueueStateSnapshot]);
   handleAgentEventRef.current = handleAgentEvent;
   syncActionsRef.current = {
     metadata: (context, version, hasLive = liveModelMeta !== null || currentModelOverride !== null) => {
@@ -3093,6 +3139,27 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     }
   }, [addNotice]);
 
+  const setSkillStartupDiagnostics = useCallback(async (enabled: boolean): Promise<SkillDiagnosticsSnapshot> => {
+    if (typeof enabled !== "boolean") throw new Error("Skill startup diagnostics enabled must be a boolean");
+    const sid = sessionIdRef.current;
+    if (!sid) throw new Error("Skill diagnostics require an active session");
+    const revision = ++skillDiagnosticsSeqRef.current;
+    const result = await sendAgentCommand<unknown>(sid, { type: "set_skill_startup_diagnostics", enabled });
+    if (!hookAliveRef.current || sessionIdRef.current !== sid) throw new Error("Skill diagnostics request became stale");
+    const snapshot = parseSkillDiagnosticsSnapshot(result);
+    if (!snapshot) throw new Error("Skill diagnostics are unavailable for this session");
+    // OMP emits its update frame before answering, so a newer frame or snapshot can
+    // already own the view. The setting was still saved: report what is current
+    // instead of failing, and never roll the view back to this older reply.
+    if (revision <= skillDiagnosticsAppliedSeqRef.current) {
+      const current = skillDiagnosticsRef.current;
+      if (!current) throw new Error("Skill diagnostics are unavailable for this session");
+      return current;
+    }
+    publishSkillDiagnostics(revision, snapshot);
+    return snapshot;
+  }, [publishSkillDiagnostics]);
+
   /** Change how steering interrupts the running agent (immediate vs wait). */
   const handleInterruptModeChange = useCallback(async (mode: "immediate" | "wait") => {
     const sid = sessionIdRef.current ?? await ensuringNewSessionRef.current;
@@ -3312,9 +3379,12 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     };
 
     try {
-      const sid = sessionIdRef.current ?? await ensureNewSession();
+      // Commands that talk to the runtime create it here. /btw <question> and the web
+      // prompt commands create it inside askBtw/handleSend, which attach their own stream.
+      const ensureRuntime = async () => sessionIdRef.current ?? await ensureNewSession();
       switch (commandName) {
         case "compact": {
+          const sid = await ensureRuntime();
           if (!sid || isCompactingRef.current || isCompacting) return complete({ handled: true, error: translate("agentSession.noSessionToCompact") });
           isCompactingRef.current = true;
           setIsCompacting(true);
@@ -3336,6 +3406,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         }
 
         case "reload": {
+          const sid = await ensureRuntime();
           if (!sid) return complete({ handled: true, error: translate("agentSession.noSessionToReload") });
           await sendAgentCommand(sid, { type: "reload" });
           await Promise.all([
@@ -3347,6 +3418,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         }
 
         case "name": {
+          const sid = await ensureRuntime();
           if (!sid) return complete({ handled: true, error: translate("agentSession.noSessionToName") });
           if (!args) return complete({ handled: true, error: translate("agentSession.nameUsage") });
           await sendAgentCommand(sid, { type: "set_session_name", name: args });
@@ -3356,6 +3428,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         }
 
         case "session": {
+          const sid = await ensureRuntime();
           if (!sid) return complete({ handled: true, error: translate("agentSession.noActiveSession") });
           const stats = await sendAgentCommand<SessionStatsInfo>(sid, { type: "get_session_stats" });
           if (stats) {
@@ -3368,6 +3441,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         case "btw": {
           // `/btw` alone opens the history; with a question it asks one.
           if (!args) {
+            const sid = await ensureRuntime();
             if (!sid) return complete({ handled: true, error: translate("agentSession.noActiveSession") });
             void openBtwHistory(sid);
             return { handled: true };
@@ -3376,6 +3450,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
         }
 
         case "copy": {
+          const sid = await ensureRuntime();
           if (!sid) return complete({ handled: true, error: translate("agentSession.noActiveSession") });
           const data = await sendAgentCommand<LastAssistantTextResponse>(sid, { type: "get_last_assistant_text" });
           const textToCopy = data?.text ?? "";
@@ -3819,7 +3894,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     data, loading, error, activeLeafId, messages, entryIds, showPreCompactionHistory, streamState,
     agentRunning, modelNames, modelList, modelsLoading, modelError, modelThinkingLevels, modelThinkingLevelMaps, newSessionModel, toolPreset, thinkingLevel, fastModeEnabled, fastModeActive, slowModeSupported, slowModeEnabled, slowModeScope, usageLimit, autoRetryEnabled, interruptMode, autoCompactionEnabled, steeringMode, followUpMode,
     liveModelMeta,
-    retryInfo, contextUsage, systemPrompt, forkingEntryId,
+    retryInfo, contextUsage, systemPrompt, skillDiagnostics, forkingEntryId,
     isCompacting, compactError, compactResult, tokensPerSecond, currentModel, displayModel, isAutoModelSelection: !displayModel, sessionStats, agentPhase,
     slashCommands, slashCommandsLoading, queuedMessages,
     notices: noticeState.visible, dismissNotice, extensionDialog, extensionCustomUi, extensionStatuses, extensionWidgets, respondToExtensionUi, sendExtensionCustomInput,
@@ -3831,7 +3906,7 @@ export function useAgentSession(opts: UseAgentSessionOptions) {
     sessionIdRef, messagesEndRef, scrollContainerRef,
     pendingScrollToUserRef, initialScrollDoneRef,
     // Actions
-    handleSend, handleAbort, handleFork, handleNavigate, handleModelChange, handleFastModeChange, handleSlowModeChange, handleAutoRetryChange, handleInterruptModeChange, handleAutoCompactionChange, handleSteeringModeChange, handleFollowUpModeChange, handleCycleModel, handleCycleThinkingLevel, handleAbortRetry, handleInterruptAndReply,
+    handleSend, handleAbort, handleFork, handleNavigate, handleModelChange, handleFastModeChange, handleSlowModeChange, handleAutoRetryChange, handleInterruptModeChange, handleAutoCompactionChange, handleSteeringModeChange, handleFollowUpModeChange, handleCycleModel, handleCycleThinkingLevel, handleAbortRetry, handleInterruptAndReply, setSkillStartupDiagnostics,
     retrySession: () => { const sid = sessionIdRef.current; if (sid) void loadSession(sid, true, true); },
     handleCompact, handleHandoff, handleSteer, handleFollowUp, handlePromptWithStreamingBehavior, handleAbortCompaction,
     handleBuiltinSlashCommand, togglePreCompactionHistory,
diff --git a/lib/agent-skill-diagnostics-route.test.mjs b/lib/agent-skill-diagnostics-route.test.mjs
new file mode 100644
index 00000000..76fcb259
--- /dev/null
+++ b/lib/agent-skill-diagnostics-route.test.mjs
@@ -0,0 +1,152 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test, { after } from "node:test";
+import { fileURLToPath } from "node:url";
+import { createJiti } from "jiti";
+
+// Real POST /api/agent/[id] handler against a real saved-session file. The omp
+// binary is a launcher stub that records every launch and exits at once, so a
+// launch record is the observable proof that a child process was created.
+const jiti = createJiti(import.meta.url, {
+  tryNative: false,
+  alias: { "@/": fileURLToPath(new URL("../", import.meta.url)) },
+});
+const agentRoute = await jiti.import("../app/api/agent/[id]/route.ts");
+
+const SAVED_ID = "saved-skill-session";
+const agentDir = mkdtempSync(join(tmpdir(), "omp-web-skill-diagnostics-route-"));
+const projectDir = join(agentDir, "sessions", "-project");
+mkdirSync(projectDir, { recursive: true });
+writeFileSync(
+  join(projectDir, "2026-01-01_saved.jsonl"),
+  `${[
+    { type: "session", version: 3, id: SAVED_ID, cwd: tmpdir(), timestamp: "2026-01-01T00:00:00.000Z" },
+    { type: "message", id: "u1", parentId: null, timestamp: "2026-01-01T00:00:00.000Z", message: { role: "user", content: "hello" } },
+  ].map((line) => JSON.stringify(line)).join("\n")}\n`,
+);
+
+const launchLog = join(agentDir, "omp-launches.log");
+const fakeOmp = join(agentDir, process.platform === "win32" ? "fake-omp.cmd" : "fake-omp");
+writeFileSync(
+  fakeOmp,
+  process.platform === "win32"
+    ? `@echo off\r\necho launched>> "${launchLog}"\r\nexit /b 1\r\n`
+    : `#!/bin/sh\necho launched >> '${launchLog}'\nexit 1\n`,
+  { mode: 0o755 },
+);
+
+const previousAgentDir = process.env.PI_CODING_AGENT_DIR;
+const previousBin = process.env.OMP_WEB_OMP_BIN;
+process.env.PI_CODING_AGENT_DIR = agentDir;
+process.env.OMP_WEB_OMP_BIN = fakeOmp;
+after(() => {
+  if (previousAgentDir === undefined) delete process.env.PI_CODING_AGENT_DIR;
+  else process.env.PI_CODING_AGENT_DIR = previousAgentDir;
+  if (previousBin === undefined) delete process.env.OMP_WEB_OMP_BIN;
+  else process.env.OMP_WEB_OMP_BIN = previousBin;
+  rmSync(agentDir, { recursive: true, force: true });
+});
+
+const launches = () => (existsSync(launchLog) ? readFileSync(launchLog, "utf8").split(/\r?\n/).filter(Boolean).length : 0);
+
+const post = (id, body, query = "") => agentRoute.POST(
+  new Request(`http://localhost/api/agent/${id}${query}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  }),
+  { params: Promise.resolve({ id }) },
+);
+
+/** Replace the process-wide wrapper registry and clear the launch record for one test. */
+function useRegistry(t, wrappers = {}) {
+  rmSync(launchLog, { force: true });
+  const previousSessions = globalThis.__ompSessions;
+  const previousLocks = globalThis.__ompStartLocks;
+  globalThis.__ompSessions = new Map(Object.entries(wrappers));
+  globalThis.__ompStartLocks = new Map();
+  t.after(() => {
+    globalThis.__ompSessions = previousSessions;
+    globalThis.__ompStartLocks = previousLocks;
+  });
+}
+
+const reply = { cwd: "/workspace", showStartupDiagnostics: false, diagnostics: [] };
+
+function wrapper({ alive = true, running = false, advisorSpawned = false } = {}) {
+  const self = {
+    advisorSpawned,
+    sent: [],
+    destroyed: 0,
+    isAlive: () => alive,
+    isRunning: () => running,
+    async send(command) {
+      self.sent.push(command);
+      return reply;
+    },
+    async destroyAndWait() {
+      self.destroyed += 1;
+    },
+  };
+  return self;
+}
+
+const COMMANDS = [
+  { type: "get_skill_diagnostics" },
+  { type: "set_skill_startup_diagnostics", enabled: false },
+];
+
+for (const command of COMMANDS) {
+  test(`${command.type} for a saved session with no live wrapper is unavailable and never starts omp`, async (t) => {
+    useRegistry(t);
+
+    const response = await post(SAVED_ID, command);
+    const text = await response.text();
+
+    assert.equal(response.status, 409, text);
+    const body = JSON.parse(text);
+    assert.equal(body.code, "skill_diagnostics_unavailable");
+    assert.match(body.error, /skill diagnostics/i);
+    assert.equal(launches(), 0, "no omp child was created");
+    assert.equal(globalThis.__ompSessions.size, 0, "no wrapper was registered");
+  });
+
+  test(`${command.type} does not resume a session whose wrapper has exited`, async (t) => {
+    const exited = wrapper({ alive: false });
+    useRegistry(t, { [SAVED_ID]: exited });
+
+    const response = await post(SAVED_ID, command);
+    const text = await response.text();
+
+    assert.equal(response.status, 409, text);
+    assert.equal(JSON.parse(text).code, "skill_diagnostics_unavailable");
+    assert.equal(launches(), 0, "no replacement omp child was created");
+    assert.deepEqual(exited.sent, [], "the exited wrapper received nothing");
+  });
+
+  test(`${command.type} is answered by an active wrapper without replacing it when the advisor query differs`, async (t) => {
+    const live = wrapper({ advisorSpawned: false });
+    useRegistry(t, { [SAVED_ID]: live });
+
+    const response = await post(SAVED_ID, command, "?advisor=1");
+    const text = await response.text();
+
+    assert.equal(response.status, 200, text);
+    assert.equal(live.destroyed, 0, "an idle live child is never restarted to read or flip a setting");
+    assert.equal(launches(), 0);
+  });
+}
+
+test("an ordinary command for the same saved session still starts omp", async (t) => {
+  // Control: proves the launch record observes a real start, so the zero-launch
+  // assertions above cannot pass vacuously.
+  useRegistry(t);
+
+  const response = await post(SAVED_ID, { type: "get_state" });
+  const text = await response.text();
+
+  assert.equal(launches(), 1, `a session-owning command resumes omp (response ${response.status}: ${text})`);
+  assert.notEqual(response.status, 409);
+});
diff --git a/lib/i18n/locales/en.json b/lib/i18n/locales/en.json
index c9f91a4e..df1d5404 100644
--- a/lib/i18n/locales/en.json
+++ b/lib/i18n/locales/en.json
@@ -1,4 +1,33 @@
 {
+  "skillDiagnostics.title": "Skill diagnostics",
+  "skillDiagnostics.details": "Details",
+  "skillDiagnostics.inspect": "View skill diagnostics",
+  "skillDiagnostics.close": "Close skill diagnostics",
+  "skillDiagnostics.dismiss": "Dismiss skill notice",
+  "skillDiagnostics.loading": "Loading skill diagnostics…",
+  "skillDiagnostics.source": "Source: {source}",
+  "skillDiagnostics.default": "Default",
+  "skillDiagnostics.variant": "Variant",
+  "skillDiagnostics.redundant": "Redundant copy",
+  "skillDiagnostics.retained": "Identical to {name} ({path})",
+  "skillDiagnostics.noDefault": "No bare default is included. Invoke a namespaced variant explicitly.",
+  "skillDiagnostics.lineage": "Shared names do not imply the same skill lineage. These details come from OMP's actual resolution.",
+  "skillDiagnostics.clean": "No conflicting skill variants or redundant installations.",
+  "skillDiagnostics.noSession": "Select a session to inspect its live skill diagnostics.",
+  "skillDiagnostics.unavailable": "Skill diagnostics are unavailable. The session must be running on an OMP version that supports diagnostics RPC.",
+  "skillDiagnostics.disable": "Turn off",
+  "skillDiagnostics.saving": "Saving…",
+  "skillDiagnostics.saveFailed": "Could not change skill startup notices.",
+  "skillDiagnostics.overridden": "Startup notices are still enabled for this session.",
+  "skillDiagnostics.reason.source-order": "Selected by provider priority, then discovery order.",
+  "skillDiagnostics.reason.custom-directory": "Custom-directory skills override provider skills.",
+  "skillDiagnostics.reason.authored-over-installed": "Authored skills override registry-installed skills.",
+  "skillDiagnostics.conflicts.one": "{count} conflicting skill name",
+  "skillDiagnostics.conflicts.other": "{count} conflicting skill names",
+  "skillDiagnostics.duplicates.one": "{count} redundant copy deduplicated",
+  "skillDiagnostics.duplicates.other": "{count} redundant copies deduplicated",
+  "settingsConfig.skillStartupNotices": "Skill startup notices",
+  "settingsConfig.skillStartupNoticesDesc": "Show conflicts and redundant skill copies when an OMP session starts. Manual diagnostics remain available when notices are off.",
   "login.title": "Welcome back",
   "login.description": "Enter the password for this omp web workspace.",
   "login.password": "Password",
diff --git a/lib/i18n/locales/ja.json b/lib/i18n/locales/ja.json
index 04e93326..549accbb 100644
--- a/lib/i18n/locales/ja.json
+++ b/lib/i18n/locales/ja.json
@@ -1,4 +1,33 @@
 {
+  "skillDiagnostics.title": "スキル診断",
+  "skillDiagnostics.details": "詳細",
+  "skillDiagnostics.inspect": "スキル診断を表示",
+  "skillDiagnostics.close": "スキル診断を閉じる",
+  "skillDiagnostics.dismiss": "スキル通知を閉じる",
+  "skillDiagnostics.loading": "スキル診断を読み込み中…",
+  "skillDiagnostics.source": "取得元: {source}",
+  "skillDiagnostics.default": "既定",
+  "skillDiagnostics.variant": "別の定義",
+  "skillDiagnostics.redundant": "重複コピー",
+  "skillDiagnostics.retained": "{name} と同一 ({path})",
+  "skillDiagnostics.noDefault": "名前空間なしの既定スキルは含まれていません。名前空間付きの定義を明示的に呼び出してください。",
+  "skillDiagnostics.lineage": "同じ名前でも同じスキルとは限りません。この詳細は OMP の実際の解決結果です。",
+  "skillDiagnostics.clean": "競合するスキル定義や重複インストールはありません。",
+  "skillDiagnostics.noSession": "セッションを選択して実行中のスキル診断を確認してください。",
+  "skillDiagnostics.unavailable": "スキル診断を取得できません。診断 RPC に対応する OMP でセッションを実行してください。",
+  "skillDiagnostics.disable": "無効にする",
+  "skillDiagnostics.saving": "保存中…",
+  "skillDiagnostics.saveFailed": "スキルの起動時通知を変更できませんでした。",
+  "skillDiagnostics.overridden": "このセッションでは起動時通知が引き続き有効です。",
+  "skillDiagnostics.reason.source-order": "取得元の優先順位、次に検出順序で選択されました。",
+  "skillDiagnostics.reason.custom-directory": "カスタムディレクトリのスキルが取得元のスキルより優先されます。",
+  "skillDiagnostics.reason.authored-over-installed": "作成したスキルがレジストリからインストールしたスキルより優先されます。",
+  "skillDiagnostics.conflicts.one": "{count} 件のスキル名が競合",
+  "skillDiagnostics.conflicts.other": "{count} 件のスキル名が競合",
+  "skillDiagnostics.duplicates.one": "{count} 件の重複コピーを除外",
+  "skillDiagnostics.duplicates.other": "{count} 件の重複コピーを除外",
+  "settingsConfig.skillStartupNotices": "スキルの起動時通知",
+  "settingsConfig.skillStartupNoticesDesc": "OMP セッションの起動時に競合や重複コピーを通知します。無効にしても診断は手動で確認できます。",
   "login.title": "おかえりなさい",
   "login.description": "この omp web ワークスペースのパスワードを入力してください。",
   "login.password": "パスワード",
diff --git a/lib/i18n/locales/zh-CN.json b/lib/i18n/locales/zh-CN.json
index 2bd433e5..b80b1891 100644
--- a/lib/i18n/locales/zh-CN.json
+++ b/lib/i18n/locales/zh-CN.json
@@ -1,4 +1,33 @@
 {
+  "skillDiagnostics.title": "技能诊断",
+  "skillDiagnostics.details": "详情",
+  "skillDiagnostics.inspect": "查看技能诊断",
+  "skillDiagnostics.close": "关闭技能诊断",
+  "skillDiagnostics.dismiss": "关闭技能提示",
+  "skillDiagnostics.loading": "正在加载技能诊断…",
+  "skillDiagnostics.source": "来源：{source}",
+  "skillDiagnostics.default": "默认",
+  "skillDiagnostics.variant": "其他定义",
+  "skillDiagnostics.redundant": "重复副本",
+  "skillDiagnostics.retained": "与 {name} 相同（{path}）",
+  "skillDiagnostics.noDefault": "未包含无命名空间的默认技能。请明确调用带命名空间的定义。",
+  "skillDiagnostics.lineage": "名称相同不代表技能来源相同。这些详情来自 OMP 的实际解析结果。",
+  "skillDiagnostics.clean": "没有冲突的技能定义或重复安装。",
+  "skillDiagnostics.noSession": "请选择一个会话以查看其运行时技能诊断。",
+  "skillDiagnostics.unavailable": "技能诊断不可用。会话必须运行在支持诊断 RPC 的 OMP 版本上。",
+  "skillDiagnostics.disable": "关闭此提示",
+  "skillDiagnostics.saving": "正在保存…",
+  "skillDiagnostics.saveFailed": "无法更改技能启动通知。",
+  "skillDiagnostics.overridden": "此会话仍启用了启动通知。",
+  "skillDiagnostics.reason.source-order": "按来源优先级及发现顺序选择。",
+  "skillDiagnostics.reason.custom-directory": "自定义目录技能优先于其他来源的技能。",
+  "skillDiagnostics.reason.authored-over-installed": "用户编写的技能优先于从注册表安装的技能。",
+  "skillDiagnostics.conflicts.one": "{count} 个冲突的技能名称",
+  "skillDiagnostics.conflicts.other": "{count} 个冲突的技能名称",
+  "skillDiagnostics.duplicates.one": "已去重 {count} 个重复副本",
+  "skillDiagnostics.duplicates.other": "已去重 {count} 个重复副本",
+  "settingsConfig.skillStartupNotices": "技能启动通知",
+  "settingsConfig.skillStartupNoticesDesc": "在 OMP 会话启动时显示冲突和重复副本。关闭通知后仍可手动查看诊断。",
   "login.title": "欢迎回来",
   "login.description": "请输入此 omp web 工作区的密码。",
   "login.password": "密码",
diff --git a/lib/omp/settings-config.test.mjs b/lib/omp/settings-config.test.mjs
index 3d678615..ee78887e 100644
--- a/lib/omp/settings-config.test.mjs
+++ b/lib/omp/settings-config.test.mjs
@@ -131,3 +131,41 @@ test("invalid Auto source input is rejected before touching config", () => {
     }
   });
 });
+
+test("persists and validates skills.showStartupDiagnostics without rewriting unrelated YAML", () => {
+  withAgentDir((dir) => {
+    const path = join(dir, "config.yml");
+    writeFileSync(path, [
+      "# user heading",
+      "personality: friendly # keep this comment",
+      "skills:",
+      "  customDirectory: /workspace/shared-skills",
+      "retry:",
+      "  maxRetries: 4",
+      "",
+    ].join("\n"), "utf8");
+
+    writeNativeSettings({ skills: { showStartupDiagnostics: false } });
+    assert.equal(readNativeSettings().settings.skills?.showStartupDiagnostics, false);
+    const persisted = readFileSync(path, "utf8");
+    assert.match(persisted, /# user heading/);
+    assert.match(persisted, /personality: friendly # keep this comment/);
+    assert.match(persisted, /customDirectory: \/workspace\/shared-skills/);
+    assert.match(persisted, /showStartupDiagnostics: false/);
+    assert.match(persisted, /maxRetries: 4/);
+
+    writeNativeSettings({ hideThinkingBlock: true });
+    assert.equal(readNativeSettings().settings.skills?.showStartupDiagnostics, false);
+    assert.throws(
+      () => writeNativeSettings({ skills: { showStartupDiagnostics: "false" } }),
+      /skills\.showStartupDiagnostics must be a boolean/,
+    );
+  });
+});
+
+test("does not expose malformed skills.showStartupDiagnostics values", () => {
+  withAgentDir((dir) => {
+    writeFileSync(join(dir, "config.yml"), "skills:\n  showStartupDiagnostics: disabled\n", "utf8");
+    assert.equal(readNativeSettings().settings.skills?.showStartupDiagnostics, undefined);
+  });
+});
diff --git a/lib/omp/settings-config.ts b/lib/omp/settings-config.ts
index 2acbd20e..13df6fc2 100644
--- a/lib/omp/settings-config.ts
+++ b/lib/omp/settings-config.ts
@@ -14,6 +14,7 @@ export type NativeSettings = {
   personality?: "default" | "friendly" | "pragmatic" | "none";
   advisor?: { enabled?: boolean; subagents?: boolean; syncBacklog?: "off" | "1" | "3" | "5"; immuneTurns?: number };
   tools?: { approvalMode?: "always-ask" | "write" | "yolo"; approval?: { bash?: "allow" | "prompt" | "deny"; extension?: "allow" | "prompt" } };
+  skills?: { showStartupDiagnostics?: boolean };
   enabledModels?: string[];
   disabledProviders?: string[];
   modelProviderOrder?: string[];
@@ -90,6 +91,7 @@ export function readNativeSettings(): { path: string; settings: NativeSettings }
   const autoThinkingSource = providers.autoThinkingSource;
   const tools = isRecord(data.tools) ? data.tools : {};
   const approval = isRecord(tools.approval) ? tools.approval : {};
+  const skills = isRecord(data.skills) ? data.skills : {};
   const retry = isRecord(data.retry) ? data.retry : {};
   const fallbackChains = isRecord(retry.fallbackChains)
     ? Object.fromEntries(Object.entries(retry.fallbackChains).filter((entry): entry is [string, string[]] => typeof entry[0] === "string" && stringArray(entry[1]) !== undefined))
@@ -134,6 +136,9 @@ export function readNativeSettings(): { path: string; settings: NativeSettings }
           ...(approval.extension === "allow" || approval.extension === "prompt" ? { extension: approval.extension } : {}),
         } } : {}),
       } } : {}),
+      ...(typeof skills.showStartupDiagnostics === "boolean" ? {
+        skills: { showStartupDiagnostics: skills.showStartupDiagnostics },
+      } : {}),
       ...(stringArray(data.enabledModels) ? { enabledModels: stringArray(data.enabledModels) } : {}),
       ...(stringArray(data.disabledProviders) ? { disabledProviders: stringArray(data.disabledProviders) } : {}),
       ...(stringArray(data.modelProviderOrder) ? { modelProviderOrder: stringArray(data.modelProviderOrder) } : {}),
@@ -185,18 +190,23 @@ export function writeNativeSettings(settings: NativeSettings): void {
   assertOptionalRecord(settings.advisor, "advisor");
   assertOptionalRecord(settings.tools, "tools");
   assertOptionalRecord(settings.tools?.approval, "tools.approval");
+  assertOptionalRecord(settings.skills, "skills");
   assertOptionalRecord(settings.retry, "retry");
   assertOptionalRecord(settings.compaction, "compaction");
   assertOptionalRecord(settings.memory, "memory");
   assertOptionalRecord(settings.autolearn, "autolearn");
   assertOptionalRecord(settings.mnemopi, "mnemopi");
   assertOptionalRecord(settings.mcp, "mcp");
+  if (settings.skills && Object.keys(settings.skills).some((key) => key !== "showStartupDiagnostics")) {
+    throw new Error("Unsupported skills setting");
+  }
   for (const [name, value] of Object.entries({
     hideThinkingBlock: settings.hideThinkingBlock,
     externalThinking: settings.externalThinking,
     "advisor.enabled": settings.advisor?.enabled,
     "advisor.subagents": settings.advisor?.subagents,
     "retry.enabled": settings.retry?.enabled,
+    "skills.showStartupDiagnostics": settings.skills?.showStartupDiagnostics,
     "retry.modelFallback": settings.retry?.modelFallback,
     "compaction.enabled": settings.compaction?.enabled,
     "compaction.midTurnEnabled": settings.compaction?.midTurnEnabled,
@@ -254,6 +264,9 @@ export function writeNativeSettings(settings: NativeSettings): void {
   if (settings.tools?.approvalMode !== undefined) doc.setIn(["tools", "approvalMode"], settings.tools.approvalMode);
   if (settings.tools?.approval?.bash !== undefined) doc.setIn(["tools", "approval", "bash"], settings.tools.approval.bash);
   if (settings.tools?.approval?.extension !== undefined) doc.setIn(["tools", "approval", "extension"], settings.tools.approval.extension);
+  if (settings.skills?.showStartupDiagnostics !== undefined) {
+    doc.setIn(["skills", "showStartupDiagnostics"], settings.skills.showStartupDiagnostics);
+  }
   if (settings.enabledModels !== undefined) doc.set("enabledModels", settings.enabledModels);
   if (settings.disabledProviders !== undefined) doc.set("disabledProviders", settings.disabledProviders);
   if (settings.modelProviderOrder !== undefined) doc.set("modelProviderOrder", settings.modelProviderOrder);
diff --git a/lib/pi-types.ts b/lib/pi-types.ts
index 77528533..74f897ac 100644
--- a/lib/pi-types.ts
+++ b/lib/pi-types.ts
@@ -1,3 +1,5 @@
+import type { SkillDiagnosticsSnapshot } from "./skill-diagnostics";
+
 // Local mirrors of the omp shapes used by omp-web. omp's SDK packages are
 // Bun-only, so these types are hand-maintained against
 // oh-my-pi/packages/coding-agent/src/modes/rpc/rpc-types.ts (protocol v1).
@@ -95,6 +97,8 @@ export interface RpcSessionState {
   usageLimit?: UsageLimitState;
   /** omp's reported output throughput; null/undefined when not generating. */
   tokensPerSecond?: number | null;
+  /** Structured skill resolution diagnostics; absent on older OMP builds. */
+  skillDiagnostics?: SkillDiagnosticsSnapshot;
 }
 
 /**
@@ -130,6 +134,8 @@ export interface WebSessionState {
   usageLimit?: UsageLimitState;
   autoRetryEnabled?: boolean;
   tokensPerSecond?: number | null;
+  /** Parsed public diagnostics DTO; absent means unsupported or malformed. */
+  skillDiagnostics?: SkillDiagnosticsSnapshot;
   todoPhases: TodoPhase[];
   extensionStatuses: Array<{ key: string; text: string }>;
   extensionWidgets: Array<{ key: string; lines: string[]; placement: "aboveEditor" | "belowEditor" }>;
diff --git a/lib/rpc-manager.test.mjs b/lib/rpc-manager.test.mjs
index a0b60f5a..88b64dd0 100644
--- a/lib/rpc-manager.test.mjs
+++ b/lib/rpc-manager.test.mjs
@@ -1457,3 +1457,125 @@ test("abort_and_restore_queue returns omp's withdrawn messages and clears the ru
   assert.equal(await wrapper.send({ type: "abort" }), null, "plain abort still answers nothing");
   assert.deepEqual(sent.filter((type) => type.startsWith("abort")), ["abort_and_restore_queue", "abort"]);
 });
+test("skill diagnostics cross the wrapper only as parsed public DTOs", async (t) => {
+  const privateSnapshot = {
+    cwd: "/workspace",
+    showStartupDiagnostics: true,
+    diagnostics: [{
+      name: "review",
+      reason: "source-order",
+      skills: [{
+        name: "review",
+        filePath: "/workspace/.agents/skills/review/SKILL.md",
+        source: "project",
+        pluginName: "tools",
+        body: "private prompt",
+        _source: { kind: "internal" },
+      }],
+      duplicates: [{
+        skill: {
+          name: "review",
+          filePath: "/home/me/.agents/skills/review/SKILL.md",
+          source: "user",
+          frontmatter: { version: 2 },
+        },
+        retained: {
+          name: "review",
+          filePath: "/workspace/.agents/skills/review/SKILL.md",
+          source: "project",
+          containRoot: "/workspace",
+        },
+      }],
+      internal: "hidden",
+    }],
+    privateField: true,
+  };
+  const publicSnapshot = {
+    cwd: "/workspace",
+    showStartupDiagnostics: true,
+    diagnostics: [{
+      name: "review",
+      reason: "source-order",
+      skills: [{
+        name: "review",
+        filePath: "/workspace/.agents/skills/review/SKILL.md",
+        source: "project",
+        pluginName: "tools",
+      }],
+      duplicates: [{
+        skill: {
+          name: "review",
+          filePath: "/home/me/.agents/skills/review/SKILL.md",
+          source: "user",
+        },
+        retained: {
+          name: "review",
+          filePath: "/workspace/.agents/skills/review/SKILL.md",
+          source: "project",
+        },
+      }],
+    }],
+  };
+  let stateDiagnostics = privateSnapshot;
+  let directDiagnostics = privateSnapshot;
+  let nativeFrame;
+  const forwarded = [];
+  const fakeProc = {
+    isAlive: true,
+    onFrame(listener) {
+      nativeFrame = listener;
+      return () => {};
+    },
+    async sendCommand(command) {
+      forwarded.push(command);
+      if (command.type === "get_state") {
+        return {
+          sessionId: "diagnostics-session",
+          isStreaming: false,
+          isCompacting: false,
+          skillDiagnostics: stateDiagnostics,
+        };
+      }
+      if (command.type === "get_skill_diagnostics") return directDiagnostics;
+      if (command.type === "set_skill_startup_diagnostics") {
+        return { ...privateSnapshot, showStartupDiagnostics: false };
+      }
+      return {};
+    },
+    sendFrame: () => {},
+    dispose: async () => {},
+  };
+  const wrapper = new SnapshotWrapper(fakeProc, process.cwd());
+  wrapper.start();
+  t.after(() => wrapper.destroyAndWait());
+
+  const state = await wrapper.send({ type: "get_state" });
+  assert.deepEqual(state.skillDiagnostics, publicSnapshot);
+  assert.deepEqual(await wrapper.send({ type: "get_skill_diagnostics" }), publicSnapshot);
+  assert.deepEqual(
+    await wrapper.send({ type: "set_skill_startup_diagnostics", enabled: true }),
+    { ...publicSnapshot, showStartupDiagnostics: false },
+    "setter replies are stripped to the public DTO",
+  );
+
+  const events = [];
+  wrapper.onEvent((event) => events.push(event));
+  nativeFrame({ type: "skill_diagnostics_update", data: privateSnapshot });
+  const event = { ...events.at(-1) };
+  delete event.web;
+  assert.deepEqual(event, { type: "skill_diagnostics_update", data: publicSnapshot });
+
+  stateDiagnostics = { cwd: "/workspace", showStartupDiagnostics: true, diagnostics: "clean" };
+  assert.equal((await wrapper.send({ type: "get_state" })).skillDiagnostics, undefined);
+  directDiagnostics = { cwd: "/workspace", showStartupDiagnostics: true, diagnostics: "clean" };
+  await assert.rejects(() => wrapper.send({ type: "get_skill_diagnostics" }), /skill diagnostics/i);
+  await assert.rejects(
+    () => wrapper.send({ type: "set_skill_startup_diagnostics", enabled: "false" }),
+    /enabled must be a boolean/i,
+  );
+  assert.equal(
+    forwarded.some((command) => command.type === "set_skill_startup_diagnostics" && command.enabled === "false"),
+    false,
+    "invalid control data must not reach OMP",
+  );
+});
diff --git a/lib/rpc-manager.ts b/lib/rpc-manager.ts
index 858b3aed..9bc9a42f 100644
--- a/lib/rpc-manager.ts
+++ b/lib/rpc-manager.ts
@@ -20,6 +20,7 @@ import { PRESET_FULL } from "./tool-presets";
 import { comparableProjectPath } from "./comparable-path";
 import { samePath } from "./paths";
 import { isRecord } from "./type-guards";
+import { parseSkillDiagnosticsSnapshot, type SkillDiagnosticsSnapshot } from "./skill-diagnostics";
 import { isReservedLaunchArg, loadProjectRegistry } from "./project-registry";
 import type {
   BashResultInfo,
@@ -736,6 +737,13 @@ export class AgentSessionWrapper {
         this.invalidateSessionLists();
         refreshSessionList = true;
         break;
+      case "skill_diagnostics_update":
+        this.emit({
+          type: "skill_diagnostics_update",
+          data: parseSkillDiagnosticsSnapshot(event.data),
+        });
+        notifyRunningChange();
+        return;
       case "response": {
         // Unsolicited failed responses surface async prompt failures (omp
         // reuses the original command id after the immediate ack). Some omp
@@ -1269,6 +1277,7 @@ export class AgentSessionWrapper {
     if (wasRunning && !this.isRunning()) {
       notifyRunningChange();
     }
+    const skillDiagnostics = parseSkillDiagnosticsSnapshot(state.skillDiagnostics);
     return {
       sessionId: state.sessionId,
       sessionFile: state.sessionFile ?? "",
@@ -1309,12 +1318,24 @@ export class AgentSessionWrapper {
       slowModeEnabled: state.slowModeEnabled ?? false,
       slowModeScope: state.slowModeScope,
       usageLimit: state.usageLimit,
+      ...(skillDiagnostics ? { skillDiagnostics } : {}),
       todoPhases: state.todoPhases ?? [],
       extensionStatuses: Array.from(this.extensionStatuses, ([key, text]) => ({ key, text })),
       extensionWidgets: Array.from(this.extensionWidgets.values()),
     };
   }
 
+  private requireSkillDiagnostics(value: unknown): SkillDiagnosticsSnapshot {
+    const snapshot = parseSkillDiagnosticsSnapshot(value);
+    if (!snapshot) {
+      throw new WebRpcError(
+        "Skill diagnostics are unavailable for this OMP session",
+        "skill_diagnostics_unsupported",
+      );
+    }
+    return snapshot;
+  }
+
   private async getStateWithTimeout(): Promise<RpcSessionState> {
     return this.proc.sendCommand<RpcSessionState>({ type: "get_state" }, GET_STATE_TIMEOUT_MS);
   }
@@ -1560,6 +1581,22 @@ export class AgentSessionWrapper {
         }
       }
 
+      case "get_skill_diagnostics": {
+        const result = await this.proc.sendCommand<unknown>({ type: "get_skill_diagnostics" }, GET_STATE_TIMEOUT_MS);
+        return this.requireSkillDiagnostics(result);
+      }
+
+      case "set_skill_startup_diagnostics": {
+        if (typeof command.enabled !== "boolean") {
+          throw new WebRpcError("enabled must be a boolean", "invalid_skill_startup_diagnostics");
+        }
+        const result = await this.proc.sendCommand<unknown>({
+          type: "set_skill_startup_diagnostics",
+          enabled: command.enabled,
+        }, GET_STATE_TIMEOUT_MS);
+        return this.requireSkillDiagnostics(result);
+      }
+
       case "set_model": {
         const { provider, modelId } = command as { provider: string; modelId: string };
         const model = await this.proc.sendCommand<OmpModel>({ type: "set_model", provider, modelId });
diff --git a/lib/skill-diagnostics.test.mjs b/lib/skill-diagnostics.test.mjs
new file mode 100644
index 00000000..14335599
--- /dev/null
+++ b/lib/skill-diagnostics.test.mjs
@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const { parseSkillDiagnosticsSnapshot } = await jiti.import("./skill-diagnostics.ts");
+
+const publicSnapshot = {
+  cwd: "/workspace",
+  showStartupDiagnostics: false,
+  diagnostics: [{
+    name: "review",
+    reason: "authored-over-installed",
+    skills: [{
+      name: "review",
+      filePath: "/workspace/.agents/skills/review/SKILL.md",
+      source: "project",
+      pluginName: "tools",
+    }],
+    duplicates: [{
+      skill: {
+        name: "review",
+        filePath: "/mirror/review/SKILL.md",
+        source: "custom",
+      },
+      retained: {
+        name: "review",
+        filePath: "/workspace/.agents/skills/review/SKILL.md",
+        source: "project",
+      },
+    }],
+  }],
+};
+
+test("constructs a public skill diagnostics DTO and strips every unlisted field", () => {
+  const wire = {
+    ...publicSnapshot,
+    prompt: "private",
+    diagnostics: [{
+      ...publicSnapshot.diagnostics[0],
+      internal: true,
+      skills: publicSnapshot.diagnostics[0].skills.map((skill) => ({
+        ...skill,
+        body: "private prompt",
+        frontmatter: { version: 4 },
+        _source: { kind: "internal" },
+        containRoot: "/workspace",
+      })),
+      duplicates: publicSnapshot.diagnostics[0].duplicates.map((duplicate) => ({
+        ...duplicate,
+        privatePair: true,
+        skill: { ...duplicate.skill, body: "private" },
+        retained: { ...duplicate.retained, frontmatter: { version: 4 } },
+      })),
+    }],
+  };
+
+  assert.deepEqual(parseSkillDiagnosticsSnapshot(wire), publicSnapshot);
+  assert.notEqual(parseSkillDiagnosticsSnapshot(wire), wire, "the parser constructs a new allowlisted object");
+});
+
+test("keeps an explicit clean snapshot distinct from absent or malformed support", () => {
+  assert.deepEqual(parseSkillDiagnosticsSnapshot({
+    cwd: "/workspace",
+    showStartupDiagnostics: true,
+    diagnostics: [],
+  }), {
+    cwd: "/workspace",
+    showStartupDiagnostics: true,
+    diagnostics: [],
+  });
+
+  for (const value of [
+    undefined,
+    null,
+    {},
+    { cwd: "/workspace", showStartupDiagnostics: true },
+    { cwd: "/workspace", showStartupDiagnostics: "yes", diagnostics: [] },
+    { cwd: "/workspace", showStartupDiagnostics: true, diagnostics: "clean" },
+    { cwd: "/workspace", showStartupDiagnostics: true, diagnostics: [{ ...publicSnapshot.diagnostics[0], reason: "new-reason" }] },
+    { cwd: "/workspace", showStartupDiagnostics: true, diagnostics: [{ ...publicSnapshot.diagnostics[0], skills: [{ name: "review", filePath: 42, source: "project" }] }] },
+    { cwd: "/workspace", showStartupDiagnostics: true, diagnostics: [{ ...publicSnapshot.diagnostics[0], skills: [{ ...publicSnapshot.diagnostics[0].skills[0], pluginName: 42 }] }] },
+    { cwd: "/workspace", showStartupDiagnostics: true, diagnostics: [{ ...publicSnapshot.diagnostics[0], duplicates: [{ skill: publicSnapshot.diagnostics[0].skills[0] }] }] },
+  ]) {
+    assert.equal(parseSkillDiagnosticsSnapshot(value), undefined);
+  }
+});
diff --git a/lib/skill-diagnostics.ts b/lib/skill-diagnostics.ts
new file mode 100644
index 00000000..62ca8d1e
--- /dev/null
+++ b/lib/skill-diagnostics.ts
@@ -0,0 +1,90 @@
+import { isRecord } from "./type-guards";
+
+export type SkillDiagnosticReason = "source-order" | "custom-directory" | "authored-over-installed";
+
+export interface SkillDiagnosticEntry {
+  name: string;
+  filePath: string;
+  source: string;
+  pluginName?: string;
+}
+
+export interface SkillDiagnosticDuplicate {
+  skill: SkillDiagnosticEntry;
+  retained: SkillDiagnosticEntry;
+}
+
+export interface SkillResolutionDiagnostic {
+  name: string;
+  reason: SkillDiagnosticReason;
+  skills: SkillDiagnosticEntry[];
+  duplicates: SkillDiagnosticDuplicate[];
+}
+
+export interface SkillDiagnosticsSnapshot {
+  cwd: string;
+  showStartupDiagnostics: boolean;
+  diagnostics: SkillResolutionDiagnostic[];
+}
+
+function parseEntry(value: unknown): SkillDiagnosticEntry | undefined {
+  if (!isRecord(value)
+    || typeof value.name !== "string"
+    || typeof value.filePath !== "string"
+    || typeof value.source !== "string"
+    || (value.pluginName !== undefined && typeof value.pluginName !== "string")) return undefined;
+  const entry: SkillDiagnosticEntry = {
+    name: value.name,
+    filePath: value.filePath,
+    source: value.source,
+  };
+  if (value.pluginName !== undefined) entry.pluginName = value.pluginName;
+  return entry;
+}
+
+function parseDiagnostic(value: unknown): SkillResolutionDiagnostic | undefined {
+  if (!isRecord(value)
+    || typeof value.name !== "string"
+    || (value.reason !== "source-order" && value.reason !== "custom-directory" && value.reason !== "authored-over-installed")
+    || !Array.isArray(value.skills)
+    || !Array.isArray(value.duplicates)) return undefined;
+
+  const skills: SkillDiagnosticEntry[] = [];
+  for (const rawSkill of value.skills) {
+    const skill = parseEntry(rawSkill);
+    if (!skill) return undefined;
+    skills.push(skill);
+  }
+
+  const duplicates: SkillDiagnosticDuplicate[] = [];
+  for (const rawDuplicate of value.duplicates) {
+    if (!isRecord(rawDuplicate)) return undefined;
+    const skill = parseEntry(rawDuplicate.skill);
+    const retained = parseEntry(rawDuplicate.retained);
+    if (!skill || !retained) return undefined;
+    duplicates.push({ skill, retained });
+  }
+
+  return { name: value.name, reason: value.reason, skills, duplicates };
+}
+
+/** Parses untrusted RPC data into an allowlisted display DTO. */
+export function parseSkillDiagnosticsSnapshot(value: unknown): SkillDiagnosticsSnapshot | undefined {
+  if (!isRecord(value)
+    || typeof value.cwd !== "string"
+    || typeof value.showStartupDiagnostics !== "boolean"
+    || !Array.isArray(value.diagnostics)) return undefined;
+
+  const diagnostics: SkillResolutionDiagnostic[] = [];
+  for (const rawDiagnostic of value.diagnostics) {
+    const diagnostic = parseDiagnostic(rawDiagnostic);
+    if (!diagnostic) return undefined;
+    diagnostics.push(diagnostic);
+  }
+
+  return {
+    cwd: value.cwd,
+    showStartupDiagnostics: value.showStartupDiagnostics,
+    diagnostics,
+  };
+}